mu - Soul of a tiny new machine. More thorough tests → More comprehensible and rewrite-friendly software → More resilient society.

return out.str(); } +:(before "End Globals") +// word boundaries +string Terminators("(){}"); +string Ignore(","); // meaningless except within [] strings +:(code) void slurp_word(istream& in, ostream& out) { char c; - if (!in.eof() && in.peek() == ',') { + if (!in.eof() && Terminators.find(in.peek()) != string::npos) { in >> c; out << c; return; } while (in >> c) { - if (isspace(c) || c == ',') { + if (isspace(c) || Terminators.find(c) != string::npos || Ignore.find(c) != string::npos) { in.putback(c); break; } @@ -219,8 +224,8 @@ void slurp_word(istream& in} } -void skip_whitespace(istream& in) { - while (!in.eof() && isspace(in.peek()) && in.peek() != '\n') { +void skip_ignored_characters(istream& in) { + while (isspace(in.peek()) || Ignore.find(in.peek()) != string::npos) { in.get(); } } @@ -229,6 +234,7 @@ void skip_whitespace_and_comments(istream& in while (true) { if (in.eof()) break; if (isspace(in.peek())) in.get(); + else if (in.peek() == ',') in.get(); else if (in.peek() == '#') skip_comment(in); else break; } @@ -241,12 +247,6 @@ void skip_comment(istream& in} } -void skip_comma(istream& in) { - skip_whitespace(in); - if (!in.eof() && in.peek() == ',') in.get(); - skip_whitespace(in); -} - //: Warn if a recipe gets redefined, because large codebases can accidentally //: step on their own toes. But there'll be many occasions later where //: we'll want to disable the warnings. @@ -261,11 +261,8 @@ bool warn_on_redefine(const string& recipe_na } // for debugging -:(before "End Globals") -bool Show_rest_of_stream = false; :(code) void show_rest_of_stream(istream& in) { - if (!Show_rest_of_stream) return; cerr << '^'; char c; while (in >> c) { @@ -281,13 +278,15 @@ vector<recipe_ordinal> recently_added_recipes;</sp long long int Reserved_for_tests = 1000; :(before "End Setup") for (long long int i = 0; i < SIZE(recently_added_recipes); ++i) { - if (recently_added_recipes.at(i) >= Reserved_for_tests) // don't renumber existing recipes, like 'interactive' - Recipe_ordinal.erase(Recipe[recently_added_recipes.at(i)].name); + if (recently_added_recipes.at(i) >= Reserved_for_tests // don't renumber existing recipes, like 'interactive' + && contains_key(Recipe, recently_added_recipes.at(i))) // in case previous test had duplicate definitions + Recipe_ordinal.erase(get(Recipe, recently_added_recipes.at(i)).name); Recipe.erase(recently_added_recipes.at(i)); } // Clear Other State For recently_added_recipes recently_added_recipes.clear(); +:(code) :(scenario parse_comment_outside_recipe) # this comment will be dropped by the tangler, so we need a dummy recipe to stop that recipe f1 [ ] @@ -296,8 +295,8 @@ recipe main [ 1:number <- copy 23 ] +parse: instruction: copy -+parse: ingredient: {name: "23", properties: ["23": "literal"]} -+parse: product: {name: "1", properties: ["1": "number"]} ++parse: ingredient: {"23": "literal"} ++parse: product: {"1": "number"} :(scenario parse_comment_amongst_instruction) recipe main [ @@ -305,8 +304,8 @@ recipe main [ 1:number <- copy 23 ] +parse: instruction: copy -+parse: ingredient: {name: "23", properties: ["23": "literal"]} -+parse: product: {name: "1", properties: ["1": "number"]} ++parse: ingredient: {"23": "literal"} ++parse: product: {"1": "number"} :(scenario parse_comment_amongst_instruction_2) recipe main [ @@ -315,8 +314,8 @@ recipe main [ # comment ] +parse: instruction: copy -+parse: ingredient: {name: "23", properties: ["23": "literal"]} -+parse: product: {name: "1", properties: ["1": "number"]} ++parse: ingredient: {"23": "literal"} ++parse: product: {"1": "number"} :(scenario parse_comment_amongst_instruction_3) recipe main [ @@ -325,19 +324,19 @@ recipe main [ 2:number <- copy 23 ] +parse: instruction: copy -+parse: ingredient: {name: "23", properties: ["23": "literal"]} -+parse: product: {name: "1", properties: ["1": "number"]} ++parse: ingredient: {"23": "literal"} ++parse: product: {"1": "number"} +parse: instruction: copy -+parse: ingredient: {name: "23", properties: ["23": "literal"]} -+parse: product: {name: "2", properties: ["2": "number"]} ++parse: ingredient: {"23": "literal"} ++parse: product: {"2": "number"} :(scenario parse_comment_after_instruction) recipe main [ 1:number <- copy 23 # comment ] +parse: instruction: copy -+parse: ingredient: {name: "23", properties: ["23": "literal"]} -+parse: product: {name: "1", properties: ["1": "number"]} ++parse: ingredient: {"23": "literal"} ++parse: product: {"1": "number"} :(scenario parse_label) recipe main [ @@ -356,43 +355,43 @@ recipe main [ 1:number <- copy 23/foo:bar:baz ] +parse: instruction: copy -+parse: ingredient: {name: "23", properties: ["23": "literal", "foo": "bar":"baz"]} -+parse: product: {name: "1", properties: ["1": "number"]} ++parse: ingredient: {"23": "literal", "foo": <"bar" : <"baz" : <>>>} ++parse: product: {"1": "number"} :(scenario parse_multiple_products) recipe main [ 1:number, 2:number <- copy 23 ] +parse: instruction: copy -+parse: ingredient: {name: "23", properties: ["23": "literal"]} -+parse: product: {name: "1", properties: ["1": "number"]} -+parse: product: {name: "2", properties: ["2": "number"]} ++parse: ingredient: {"23": "literal"} ++parse: product: {"1": "number"} ++parse: product: {"2": "number"} :(scenario parse_multiple_ingredients) recipe main [ 1:number, 2:number <- copy 23, 4:number ] +parse: instruction: copy -+parse: ingredient: {name: "23", properties: ["23": "literal"]} -+parse: ingredient: {name: "4", properties: ["4": "number"]} -+parse: product: {name: "1", properties: ["1": "number"]} -+parse: product: {name: "2", properties: ["2": "number"]} ++parse: ingredient: {"23": "literal"} ++parse: ingredient: {"4": "number"} ++parse: product: {"1": "number"} ++parse: product: {"2": "number"} :(scenario parse_multiple_types) recipe main [ 1:number, 2:address:number <- copy 23, 4:number ] +parse: instruction: copy -+parse: ingredient: {name: "23", properties: ["23": "literal"]} -+parse: ingredient: {name: "4", properties: ["4": "number"]} -+parse: product: {name: "1", properties: ["1": "number"]} -+parse: product: {name: "2", properties: ["2": "address":"number"]} ++parse: ingredient: {"23": "literal"} ++parse: ingredient: {"4": "number"} ++parse: product: {"1": "number"} ++parse: product: {"2": <"address" : <"number" : <>>>} :(scenario parse_properties) recipe main [ 1:number:address/lookup <- copy 23 ] -+parse: product: {name: "1", properties: ["1": "number":"address", "lookup": ]} ++parse: product: {"1": <"number" : <"address" : <>>>, "lookup": <>} //: this test we can't represent with a scenario :(code) diff --git a/html/012transform.cc.html b/html/012transform.cc.html index 24c3b436..6770e137 100644 --- a/html/012transform.cc.html +++ b/html/012transform.cc.html @@ -13,10 +13,11 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.Identifier { color: #804000; } .Constant { color: #00a0a0; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } -.Identifier { color: #804000; } +.CommentedCode { color: #6c6c6c; } --> </style> @@ -32,10 +33,21 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } //: //: The hope is that this framework of transform tools will provide a //: deconstructed alternative to conventional compilers. +//: +//: We're going to have many transforms in mu, and getting their order right +//: (not the same as ordering of layers) is a well-known problem. Some tips: +//: a) Design each layer to rely on as few previous layers as possible. +//: +//: b) When positioning transforms, try to find the tightest constraint in +//: each transform relative to previous layers. +//: +//: c) Even so you'll periodically need to try adjusting each transform +//: relative to those in previous layers to find a better arrangement. :(before "End recipe Fields") long long int transformed_until; - recipe() :transformed_until(-1) {} +:(before "End recipe Constructor") +transformed_until = -1; :(before "End Types") typedef void (*transform_fn)(recipe_ordinal); @@ -43,22 +55,31 @@ typedef void (*transform_fn:(before "End Globals") vector<transform_fn> Transform; +:(after "int main") + // Begin Transforms + // End Transforms + :(code) void transform_all() { + trace(9990, "transform") << "=== transform_all()" << end(); for (long long int t = 0; t < SIZE(Transform); ++t) { +//? cerr << "transform " << t << '\n'; for (map<recipe_ordinal, recipe>::iterator p = Recipe.begin(); p != Recipe.end(); ++p) { recipe& r = p->second; if (r.steps.empty()) continue; if (r.transformed_until != t-1) continue; + // End Transform Checks (*Transform.at(t))(/*recipe_ordinal*/p->first); r.transformed_until = t; } } parse_int_reagents(); // do this after all other transforms have run - // End Transform + // End Transform All } void parse_int_reagents() { + trace(9991, "transform") << "--- parsing any uninitialized reagents as integers" << end(); +//? cerr << "--- parsing any uninitialized reagents as integers" << '\n'; for (map<recipe_ordinal, recipe>::iterator p = Recipe.begin(); p != Recipe.end(); ++p) { recipe& r = p->second; if (r.steps.empty()) continue; diff --git a/html/013update_operation.cc.html b/html/013update_operation.cc.html new file mode 100644 index 00000000..c2377b97 --- /dev/null +++ b/html/013update_operation.cc.html @@ -0,0 +1,67 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> +<meta http-equiv="content-type" content="text/html; charset=UTF-8"> +<title>Mu - 013update_operation.cc</title> +<meta name="Generator" content="Vim/7.4"> +<meta name="plugin-version" content="vim7.4_v1"> +<meta name="syntax" content="cpp"> +<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> +<meta name="colorscheme" content="minimal"> +<style type="text/css"> + +</style> + +<script type='text/javascript'> + +</script> +</head> +<body> +<pre id='vimCodeElement'> +//: Once all code is loaded, save operation ids of instructions and check that +//: nothing's undefined. + +:(before "End Transforms") +Transform.push_back(update_instruction_operations); // idempotent + +:(code) +void update_instruction_operations(recipe_ordinal r) { + trace(9991, "transform") << "--- compute instruction operations for recipe " << get(Recipe, r).name << end(); +//? cerr << "--- compute instruction operations for recipe " << get(Recipe, r).name << '\n'; + for (long long int index = 0; index < SIZE(get(Recipe, r).steps); ++index) { + instruction& inst = get(Recipe, r).steps.at(index); + if (inst.is_label) continue; + if (!contains_key(Recipe_ordinal, inst.name)) { + raise_error << maybe(get(Recipe, r).name) << "instruction " << inst.name << " has no recipe\n" << end(); + return; + } + inst.operation = get(Recipe_ordinal, inst.name); + } +} + +// hook to suppress inserting recipe name into errors and warnings (for later layers) +string maybe(string s) { + return s + ": "; +} + +// temporarily suppress run +void transform(string form) { + load(form); + transform_all(); +} +</pre> +</body> +</html> + diff --git a/html/013literal_string.cc.html b/html/014literal_string.cc.html index 56fff30c..b137323a 100644 --- a/html/013literal_string.cc.html +++ b/html/014literal_string.cc.html @@ -2,7 +2,7 @@ <html> <head> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> -<title>Mu - 013literal_string.cc</title> +<title>Mu - 014literal_string.cc</title> <meta name="Generator" content="Vim/7.4"> <meta name="plugin-version" content="vim7.4_v1"> <meta name="syntax" content="cpp"> @@ -13,13 +13,13 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.traceContains { color: #008000; } .cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } .Identifier { color: #804000; } .Constant { color: #00a0a0; } -.traceContains { color: #008000; } --> </style> @@ -43,18 +43,18 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe main [ 1:address:array:character <- copy [abc def] # copy can't really take a string ] -+parse: ingredient: {name: "abc def", properties: [_: "literal-string"]} ++parse: ingredient: {"abc def": "literal-string"} :(scenario string_literal_with_colons) recipe main [ 1:address:array:character <- copy [abc:def/ghi] ] -+parse: ingredient: {name: "abc:def/ghi", properties: [_: "literal-string"]} ++parse: ingredient: {"abc:def/ghi": "literal-string"} :(before "End Mu Types Initialization") -Type_ordinal["literal-string"] = 0; +put(Type_ordinal, "literal-string", 0); -:(after "string next_word(istream& in)") +:(before "End next_word Special-cases") if (in.peek() == '[') { string result = slurp_quoted(in); skip_whitespace(in); @@ -66,7 +66,7 @@ Type_ordinal["literal-string"] = (istream& in) { ostringstream out; assert(!in.eof()); assert(in.peek() == '['); out << static_cast<char>(in.get()); // slurp the '[' - if (code_string(in, out)) + if (is_code_string(in, out)) slurp_quoted_comment_aware(in, out); else slurp_quoted_comment_oblivious(in, out); @@ -75,7 +75,7 @@ string slurp_quoted(istream& in// A string is a code string if it contains a newline before any non-whitespace // todo: support comments before the newline. But that gets messy. -bool code_string(istream& in, ostringstream& out) { +bool is_code_string(istream& in, ostream& out) { while (!in.eof()) { char c = in.get(); if (!isspace(c)) { @@ -92,7 +92,7 @@ bool code_string(istream& in// Read a regular string. Regular strings can only contain other regular // strings. -void slurp_quoted_comment_oblivious(istream& in, ostringstream& out) { +void slurp_quoted_comment_oblivious(istream& in, ostream& out) { int brace_depth = 1; while (!in.eof()) { char c = in.get(); @@ -106,13 +106,13 @@ void slurp_quoted_comment_oblivious(istream& if (brace_depth == 0) break; } if (in.eof() && brace_depth > 0) { - raise << "unbalanced '['\n" << end(); + raise_error << "unbalanced '['\n" << end(); out.clear(); } } // Read a code string. Code strings can contain either code or regular strings. -void slurp_quoted_comment_aware(istream& in, ostringstream& out) { +void slurp_quoted_comment_aware(istream& in, ostream& out) { char c; while (in >> c) { if (c == '\\') { @@ -133,7 +133,7 @@ void slurp_quoted_comment_aware(istream& in<s out << c; if (c == ']') return; } - raise << "unbalanced '['\n" << end(); + raise_error << "unbalanced '['\n" << end(); out.clear(); } @@ -142,18 +142,15 @@ if (s.at(*s.rbegin() == ']'); // delete [] delimiters s.erase(0, 1); - s.erase(SIZE(s)-1); + strip_last(s); name = s; - types.push_back(0); - properties.push_back(pair<string, vector<string> >(name, vector<string>())); - properties.back().second.push_back("literal-string"); + type = new type_tree(0); + properties.push_back(pair<string, string_tree*>(name, new string_tree("literal-string"))); return; } -//: Two tweaks to printing literal strings compared to other reagents: -//: a) Don't print the string twice in the representation, just put '_' in -//: the property list. -//: b) Escape newlines in the string to make it more friendly to trace(). +//: Unlike other reagents, escape newlines in literal strings to make them +//: more friendly to trace(). :(after "string reagent::to_string()") if (is_literal_string(*this)) @@ -161,14 +158,14 @@ if (s.at:(code) bool is_literal_string(const reagent& x) { - return !x.properties.at(0).second.empty() && x.properties.at(0).second.at(0) == "literal-string"; + return x.properties.at(0).second && x.properties.at(0).second->value == "literal-string"; } string emit_literal_string(string name) { size_t pos = 0; while (pos != string::npos) pos = replace(name, "\n", "\\n", pos); - return "{name: \""+name+"\", properties: [_: \"literal-string\"]}"; + return "{\""+name+"\": \"literal-string\"}"; } size_t replace(string& str, const string& from, const string& to, size_t n) { @@ -178,41 +175,45 @@ size_t replace(string& strreturn result; } +void strip_last(string& s) { + if (!s.empty()) s.erase(SIZE(s)-1); +} + :(scenario string_literal_nested) recipe main [ 1:address:array:character <- copy [abc [def]] ] -+parse: ingredient: {name: "abc [def]", properties: [_: "literal-string"]} ++parse: ingredient: {"abc [def]": "literal-string"} :(scenario string_literal_escaped) recipe main [ 1:address:array:character <- copy [abc \[def] ] -+parse: ingredient: {name: "abc [def", properties: [_: "literal-string"]} ++parse: ingredient: {"abc [def": "literal-string"} :(scenario string_literal_escaped_comment_aware) recipe main [ 1:address:array:character <- copy [ abc \\\[def] ] -+parse: ingredient: {name: "\nabc \[def", properties: [_: "literal-string"]} ++parse: ingredient: {"\nabc \[def": "literal-string"} :(scenario string_literal_and_comment) recipe main [ 1:address:array:character <- copy [abc] # comment ] ++parse: --- defining main +parse: instruction: copy -+parse: ingredient: {name: "abc", properties: [_: "literal-string"]} -+parse: product: {name: "1", properties: ["1": "address":"array":"character"]} -# no other ingredients -$parse: 3 ++parse: number of ingredients: 1 ++parse: ingredient: {"abc": "literal-string"} ++parse: product: {"1": <"address" : <"array" : <"character" : <>>>>} :(scenario string_literal_escapes_newlines_in_trace) recipe main [ copy [abc def] ] -+parse: ingredient: {name: "abc\ndef", properties: [_: "literal-string"]} ++parse: ingredient: {"abc\ndef": "literal-string"} :(scenario string_literal_can_skip_past_comments) recipe main [ @@ -221,13 +222,13 @@ recipe main [ bar ] ] -+parse: ingredient: {name: "\n # ']' inside comment\n bar\n ", properties: [_: "literal-string"]} ++parse: ingredient: {"\n # ']' inside comment\n bar\n ": "literal-string"} :(scenario string_literal_empty) recipe main [ copy [] ] -+parse: ingredient: {name: "", properties: [_: "literal-string"]} ++parse: ingredient: {"": "literal-string"} </pre> </body> </html> diff --git a/html/014literal_noninteger.cc.html b/html/015literal_noninteger.cc.html index eb054c75..4c0f8852 100644 --- a/html/014literal_noninteger.cc.html +++ b/html/015literal_noninteger.cc.html @@ -2,7 +2,7 @@ <html> <head> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> -<title>Mu - 014literal_noninteger.cc</title> +<title>Mu - 015literal_noninteger.cc</title> <meta name="Generator" content="Vim/7.4"> <meta name="plugin-version" content="vim7.4_v1"> <meta name="syntax" content="cpp"> @@ -13,13 +13,13 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.traceContains { color: #008000; } .cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } .Identifier { color: #804000; } .Constant { color: #00a0a0; } -.traceContains { color: #008000; } --> </style> @@ -38,14 +38,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe main [ 1:number <- copy 3.14159 ] -+parse: ingredient: {name: "3.14159", properties: ["3.14159": "literal-number"]} ++parse: ingredient: {"3.14159": "literal-number"} :(after "Parsing reagent(string s)") if (is_noninteger(s)) { name = s; - types.push_back(0); - properties.push_back(pair<string, vector<string> >(name, vector<string>())); - properties.back().second.push_back("literal-number"); + type = new type_tree(0); + properties.push_back(pair<string, string_tree*>(name, new string_tree("literal-number"))); set_value(to_double(s)); return; } @@ -53,7 +52,8 @@ if (is_noninteger( :(code) bool is_noninteger(const string& s) { return s.find_first_not_of("0123456789-.") == string::npos - && s.find('.') != string::npos; + && s.find_first_of ("0123456789-") != string::npos + && std::count(s.begin(), s.end(), '.') == 1; } double to_double(string n) { @@ -63,6 +63,16 @@ double to_double(string n assert(*end == '\0'); return result; } + +void test_is_noninteger() { + CHECK(!is_noninteger("1234")); + CHECK(!is_noninteger("1a2")); + CHECK(is_noninteger("234.0")); + CHECK(!is_noninteger("...")); + CHECK(!is_noninteger(".")); + CHECK(is_noninteger("2.")); + CHECK(is_noninteger(".2")); +} </pre> </body> </html> diff --git a/html/020run.cc.html b/html/020run.cc.html index 92ad8931..38ffeb73 100644 --- a/html/020run.cc.html +++ b/html/020run.cc.html @@ -16,9 +16,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } .SalientComment { color: #00ffff; } .CommentedCode { color: #6c6c6c; } .PreProc { color: #c000c0; } -.traceAbsent { color: #c00000; } .Delimiter { color: #a04060; } .traceContains { color: #008000; } +.traceAbsent { color: #c00000; } .cSpecial { color: #008000; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } @@ -99,10 +99,10 @@ void run_current_routine() // Running One Instruction //? Instructions_running[current_recipe_name()]++; if (current_instruction().is_label) { ++current_step_index(); continue; } - trace(Initial_callstack_depth+Callstack_depth, "run") << current_instruction().to_string() << end(); - if (Memory[0] != 0) { - raise << "something wrote to location 0; this should never happen\n" << end(); - Memory[0] = 0; + trace(Initial_callstack_depth + Trace_stream->callstack_depth, "run") << current_instruction().to_string() << end(); + if (get_or_insert(Memory, 0) != 0) { + raise_error << "something wrote to location 0; this should never happen\n" << end(); + put(Memory, 0, 0); } // Read all ingredients from memory. // Each ingredient loads a vector of values rather than a single value; mu @@ -120,20 +120,6 @@ void run_current_routine() switch (current_instruction().operation) { // Primitive Recipe Implementations case COPY: { - if (SIZE(current_instruction().products) != SIZE(ingredients)) { - raise << "ingredients and products should match in '" << current_instruction().to_string() << "'\n" << end(); - break; - } - for (long long int i = 0; i < SIZE(ingredients); ++i) { - if (!is_mu_array(current_instruction().ingredients.at(i)) && is_mu_array(current_instruction().products.at(i))) { - raise << "can't copy " << current_instruction().ingredients.at(i).original_string << " to array " << current_instruction().products.at(i).original_string << "\n" << end(); - goto finish_instruction; - } - if (is_mu_array(current_instruction().ingredients.at(i)) && !is_mu_array(current_instruction().products.at(i))) { - raise << "can't copy array " << current_instruction().ingredients.at(i).original_string << " to " << current_instruction().products.at(i).original_string << "\n" << end(); - goto finish_instruction; - } - } copy(ingredients.begin(), ingredients.end(), inserter(products, products.begin())); break; } @@ -142,9 +128,8 @@ void run_current_routine() cout << "not a primitive op: " << current_instruction().operation << '\n'; } } - finish_instruction: if (SIZE(products) < SIZE(current_instruction().products)) { - raise << SIZE(products) << " vs " << SIZE(current_instruction().products) << ": failed to write to all products! " << current_instruction().to_string() << end(); + raise_error << SIZE(products) << " vs " << SIZE(current_instruction().products) << ": failed to write to all products! " << current_instruction().to_string() << '\n' << end(); } else { for (long long int i = 0; i < SIZE(current_instruction().products); ++i) { @@ -171,21 +156,23 @@ inline long long int& current_step_index() <s } inline const string& current_recipe_name() { - return Recipe[Current_routine->running_recipe].name; + return get(Recipe, Current_routine->running_recipe).name; } inline const instruction& current_instruction() { - return Recipe[Current_routine->running_recipe].steps.at(Current_routine->running_step_index); + return get(Recipe, Current_routine->running_recipe).steps.at(Current_routine->running_step_index); } inline bool routine::completed() const { - return running_step_index >= SIZE(Recipe[running_recipe].steps); + return running_step_index >= SIZE(get(Recipe, running_recipe).steps); } //:: Startup flow //: Step 1: load all .mu files with numeric prefixes (in order) :(before "End Load Recipes") +//? Trace_file = "interactive"; +//? START_TRACING_UNTIL_END_OF_SCOPE; load_permanently("core.mu"); transform_all(); @@ -203,24 +190,26 @@ if (argc > 1<spa argc--; } transform_all(); - if (Run_tests) Recipe.erase(Recipe_ordinal[string("main")]); +//? dump_recipe("handle-keyboard-event"), exit(0); + if (Run_tests) Recipe.erase(get(Recipe_ordinal, string("main"))); + // End Loading .mu Files } //: Step 3: if we aren't running tests, locate a recipe called 'main' and //: start running it. :(before "End Main") -if (!Run_tests) { +if (!Run_tests && contains_key(Recipe_ordinal, string("main")) && contains_key(Recipe, get(Recipe_ordinal, string("main")))) { setup(); //? Trace_file = "interactive"; //? START_TRACING_UNTIL_END_OF_SCOPE; -//? Trace_stream->collect_layers.insert("app"); + trace(9990, "run") << "=== Starting to run" << end(); run_main(argc, argv); teardown(); } :(code) void run_main(int argc, char* argv[]) { - recipe_ordinal r = Recipe_ordinal[string("main")]; + recipe_ordinal r = get(Recipe_ordinal, string("main")); if (r) run(r); } @@ -261,10 +250,11 @@ void load_permanently(string filename(filename.c_str()); fin.peek(); if (!fin) { - raise << "no such file " << filename << '\n' << end(); + raise_error << "no such file " << filename << '\n' << end(); return; } fin >> std::noskipws; + trace(9990, "load") << "=== " << filename << end(); load(fin); fin.close(); // freeze everything so it doesn't get cleared by tests @@ -292,6 +282,7 @@ void load_all_permanently(string dir} :(before "End Includes") #include<dirent.h> +#include<sys/stat.h> //:: Reading from memory, writing to memory. @@ -305,59 +296,69 @@ vector<double> read_memory(reagent x.value; long long int size = size_of(x); for (long long int offset = 0; offset < size; ++offset) { - double val = Memory[base+offset]; - trace(Primitive_recipe_depth, "mem") << "location " << base+offset << " is " << val << end(); + double val = get_or_insert(Memory, base+offset); + trace(9999, "mem") << "location " << base+offset << " is " << no_scientific(val) << end(); result.push_back(val); } return result; } void write_memory(reagent x, vector<double> data) { + if (!x.type) { + raise_error << "can't write to " << x.to_string() << "; no type\n" << end(); + return; + } if (is_dummy(x)) return; if (is_literal(x)) return; long long int base = x.value; if (size_mismatch(x, data)) { - raise << current_recipe_name() << ": size mismatch in storing to " << x.original_string << " (" << size_of(x.types) << " vs " << SIZE(data) << ") at '" << current_instruction().to_string() << "'\n" << end(); + raise_error << maybe(current_recipe_name()) << "size mismatch in storing to " << x.original_string << " (" << size_of(x.type) << " vs " << SIZE(data) << ") at '" << current_instruction().to_string() << "'\n" << end(); return; } for (long long int offset = 0; offset < SIZE(data); ++offset) { - trace(Primitive_recipe_depth, "mem") << "storing " << data.at(offset) << " in location " << base+offset << end(); - Memory[base+offset] = data.at(offset); + if (base+offset == 0) continue; + trace(9999, "mem") << "storing " << no_scientific(data.at(offset)) << " in location " << base+offset << end(); + put(Memory, base+offset, data.at(offset)); } } :(code) long long int size_of(const reagent& r) { - if (r.types.empty()) return 0; + if (r.type == NULL) return 0; // End size_of(reagent) Cases - return size_of(r.types); + return size_of(r.type); } -long long int size_of(const vector<type_ordinal>& types) { - if (types.empty()) return 0; - // End size_of(types) Cases +long long int size_of(const type_tree* type) { + if (type == NULL) return 0; + // End size_of(type) Cases return 1; } bool size_mismatch(const reagent& x, const vector<double>& data) { - if (x.types.empty()) return true; + if (x.type == NULL) return true; // End size_mismatch(x) Cases //? if (size_of(x) != SIZE(data)) cerr << size_of(x) << " vs " << SIZE(data) << '\n'; return size_of(x) != SIZE(data); } -bool is_dummy(const reagent& x) { +inline bool is_dummy(const reagent& x) { return x.name == "_"; } -bool is_literal(const reagent& r) { - return SIZE(r.types) == 1 && r.types.at(0) == 0; +inline bool is_literal(const reagent& r) { + if (!r.type) return false; + if (r.type->value == 0) + assert(!r.type->left && !r.type->right); + return r.type->value == 0; } -bool is_mu_array(reagent r) { - return !r.types.empty() && r.types.at(0) == Type_ordinal["array"]; +inline bool scalar(const vector<long long int>& x) { + return SIZE(x) == 1; +} +inline bool scalar(const vector<double>& x) { + return SIZE(x) == 1; } -:(code) // helper for tests void run(string form) { vector<recipe_ordinal> tmp = load(form); @@ -383,32 +384,12 @@ recipe main [ +run: _ <- copy 0 :(scenario write_to_0_disallowed) +% Hide_errors = true; recipe main [ - 0 <- copy 34 + 0:number <- copy 34 ] -mem: storing 34 in location 0 -:(scenario copy_checks_reagent_count) -% Hide_warnings = true; -recipe main [ - 1:number <- copy 34, 35 -] -+warn: ingredients and products should match in '1:number <- copy 34, 35' - -:(scenario write_scalar_to_array_disallowed) -% Hide_warnings = true; -recipe main [ - 1:array:number <- copy 34 -] -+warn: can't copy 34 to array 1:array:number - -:(scenario write_scalar_to_array_disallowed_2) -% Hide_warnings = true; -recipe main [ - 1:number, 2:array:number <- copy 34, 35 -] -+warn: can't copy 35 to array 2:array:number - //: mu is robust to various combinations of commas and spaces. You just have //: to put spaces around the '<-'. diff --git a/html/021arithmetic.cc.html b/html/021arithmetic.cc.html deleted file mode 100644 index 7575dd28..00000000 --- a/html/021arithmetic.cc.html +++ /dev/null @@ -1,266 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> -<html> -<head> -<meta http-equiv="content-type" content="text/html; charset=UTF-8"> -<title>Mu - 021arithmetic.cc</title> -<meta name="Generator" content="Vim/7.4"> -<meta name="plugin-version" content="vim7.4_v1"> -<meta name="syntax" content="cpp"> -<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> -<meta name="colorscheme" content="minimal"> -<style type="text/css"> - -</style> - -<script type='text/javascript'> - -</script> -</head> -<body> -<pre id='vimCodeElement'> -//: Arithmetic primitives - -:(before "End Primitive Recipe Declarations") -ADD, -:(before "End Primitive Recipe Numbers") -Recipe_ordinal["add"] = ADD; -:(before "End Primitive Recipe Implementations") -case ADD: { - double result = 0; - for (long long int i = 0; i < SIZE(ingredients); ++i) { - if (!scalar(ingredients.at(i))) { - raise << current_recipe_name() << ": 'add' requires number ingredients, but got " << current_instruction().ingredients.at(i).original_string << '\n' << end(); - goto finish_instruction; - } - result += ingredients.at(i).at(0); - } - products.resize(1); - products.at(0).push_back(result); - break; -} - -:(scenario add_literal) -recipe main [ - 1:number <- add 23, 34 -] -+mem: storing 57 in location 1 - -:(scenario add) -recipe main [ - 1:number <- copy 23 - 2:number <- copy 34 - 3:number <- add 1:number, 2:number -] -+mem: storing 57 in location 3 - -:(scenario add_multiple) -recipe main [ - 1:number <- add 3, 4, 5 -] -+mem: storing 12 in location 1 - -:(before "End Primitive Recipe Declarations") -SUBTRACT, -:(before "End Primitive Recipe Numbers") -Recipe_ordinal["subtract"] = SUBTRACT; -:(before "End Primitive Recipe Implementations") -case SUBTRACT: { - if (ingredients.empty()) { - raise << current_recipe_name() << ": 'subtract' has no ingredients\n" << end(); - break; - } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": 'subtract' requires number ingredients, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); - goto finish_instruction; - } - double result = ingredients.at(0).at(0); - for (long long int i = 1; i < SIZE(ingredients); ++i) { - if (!scalar(ingredients.at(i))) { - raise << current_recipe_name() << ": 'subtract' requires number ingredients, but got " << current_instruction().ingredients.at(i).original_string << '\n' << end(); - goto finish_instruction; - } - result -= ingredients.at(i).at(0); - } - products.resize(1); - products.at(0).push_back(result); - break; -} - -:(scenario subtract_literal) -recipe main [ - 1:number <- subtract 5, 2 -] -+mem: storing 3 in location 1 - -:(scenario subtract) -recipe main [ - 1:number <- copy 23 - 2:number <- copy 34 - 3:number <- subtract 1:number, 2:number -] -+mem: storing -11 in location 3 - -:(scenario subtract_multiple) -recipe main [ - 1:number <- subtract 6, 3, 2 -] -+mem: storing 1 in location 1 - -:(before "End Primitive Recipe Declarations") -MULTIPLY, -:(before "End Primitive Recipe Numbers") -Recipe_ordinal["multiply"] = MULTIPLY; -:(before "End Primitive Recipe Implementations") -case MULTIPLY: { - double result = 1; - for (long long int i = 0; i < SIZE(ingredients); ++i) { - if (!scalar(ingredients.at(i))) { - raise << current_recipe_name() << ": 'multiply' requires number ingredients, but got " << current_instruction().ingredients.at(i).original_string << '\n' << end(); - goto finish_instruction; - } - result *= ingredients.at(i).at(0); - } - products.resize(1); - products.at(0).push_back(result); - break; -} - -:(scenario multiply_literal) -recipe main [ - 1:number <- multiply 2, 3 -] -+mem: storing 6 in location 1 - -:(scenario multiply) -recipe main [ - 1:number <- copy 4 - 2:number <- copy 6 - 3:number <- multiply 1:number, 2:number -] -+mem: storing 24 in location 3 - -:(scenario multiply_multiple) -recipe main [ - 1:number <- multiply 2, 3, 4 -] -+mem: storing 24 in location 1 - -:(before "End Primitive Recipe Declarations") -DIVIDE, -:(before "End Primitive Recipe Numbers") -Recipe_ordinal["divide"] = DIVIDE; -:(before "End Primitive Recipe Implementations") -case DIVIDE: { - if (ingredients.empty()) { - raise << current_recipe_name() << ": 'divide' has no ingredients\n" << end(); - break; - } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": 'divide' requires number ingredients, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); - goto finish_instruction; - } - double result = ingredients.at(0).at(0); - for (long long int i = 1; i < SIZE(ingredients); ++i) { - if (!scalar(ingredients.at(i))) { - raise << current_recipe_name() << ": 'divide' requires number ingredients, but got " << current_instruction().ingredients.at(i).original_string << '\n' << end(); - goto finish_instruction; - } - result /= ingredients.at(i).at(0); - } - products.resize(1); - products.at(0).push_back(result); - break; -} - -:(scenario divide_literal) -recipe main [ - 1:number <- divide 8, 2 -] -+mem: storing 4 in location 1 - -:(scenario divide) -recipe main [ - 1:number <- copy 27 - 2:number <- copy 3 - 3:number <- divide 1:number, 2:number -] -+mem: storing 9 in location 3 - -:(scenario divide_multiple) -recipe main [ - 1:number <- divide 12, 3, 2 -] -+mem: storing 2 in location 1 - -//: Integer division - -:(before "End Primitive Recipe Declarations") -DIVIDE_WITH_REMAINDER, -:(before "End Primitive Recipe Numbers") -Recipe_ordinal["divide-with-remainder"] = DIVIDE_WITH_REMAINDER; -:(before "End Primitive Recipe Implementations") -case DIVIDE_WITH_REMAINDER: { - products.resize(2); - if (SIZE(ingredients) != 2) { - raise << current_recipe_name() << ": 'divide-with-remainder' requires exactly two ingredients, but got '" << current_instruction().to_string() << "'\n" << end(); - break; - } - if (!scalar(ingredients.at(0)) || !scalar(ingredients.at(1))) { - raise << current_recipe_name() << ": 'divide-with-remainder' requires number ingredients, but got '" << current_instruction().to_string() << "'\n" << end(); - goto finish_instruction; - } - long long int quotient = ingredients.at(0).at(0) / ingredients.at(1).at(0); - long long int remainder = static_cast<long long int>(ingredients.at(0).at(0)) % static_cast<long long int>(ingredients.at(1).at(0)); - // very large integers will lose precision - products.at(0).push_back(quotient); - products.at(1).push_back(remainder); - break; -} - -:(scenario divide_with_remainder_literal) -recipe main [ - 1:number, 2:number <- divide-with-remainder 9, 2 -] -+mem: storing 4 in location 1 -+mem: storing 1 in location 2 - -:(scenario divide_with_remainder) -recipe main [ - 1:number <- copy 27 - 2:number <- copy 11 - 3:number, 4:number <- divide-with-remainder 1:number, 2:number -] -+mem: storing 2 in location 3 -+mem: storing 5 in location 4 - -:(scenario divide_with_decimal_point) -recipe main [ - # todo: literal floats? - 1:number <- divide 5, 2 -] -+mem: storing 2.5 in location 1 - -:(code) -inline bool scalar(const vector<long long int>& x) { - return SIZE(x) == 1; -} -inline bool scalar(const vector<double>& x) { - return SIZE(x) == 1; -} -</pre> -</body> -</html> - diff --git a/html/021check_instruction.cc.html b/html/021check_instruction.cc.html new file mode 100644 index 00000000..f0238926 --- /dev/null +++ b/html/021check_instruction.cc.html @@ -0,0 +1,183 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> +<meta http-equiv="content-type" content="text/html; charset=UTF-8"> +<title>Mu - 021check_instruction.cc</title> +<meta name="Generator" content="Vim/7.4"> +<meta name="plugin-version" content="vim7.4_v1"> +<meta name="syntax" content="cpp"> +<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> +<meta name="colorscheme" content="minimal"> +<style type="text/css"> + +</style> + +<script type='text/javascript'> + +</script> +</head> +<body> +<pre id='vimCodeElement'> +//: Introduce a new transform to perform various checks in instructions before +//: we start running them. It'll be extensible, so that we can add checks for +//: new recipes as we extend 'run' to support them. +//: +//: Doing checking in a separate part complicates things, because the values +//: of variables in memory and the processor (current_recipe_name, +//: current_instruction) aren't available at checking time. If I had a more +//: sophisticated layer system I'd introduce the simpler version first and +//: transform it in a separate layer or set of layers. + +:(after "Transform.push_back(update_instruction_operations)") +Transform.push_back(check_instruction); // idempotent + +:(code) +void check_instruction(const recipe_ordinal r) { + trace(9991, "transform") << "--- perform checks for recipe " << get(Recipe, r).name << end(); +//? cerr << "--- perform checks for recipe " << get(Recipe, r).name << '\n'; + map<string, vector<type_ordinal> > metadata; + for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) { + instruction& inst = get(Recipe, r).steps.at(i); + if (inst.is_label) continue; + switch (inst.operation) { + // Primitive Recipe Checks + case COPY: { + if (SIZE(inst.products) != SIZE(inst.ingredients)) { + raise_error << "ingredients and products should match in '" << inst.to_string() << "'\n" << end(); + break; + } + for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { + if (!types_match(inst.products.at(i), inst.ingredients.at(i))) { + raise_error << maybe(get(Recipe, r).name) << "can't copy " << inst.ingredients.at(i).original_string << " to " << inst.products.at(i).original_string << "; types don't match\n" << end(); + goto finish_checking_instruction; + } + } + break; + } + // End Primitive Recipe Checks + default: { + // Defined Recipe Checks + // End Defined Recipe Checks + } + } + finish_checking_instruction:; + } +} + +:(scenario copy_checks_reagent_count) +% Hide_errors = true; +recipe main [ + 1:number <- copy 34, 35 +] ++error: ingredients and products should match in '1:number <- copy 34, 35' + +:(scenario write_scalar_to_array_disallowed) +% Hide_errors = true; +recipe main [ + 1:array:number <- copy 34 +] ++error: main: can't copy 34 to 1:array:number; types don't match + +:(scenario write_scalar_to_array_disallowed_2) +% Hide_errors = true; +recipe main [ + 1:number, 2:array:number <- copy 34, 35 +] ++error: main: can't copy 35 to 2:array:number; types don't match + +:(scenario write_scalar_to_address_disallowed) +% Hide_errors = true; +recipe main [ + 1:address:number <- copy 34 +] ++error: main: can't copy 34 to 1:address:number; types don't match + +:(code) +bool types_match(reagent lhs, reagent rhs) { + // '_' never raises type error + if (is_dummy(lhs)) return true; + // to sidestep type-checking, use /raw in the source. + // this is unsafe, and will be highlighted in red inside vim. just for some tests. + if (is_raw(rhs)) return true; + // allow writing 0 to any address + if (rhs.name == "0" && is_mu_address(lhs)) return true; + if (is_literal(rhs)) return !is_mu_array(lhs) && !is_mu_address(lhs) && size_of(rhs) == size_of(lhs); + if (!lhs.type) return !rhs.type; + return types_match(lhs.type, rhs.type); +} + +// two types match if the second begins like the first +// (trees perform the same check recursively on each subtree) +bool types_match(type_tree* lhs, type_tree* rhs) { + if (!lhs) return true; + if (!rhs || rhs->value == 0) { + if (lhs->value == get(Type_ordinal, "array")) return false; + if (lhs->value == get(Type_ordinal, "address")) return false; + return size_of(rhs) == size_of(lhs); + } + if (lhs->value != rhs->value) return false; + return types_match(lhs->left, rhs->left) && types_match(lhs->right, rhs->right); +} + +// hacky version that allows 0 addresses +bool types_match(const reagent lhs, const type_tree* rhs, const vector<double>& data) { + if (is_dummy(lhs)) return true; + if (rhs->value == 0) { + if (lhs.type->value == get(Type_ordinal, "array")) return false; + if (lhs.type->value == get(Type_ordinal, "address")) return scalar(data) && data.at(0) == 0; + return size_of(rhs) == size_of(lhs); + } + if (lhs.type->value != rhs->value) return false; + return types_match(lhs.type->left, rhs->left) && types_match(lhs.type->right, rhs->right); +} + +bool is_raw(const reagent& r) { + return has_property(r, "raw"); +} + +bool is_mu_array(reagent r) { + if (!r.type) return false; + if (is_literal(r)) return false; + return r.type->value == get(Type_ordinal, "array"); +} + +bool is_mu_address(reagent r) { + if (!r.type) return false; + if (is_literal(r)) return false; + return r.type->value == get(Type_ordinal, "address"); +} + +bool is_mu_number(reagent r) { + if (!r.type) return false; + if (is_literal(r)) + return r.properties.at(0).second->value == "literal-number" + || r.properties.at(0).second->value == "literal"; + if (r.type->value == get(Type_ordinal, "character")) return true; // permit arithmetic on unicode code points + return r.type->value == get(Type_ordinal, "number"); +} + +bool is_mu_scalar(reagent r) { + if (!r.type) return false; + if (is_literal(r)) + return !r.properties.at(0).second || r.properties.at(0).second->value != "literal-string"; + if (is_mu_array(r)) return false; + return size_of(r) == 1; +} +</pre> +</body> +</html> + diff --git a/html/022arithmetic.cc.html b/html/022arithmetic.cc.html new file mode 100644 index 00000000..0a353d6d --- /dev/null +++ b/html/022arithmetic.cc.html @@ -0,0 +1,353 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> +<meta http-equiv="content-type" content="text/html; charset=UTF-8"> +<title>Mu - 022arithmetic.cc</title> +<meta name="Generator" content="Vim/7.4"> +<meta name="plugin-version" content="vim7.4_v1"> +<meta name="syntax" content="cpp"> +<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> +<meta name="colorscheme" content="minimal"> +<style type="text/css"> + +</style> + +<script type='text/javascript'> + +</script> +</head> +<body> +<pre id='vimCodeElement'> +//: Arithmetic primitives + +:(before "End Primitive Recipe Declarations") +ADD, +:(before "End Primitive Recipe Numbers") +put(Recipe_ordinal, "add", ADD); +:(before "End Primitive Recipe Checks") +case ADD: { + // primary goal of these checks is to forbid address arithmetic + for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { + if (!is_mu_number(inst.ingredients.at(i))) { + raise_error << maybe(get(Recipe, r).name) << "'add' requires number ingredients, but got " << inst.ingredients.at(i).original_string << '\n' << end(); + goto finish_checking_instruction; + } + } + if (SIZE(inst.products) > 1) { + raise_error << maybe(get(Recipe, r).name) << "'add' yields exactly one product in '" << inst.to_string() << "'\n" << end(); + break; + } + if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "'add' should yield a number, but got " << inst.products.at(0).original_string << '\n' << end(); + break; + } + break; +} +:(before "End Primitive Recipe Implementations") +case ADD: { + double result = 0; + for (long long int i = 0; i < SIZE(ingredients); ++i) { + result += ingredients.at(i).at(0); + } + products.resize(1); + products.at(0).push_back(result); + break; +} + +:(scenario add_literal) +recipe main [ + 1:number <- add 23, 34 +] ++mem: storing 57 in location 1 + +:(scenario add) +recipe main [ + 1:number <- copy 23 + 2:number <- copy 34 + 3:number <- add 1:number, 2:number +] ++mem: storing 57 in location 3 + +:(scenario add_multiple) +recipe main [ + 1:number <- add 3, 4, 5 +] ++mem: storing 12 in location 1 + +:(scenario add_checks_type) +% Hide_errors = true; +recipe main [ + 1:number <- add 2:boolean, 1 +] ++error: main: 'add' requires number ingredients, but got 2:boolean + +:(scenario add_checks_return_type) +% Hide_errors = true; +recipe main [ + 1:address:number <- add 2, 2 +] ++error: main: 'add' should yield a number, but got 1:address:number + +:(before "End Primitive Recipe Declarations") +SUBTRACT, +:(before "End Primitive Recipe Numbers") +put(Recipe_ordinal, "subtract", SUBTRACT); +:(before "End Primitive Recipe Checks") +case SUBTRACT: { + if (inst.ingredients.empty()) { + raise_error << maybe(get(Recipe, r).name) << "'subtract' has no ingredients\n" << end(); + break; + } + for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { + if (is_raw(inst.ingredients.at(i))) continue; // permit address offset computations in tests + if (!is_mu_number(inst.ingredients.at(i))) { + raise_error << maybe(get(Recipe, r).name) << "'subtract' requires number ingredients, but got " << inst.ingredients.at(i).original_string << '\n' << end(); + goto finish_checking_instruction; + } + } + if (SIZE(inst.products) > 1) { + raise_error << maybe(get(Recipe, r).name) << "'subtract' yields exactly one product in '" << inst.to_string() << "'\n" << end(); + break; + } + if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "'subtract' should yield a number, but got " << inst.products.at(0).original_string << '\n' << end(); + break; + } + break; +} +:(before "End Primitive Recipe Implementations") +case SUBTRACT: { + double result = ingredients.at(0).at(0); + for (long long int i = 1; i < SIZE(ingredients); ++i) + result -= ingredients.at(i).at(0); + products.resize(1); + products.at(0).push_back(result); + break; +} + +:(scenario subtract_literal) +recipe main [ + 1:number <- subtract 5, 2 +] ++mem: storing 3 in location 1 + +:(scenario subtract) +recipe main [ + 1:number <- copy 23 + 2:number <- copy 34 + 3:number <- subtract 1:number, 2:number +] ++mem: storing -11 in location 3 + +:(scenario subtract_multiple) +recipe main [ + 1:number <- subtract 6, 3, 2 +] ++mem: storing 1 in location 1 + +:(before "End Primitive Recipe Declarations") +MULTIPLY, +:(before "End Primitive Recipe Numbers") +put(Recipe_ordinal, "multiply", MULTIPLY); +:(before "End Primitive Recipe Checks") +case MULTIPLY: { + for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { + if (!is_mu_number(inst.ingredients.at(i))) { + raise_error << maybe(get(Recipe, r).name) << "'multiply' requires number ingredients, but got " << inst.ingredients.at(i).original_string << '\n' << end(); + goto finish_checking_instruction; + } + } + if (SIZE(inst.products) > 1) { + raise_error << maybe(get(Recipe, r).name) << "'multiply' yields exactly one product in '" << inst.to_string() << "'\n" << end(); + break; + } + if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "'multiply' should yield a number, but got " << inst.products.at(0).original_string << '\n' << end(); + break; + } + break; +} +:(before "End Primitive Recipe Implementations") +case MULTIPLY: { + double result = 1; + for (long long int i = 0; i < SIZE(ingredients); ++i) { + result *= ingredients.at(i).at(0); + } + products.resize(1); + products.at(0).push_back(result); + break; +} + +:(scenario multiply_literal) +recipe main [ + 1:number <- multiply 2, 3 +] ++mem: storing 6 in location 1 + +:(scenario multiply) +recipe main [ + 1:number <- copy 4 + 2:number <- copy 6 + 3:number <- multiply 1:number, 2:number +] ++mem: storing 24 in location 3 + +:(scenario multiply_multiple) +recipe main [ + 1:number <- multiply 2, 3, 4 +] ++mem: storing 24 in location 1 + +:(before "End Primitive Recipe Declarations") +DIVIDE, +:(before "End Primitive Recipe Numbers") +put(Recipe_ordinal, "divide", DIVIDE); +:(before "End Primitive Recipe Checks") +case DIVIDE: { + if (inst.ingredients.empty()) { + raise_error << maybe(get(Recipe, r).name) << "'divide' has no ingredients\n" << end(); + break; + } + for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { + if (!is_mu_number(inst.ingredients.at(i))) { + raise_error << maybe(get(Recipe, r).name) << "'divide' requires number ingredients, but got " << inst.ingredients.at(i).original_string << '\n' << end(); + goto finish_checking_instruction; + } + } + if (SIZE(inst.products) > 1) { + raise_error << maybe(get(Recipe, r).name) << "'divide' yields exactly one product in '" << inst.to_string() << "'\n" << end(); + break; + } + if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "'divide' should yield a number, but got " << inst.products.at(0).original_string << '\n' << end(); + break; + } + break; +} +:(before "End Primitive Recipe Implementations") +case DIVIDE: { + double result = ingredients.at(0).at(0); + for (long long int i = 1; i < SIZE(ingredients); ++i) + result /= ingredients.at(i).at(0); + products.resize(1); + products.at(0).push_back(result); + break; +} + +:(scenario divide_literal) +recipe main [ + 1:number <- divide 8, 2 +] ++mem: storing 4 in location 1 + +:(scenario divide) +recipe main [ + 1:number <- copy 27 + 2:number <- copy 3 + 3:number <- divide 1:number, 2:number +] ++mem: storing 9 in location 3 + +:(scenario divide_multiple) +recipe main [ + 1:number <- divide 12, 3, 2 +] ++mem: storing 2 in location 1 + +//: Integer division + +:(before "End Primitive Recipe Declarations") +DIVIDE_WITH_REMAINDER, +:(before "End Primitive Recipe Numbers") +put(Recipe_ordinal, "divide-with-remainder", DIVIDE_WITH_REMAINDER); +:(before "End Primitive Recipe Checks") +case DIVIDE_WITH_REMAINDER: { + if (SIZE(inst.ingredients) != 2) { + raise_error << maybe(get(Recipe, r).name) << "'divide-with-remainder' requires exactly two ingredients, but got '" << inst.to_string() << "'\n" << end(); + break; + } + if (!is_mu_number(inst.ingredients.at(0)) || !is_mu_number(inst.ingredients.at(1))) { + raise_error << maybe(get(Recipe, r).name) << "'divide-with-remainder' requires number ingredients, but got '" << inst.to_string() << "'\n" << end(); + break; + } + if (SIZE(inst.products) > 2) { + raise_error << maybe(get(Recipe, r).name) << "'divide-with-remainder' yields two products in '" << inst.to_string() << "'\n" << end(); + break; + } + for (long long int i = 0; i < SIZE(inst.products); ++i) { + if (!is_dummy(inst.products.at(i)) && !is_mu_number(inst.products.at(i))) { + raise_error << maybe(get(Recipe, r).name) << "'divide-with-remainder' should yield a number, but got " << inst.products.at(i).original_string << '\n' << end(); + goto finish_checking_instruction; + } + } + break; +} +:(before "End Primitive Recipe Implementations") +case DIVIDE_WITH_REMAINDER: { + products.resize(2); + long long int a = static_cast<long long int>(ingredients.at(0).at(0)); + long long int b = static_cast<long long int>(ingredients.at(1).at(0)); + if (b == 0) { + raise_error << maybe(current_recipe_name()) << "divide by zero in '" << current_instruction().to_string() << "'\n" << end(); + break; + } + long long int quotient = a / b; + long long int remainder = a % b; + // very large integers will lose precision + products.at(0).push_back(quotient); + products.at(1).push_back(remainder); + break; +} + +:(scenario divide_with_remainder_literal) +recipe main [ + 1:number, 2:number <- divide-with-remainder 9, 2 +] ++mem: storing 4 in location 1 ++mem: storing 1 in location 2 + +:(scenario divide_with_remainder) +recipe main [ + 1:number <- copy 27 + 2:number <- copy 11 + 3:number, 4:number <- divide-with-remainder 1:number, 2:number +] ++mem: storing 2 in location 3 ++mem: storing 5 in location 4 + +:(scenario divide_with_decimal_point) +recipe main [ + 1:number <- divide 5, 2 +] ++mem: storing 2.5 in location 1 + +:(scenario divide_by_zero) +recipe main [ + 1:number <- divide 4, 0 +] ++mem: storing inf in location 1 + +:(scenario divide_by_zero_2) +% Hide_errors = true; +recipe main [ + 1:number <- divide-with-remainder 4, 0 +] +# integer division can't return floating-point infinity ++error: main: divide by zero in '1:number <- divide-with-remainder 4, 0' +</pre> +</body> +</html> + diff --git a/html/022boolean.cc.html b/html/023boolean.cc.html index f1c0b5b2..1daa8686 100644 --- a/html/022boolean.cc.html +++ b/html/023boolean.cc.html @@ -2,7 +2,7 @@ <html> <head> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> -<title>Mu - 022boolean.cc</title> +<title>Mu - 023boolean.cc</title> <meta name="Generator" content="Vim/7.4"> <meta name="plugin-version" content="vim7.4_v1"> <meta name="syntax" content="cpp"> @@ -13,8 +13,8 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.cSpecial { color: #008000; } .traceContains { color: #008000; } +.cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } @@ -36,17 +36,22 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } :(before "End Primitive Recipe Declarations") AND, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["and"] = AND; +put(Recipe_ordinal, "and", AND); +:(before "End Primitive Recipe Checks") +case AND: { + for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { + if (!is_mu_scalar(inst.ingredients.at(i))) { + raise_error << maybe(get(Recipe, r).name) << "'and' requires boolean ingredients, but got " << inst.ingredients.at(i).original_string << '\n' << end(); + goto finish_checking_instruction; + } + } + break; +} :(before "End Primitive Recipe Implementations") case AND: { bool result = true; - for (long long int i = 0; i < SIZE(ingredients); ++i) { - if (!scalar(ingredients.at(i))) { - raise << current_recipe_name() << ": 'and' requires boolean ingredients, but got " << current_instruction().ingredients.at(i).original_string << '\n' << end(); - goto finish_instruction; - } + for (long long int i = 0; i < SIZE(ingredients); ++i) result = result && ingredients.at(i).at(0); - } products.resize(1); products.at(0).push_back(result); break; @@ -81,17 +86,22 @@ recipe main [ :(before "End Primitive Recipe Declarations") OR, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["or"] = OR; +put(Recipe_ordinal, "or", OR); +:(before "End Primitive Recipe Checks") +case OR: { + for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { + if (!is_mu_scalar(inst.ingredients.at(i))) { + raise_error << maybe(get(Recipe, r).name) << "'and' requires boolean ingredients, but got " << inst.ingredients.at(i).original_string << '\n' << end(); + goto finish_checking_instruction; + } + } + break; +} :(before "End Primitive Recipe Implementations") case OR: { bool result = false; - for (long long int i = 0; i < SIZE(ingredients); ++i) { - if (!scalar(ingredients.at(i))) { - raise << current_recipe_name() << ": 'or' requires boolean ingredients, but got " << current_instruction().ingredients.at(i).original_string << '\n' << end(); - goto finish_instruction; - } + for (long long int i = 0; i < SIZE(ingredients); ++i) result = result || ingredients.at(i).at(0); - } products.resize(1); products.at(0).push_back(result); break; @@ -126,15 +136,25 @@ recipe main [ :(before "End Primitive Recipe Declarations") NOT, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["not"] = NOT; +put(Recipe_ordinal, "not", NOT); +:(before "End Primitive Recipe Checks") +case NOT: { + if (SIZE(inst.products) > SIZE(inst.ingredients)) { + raise_error << maybe(get(Recipe, r).name) << "'not' cannot have fewer ingredients than products in '" << inst.to_string() << "'\n" << end(); + break; + } + for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { + if (!is_mu_scalar(inst.ingredients.at(i))) { + raise_error << maybe(get(Recipe, r).name) << "'not' requires boolean ingredients, but got " << inst.ingredients.at(i).original_string << '\n' << end(); + goto finish_checking_instruction; + } + } + break; +} :(before "End Primitive Recipe Implementations") case NOT: { products.resize(SIZE(ingredients)); for (long long int i = 0; i < SIZE(ingredients); ++i) { - if (!scalar(ingredients.at(i))) { - raise << current_recipe_name() << ": 'not' requires boolean ingredients, but got " << current_instruction().ingredients.at(i).original_string << '\n' << end(); - goto finish_instruction; - } products.at(i).push_back(!ingredients.at(i).at(0)); } break; diff --git a/html/023jump.cc.html b/html/024jump.cc.html index 9e239685..8f392805 100644 --- a/html/023jump.cc.html +++ b/html/024jump.cc.html @@ -2,7 +2,7 @@ <html> <head> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> -<title>Mu - 023jump.cc</title> +<title>Mu - 024jump.cc</title> <meta name="Generator" content="Vim/7.4"> <meta name="plugin-version" content="vim7.4_v1"> <meta name="syntax" content="cpp"> @@ -13,6 +13,7 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.traceContains { color: #008000; } .traceAbsent { color: #c00000; } .cSpecial { color: #008000; } .Comment { color: #9090ff; } @@ -20,7 +21,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } .Special { color: #ff6060; } .Identifier { color: #804000; } .Constant { color: #00a0a0; } -.traceContains { color: #008000; } --> </style> @@ -46,26 +46,30 @@ recipe main [ :(before "End Primitive Recipe Declarations") JUMP, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["jump"] = JUMP; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "jump", JUMP); +:(before "End Primitive Recipe Checks") case JUMP: { - if (SIZE(ingredients) != 1) { - raise << current_recipe_name() << ": 'jump' requires exactly one ingredient, but got " << current_instruction().to_string() << '\n' << end(); + if (SIZE(inst.ingredients) != 1) { + raise_error << maybe(get(Recipe, r).name) << "'jump' requires exactly one ingredient, but got " << inst.to_string() << '\n' << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'jump' should be a label or offset, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_scalar(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'jump' should be a label or offset, but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case JUMP: { assert(current_instruction().ingredients.at(0).initialized); current_step_index() += ingredients.at(0).at(0)+1; - trace(Primitive_recipe_depth, "run") << "jumping to instruction " << current_step_index() << end(); + trace(9998, "run") << "jumping to instruction " << current_step_index() << end(); continue; // skip rest of this instruction } //: special type to designate jump targets :(before "End Mu Types Initialization") -Type_ordinal["offset"] = 0; +put(Type_ordinal, "offset", 0); :(scenario jump_backward) recipe main [ @@ -81,28 +85,32 @@ recipe main [ :(before "End Primitive Recipe Declarations") JUMP_IF, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["jump-if"] = JUMP_IF; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "jump-if", JUMP_IF); +:(before "End Primitive Recipe Checks") case JUMP_IF: { - if (SIZE(ingredients) != 2) { - raise << current_recipe_name() << ": 'jump-if' requires exactly two ingredients, but got " << current_instruction().to_string() << '\n' << end(); + if (SIZE(inst.ingredients) != 2) { + raise_error << maybe(get(Recipe, r).name) << "'jump-if' requires exactly two ingredients, but got " << inst.to_string() << '\n' << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": 'jump-if' requires a boolean for its first ingredient, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_scalar(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "'jump-if' requires a boolean for its first ingredient, but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } - if (!scalar(ingredients.at(1))) { - raise << current_recipe_name() << ": 'jump-if' requires a label or offset for its second ingredient, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_scalar(inst.ingredients.at(1))) { + raise_error << maybe(get(Recipe, r).name) << "'jump-if' requires a label or offset for its second ingredient, but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case JUMP_IF: { assert(current_instruction().ingredients.at(1).initialized); if (!ingredients.at(0).at(0)) { - trace(Primitive_recipe_depth, "run") << "jump-if fell through" << end(); + trace(9998, "run") << "jump-if fell through" << end(); break; } current_step_index() += ingredients.at(1).at(0)+1; - trace(Primitive_recipe_depth, "run") << "jumping to instruction " << current_step_index() << end(); + trace(9998, "run") << "jumping to instruction " << current_step_index() << end(); continue; // skip rest of this instruction } @@ -129,28 +137,32 @@ recipe main [ :(before "End Primitive Recipe Declarations") JUMP_UNLESS, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["jump-unless"] = JUMP_UNLESS; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "jump-unless", JUMP_UNLESS); +:(before "End Primitive Recipe Checks") case JUMP_UNLESS: { - if (SIZE(ingredients) != 2) { - raise << current_recipe_name() << ": 'jump-unless' requires exactly two ingredients, but got " << current_instruction().to_string() << '\n' << end(); + if (SIZE(inst.ingredients) != 2) { + raise_error << maybe(get(Recipe, r).name) << "'jump-unless' requires exactly two ingredients, but got " << inst.to_string() << '\n' << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": 'jump-unless' requires a boolean for its first ingredient, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_scalar(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "'jump-unless' requires a boolean for its first ingredient, but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } - if (!scalar(ingredients.at(1))) { - raise << current_recipe_name() << ": 'jump-unless' requires a label or offset for its second ingredient, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_scalar(inst.ingredients.at(1))) { + raise_error << maybe(get(Recipe, r).name) << "'jump-unless' requires a label or offset for its second ingredient, but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case JUMP_UNLESS: { assert(current_instruction().ingredients.at(1).initialized); if (ingredients.at(0).at(0)) { - trace(Primitive_recipe_depth, "run") << "jump-unless fell through" << end(); + trace(9998, "run") << "jump-unless fell through" << end(); break; } current_step_index() += ingredients.at(1).at(0)+1; - trace(Primitive_recipe_depth, "run") << "jumping to instruction " << current_step_index() << end(); + trace(9998, "run") << "jumping to instruction " << current_step_index() << end(); continue; // skip rest of this instruction } diff --git a/html/024compare.cc.html b/html/025compare.cc.html index 1fb7c4a5..9d4fc286 100644 --- a/html/024compare.cc.html +++ b/html/025compare.cc.html @@ -2,7 +2,7 @@ <html> <head> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> -<title>Mu - 024compare.cc</title> +<title>Mu - 025compare.cc</title> <meta name="Generator" content="Vim/7.4"> <meta name="plugin-version" content="vim7.4_v1"> <meta name="syntax" content="cpp"> @@ -13,8 +13,8 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.cSpecial { color: #008000; } .traceContains { color: #008000; } +.cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } @@ -36,13 +36,17 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } :(before "End Primitive Recipe Declarations") EQUAL, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["equal"] = EQUAL; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "equal", EQUAL); +:(before "End Primitive Recipe Checks") case EQUAL: { - if (SIZE(ingredients) <= 1) { - raise << current_recipe_name() << ": 'equal' needs at least two ingredients to compare in '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) <= 1) { + raise_error << maybe(get(Recipe, r).name) << "'equal' needs at least two ingredients to compare in '" << inst.to_string() << "'\n" << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case EQUAL: { vector<double>& exemplar = ingredients.at(0); bool result = true; for (long long int i = 1; i < SIZE(ingredients); ++i) { @@ -91,26 +95,29 @@ recipe main [ :(before "End Primitive Recipe Declarations") GREATER_THAN, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["greater-than"] = GREATER_THAN; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "greater-than", GREATER_THAN); +:(before "End Primitive Recipe Checks") case GREATER_THAN: { - bool result = true; - if (SIZE(ingredients) <= 1) { - raise << current_recipe_name() << ": 'greater-than' needs at least two ingredients to compare in '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) <= 1) { + raise_error << maybe(get(Recipe, r).name) << "'greater-than' needs at least two ingredients to compare in '" << inst.to_string() << "'\n" << end(); break; } - for (long long int i = 0; i < SIZE(ingredients); ++i) { - if (!scalar(ingredients.at(i))) { - raise << current_recipe_name() << ": 'greater-than' can only compare numbers; got " << current_instruction().ingredients.at(i).original_string << '\n' << end(); - goto finish_greater_than; + for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { + if (!is_mu_number(inst.ingredients.at(i))) { + raise_error << maybe(get(Recipe, r).name) << "'greater-than' can only compare numbers; got " << inst.ingredients.at(i).original_string << '\n' << end(); + goto finish_checking_instruction; } } + break; +} +:(before "End Primitive Recipe Implementations") +case GREATER_THAN: { + bool result = true; for (long long int i = /**/1; i < SIZE(ingredients); ++i) { if (ingredients.at(i-1).at(0) <= ingredients.at(i).at(0)) { result = false; } } - finish_greater_than: products.resize(1); products.at(0).push_back(result); break; @@ -147,26 +154,29 @@ recipe main [ :(before "End Primitive Recipe Declarations") LESSER_THAN, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["lesser-than"] = LESSER_THAN; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "lesser-than", LESSER_THAN); +:(before "End Primitive Recipe Checks") case LESSER_THAN: { - bool result = true; - if (SIZE(ingredients) <= 1) { - raise << current_recipe_name() << ": 'lesser-than' needs at least two ingredients to compare in '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) <= 1) { + raise_error << maybe(get(Recipe, r).name) << "'lesser-than' needs at least two ingredients to compare in '" << inst.to_string() << "'\n" << end(); break; } - for (long long int i = 0; i < SIZE(ingredients); ++i) { - if (!scalar(ingredients.at(i))) { - raise << current_recipe_name() << ": 'lesser-than' can only compare numbers; got " << current_instruction().ingredients.at(i).original_string << '\n' << end(); - goto finish_lesser_than; + for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { + if (!is_mu_number(inst.ingredients.at(i))) { + raise_error << maybe(get(Recipe, r).name) << "'lesser-than' can only compare numbers; got " << inst.ingredients.at(i).original_string << '\n' << end(); + goto finish_checking_instruction; } } + break; +} +:(before "End Primitive Recipe Implementations") +case LESSER_THAN: { + bool result = true; for (long long int i = /**/1; i < SIZE(ingredients); ++i) { if (ingredients.at(i-1).at(0) >= ingredients.at(i).at(0)) { result = false; } } - finish_lesser_than: products.resize(1); products.at(0).push_back(result); break; @@ -203,26 +213,29 @@ recipe main [ :(before "End Primitive Recipe Declarations") GREATER_OR_EQUAL, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["greater-or-equal"] = GREATER_OR_EQUAL; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "greater-or-equal", GREATER_OR_EQUAL); +:(before "End Primitive Recipe Checks") case GREATER_OR_EQUAL: { - bool result = true; - if (SIZE(ingredients) <= 1) { - raise << current_recipe_name() << ": 'greater-or-equal' needs at least two ingredients to compare in '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) <= 1) { + raise_error << maybe(get(Recipe, r).name) << "'greater-or-equal' needs at least two ingredients to compare in '" << inst.to_string() << "'\n" << end(); break; } - for (long long int i = 0; i < SIZE(ingredients); ++i) { - if (!scalar(ingredients.at(i))) { - raise << current_recipe_name() << ": 'greater-or-equal' can only compare numbers; got " << current_instruction().ingredients.at(i).original_string << '\n' << end(); - goto finish_greater_or_equal; + for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { + if (!is_mu_number(inst.ingredients.at(i))) { + raise_error << maybe(get(Recipe, r).name) << "'greater-or-equal' can only compare numbers; got " << inst.ingredients.at(i).original_string << '\n' << end(); + goto finish_checking_instruction; } } + break; +} +:(before "End Primitive Recipe Implementations") +case GREATER_OR_EQUAL: { + bool result = true; for (long long int i = /**/1; i < SIZE(ingredients); ++i) { if (ingredients.at(i-1).at(0) < ingredients.at(i).at(0)) { result = false; } } - finish_greater_or_equal: products.resize(1); products.at(0).push_back(result); break; @@ -267,26 +280,29 @@ recipe main [ :(before "End Primitive Recipe Declarations") LESSER_OR_EQUAL, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["lesser-or-equal"] = LESSER_OR_EQUAL; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "lesser-or-equal", LESSER_OR_EQUAL); +:(before "End Primitive Recipe Checks") case LESSER_OR_EQUAL: { - bool result = true; - if (SIZE(ingredients) <= 1) { - raise << current_recipe_name() << ": 'lesser-or-equal' needs at least two ingredients to compare in '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) <= 1) { + raise_error << maybe(get(Recipe, r).name) << "'lesser-or-equal' needs at least two ingredients to compare in '" << inst.to_string() << "'\n" << end(); break; } - for (long long int i = 0; i < SIZE(ingredients); ++i) { - if (!scalar(ingredients.at(i))) { - raise << current_recipe_name() << ": 'lesser-or-equal' can only compare numbers; got " << current_instruction().ingredients.at(i).original_string << '\n' << end(); - goto finish_lesser_or_equal; + for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { + if (!is_mu_number(inst.ingredients.at(i))) { + raise_error << maybe(get(Recipe, r).name) << "'lesser-or-equal' can only compare numbers; got " << inst.ingredients.at(i).original_string << '\n' << end(); + goto finish_checking_instruction; } } + break; +} +:(before "End Primitive Recipe Implementations") +case LESSER_OR_EQUAL: { + bool result = true; for (long long int i = /**/1; i < SIZE(ingredients); ++i) { if (ingredients.at(i-1).at(0) > ingredients.at(i).at(0)) { result = false; } } - finish_lesser_or_equal: products.resize(1); products.at(0).push_back(result); break; diff --git a/html/029tools.cc.html b/html/029tools.cc.html index 77e709c2..018e0f01 100644 --- a/html/029tools.cc.html +++ b/html/029tools.cc.html @@ -13,12 +13,12 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.cSpecial { color: #008000; } +.traceContains { color: #008000; } .SalientComment { color: #00ffff; } -.Special { color: #ff6060; } +.cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } -.traceContains { color: #008000; } +.Special { color: #ff6060; } .Identifier { color: #804000; } .Constant { color: #00a0a0; } --> @@ -43,22 +43,26 @@ recipe main [ :(before "End Primitive Recipe Declarations") TRACE, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["trace"] = TRACE; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "trace", TRACE); +:(before "End Primitive Recipe Checks") case TRACE: { - if (SIZE(current_instruction().ingredients) < 3) { - raise << current_recipe_name() << ": 'trace' takes three or more ingredients rather than '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) < 3) { + raise_error << maybe(get(Recipe, r).name) << "'trace' takes three or more ingredients rather than '" << inst.to_string() << "'\n" << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'trace' should be a number (depth), but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_number(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'trace' should be a number (depth), but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } - long long int depth = ingredients.at(0).at(0); - if (!is_literal_string(current_instruction().ingredients.at(1))) { - raise << current_recipe_name() << ": second ingredient of 'trace' should be a literal string (label), but got " << current_instruction().ingredients.at(1).original_string << '\n' << end(); + if (!is_literal_string(inst.ingredients.at(1))) { + raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'trace' should be a literal string (label), but got " << inst.ingredients.at(1).original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case TRACE: { + long long int depth = ingredients.at(0).at(0); string label = current_instruction().ingredients.at(1).name; ostringstream out; for (long long int i = 2; i < SIZE(current_instruction().ingredients); ++i) { @@ -73,14 +77,18 @@ case TRACE: { :(before "End Primitive Recipe Declarations") STASH, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["stash"] = STASH; +put(Recipe_ordinal, "stash", STASH); +:(before "End Primitive Recipe Checks") +case STASH: { + break; +} :(before "End Primitive Recipe Implementations") case STASH: { ostringstream out; for (long long int i = 0; i < SIZE(current_instruction().ingredients); ++i) { out << print_mu(current_instruction().ingredients.at(i), ingredients.at(i)); } - trace(1, "app") << out.str() << end(); + trace(2, "app") << out.str() << end(); break; } @@ -110,63 +118,53 @@ string print_mu(const reagent& r// End print Special-cases(reagent r, data) ostringstream out; for (long long i = 0; i < SIZE(data); ++i) { - out << data.at(i) << ' '; + out << no_scientific(data.at(i)) << ' '; } return out.str(); } :(before "End Primitive Recipe Declarations") -HIDE_WARNINGS, +HIDE_ERRORS, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["hide-warnings"] = HIDE_WARNINGS; +put(Recipe_ordinal, "hide-errors", HIDE_ERRORS); +:(before "End Primitive Recipe Checks") +case HIDE_ERRORS: { + break; +} :(before "End Primitive Recipe Implementations") -case HIDE_WARNINGS: { +case HIDE_ERRORS: { + Hide_errors = true; Hide_warnings = true; break; } :(before "End Primitive Recipe Declarations") -SHOW_WARNINGS, +SHOW_ERRORS, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["show-warnings"] = SHOW_WARNINGS; -:(before "End Primitive Recipe Implementations") -case SHOW_WARNINGS: { - Hide_warnings = false; +put(Recipe_ordinal, "show-errors", SHOW_ERRORS); +:(before "End Primitive Recipe Checks") +case SHOW_ERRORS: { break; } - -:(before "End Primitive Recipe Declarations") -_START_TRACING, -:(before "End Primitive Recipe Numbers") -Recipe_ordinal["$start-tracing"] = _START_TRACING; :(before "End Primitive Recipe Implementations") -case _START_TRACING: { - if (current_instruction().ingredients.empty()) - Trace_stream->dump_layer = "all"; - else - Trace_stream->dump_layer = current_instruction().ingredients.at(0).name; +case SHOW_ERRORS: { + Hide_errors = false; + Hide_warnings = false; break; } :(before "End Primitive Recipe Declarations") -_STOP_TRACING, +TRACE_UNTIL, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$stop-tracing"] = _STOP_TRACING; -:(before "End Primitive Recipe Implementations") -case _STOP_TRACING: { - Trace_stream->dump_layer = ""; +put(Recipe_ordinal, "trace-until", TRACE_UNTIL); +:(before "End Primitive Recipe Checks") +case TRACE_UNTIL: { break; } - -:(before "End Primitive Recipe Declarations") -_CLOSE_TRACE, -:(before "End Primitive Recipe Numbers") -Recipe_ordinal["$close-trace"] = _CLOSE_TRACE; :(before "End Primitive Recipe Implementations") -case _CLOSE_TRACE: { +case TRACE_UNTIL: { if (Trace_stream) { - delete Trace_stream; - Trace_stream = NULL; + Trace_stream->collect_depth = ingredients.at(0).at(0); } break; } @@ -174,7 +172,11 @@ case _CLOSE_TRACE: { :(before "End Primitive Recipe Declarations") _DUMP_TRACE, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$dump-trace"] = _DUMP_TRACE; +put(Recipe_ordinal, "$dump-trace", _DUMP_TRACE); +:(before "End Primitive Recipe Checks") +case _DUMP_TRACE: { + break; +} :(before "End Primitive Recipe Implementations") case _DUMP_TRACE: { if (ingredients.empty()) { @@ -189,42 +191,68 @@ case _DUMP_TRACE: { :(before "End Primitive Recipe Declarations") _CLEAR_TRACE, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$clear-trace"] = _CLEAR_TRACE; +put(Recipe_ordinal, "$clear-trace", _CLEAR_TRACE); +:(before "End Primitive Recipe Checks") +case _CLEAR_TRACE: { + break; +} :(before "End Primitive Recipe Implementations") case _CLEAR_TRACE: { - CLEAR_TRACE; + if (Trace_stream) Trace_stream->past_lines.clear(); + break; +} + +:(before "End Primitive Recipe Declarations") +_SAVE_TRACE, +:(before "End Primitive Recipe Numbers") +put(Recipe_ordinal, "$save-trace", _SAVE_TRACE); +:(before "End Primitive Recipe Checks") +case _SAVE_TRACE: { + break; +} +:(before "End Primitive Recipe Implementations") +case _SAVE_TRACE: { + if (!Trace_file.empty()) { + ofstream fout((Trace_dir+Trace_file).c_str()); + fout << Trace_stream->readable_contents(""); + fout.close(); + } break; } //: assert: perform sanity checks at runtime :(scenario assert) -% Hide_warnings = true; // '%' lines insert arbitrary C code into tests before calling 'run' with the lines below. Must be immediately after :(scenario) line. +% Hide_errors = true; // '%' lines insert arbitrary C code into tests before calling 'run' with the lines below. Must be immediately after :(scenario) line. recipe main [ assert 0, [this is an assert in mu] ] -+warn: this is an assert in mu ++error: this is an assert in mu :(before "End Primitive Recipe Declarations") ASSERT, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["assert"] = ASSERT; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "assert", ASSERT); +:(before "End Primitive Recipe Checks") case ASSERT: { - if (SIZE(ingredients) != 2) { - raise << current_recipe_name() << ": 'assert' takes exactly two ingredients rather than '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) != 2) { + raise_error << maybe(get(Recipe, r).name) << "'assert' takes exactly two ingredients rather than '" << inst.to_string() << "'\n" << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": 'assert' requires a boolean for its first ingredient, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_scalar(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "'assert' requires a boolean for its first ingredient, but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } - if (!scalar(ingredients.at(1))) { - raise << current_recipe_name() << ": 'assert' requires a literal string for its second ingredient, but got " << current_instruction().ingredients.at(1).original_string << '\n' << end(); + if (!is_literal_string(inst.ingredients.at(1))) { + raise_error << maybe(get(Recipe, r).name) << "'assert' requires a literal string for its second ingredient, but got " << inst.ingredients.at(1).original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case ASSERT: { if (!ingredients.at(0).at(0)) { - raise << current_instruction().ingredients.at(1).name << '\n' << end(); + raise_error << current_instruction().ingredients.at(1).name << '\n' << end(); } break; } @@ -234,12 +262,16 @@ case ASSERT: { :(before "End Primitive Recipe Declarations") _PRINT, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$print"] = _PRINT; +put(Recipe_ordinal, "$print", _PRINT); +:(before "End Primitive Recipe Checks") +case _PRINT: { + break; +} :(before "End Primitive Recipe Implementations") case _PRINT: { for (long long int i = 0; i < SIZE(ingredients); ++i) { if (is_literal(current_instruction().ingredients.at(i))) { - trace(Primitive_recipe_depth, "run") << "$print: " << current_instruction().ingredients.at(i).name << end(); + trace(9998, "run") << "$print: " << current_instruction().ingredients.at(i).name << end(); if (has_property(current_instruction().ingredients.at(i), "newline")) cout << '\n'; else @@ -247,9 +279,9 @@ case _PRINT: { } else { for (long long int j = 0; j < SIZE(ingredients.at(i)); ++j) { - trace(Primitive_recipe_depth, "run") << "$print: " << ingredients.at(i).at(j) << end(); + trace(9998, "run") << "$print: " << ingredients.at(i).at(j) << end(); if (j > 0) cout << " "; - cout << ingredients.at(i).at(j); + cout << no_scientific(ingredients.at(i).at(j)); } } } @@ -259,7 +291,11 @@ case _PRINT: { :(before "End Primitive Recipe Declarations") _EXIT, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$exit"] = _EXIT; +put(Recipe_ordinal, "$exit", _EXIT); +:(before "End Primitive Recipe Checks") +case _EXIT: { + break; +} :(before "End Primitive Recipe Implementations") case _EXIT: { exit(0); @@ -269,25 +305,31 @@ case _EXIT: { :(before "End Primitive Recipe Declarations") _SYSTEM, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$system"] = _SYSTEM; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "$system", _SYSTEM); +:(before "End Primitive Recipe Checks") case _SYSTEM: { - if (current_instruction().ingredients.empty()) { - raise << current_recipe_name() << ": '$system' requires exactly one ingredient, but got none\n" << end(); + if (SIZE(inst.ingredients) != 1) { + raise_error << maybe(get(Recipe, r).name) << "'$system' requires exactly one ingredient, but got none\n" << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case _SYSTEM: { int status = system(current_instruction().ingredients.at(0).name.c_str()); products.resize(1); products.at(0).push_back(status); break; } -//:: helpers for debugging - :(before "End Primitive Recipe Declarations") _DUMP_MEMORY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$dump-memory"] = _DUMP_MEMORY; +put(Recipe_ordinal, "$dump-memory", _DUMP_MEMORY); +:(before "End Primitive Recipe Checks") +case _DUMP_MEMORY: { + break; +} :(before "End Primitive Recipe Implementations") case _DUMP_MEMORY: { dump_memory(); diff --git a/html/030container.cc.html b/html/030container.cc.html index 7d0d4a26..403c6a60 100644 --- a/html/030container.cc.html +++ b/html/030container.cc.html @@ -13,15 +13,15 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.traceContains { color: #008000; } .SalientComment { color: #00ffff; } -.traceAbsent { color: #c00000; } .cSpecial { color: #008000; } +.traceAbsent { color: #c00000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } .Identifier { color: #804000; } .Constant { color: #00a0a0; } -.traceContains { color: #008000; } --> </style> @@ -37,21 +37,21 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } :(before "End Mu Types Initialization") //: We'll use this container as a running example, with two number elements. -type_ordinal point = Type_ordinal["point"] = Next_type_ordinal++; -Type[point].size = 2; -Type[point].kind = container; -Type[point].name = "point"; -vector<type_ordinal> i; -i.push_back(number); -Type[point].elements.push_back(i); -Type[point].elements.push_back(i); +type_ordinal point = put(Type_ordinal, "point", Next_type_ordinal++); +get_or_insert(Type, point).size = 2; +get(Type, point).kind = CONTAINER; +get(Type, point).name = "point"; +get(Type, point).elements.push_back(new type_tree(number)); +get(Type, point).element_names.push_back("x"); +get(Type, point).elements.push_back(new type_tree(number)); +get(Type, point).element_names.push_back("y"); //: Containers can be copied around with a single instruction just like //: numbers, no matter how large they are. //: Tests in this layer often explicitly setup memory before reading it as a //: container. Don't do this in general. I'm tagging exceptions with /raw to -//: avoid warnings. +//: avoid errors. :(scenario copy_multiple_locations) recipe main [ 1:number <- copy 34 @@ -61,27 +61,25 @@ recipe main [ +mem: storing 34 in location 3 +mem: storing 35 in location 4 -//: trying to copy to a differently-sized destination will fail +//: trying to copy to a differently-typed destination will fail :(scenario copy_checks_size) -% Hide_warnings = true; +% Hide_errors = true; recipe main [ 2:point <- copy 1:number ] -+warn: main: size mismatch in storing to 2:point (2 vs 1) at '2:point <- copy 1:number' ++error: main: can't copy 1:number to 2:point; types don't match :(before "End Mu Types Initialization") // A more complex container, containing another container as one of its // elements. -type_ordinal point_number = Type_ordinal["point-number"] = Next_type_ordinal++; -Type[point_number].size = 2; -Type[point_number].kind = container; -Type[point_number].name = "point-number"; -vector<type_ordinal> p2; -p2.push_back(point); -Type[point_number].elements.push_back(p2); -vector<type_ordinal> i2; -i2.push_back(number); -Type[point_number].elements.push_back(i2); +type_ordinal point_number = put(Type_ordinal, "point-number", Next_type_ordinal++); +get_or_insert(Type, point_number).size = 2; +get(Type, point_number).kind = CONTAINER; +get(Type, point_number).name = "point-number"; +get(Type, point_number).elements.push_back(new type_tree(point)); +get(Type, point_number).element_names.push_back("xy"); +get(Type, point_number).elements.push_back(new type_tree(number)); +get(Type, point_number).element_names.push_back("z"); :(scenario copy_handles_nested_container_elements) recipe main [ @@ -119,17 +117,26 @@ recipe main [ ] +mem: storing 0 in location 7 -:(before "End size_of(types) Cases") -type_info t = Type[types.at(0)]; -if (t.kind == container) { +:(before "End size_of(type) Cases") +if (type->value == -1) { + // error value, but we'll raise it elsewhere + return 1; +} +if (type->value == 0) { + assert(!type->left && !type->right); + return 1; +} +type_info t = get(Type, type->value); +if (t.kind == CONTAINER) { // size of a container is the sum of the sizes of its elements long long int result = 0; for (long long int i = 0; i < SIZE(t.elements); ++i) { // todo: strengthen assertion to disallow mutual type recursion - if (types.at(0) == t.elements.at(i).at(0)) { - raise << "container " << t.name << " can't include itself as a member\n" << end(); + if (t.elements.at(i)->value == type->value) { + raise_error << "container " << t.name << " can't include itself as a member\n" << end(); return 0; } + // End size_of(type) Container Cases result += size_of(t.elements.at(i)); } return result; @@ -156,48 +163,81 @@ recipe main [ :(before "End Primitive Recipe Declarations") GET, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["get"] = GET; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "get", GET); +:(before "End Primitive Recipe Checks") case GET: { - if (SIZE(ingredients) != 2) { - raise << current_recipe_name() << ": 'get' expects exactly 2 ingredients in '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) != 2) { + raise_error << maybe(get(Recipe, r).name) << "'get' expects exactly 2 ingredients in '" << inst.to_string() << "'\n" << end(); break; } - reagent base = current_instruction().ingredients.at(0); - long long int base_address = base.value; - if (base_address == 0) { - raise << current_recipe_name() << ": tried to access location 0 in '" << current_instruction().to_string() << "'\n" << end(); + reagent base = inst.ingredients.at(0); // new copy for every invocation + // Update GET base in Check + if (!base.type || !base.type->value || get(Type, base.type->value).kind != CONTAINER) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'get' should be a container, but got " << inst.ingredients.at(0).original_string << '\n' << end(); + break; + } + type_ordinal base_type = base.type->value; + reagent offset = inst.ingredients.at(1); + if (!is_literal(offset) || !is_mu_scalar(offset)) { + raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'get' should have type 'offset', but got " << inst.ingredients.at(1).original_string << '\n' << end(); + break; + } + long long int offset_value = 0; + if (is_integer(offset.name)) // later layers permit non-integer offsets + offset_value = to_integer(offset.name); + else + offset_value = offset.value; + if (offset_value < 0 || offset_value >= SIZE(get(Type, base_type).elements)) { + raise_error << maybe(get(Recipe, r).name) << "invalid offset " << offset_value << " for " << get(Type, base_type).name << '\n' << end(); break; } - if (base.types.empty() || Type[base.types.at(0)].kind != container) { - raise << current_recipe_name () << ": first ingredient of 'get' should be a container, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + reagent product = inst.products.at(0); + // Update GET product in Check + const reagent element = element_type(base, offset_value); + if (!types_match(product, element)) { + raise_error << maybe(get(Recipe, r).name) << "'get' " << offset.original_string << " (" << offset_value << ") on " << get(Type, base_type).name << " can't be saved in " << product.original_string << "; type should be " << debug_string(element.type) << " but is " << debug_string(product.type) << '\n' << end(); break; } - type_ordinal base_type = base.types.at(0); - if (!is_literal(current_instruction().ingredients.at(1))) { - raise << current_recipe_name() << ": second ingredient of 'get' should have type 'offset', but got " << current_instruction().ingredients.at(1).original_string << '\n' << end(); + break; +} +:(before "End Primitive Recipe Implementations") +case GET: { + reagent base = current_instruction().ingredients.at(0); + // Update GET base in Run + long long int base_address = base.value; + if (base_address == 0) { + raise_error << maybe(current_recipe_name()) << "tried to access location 0 in '" << current_instruction().to_string() << "'\n" << end(); break; } - assert(scalar(ingredients.at(1))); + type_ordinal base_type = base.type->value; long long int offset = ingredients.at(1).at(0); + if (offset < 0 || offset >= SIZE(get(Type, base_type).elements)) break; // copied from Check above long long int src = base_address; for (long long int i = 0; i < offset; ++i) { - src += size_of(Type[base_type].elements.at(i)); + // End GET field Cases + src += size_of(get(Type, base_type).elements.at(i)); } - trace(Primitive_recipe_depth, "run") << "address to copy is " << src << end(); - if (offset < 0 || offset >= SIZE(Type[base_type].elements)) { - raise << current_recipe_name() << ": invalid offset " << offset << " for " << Type[base_type].name << '\n' << end(); - break; - } - type_ordinal src_type = Type[base_type].elements.at(offset).at(0); - trace(Primitive_recipe_depth, "run") << "its type is " << Type[src_type].name << end(); - reagent tmp; + trace(9998, "run") << "address to copy is " << src << end(); + reagent tmp = element_type(base, offset); tmp.set_value(src); - tmp.types.push_back(src_type); + trace(9998, "run") << "its type is " << debug_string(tmp.type) << end(); products.push_back(read_memory(tmp)); break; } +:(code) +const reagent element_type(const reagent& canonized_base, long long int offset_value) { + assert(offset_value >= 0); + assert(contains_key(Type, canonized_base.type->value)); + assert(!get(Type, canonized_base.type->value).name.empty()); + const type_info& info = get(Type, canonized_base.type->value); + assert(info.kind == CONTAINER); + reagent element; + element.type = new type_tree(*info.elements.at(offset_value)); + // End element_type Special-cases + return element; +} + :(scenario get_handles_nested_container_elements) recipe main [ 12:number <- copy 34 @@ -207,92 +247,143 @@ recipe main [ ] +mem: storing 36 in location 15 -//:: To write to elements of containers, you need their address. - -:(scenario get_address) +:(scenario get_out_of_bounds) +% Hide_errors = true; recipe main [ 12:number <- copy 34 13:number <- copy 35 - 15:address:number <- get-address 12:point/raw, 1:offset # unsafe + 14:number <- copy 36 + get 12:point-number/raw, 2:offset # point-number occupies 3 locations but has only 2 fields; out of bounds ] -+mem: storing 13 in location 15 ++error: main: invalid offset 2 for point-number -:(scenario get_out_of_bounds) -% Hide_warnings = true; +:(scenario get_out_of_bounds_2) +% Hide_errors = true; recipe main [ 12:number <- copy 34 13:number <- copy 35 14:number <- copy 36 - get 12:point-number/raw, 2:offset # point-number occupies 3 locations but has only 2 fields; out of bounds + get 12:point-number/raw, -1:offset ] -+warn: main: invalid offset 2 for point-number ++error: main: invalid offset -1 for point-number -:(scenario get_out_of_bounds_2) -% Hide_warnings = true; +:(scenario get_product_type_mismatch) +% Hide_errors = true; recipe main [ 12:number <- copy 34 13:number <- copy 35 14:number <- copy 36 - get 12:point-number/raw, -1:offset + 15:address:number <- get 12:point-number/raw, 1:offset +] ++error: main: 'get' 1:offset (1) on point-number can't be saved in 15:address:number; type should be number but is <address : <number : <>>> + +//:: To write to elements of containers, you need their address. + +:(scenario get_address) +recipe main [ + 12:number <- copy 34 + 13:number <- copy 35 + 15:address:number <- get-address 12:point/raw, 1:offset # unsafe ] -+warn: main: invalid offset -1 for point-number ++mem: storing 13 in location 15 :(before "End Primitive Recipe Declarations") GET_ADDRESS, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["get-address"] = GET_ADDRESS; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "get-address", GET_ADDRESS); +:(before "End Primitive Recipe Checks") case GET_ADDRESS: { - reagent base = current_instruction().ingredients.at(0); - long long int base_address = base.value; - if (base_address == 0) { - raise << current_recipe_name() << ": tried to access location 0 in '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) != 2) { + raise_error << maybe(get(Recipe, r).name) << "'get-address' expects exactly 2 ingredients in '" << inst.to_string() << "'\n" << end(); break; } - if (base.types.empty() || Type[base.types.at(0)].kind != container) { - raise << current_recipe_name () << ": first ingredient of 'get-address' should be a container, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + reagent base = inst.ingredients.at(0); + // Update GET_ADDRESS base in Check + if (!base.type || get(Type, base.type->value).kind != CONTAINER) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'get-address' should be a container, but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } - type_ordinal base_type = base.types.at(0); - if (!is_literal(current_instruction().ingredients.at(1))) { - raise << current_recipe_name() << ": second ingredient of 'get-address' should have type 'offset', but got " << current_instruction().ingredients.at(1).original_string << '\n' << end(); + type_ordinal base_type = base.type->value; + reagent offset = inst.ingredients.at(1); + if (!is_literal(offset) || !is_mu_scalar(offset)) { + raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'get' should have type 'offset', but got " << inst.ingredients.at(1).original_string << '\n' << end(); break; } - assert(scalar(ingredients.at(1))); - long long int offset = ingredients.at(1).at(0); - if (offset < 0 || offset >= SIZE(Type[base_type].elements)) { - raise << "invalid offset " << offset << " for " << Type[base_type].name << '\n' << end(); + long long int offset_value = 0; + if (is_integer(offset.name)) { // later layers permit non-integer offsets + offset_value = to_integer(offset.name); + if (offset_value < 0 || offset_value >= SIZE(get(Type, base_type).elements)) { + raise_error << maybe(get(Recipe, r).name) << "invalid offset " << offset_value << " for " << get(Type, base_type).name << '\n' << end(); + break; + } + } + else { + offset_value = offset.value; + } + reagent product = inst.products.at(0); + // Update GET_ADDRESS product in Check + // same type as for GET.. + reagent element = element_type(base, offset_value); + // ..except for an address at the start + element.type = new type_tree(get(Type_ordinal, "address"), element.type); + if (!types_match(product, element)) { + raise_error << maybe(get(Recipe, r).name) << "'get-address' " << offset.original_string << " (" << offset_value << ") on " << get(Type, base_type).name << " can't be saved in " << product.original_string << "; type should be " << debug_string(element.type) << '\n' << end(); + break; + } + break; +} +:(before "End Primitive Recipe Implementations") +case GET_ADDRESS: { + reagent base = current_instruction().ingredients.at(0); + // Update GET_ADDRESS base in Run + long long int base_address = base.value; + if (base_address == 0) { + raise_error << maybe(current_recipe_name()) << "tried to access location 0 in '" << current_instruction().to_string() << "'\n" << end(); break; } + type_ordinal base_type = base.type->value; + long long int offset = ingredients.at(1).at(0); + if (offset < 0 || offset >= SIZE(get(Type, base_type).elements)) break; // copied from Check above long long int result = base_address; for (long long int i = 0; i < offset; ++i) { - result += size_of(Type[base_type].elements.at(i)); + // End GET_ADDRESS field Cases + result += size_of(get(Type, base_type).elements.at(i)); } - trace(Primitive_recipe_depth, "run") << "address to copy is " << result << end(); + trace(9998, "run") << "address to copy is " << result << end(); products.resize(1); products.at(0).push_back(result); break; } :(scenario get_address_out_of_bounds) -% Hide_warnings = true; +% Hide_errors = true; recipe main [ 12:number <- copy 34 13:number <- copy 35 14:number <- copy 36 get-address 12:point-number/raw, 2:offset # point-number occupies 3 locations but has only 2 fields; out of bounds ] -+warn: invalid offset 2 for point-number ++error: main: invalid offset 2 for point-number :(scenario get_address_out_of_bounds_2) -% Hide_warnings = true; +% Hide_errors = true; recipe main [ 12:number <- copy 34 13:number <- copy 35 14:number <- copy 36 get-address 12:point-number/raw, -1:offset ] -+warn: invalid offset -1 for point-number ++error: main: invalid offset -1 for point-number + +:(scenario get_address_product_type_mismatch) +% Hide_errors = true; +recipe main [ + 12:number <- copy 34 + 13:number <- copy 35 + 14:number <- copy 36 + 15:number <- get-address 12:point-number/raw, 1:offset +] ++error: main: 'get-address' 1:offset (1) on point-number can't be saved in 15:number; type should be <address : <number : <>>> //:: Allow containers to be defined in mu code. @@ -302,11 +393,11 @@ container foo [ x:number y:number ] -+parse: reading container foo -+parse: element name: x -+parse: type: 1 -+parse: element name: y -+parse: type: 1 ++parse: --- defining container foo ++parse: element name: x ++parse: type: 1 ++parse: element name: y ++parse: type: 1 :(scenario container_use_before_definition) container foo [ @@ -318,57 +409,66 @@ container bar [ x:number y:number ] -+parse: reading container foo ++parse: --- defining container foo +parse: type number: 1000 +parse: element name: x +parse: type: 1 +parse: element name: y +parse: type: 1001 -+parse: reading container bar ++parse: --- defining container bar +parse: type number: 1001 :(before "End Command Handlers") else if (command == "container") { - insert_container(command, container, in); + insert_container(command, CONTAINER, in); } :(code) void insert_container(const string& command, kind_of_type kind, istream& in) { skip_whitespace(in); string name = next_word(in); - trace("parse") << "reading " << command << ' ' << name << end(); - if (Type_ordinal.find(name) == Type_ordinal.end() - || Type_ordinal[name] == 0) { - Type_ordinal[name] = Next_type_ordinal++; + // End container Name Refinements + trace(9991, "parse") << "--- defining " << command << ' ' << name << end(); + if (!contains_key(Type_ordinal, name) + || get(Type_ordinal, name) == 0) { + put(Type_ordinal, name, Next_type_ordinal++); } - trace("parse") << "type number: " << Type_ordinal[name] << end(); + trace(9999, "parse") << "type number: " << get(Type_ordinal, name) << end(); skip_bracket(in, "'container' must begin with '['"); - type_info& t = Type[Type_ordinal[name]]; - recently_added_types.push_back(Type_ordinal[name]); - t.name = name; - t.kind = kind; + type_info& info = get_or_insert(Type, get(Type_ordinal, name)); + recently_added_types.push_back(get(Type_ordinal, name)); + info.name = name; + info.kind = kind; while (!in.eof()) { skip_whitespace_and_comments(in); string element = next_word(in); if (element == "]") break; + // End insert_container Special Definitions(element) istringstream inner(element); - t.element_names.push_back(slurp_until(inner, ':')); - trace("parse") << " element name: " << t.element_names.back() << end(); - vector<type_ordinal> types; - while (!inner.eof()) { + info.element_names.push_back(slurp_until(inner, ':')); + trace(9993, "parse") << " element name: " << info.element_names.back() << end(); + type_tree* new_type = NULL; + for (type_tree** curr_type = &new_type; !inner.eof(); curr_type = &(*curr_type)->right) { string type_name = slurp_until(inner, ':'); - if (Type_ordinal.find(type_name) == Type_ordinal.end() + // End insert_container Special Uses(type_name) + if (!contains_key(Type_ordinal, type_name) // types can contain integers, like for array sizes && !is_integer(type_name)) { - Type_ordinal[type_name] = Next_type_ordinal++; + put(Type_ordinal, type_name, Next_type_ordinal++); } - types.push_back(Type_ordinal[type_name]); - trace("parse") << " type: " << types.back() << end(); + *curr_type = new type_tree(get(Type_ordinal, type_name)); + trace(9993, "parse") << " type: " << get(Type_ordinal, type_name) << end(); } - t.elements.push_back(types); + info.elements.push_back(new_type); } - assert(SIZE(t.elements) == SIZE(t.element_names)); - t.size = SIZE(t.elements); + assert(SIZE(info.elements) == SIZE(info.element_names)); + info.size = SIZE(info.elements); +} + +void skip_bracket(istream& in, string message) { + skip_whitespace_and_comments(in); + if (in.get() != '[') + raise_error << message << '\n' << end(); } :(scenarios run) @@ -397,7 +497,12 @@ vector<type_ordinal> recently_added_types; recently_added_types.clear(); :(before "End Setup") //: for tests for (long long int i = 0; i < SIZE(recently_added_types); ++i) { - Type_ordinal.erase(Type[recently_added_types.at(i)].name); + if (!contains_key(Type, recently_added_types.at(i))) continue; + Type_ordinal.erase(get(Type, recently_added_types.at(i)).name); + // todo: why do I explicitly need to provide this? + for (long long int j = 0; j < SIZE(Type.at(recently_added_types.at(i)).elements); ++j) { + delete Type.at(recently_added_types.at(i)).elements.at(j); + } Type.erase(recently_added_types.at(i)); } recently_added_types.clear(); @@ -411,9 +516,7 @@ while(p != Type_ordinal.< // increment iterator ++p; // now delete current item if necessary - if (t >= 1000) { - Type_ordinal.erase(name); - } + if (t >= 1000) Type_ordinal.erase(name); } //: lastly, ensure scenarios are consistent by always starting them at the //: same type number. @@ -423,60 +526,72 @@ assert(Next_type_ordinal < :(before "End Setup") Next_type_ordinal = 1000; -//:: Allow container definitions anywhere in the codebase, but warn if you -//:: can't find a definition. +//:: Allow container definitions anywhere in the codebase, but complain if you +//:: can't find a definition at the end. -:(scenario run_warns_on_unknown_types) -% Hide_warnings = true; +:(scenario run_complains_on_unknown_types) +% Hide_errors = true; recipe main [ # integer is not a type 1:integer <- copy 0 ] -+warn: unknown type: integer ++error: main: unknown type in '1:integer <- copy 0' :(scenario run_allows_type_definition_after_use) -% Hide_warnings = true; +% Hide_errors = true; recipe main [ - 1:bar <- copy 0 + 1:bar <- copy 0/raw ] container bar [ x:number ] --warn: unknown type: bar -$warn: 0 +-error: unknown type: bar +$error: 0 -:(after "int main") - Transform.push_back(check_invalid_types); +:(after "Begin Transforms") +Transform.push_back(check_or_set_invalid_types); // idempotent :(code) -void check_invalid_types(const recipe_ordinal r) { - for (long long int index = 0; index < SIZE(Recipe[r].steps); ++index) { - const instruction& inst = Recipe[r].steps.at(index); +void check_or_set_invalid_types(const recipe_ordinal r) { + for (long long int index = 0; index < SIZE(get(Recipe, r).steps); ++index) { + const instruction& inst = get(Recipe, r).steps.at(index); for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { - check_invalid_types(inst.ingredients.at(i)); + check_or_set_invalid_types(inst.ingredients.at(i).type, inst.ingredients.at(i).properties.at(0).second, + maybe(get(Recipe, r).name), "'"+inst.to_string()+"'"); } for (long long int i = 0; i < SIZE(inst.products); ++i) { - check_invalid_types(inst.products.at(i)); + check_or_set_invalid_types(inst.products.at(i).type, inst.products.at(i).properties.at(0).second, + maybe(get(Recipe, r).name), "'"+inst.to_string()+"'"); } } } -void check_invalid_types(const reagent& r) { - for (long long int i = 0; i < SIZE(r.types); ++i) { - if (r.types.at(i) == 0) continue; - if (Type.find(r.types.at(i)) == Type.end()) - raise << "unknown type: " << r.properties.at(0).second.at(i) << '\n' << end(); +void check_or_set_invalid_types(type_tree* type, const string_tree* type_name, const string& block, const string& name) { + // can't assert that type_name is non-null, even at the top of a recursive call tree + if (!type) return; // will throw a more precise error elsewhere + // End Container Type Checks + if (type->value == 0) { + assert(!type->left && !type->right); + return; } + if (!contains_key(Type, type->value)) { + if (type_name && contains_key(Type_ordinal, type_name->value)) + type->value = get(Type_ordinal, type_name->value); + else + raise_error << block << "unknown type in " << name << '\n' << end(); + } + check_or_set_invalid_types(type->left, type_name ? type_name->left : NULL, block, name); + check_or_set_invalid_types(type->right, type_name ? type_name->right : NULL, block, name); } :(scenario container_unknown_field) -% Hide_warnings = true; +% Hide_errors = true; container foo [ x:number y:bar ] -+warn: unknown type for field y in foo ++error: foo: unknown type in y :(scenario read_container_with_bracket_in_comment) container foo [ @@ -484,35 +599,62 @@ container foo [ # ']' in comment y:number ] -+parse: reading container foo -+parse: element name: x -+parse: type: 1 -+parse: element name: y -+parse: type: 1 ++parse: --- defining container foo ++parse: element name: x ++parse: type: 1 ++parse: element name: y ++parse: type: 1 -:(before "End Transform") +:(before "End Transform All") check_container_field_types(); :(code) void check_container_field_types() { for (map<type_ordinal, type_info>::iterator p = Type.begin(); p != Type.end(); ++p) { const type_info& info = p->second; - for (long long int i = 0; i < SIZE(info.elements); ++i) { - for (long long int j = 0; j < SIZE(info.elements.at(i)); ++j) { - if (info.elements.at(i).at(j) == 0) continue; - if (Type.find(info.elements.at(i).at(j)) == Type.end()) - raise << "unknown type for field " << info.element_names.at(i) << " in " << info.name << '\n' << end(); - } + // Check Container Field Types(info) + for (long long int i = 0; i < SIZE(info.elements); ++i) + check_invalid_types(info.elements.at(i), maybe(info.name), info.element_names.at(i)); + } +} + +void check_invalid_types(const recipe_ordinal r) { + for (long long int index = 0; index < SIZE(get(Recipe, r).steps); ++index) { + const instruction& inst = get(Recipe, r).steps.at(index); + for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { + check_invalid_types(inst.ingredients.at(i).type, + maybe(get(Recipe, r).name), "'"+inst.to_string()+"'"); + } + for (long long int i = 0; i < SIZE(inst.products); ++i) { + check_invalid_types(inst.products.at(i).type, + maybe(get(Recipe, r).name), "'"+inst.to_string()+"'"); } } } +void check_invalid_types(type_tree* type, const string& block, const string& name) { + if (!type) return; // will throw a more precise error elsewhere + // End Container Type Checks + if (type->value == 0) { + assert(!type->left && !type->right); + return; + } + if (!contains_key(Type, type->value)) + raise_error << block << "unknown type in " << name << '\n' << end(); + check_invalid_types(type->left, block, name); + check_invalid_types(type->right, block, name); +} + //:: Construct types out of their constituent fields. Doesn't currently do //:: type-checking but *does* match sizes. :(before "End Primitive Recipe Declarations") MERGE, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["merge"] = MERGE; +put(Recipe_ordinal, "merge", MERGE); +:(before "End Primitive Recipe Checks") +case MERGE: { + break; +} :(before "End Primitive Recipe Implementations") case MERGE: { products.resize(1); @@ -533,15 +675,6 @@ recipe main [ ] +mem: storing 3 in location 1 +mem: storing 4 in location 2 - -//:: helpers - -:(code) -void skip_bracket(istream& in, string message) { - skip_whitespace_and_comments(in); - if (in.get() != '[') - raise << message << '\n' << end(); -} </pre> </body> </html> diff --git a/html/031address.cc.html b/html/031address.cc.html index caad95d7..f2b0e28f 100644 --- a/html/031address.cc.html +++ b/html/031address.cc.html @@ -13,15 +13,15 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.SalientComment { color: #00ffff; } +.traceContains { color: #008000; } .traceAbsent { color: #c00000; } .cSpecial { color: #008000; } +.SalientComment { color: #00ffff; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } .Identifier { color: #804000; } .Constant { color: #00a0a0; } -.traceContains { color: #008000; } --> </style> @@ -38,7 +38,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } :(scenario copy_indirect) recipe main [ - 1:address:number <- copy 2 + 1:address:number <- copy 2/raw 2:number <- copy 34 # This loads location 1 as an address and looks up *that* location. 3:number <- copy 1:address:number/lookup @@ -46,76 +46,104 @@ recipe main [ +mem: storing 34 in location 3 :(before "long long int base = x.value" following "vector<double> read_memory(reagent x)") -x = canonize(x); +canonize(x); //: similarly, write to addresses pointing at other locations using the //: 'lookup' property :(scenario store_indirect) recipe main [ - 1:address:number <- copy 2 + 1:address:number <- copy 2/raw 1:address:number/lookup <- copy 34 ] +mem: storing 34 in location 2 :(before "long long int base = x.value" following "void write_memory(reagent x, vector<double> data)") -x = canonize(x); +canonize(x); if (x.value == 0) { - raise << "can't write to location 0 in '" << current_instruction().to_string() << "'\n" << end(); + raise_error << "can't write to location 0 in '" << current_instruction().to_string() << "'\n" << end(); return; } -:(after "bool is_mu_array(reagent r)") -r = canonize(r); - //: writes to address 0 always loudly fail -:(scenario store_to_0_warns) -% Hide_warnings = true; +:(scenario store_to_0_fails) +% Hide_errors = true; recipe main [ 1:address:number <- copy 0 1:address:number/lookup <- copy 34 ] -mem: storing 34 in location 0 -+warn: can't write to location 0 in '1:address:number/lookup <- copy 34' ++error: can't write to location 0 in '1:address:number/lookup <- copy 34' :(code) -reagent canonize(reagent x) { - if (is_literal(x)) return x; - reagent r = x; - while (has_property(r, "lookup")) - r = lookup_memory(r); - return r; +void canonize(reagent& x) { + if (is_literal(x)) return; + // End canonize(x) Special-cases + while (has_property(x, "lookup")) + lookup_memory(x); } -reagent lookup_memory(reagent x) { - static const type_ordinal ADDRESS = Type_ordinal["address"]; - reagent result; - if (x.types.empty() || x.types.at(0) != ADDRESS) { - raise << current_recipe_name() << ": tried to /lookup " << x.original_string << " but it isn't an address\n" << end(); - return result; +void lookup_memory(reagent& x) { + if (!x.type || x.type->value != get(Type_ordinal, "address")) { + raise_error << maybe(current_recipe_name()) << "tried to /lookup " << x.original_string << " but it isn't an address\n" << end(); } // compute value if (x.value == 0) { - raise << current_recipe_name() << ": tried to /lookup 0\n" << end(); - return result; + raise_error << maybe(current_recipe_name()) << "tried to /lookup 0\n" << end(); } - result.set_value(Memory[x.value]); - trace(Primitive_recipe_depth, "mem") << "location " << x.value << " is " << result.value << end(); - - // populate types - copy(++x.types.begin(), x.types.end(), inserter(result.types, result.types.begin())); - - // drop-one 'lookup' - long long int i = 0; - long long int len = SIZE(x.properties); - for (i = 0; i < len; ++i) { - if (x.properties.at(i).first == "lookup") break; - result.properties.push_back(x.properties.at(i)); + trace(9999, "mem") << "location " << x.value << " is " << no_scientific(get_or_insert(Memory, x.value)) << end(); + x.set_value(get_or_insert(Memory, x.value)); + drop_address_from_type(x); + drop_one_lookup(x); +} + +:(after "bool types_match(reagent lhs, reagent rhs)") + if (!canonize_type(lhs)) return false; + if (!canonize_type(rhs)) return false; + +:(after "bool is_mu_array(reagent r)") + if (!canonize_type(r)) return false; + +:(after "bool is_mu_address(reagent r)") + if (!canonize_type(r)) return false; + +:(after "bool is_mu_number(reagent r)") + if (!canonize_type(r)) return false; + +:(code) +bool canonize_type(reagent& r) { + while (has_property(r, "lookup")) { + if (!r.type || r.type->value != get(Type_ordinal, "address")) { + raise_error << "can't lookup non-address: " << r.to_string() << ": " << debug_string(r.type) << '\n' << end(); + return false; + } + drop_address_from_type(r); + drop_one_lookup(r); + } + return true; +} + +void drop_address_from_type(reagent& r) { + type_tree* tmp = r.type; + r.type = tmp->right; + tmp->right = NULL; + delete tmp; + // property + if (r.properties.at(0).second) { + string_tree* tmp2 = r.properties.at(0).second; + r.properties.at(0).second = tmp2->right; + tmp2->right = NULL; + delete tmp2; } - ++i; // skip first lookup - for (; i < len; ++i) { - result.properties.push_back(x.properties.at(i)); +} + +void drop_one_lookup(reagent& r) { + for (vector<pair<string, string_tree*> >::iterator p = r.properties.begin(); p != r.properties.end(); ++p) { + if (p->first == "lookup") { + r.properties.erase(p); + return; + } } - return result; + assert(false); } //:: 'get' can read from container address @@ -128,6 +156,16 @@ recipe main [ ] +mem: storing 34 in location 4 +:(scenario get_indirect2) +recipe main [ + 1:number <- copy 2 + 2:number <- copy 34 + 3:number <- copy 35 + 4:address:number <- copy 5/raw + *4:address:number <- get 1:address:point/lookup, 0:offset +] ++mem: storing 34 in location 5 + :(scenario include_nonlookup_properties) recipe main [ 1:number <- copy 2 @@ -137,8 +175,12 @@ recipe main [ ] +mem: storing 34 in location 4 -:(after "reagent base = " following "case GET:") -base = canonize(base); +:(after "Update GET base in Check") +if (!canonize_type(base)) break; +:(after "Update GET product in Check") +if (!canonize_type(product)) break; +:(after "Update GET base in Run") +canonize(base); :(scenario get_address_indirect) # 'get' can read from container address @@ -146,31 +188,37 @@ recipe main [ 1:number <- copy 2 2:number <- copy 34 3:number <- copy 35 - 4:number <- get-address 1:address:point/lookup, 0:offset + 4:address:number <- get-address 1:address:point/lookup, 0:offset ] +mem: storing 2 in location 4 -:(after "reagent base = " following "case GET_ADDRESS:") -base = canonize(base); +:(after "Update GET_ADDRESS base in Check") +if (!canonize_type(base)) break; +:(after "Update GET_ADDRESS product in Check") +if (!canonize_type(base)) break; +:(after "Update GET_ADDRESS base in Run") +canonize(base); //:: abbreviation for '/lookup': a prefix '*' :(scenario lookup_abbreviation) recipe main [ - 1:address:number <- copy 2 + 1:address:number <- copy 2/raw 2:number <- copy 34 3:number <- copy *1:address:number ] ++parse: ingredient: {"1": <"address" : <"number" : <>>>, "lookup": <>} +mem: storing 34 in location 3 :(before "End Parsing reagent") { while (!name.empty() && name.at(0) == '*') { name.erase(0, 1); - properties.push_back(pair<string, vector<string> >("lookup", vector<string>())); + properties.push_back(pair<string, string_tree*>("lookup", NULL)); } if (name.empty()) - raise << "illegal name " << original_string << '\n' << end(); + raise_error << "illegal name " << original_string << '\n' << end(); + properties.at(0).first = name; } //:: helpers for debugging @@ -178,11 +226,12 @@ recipe main [ :(before "End Primitive Recipe Declarations") _DUMP, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$dump"] = _DUMP; +put(Recipe_ordinal, "$dump", _DUMP); :(before "End Primitive Recipe Implementations") case _DUMP: { - reagent after_canonize = canonize(current_instruction().ingredients.at(0)); - cerr << current_recipe_name() << ": " << current_instruction().ingredients.at(0).name << ' ' << current_instruction().ingredients.at(0).value << " => " << after_canonize.value << " => " << Memory[after_canonize.value] << '\n'; + reagent after_canonize = current_instruction().ingredients.at(0); + canonize(after_canonize); + cerr << maybe(current_recipe_name()) << current_instruction().ingredients.at(0).name << ' ' << no_scientific(current_instruction().ingredients.at(0).value) << " => " << no_scientific(after_canonize.value) << " => " << no_scientific(get_or_insert(Memory, after_canonize.value)) << '\n'; break; } @@ -193,15 +242,17 @@ long long int foo = -1;</s :(before "End Primitive Recipe Declarations") _FOO, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$foo"] = _FOO; +put(Recipe_ordinal, "$foo", _FOO); :(before "End Primitive Recipe Implementations") case _FOO: { if (current_instruction().ingredients.empty()) { - if (foo != -1) cerr << foo << ": " << Memory[foo] << '\n'; + if (foo != -1) cerr << foo << ": " << no_scientific(get_or_insert(Memory, foo)) << '\n'; else cerr << '\n'; } else { - foo = canonize(current_instruction().ingredients.at(0)).value; + reagent tmp = current_instruction().ingredients.at(0); + canonize(tmp); + foo = tmp.value; } break; } diff --git a/html/032array.cc.html b/html/032array.cc.html index c73052a4..8c0ce105 100644 --- a/html/032array.cc.html +++ b/html/032array.cc.html @@ -13,6 +13,7 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.traceContains { color: #008000; } .SalientComment { color: #00ffff; } .cSpecial { color: #008000; } .Comment { color: #9090ff; } @@ -20,7 +21,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } .Special { color: #ff6060; } .Identifier { color: #804000; } .Constant { color: #00a0a0; } -.traceContains { color: #008000; } --> </style> @@ -50,40 +50,47 @@ recipe main [ :(before "End Primitive Recipe Declarations") CREATE_ARRAY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["create-array"] = CREATE_ARRAY; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "create-array", CREATE_ARRAY); +:(before "End Primitive Recipe Checks") case CREATE_ARRAY: { - if (current_instruction().products.empty()) { - raise << current_recipe_name () << ": 'create-array' needs one product and no ingredients but got '" << current_instruction().to_string() << '\n' << end(); + if (inst.products.empty()) { + raise_error << maybe(get(Recipe, r).name) << "'create-array' needs one product and no ingredients but got '" << inst.to_string() << '\n' << end(); break; } - reagent product = canonize(current_instruction().products.at(0)); + reagent product = inst.products.at(0); + canonize_type(product); if (!is_mu_array(product)) { - raise << current_recipe_name () << ": 'create-array' cannot create non-array " << product.original_string << '\n' << end(); + raise_error << maybe(get(Recipe, r).name) << "'create-array' cannot create non-array " << product.original_string << '\n' << end(); break; } - long long int base_address = product.value; - if (SIZE(product.types) == 1) { - raise << current_recipe_name () << ": create array of what? " << current_instruction().to_string() << '\n' << end(); + if (!product.type->right) { + raise_error << maybe(get(Recipe, r).name) << "create array of what? " << inst.to_string() << '\n' << end(); break; } // 'create-array' will need to check properties rather than types - if (SIZE(product.properties.at(0).second) <= 2) { - raise << current_recipe_name () << ": create array of what size? " << current_instruction().to_string() << '\n' << end(); + if (!product.properties.at(0).second || !product.properties.at(0).second->right || !product.properties.at(0).second->right->right) { + raise_error << maybe(get(Recipe, r).name) << "create array of what size? " << inst.to_string() << '\n' << end(); break; } - if (!is_integer(product.properties.at(0).second.at(2))) { - raise << current_recipe_name () << ": 'create-array' product should specify size of array after its element type, but got " << product.properties.at(0).second.at(2) << '\n' << end(); + if (!is_integer(product.properties.at(0).second->right->right->value)) { + raise_error << maybe(get(Recipe, r).name) << "'create-array' product should specify size of array after its element type, but got " << product.properties.at(0).second->right->right->value << '\n' << end(); break; } - long long int array_size= to_integer(product.properties.at(0).second.at(2)); + break; +} +:(before "End Primitive Recipe Implementations") +case CREATE_ARRAY: { + reagent product = current_instruction().products.at(0); + canonize(product); + long long int base_address = product.value; + long long int array_size = to_integer(product.properties.at(0).second->right->right->value); // initialize array size, so that size_of will work - Memory[base_address] = array_size; // in array elements + put(Memory, base_address, array_size); // in array elements long long int size = size_of(product); // in locations - trace("run") << "creating array of size " << size << '\n' << end(); + trace(9998, "run") << "creating array of size " << size << '\n' << end(); // initialize array for (long long int i = 1; i <= size_of(product); ++i) { - Memory[base_address+i] = 0; + put(Memory, base_address+i, 0); } // dummy product; doesn't actually do anything products.resize(1); @@ -112,7 +119,7 @@ recipe main [ 2:number <- copy 14 3:number <- copy 15 4:number <- copy 16 - 5:address:array:number <- copy 1 # unsafe + 5:address:array:number <- copy 1/raw 6:array:number <- copy *5:address:array:number ] +mem: storing 3 in location 6 @@ -132,15 +139,15 @@ recipe main [ //: disable the size mismatch check since the destination array need not be initialized :(before "End size_mismatch(x) Cases") -if (x.types.at(0) == Type_ordinal["array"]) return false; +if (x.type && x.type->value == get(Type_ordinal, "array")) return false; :(before "End size_of(reagent) Cases") -if (r.types.at(0) == Type_ordinal["array"]) { - if (SIZE(r.types) == 1) { - raise << current_recipe_name() << ": '" << r.original_string << "' is an array of what?\n" << end(); +if (r.type && r.type->value == get(Type_ordinal, "array")) { + if (!r.type->right) { + raise_error << maybe(current_recipe_name()) << "'" << r.original_string << "' is an array of what?\n" << end(); return 1; } // skip the 'array' type to get at the element type - return 1 + Memory[r.value]*size_of(array_element(r.types)); + return 1 + get_or_insert(Memory, r.value)*size_of(array_element(r.type)); } //:: To access elements of an array, use 'index' @@ -169,43 +176,60 @@ recipe main [ :(before "End Primitive Recipe Declarations") INDEX, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["index"] = INDEX; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "index", INDEX); +:(before "End Primitive Recipe Checks") case INDEX: { - if (SIZE(current_instruction().ingredients) != 2) { - raise << current_recipe_name() << ": 'index' expects exactly 2 ingredients in '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) != 2) { + raise_error << maybe(get(Recipe, r).name) << "'index' expects exactly 2 ingredients in '" << inst.to_string() << "'\n" << end(); break; } - reagent base = canonize(current_instruction().ingredients.at(0)); + reagent base = inst.ingredients.at(0); + canonize_type(base); if (!is_mu_array(base)) { - raise << current_recipe_name () << ": 'index' on a non-array " << base.original_string << '\n' << end(); + raise_error << maybe(get(Recipe, r).name) << "'index' on a non-array " << base.original_string << '\n' << end(); break; } + if (inst.products.empty()) break; + reagent product = inst.products.at(0); + canonize_type(product); + reagent element; + element.type = new type_tree(*array_element(base.type)); + if (!types_match(product, element)) { + raise_error << maybe(get(Recipe, r).name) << "'index' on " << base.original_string << " can't be saved in " << product.original_string << "; type should be " << debug_string(element.type) << '\n' << end(); + break; + } + break; +} +:(before "End Primitive Recipe Implementations") +case INDEX: { + reagent base = current_instruction().ingredients.at(0); + canonize(base); long long int base_address = base.value; if (base_address == 0) { - raise << current_recipe_name() << ": tried to access location 0 in '" << current_instruction().to_string() << "'\n" << end(); + raise_error << maybe(current_recipe_name()) << "tried to access location 0 in '" << current_instruction().to_string() << "'\n" << end(); break; } - reagent offset = canonize(current_instruction().ingredients.at(1)); + reagent offset = current_instruction().ingredients.at(1); + canonize(offset); vector<double> offset_val(read_memory(offset)); - vector<type_ordinal> element_type = array_element(base.types); - if (offset_val.at(0) < 0 || offset_val.at(0) >= Memory[base_address]) { - raise << current_recipe_name() << ": invalid index " << offset_val.at(0) << '\n' << end(); + type_tree* element_type = array_element(base.type); + if (offset_val.at(0) < 0 || offset_val.at(0) >= get_or_insert(Memory, base_address)) { + raise_error << maybe(current_recipe_name()) << "invalid index " << no_scientific(offset_val.at(0)) << '\n' << end(); break; } long long int src = base_address + 1 + offset_val.at(0)*size_of(element_type); - trace(Primitive_recipe_depth, "run") << "address to copy is " << src << end(); - trace(Primitive_recipe_depth, "run") << "its type is " << Type[element_type.at(0)].name << end(); + trace(9998, "run") << "address to copy is " << src << end(); + trace(9998, "run") << "its type is " << get(Type, element_type->value).name << end(); reagent tmp; tmp.set_value(src); - copy(element_type.begin(), element_type.end(), inserter(tmp.types, tmp.types.begin())); + tmp.type = new type_tree(*element_type); products.push_back(read_memory(tmp)); break; } :(code) -vector<type_ordinal> array_element(const vector<type_ordinal>& types) { - return vector<type_ordinal>(++types.begin(), types.end()); +type_tree* array_element(const type_tree* type) { + return type->right; } :(scenario index_indirect) @@ -214,13 +238,13 @@ recipe main [ 2:number <- copy 14 3:number <- copy 15 4:number <- copy 16 - 5:address:array:number <- copy 1 + 5:address:array:number <- copy 1/raw 6:number <- index *5:address:array:number, 1 ] +mem: storing 15 in location 6 :(scenario index_out_of_bounds) -% Hide_warnings = true; +% Hide_errors = true; recipe main [ 1:array:number:3 <- create-array 2:number <- copy 14 @@ -232,10 +256,10 @@ recipe main [ 8:address:array:point <- copy 1 index *8:address:array:point, 4 # less than size of array in locations, but larger than its length in elements ] -+warn: main: invalid index 4 ++error: main: invalid index 4 :(scenario index_out_of_bounds_2) -% Hide_warnings = true; +% Hide_errors = true; recipe main [ 1:array:point:3 <- create-array 2:number <- copy 14 @@ -244,10 +268,25 @@ recipe main [ 5:number <- copy 14 6:number <- copy 15 7:number <- copy 16 - 8:address:array:point <- copy 1 + 8:address:array:point <- copy 1/raw index *8:address:array:point, -1 ] -+warn: main: invalid index -1 ++error: main: invalid index -1 + +:(scenario index_product_type_mismatch) +% Hide_errors = true; +recipe main [ + 1:array:point:3 <- create-array + 2:number <- copy 14 + 3:number <- copy 15 + 4:number <- copy 16 + 5:number <- copy 14 + 6:number <- copy 15 + 7:number <- copy 16 + 8:address:array:point <- copy 1/raw + 9:number <- index *8:address:array:point, 0 +] ++error: main: 'index' on *8:address:array:point can't be saved in 9:number; type should be point //:: To write to elements of containers, you need their address. @@ -257,35 +296,53 @@ recipe main [ 2:number <- copy 14 3:number <- copy 15 4:number <- copy 16 - 5:number <- index-address 1:array:number, 0 + 5:address:number <- index-address 1:array:number, 0 ] +mem: storing 2 in location 5 :(before "End Primitive Recipe Declarations") INDEX_ADDRESS, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["index-address"] = INDEX_ADDRESS; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "index-address", INDEX_ADDRESS); +:(before "End Primitive Recipe Checks") case INDEX_ADDRESS: { - if (SIZE(current_instruction().ingredients) != 2) { - raise << current_recipe_name() << ": 'index-address' expects exactly 2 ingredients in '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) != 2) { + raise_error << maybe(get(Recipe, r).name) << "'index-address' expects exactly 2 ingredients in '" << inst.to_string() << "'\n" << end(); break; } - reagent base = canonize(current_instruction().ingredients.at(0)); + reagent base = inst.ingredients.at(0); + canonize_type(base); if (!is_mu_array(base)) { - raise << current_recipe_name () << ": 'index-address' on a non-array " << base.original_string << '\n' << end(); + raise_error << maybe(get(Recipe, r).name) << "'index-address' on a non-array " << base.original_string << '\n' << end(); break; } + if (inst.products.empty()) break; + reagent product = inst.products.at(0); + canonize_type(product); + reagent element; + element.type = new type_tree(*array_element(base.type)); + element.type = new type_tree(get(Type_ordinal, "address"), element.type); + if (!types_match(product, element)) { + raise_error << maybe(get(Recipe, r).name) << "'index' on " << base.original_string << " can't be saved in " << product.original_string << "; type should be " << debug_string(element.type) << '\n' << end(); + break; + } + break; +} +:(before "End Primitive Recipe Implementations") +case INDEX_ADDRESS: { + reagent base = current_instruction().ingredients.at(0); + canonize(base); long long int base_address = base.value; if (base_address == 0) { - raise << current_recipe_name() << ": tried to access location 0 in '" << current_instruction().to_string() << "'\n" << end(); + raise_error << maybe(current_recipe_name()) << "tried to access location 0 in '" << current_instruction().to_string() << "'\n" << end(); break; } - reagent offset = canonize(current_instruction().ingredients.at(1)); + reagent offset = current_instruction().ingredients.at(1); + canonize(offset); vector<double> offset_val(read_memory(offset)); - vector<type_ordinal> element_type = array_element(base.types); - if (offset_val.at(0) < 0 || offset_val.at(0) >= Memory[base_address]) { - raise << current_recipe_name() << ": invalid index " << offset_val.at(0) << '\n' << end(); + type_tree* element_type = array_element(base.type); + if (offset_val.at(0) < 0 || offset_val.at(0) >= get_or_insert(Memory, base_address)) { + raise_error << maybe(current_recipe_name()) << "invalid index " << no_scientific(offset_val.at(0)) << '\n' << end(); break; } long long int result = base_address + 1 + offset_val.at(0)*size_of(element_type); @@ -295,7 +352,7 @@ case INDEX_ADDRESS: { } :(scenario index_address_out_of_bounds) -% Hide_warnings = true; +% Hide_errors = true; recipe main [ 1:array:point:3 <- create-array 2:number <- copy 14 @@ -307,10 +364,10 @@ recipe main [ 8:address:array:point <- copy 1 # unsafe index-address *8:address:array:point, 4 # less than size of array in locations, but larger than its length in elements ] -+warn: main: invalid index 4 ++error: main: invalid index 4 :(scenario index_address_out_of_bounds_2) -% Hide_warnings = true; +% Hide_errors = true; recipe main [ 1:array:point:3 <- create-array 2:number <- copy 14 @@ -319,10 +376,25 @@ recipe main [ 5:number <- copy 14 6:number <- copy 15 7:number <- copy 16 - 8:address:array:point <- copy 1 # unsafe + 8:address:array:point <- copy 1/raw index-address *8:address:array:point, -1 ] -+warn: main: invalid index -1 ++error: main: invalid index -1 + +:(scenario index_address_product_type_mismatch) +% Hide_errors = true; +recipe main [ + 1:array:point:3 <- create-array + 2:number <- copy 14 + 3:number <- copy 15 + 4:number <- copy 16 + 5:number <- copy 14 + 6:number <- copy 15 + 7:number <- copy 16 + 8:address:array:point <- copy 1/raw + 9:address:number <- index-address *8:address:array:point, 0 +] ++error: main: 'index' on *8:address:array:point can't be saved in 9:address:number; type should be <address : <point : <>>> //:: compute the length of an array @@ -339,24 +411,31 @@ recipe main [ :(before "End Primitive Recipe Declarations") LENGTH, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["length"] = LENGTH; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "length", LENGTH); +:(before "End Primitive Recipe Checks") case LENGTH: { - if (SIZE(current_instruction().ingredients) != 1) { - raise << current_recipe_name() << ": 'length' expects exactly 2 ingredients in '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) != 1) { + raise_error << maybe(get(Recipe, r).name) << "'length' expects exactly 2 ingredients in '" << inst.to_string() << "'\n" << end(); break; } - reagent x = canonize(current_instruction().ingredients.at(0)); + reagent x = inst.ingredients.at(0); + canonize_type(x); if (!is_mu_array(x)) { - raise << "tried to calculate length of non-array " << x.original_string << '\n' << end(); + raise_error << "tried to calculate length of non-array " << x.original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case LENGTH: { + reagent x = current_instruction().ingredients.at(0); + canonize(x); if (x.value == 0) { - raise << current_recipe_name() << ": tried to access location 0 in '" << current_instruction().to_string() << "'\n" << end(); + raise_error << maybe(current_recipe_name()) << "tried to access location 0 in '" << current_instruction().to_string() << "'\n" << end(); break; } products.resize(1); - products.at(0).push_back(Memory[x.value]); + products.at(0).push_back(get_or_insert(Memory, x.value)); break; } diff --git a/html/033exclusive_container.cc.html b/html/033exclusive_container.cc.html index beea9b0e..a4fc191a 100644 --- a/html/033exclusive_container.cc.html +++ b/html/033exclusive_container.cc.html @@ -13,9 +13,9 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.cSpecial { color: #008000; } -.SalientComment { color: #00ffff; } .traceContains { color: #008000; } +.SalientComment { color: #00ffff; } +.cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } @@ -41,23 +41,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } :(before "End Mu Types Initialization") //: We'll use this container as a running example, with two number elements. { -type_ordinal tmp = Type_ordinal["number-or-point"] = Next_type_ordinal++; -Type[tmp].size = 2; -Type[tmp].kind = exclusive_container; -Type[tmp].name = "number-or-point"; -vector<type_ordinal> t1; -t1.push_back(number); -Type[tmp].elements.push_back(t1); -vector<type_ordinal> t2; -t2.push_back(point); -Type[tmp].elements.push_back(t2); -Type[tmp].element_names.push_back("i"); -Type[tmp].element_names.push_back("p"); +type_ordinal tmp = put(Type_ordinal, "number-or-point", Next_type_ordinal++); +get_or_insert(Type, tmp).size = 2; +get(Type, tmp).kind = EXCLUSIVE_CONTAINER; +get(Type, tmp).name = "number-or-point"; +get(Type, tmp).elements.push_back(new type_tree(number)); +get(Type, tmp).element_names.push_back("i"); +get(Type, tmp).elements.push_back(new type_tree(point)); +get(Type, tmp).element_names.push_back("p"); } //: Tests in this layer often explicitly setup memory before reading it as an //: array. Don't do this in general. I'm tagging exceptions with /raw to -//: avoid warnings. +//: avoid errors. :(scenario copy_exclusive_container) # Copying exclusive containers copies all their contents and an extra location for the tag. recipe main [ @@ -70,8 +66,8 @@ recipe main [ +mem: storing 34 in location 5 +mem: storing 35 in location 6 -:(before "End size_of(types) Cases") -if (t.kind == exclusive_container) { +:(before "End size_of(type) Cases") +if (t.kind == EXCLUSIVE_CONTAINER) { // size of an exclusive container is the size of its largest variant // (So like containers, it can't contain arrays.) long long int result = 0; @@ -91,7 +87,7 @@ if (t.kind == excl //: 'maybe-convert' requires a literal in ingredient 1. We'll use a synonym //: called 'variant'. :(before "End Mu Types Initialization") -Type_ordinal["variant"] = 0; +put(Type_ordinal, "variant", 0); :(scenario maybe_convert) recipe main [ @@ -114,30 +110,37 @@ recipe main [ :(before "End Primitive Recipe Declarations") MAYBE_CONVERT, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["maybe-convert"] = MAYBE_CONVERT; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "maybe-convert", MAYBE_CONVERT); +:(before "End Primitive Recipe Checks") case MAYBE_CONVERT: { - if (SIZE(ingredients) != 2) { - raise << current_recipe_name() << ": 'maybe-convert' expects exactly 2 ingredients in '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) != 2) { + raise_error << maybe(get(Recipe, r).name) << "'maybe-convert' expects exactly 2 ingredients in '" << inst.to_string() << "'\n" << end(); break; } - reagent base = canonize(current_instruction().ingredients.at(0)); - long long int base_address = base.value; - if (base_address == 0) { - raise << current_recipe_name() << ": tried to access location 0 in '" << current_instruction().to_string() << "'\n" << end(); + reagent base = inst.ingredients.at(0); + canonize_type(base); + if (!base.type || !base.type->value || get(Type, base.type->value).kind != EXCLUSIVE_CONTAINER) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'maybe-convert' should be an exclusive-container, but got " << base.original_string << '\n' << end(); break; } - if (base.types.empty() || Type[base.types.at(0)].kind != exclusive_container) { - raise << current_recipe_name () << ": first ingredient of 'maybe-convert' should be an exclusive-container, but got " << base.original_string << '\n' << end(); + if (!is_literal(inst.ingredients.at(1))) { + raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'maybe-convert' should have type 'variant', but got " << inst.ingredients.at(1).original_string << '\n' << end(); break; } - if (!is_literal(current_instruction().ingredients.at(1))) { - raise << current_recipe_name() << ": second ingredient of 'maybe-convert' should have type 'variant', but got " << current_instruction().ingredients.at(1).original_string << '\n' << end(); + break; +} +:(before "End Primitive Recipe Implementations") +case MAYBE_CONVERT: { + reagent base = current_instruction().ingredients.at(0); + canonize(base); + long long int base_address = base.value; + if (base_address == 0) { + raise_error << maybe(current_recipe_name()) << "tried to access location 0 in '" << current_instruction().to_string() << "'\n" << end(); break; } long long int tag = current_instruction().ingredients.at(1).value; long long int result; - if (tag == static_cast<long long int>(Memory[base_address])) { + if (tag == static_cast<long long int>(get_or_insert(Memory, base_address))) { result = base_address+1; } else { @@ -155,7 +158,7 @@ exclusive-container foo [ x:number y:number ] -+parse: reading exclusive-container foo ++parse: --- defining exclusive-container foo +parse: element name: x +parse: type: 1 +parse: element name: y @@ -163,7 +166,7 @@ exclusive-container foo [ :(before "End Command Handlers") else if (command == "exclusive-container") { - insert_container(command, exclusive_container, in); + insert_container(command, EXCLUSIVE_CONTAINER, in); } //:: To construct exclusive containers out of variant types, use 'merge'. @@ -188,9 +191,10 @@ recipe main [ :(before "End size_mismatch(x) Cases") if (current_instruction().operation == MERGE && !current_instruction().products.empty() - && !current_instruction().products.at(0).types.empty()) { - reagent x = canonize(current_instruction().products.at(0)); - if (Type[x.types.at(0)].kind == exclusive_container) { + && current_instruction().products.at(0).type) { + reagent x = current_instruction().products.at(0); + canonize(x); + if (get(Type, x.type->value).kind == EXCLUSIVE_CONTAINER) { return size_of(x) < SIZE(data); } } diff --git a/html/034call.cc.html b/html/034call.cc.html index 8c95766f..10ad7632 100644 --- a/html/034call.cc.html +++ b/html/034call.cc.html @@ -13,15 +13,15 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.PreProc { color: #c000c0; } +.traceContains { color: #008000; } .SalientComment { color: #00ffff; } .cSpecial { color: #008000; } +.PreProc { color: #c000c0; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } .Identifier { color: #804000; } .Constant { color: #00a0a0; } -.traceContains { color: #008000; } --> </style> @@ -77,6 +77,9 @@ struct call { running_step_index = 0; // End call Constructor } + ~call() { + // End call Destructor + } }; typedef list<call> call_stack; @@ -90,57 +93,80 @@ struct routine { }; :(code) routine::routine(recipe_ordinal r) { + if (Trace_stream) { + ++Trace_stream->callstack_depth; + trace(9999, "trace") << "new routine; incrementing callstack depth to " << Trace_stream->callstack_depth << end(); + assert(Trace_stream->callstack_depth < 9000); // 9998-101 plus cushion + } calls.push_front(call(r)); // End routine Constructor } +:(code) +inline call& current_call() { + return Current_routine->calls.front(); +} + //:: now update routine's helpers :(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; + return current_call().running_step_index; } :(replace{} "inline const string& current_recipe_name()") inline const string& current_recipe_name() { assert(!Current_routine->calls.empty()); - return Recipe[Current_routine->calls.front().running_recipe].name; + return get(Recipe, current_call().running_recipe).name; } :(replace{} "inline const instruction& current_instruction()") inline const instruction& current_instruction() { assert(!Current_routine->calls.empty()); - return Recipe[Current_routine->calls.front().running_recipe].steps.at(Current_routine->calls.front().running_step_index); + return to_instruction(current_call()); +} +:(code) +inline const instruction& to_instruction(const call& call) { + return get(Recipe, call.running_recipe).steps.at(call.running_step_index); } +:(after "Defined Recipe Checks") +// not a primitive; check that it's present in the book of recipes +if (!contains_key(Recipe, inst.operation)) { + raise_error << maybe(get(Recipe, r).name) << "undefined operation in '" << inst.to_string() << "'\n" << end(); + break; +} :(replace{} "default:" following "End Primitive Recipe Implementations") default: { - // not a primitive; try to look up the book of recipes - if (Recipe.find(current_instruction().operation) == Recipe.end()) { - raise << current_recipe_name() << ": undefined operation in '" << current_instruction().to_string() << "'\n" << end(); + const instruction& call_instruction = current_instruction(); + if (Recipe.find(current_instruction().operation) == Recipe.end()) { // duplicate from Checks // stop running this instruction immediately ++current_step_index(); continue; } + // not a primitive; look up the book of recipes + if (Trace_stream) { + ++Trace_stream->callstack_depth; + trace(9999, "trace") << "incrementing callstack depth to " << Trace_stream->callstack_depth << end(); + assert(Trace_stream->callstack_depth < 9000); // 9998-101 plus cushion + } Current_routine->calls.push_front(call(current_instruction().operation)); - call_housekeeping: - ++Callstack_depth; - assert(Callstack_depth < 9000); // 9998-101 plus cushion + // End Call Housekeeping continue; // not done with caller; don't increment current_step_index() } -:(scenario calling_undefined_recipe_warns) -% Hide_warnings = true; +:(scenario calling_undefined_recipe_fails) +% Hide_errors = true; recipe main [ foo ] -+warn: main: undefined operation in 'foo ' ++error: main: undefined operation in 'foo ' :(scenario calling_undefined_recipe_handles_missing_result) -% Hide_warnings = true; +% Hide_errors = true; recipe main [ x:number <- foo ] -+warn: main: undefined operation in 'x:number <- foo ' ++error: main: undefined operation in 'x:number <- foo ' //:: finally, we need to fix the termination conditions for the run loop @@ -151,7 +177,7 @@ inline bool routine::completed() const & routine::steps() const { assert(!calls.empty()); - return Recipe[calls.front().running_recipe].steps; + return get(Recipe, calls.front().running_recipe).steps; } :(before "Running One Instruction") @@ -159,11 +185,15 @@ inline const vector<instruction>& routine::steps// it, and the one below that, and so on while (current_step_index() >= SIZE(Current_routine->steps())) { // Falling Through End Of Recipe - --Callstack_depth; + if (Trace_stream) { + trace(9999, "trace") << "fall-through: exiting " << current_recipe_name() << "; decrementing callstack depth from " << Trace_stream->callstack_depth << end(); + --Trace_stream->callstack_depth; + assert(Trace_stream->callstack_depth >= 0); + } Current_routine->calls.pop_front(); if (Current_routine->calls.empty()) return; // Complete Call Fallthrough - // todo: no products returned warning + // todo: fail if no products returned ++current_step_index(); } diff --git a/html/035call_ingredient.cc.html b/html/035call_ingredient.cc.html index 517cf646..104c66dc 100644 --- a/html/035call_ingredient.cc.html +++ b/html/035call_ingredient.cc.html @@ -13,13 +13,13 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.traceContains { color: #008000; } .cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } .Identifier { color: #804000; } .Constant { color: #00a0a0; } -.traceContains { color: #008000; } --> </style> @@ -55,41 +55,79 @@ recipe f [ :(before "End call Fields") vector<vector<double> > ingredient_atoms; +vector<type_tree*> ingredient_types; long long int next_ingredient_to_process; :(before "End call Constructor") next_ingredient_to_process = 0; -:(after "call_housekeeping:") +:(before "End Call Housekeeping") for (long long int i = 0; i < SIZE(ingredients); ++i) { - Current_routine->calls.front().ingredient_atoms.push_back(ingredients.at(i)); + current_call().ingredient_atoms.push_back(ingredients.at(i)); + reagent ingredient = call_instruction.ingredients.at(i); + canonize_type(ingredient); + current_call().ingredient_types.push_back(ingredient.type); + ingredient.type = NULL; // release long-lived pointer +} +:(before "End call Destructor") +for (long long int i = 0; i < SIZE(ingredient_types); ++i) { + delete ingredient_types.at(i); } :(before "End Primitive Recipe Declarations") NEXT_INGREDIENT, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["next-ingredient"] = NEXT_INGREDIENT; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "next-ingredient", NEXT_INGREDIENT); +:(before "End Primitive Recipe Checks") case NEXT_INGREDIENT: { - if (!ingredients.empty()) { - raise << current_recipe_name() << ": 'next-ingredient' didn't expect any ingredients in '" << current_instruction().to_string() << "'\n" << end(); + if (!inst.ingredients.empty()) { + raise_error << maybe(get(Recipe, r).name) << "'next-ingredient' didn't expect any ingredients in '" << inst.to_string() << "'\n" << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case NEXT_INGREDIENT: { assert(!Current_routine->calls.empty()); - if (Current_routine->calls.front().next_ingredient_to_process < SIZE(Current_routine->calls.front().ingredient_atoms)) { + if (current_call().next_ingredient_to_process < SIZE(current_call().ingredient_atoms)) { + reagent product = current_instruction().products.at(0); + canonize_type(product); + if (!types_match(product, + current_call().ingredient_types.at(current_call().next_ingredient_to_process), + current_call().ingredient_atoms.at(current_call().next_ingredient_to_process) + )) { + raise_error << maybe(current_recipe_name()) << "wrong type for ingredient " << current_instruction().products.at(0).original_string << '\n' << end(); + } products.push_back( - Current_routine->calls.front().ingredient_atoms.at(Current_routine->calls.front().next_ingredient_to_process)); + current_call().ingredient_atoms.at(current_call().next_ingredient_to_process)); 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; + ++current_call().next_ingredient_to_process; } else { + if (SIZE(current_instruction().products) < 2) + raise_error << maybe(current_recipe_name()) << "no ingredient to save in " << current_instruction().products.at(0).original_string << '\n' << end(); + if (current_instruction().products.empty()) break; products.resize(2); - products.at(0).push_back(0); // todo: will fail noisily if we try to read a compound value + // pad the first product with sufficient zeros to match its type + long long int size = size_of(current_instruction().products.at(0)); + for (long long int i = 0; i < size; ++i) { + products.at(0).push_back(0); + } products.at(1).push_back(0); } break; } +:(scenario next_ingredient_fail_on_missing) +% Hide_errors = true; +recipe main [ + f +] +recipe f [ + 11:number <- next-ingredient +] ++error: f: no ingredient to save in 11:number + :(scenario rewind_ingredients) recipe main [ f 2 @@ -108,10 +146,14 @@ recipe f [ :(before "End Primitive Recipe Declarations") REWIND_INGREDIENTS, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["rewind-ingredients"] = REWIND_INGREDIENTS; +put(Recipe_ordinal, "rewind-ingredients", REWIND_INGREDIENTS); +:(before "End Primitive Recipe Checks") +case REWIND_INGREDIENTS: { + break; +} :(before "End Primitive Recipe Implementations") case REWIND_INGREDIENTS: { - Current_routine->calls.front().next_ingredient_to_process = 0; + current_call().next_ingredient_to_process = 0; break; } @@ -129,25 +171,28 @@ recipe f [ :(before "End Primitive Recipe Declarations") INGREDIENT, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["ingredient"] = INGREDIENT; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "ingredient", INGREDIENT); +:(before "End Primitive Recipe Checks") case INGREDIENT: { - if (SIZE(ingredients) != 1) { - raise << current_recipe_name() << ": 'ingredient' expects exactly one ingredient, but got '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) != 1) { + raise_error << maybe(get(Recipe, r).name) << "'ingredient' expects exactly one ingredient, but got '" << inst.to_string() << "'\n" << end(); break; } - if (!is_literal(current_instruction().ingredients.at(0))) { - raise << current_recipe_name() << ": 'ingredient' expects a literal ingredient, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_literal(inst.ingredients.at(0)) && !is_mu_number(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "'ingredient' expects a literal ingredient, but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } - 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); + break; +} +:(before "End Primitive Recipe Implementations") +case INGREDIENT: { + if (static_cast<long long int>(ingredients.at(0).at(0)) < SIZE(current_call().ingredient_atoms)) { + current_call().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)); + current_call().ingredient_atoms.at(current_call().next_ingredient_to_process)); 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; + ++current_call().next_ingredient_to_process; } else { if (SIZE(current_instruction().products) > 1) { diff --git a/html/036call_reply.cc.html b/html/036call_reply.cc.html index bdc9cb07..45622e07 100644 --- a/html/036call_reply.cc.html +++ b/html/036call_reply.cc.html @@ -13,13 +13,13 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.traceContains { color: #008000; } .cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } .Identifier { color: #804000; } .Constant { color: #00a0a0; } -.traceContains { color: #008000; } --> </style> @@ -48,36 +48,58 @@ recipe f [ :(before "End Primitive Recipe Declarations") REPLY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["reply"] = REPLY; +put(Recipe_ordinal, "reply", REPLY); +:(before "End Primitive Recipe Checks") +case REPLY: { + break; // continue to process rest of *caller* instruction +} :(before "End Primitive Recipe Implementations") case REPLY: { // Starting Reply const instruction& reply_inst = current_instruction(); // save pointer into recipe before pop const string& callee = current_recipe_name(); - --Callstack_depth; + if (Trace_stream) { + trace(9999, "trace") << "reply: decrementing callstack depth from " << Trace_stream->callstack_depth << end(); + --Trace_stream->callstack_depth; + assert(Trace_stream->callstack_depth >= 0); + } Current_routine->calls.pop_front(); // just in case 'main' returns a value, drop it for now if (Current_routine->calls.empty()) goto stop_running_current_routine; const instruction& caller_instruction = current_instruction(); + // check types with the caller + if (SIZE(caller_instruction.products) > SIZE(ingredients)) { + raise_error << "too few values replied from " << callee << '\n' << end(); + break; + } + for (long long int i = 0; i < SIZE(caller_instruction.products); ++i) { + if (!types_match(caller_instruction.products.at(i), reply_inst.ingredients.at(i))) { + raise_error << maybe(callee) << "reply ingredient " << reply_inst.ingredients.at(i).original_string << " can't be saved in " << caller_instruction.products.at(i).original_string << '\n' << end(); + reagent lhs = reply_inst.ingredients.at(i); + canonize_type(lhs); + reagent rhs = caller_instruction.products.at(i); + canonize_type(rhs); + raise_error << debug_string(lhs.type) << " vs " << debug_string(rhs.type) << '\n' << end(); + goto finish_reply; + } + } // make reply products available to caller 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. - if (SIZE(caller_instruction.products) > SIZE(ingredients)) - raise << "too few values replied from " << callee << '\n' << end(); for (long long int i = 0; i < SIZE(caller_instruction.products); ++i) { - trace(Primitive_recipe_depth, "run") << "result " <" is " << to_string(ingredients.at(i)) << end(); + trace(9998, "run") << "result " <" is " << to_string(ingredients.at(i)) << end(); if (has_property(reply_inst.ingredients.at(i), "same-as-ingredient")) { - vector<string> tmp = property(reply_inst.ingredients.at(i), "same-as-ingredient"); - if (SIZE(tmp) != 1) { - raise << current_recipe_name() << ": 'same-as-ingredient' metadata should take exactly one value in " << reply_inst.to_string() << '\n' << end(); + string_tree* tmp = property(reply_inst.ingredients.at(i), "same-as-ingredient"); + if (!tmp || tmp->right) { + raise_error << maybe(current_recipe_name()) << "'same-as-ingredient' metadata should take exactly one value in " << reply_inst.to_string() << '\n' << end(); goto finish_reply; } - long long int ingredient_index = to_integer(tmp.at(0)); + long long int ingredient_index = to_integer(tmp->value); if (ingredient_index >= SIZE(caller_instruction.ingredients)) - raise << current_recipe_name() << ": 'same-as-ingredient' metadata overflows ingredients in: " << caller_instruction.to_string() << '\n' << end(); + raise_error << maybe(current_recipe_name()) << "'same-as-ingredient' metadata overflows ingredients in: " << caller_instruction.to_string() << '\n' << end(); if (!is_dummy(caller_instruction.products.at(i)) && caller_instruction.products.at(i).value != caller_instruction.ingredients.at(ingredient_index).value) - raise << current_recipe_name() << ": 'same-as-ingredient' product from call to " << callee << " must be " << caller_instruction.ingredients.at(ingredient_index).original_string << " rather than " << caller_instruction.products.at(i).original_string << '\n' << end(); + raise_error << maybe(current_recipe_name()) << "'" << caller_instruction.to_string() << "' should write to " << caller_instruction.ingredients.at(ingredient_index).original_string << " rather than " << caller_instruction.products.at(i).original_string << '\n' << end(); } } // End Reply @@ -93,53 +115,66 @@ recipe main [ recipe f [ 12:number <- next-ingredient 13:number <- copy 35 - reply 12:point/raw # unsafe + reply 12:point/raw ] +run: result 0 is [2, 35] +mem: storing 2 in location 3 +mem: storing 35 in location 4 +:(scenario reply_type_mismatch) +% Hide_errors = true; +recipe main [ + 3:number <- f 2 +] +recipe f [ + 12:number <- next-ingredient + 13:number <- copy 35 + 14:point <- copy 12:point/raw + reply 14:point +] ++error: f: reply ingredient 14:point can't be saved in 3:number + //: In mu we'd like to assume that any instruction doesn't modify its //: ingredients unless they're also products. The /same-as-ingredient inside //: the recipe's 'reply' will help catch accidental misuse of such //: 'ingredient-products' (sometimes called in-out parameters in other languages). :(scenario reply_same_as_ingredient) -% Hide_warnings = true; +% Hide_errors = true; recipe main [ 1:number <- copy 0 2:number <- test1 1:number # call with different ingredient and product ] recipe test1 [ - 10:address:number <- next-ingredient - reply 10:address:number/same-as-ingredient:0 + 10:number <- next-ingredient + reply 10:number/same-as-ingredient:0 ] -+warn: main: 'same-as-ingredient' product from call to test1 must be 1:number rather than 2:number ++error: main: '2:number <- test1 1:number' should write to 1:number rather than 2:number :(scenario reply_same_as_ingredient_dummy) -% Hide_warnings = true; +# % Hide_errors = true; recipe main [ 1:number <- copy 0 _ <- test1 1:number # call with different ingredient and product ] recipe test1 [ - 10:address:number <- next-ingredient - reply 10:address:number/same-as-ingredient:0 + 10:number <- next-ingredient + reply 10:number/same-as-ingredient:0 ] -$warn: 0 +$error: 0 :(code) string to_string(const vector<double>& in) { if (in.empty()) return "[]"; ostringstream out; if (SIZE(in) == 1) { - out << in.at(0); + out << no_scientific(in.at(0)); return out.str(); } out << "["; for (long long int i = 0; i < SIZE(in); ++i) { if (i > 0) out << ", "; - out << in.at(i); + out << no_scientific(in.at(i)); } out << "]"; return out.str(); @@ -167,7 +202,7 @@ recipe test1 [ ] +mem: storing 34 in location 1 -:(before "End Rewrite Instruction(curr)") +:(before "End Rewrite Instruction(curr, recipe result)") // rewrite `reply-if a, b, c, ...` to // ``` // jump-unless a, 1:offset @@ -175,7 +210,7 @@ recipe test1 [ // ``` if (curr.name == "reply-if") { if (curr.products.empty()) { - curr.operation = Recipe_ordinal["jump-unless"]; + curr.operation = get(Recipe_ordinal, "jump-unless"); curr.name = "jump-unless"; vector<reagent> results; copy(++curr.ingredients.begin(), curr.ingredients.end(), inserter(results, results.end())); @@ -183,12 +218,12 @@ if (curr.name == < curr.ingredients.push_back(reagent("1:offset")); result.steps.push_back(curr); curr.clear(); - curr.operation = Recipe_ordinal["reply"]; + curr.operation = get(Recipe_ordinal, "reply"); curr.name = "reply"; curr.ingredients.swap(results); } else { - raise << "'reply-if' never yields any products\n" << end(); + raise_error << "'reply-if' never yields any products\n" << end(); } } // rewrite `reply-unless a, b, c, ...` to @@ -198,7 +233,7 @@ if (curr.name == < // ``` if (curr.name == "reply-unless") { if (curr.products.empty()) { - curr.operation = Recipe_ordinal["jump-if"]; + curr.operation = get(Recipe_ordinal, "jump-if"); curr.name = "jump-if"; vector<reagent> results; copy(++curr.ingredients.begin(), curr.ingredients.end(), inserter(results, results.end())); @@ -206,12 +241,12 @@ if (curr.name == < curr.ingredients.push_back(reagent("1:offset")); result.steps.push_back(curr); curr.clear(); - curr.operation = Recipe_ordinal["reply"]; + curr.operation = get(Recipe_ordinal, "reply"); curr.name = "reply"; curr.ingredients.swap(results); } else { - raise << "'reply-unless' never yields any products\n" << end(); + raise_error << "'reply-unless' never yields any products\n" << end(); } } </pre> diff --git a/html/037recipe.cc.html b/html/037recipe.cc.html index 856e671c..44573495 100644 --- a/html/037recipe.cc.html +++ b/html/037recipe.cc.html @@ -13,13 +13,10 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } -.Special { color: #ff6060; } .Identifier { color: #804000; } .Constant { color: #00a0a0; } -.traceContains { color: #008000; } --> </style> @@ -35,61 +32,26 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } //: also like to make the recipe a variable, pass recipes to "higher-order" //: recipes, return recipes from recipes and so on. -:(scenario call_literal_recipe) -recipe main [ - 1:number <- call f:recipe, 34 -] -recipe f [ - 2:number <- next-ingredient - reply 2:number -] -+mem: storing 34 in location 1 - -:(scenario call_variable) -recipe main [ - 1:recipe-ordinal <- copy f:recipe - 2:number <- call 1:recipe-ordinal, 34 -] -recipe f [ - 3:number <- next-ingredient - reply 3:number -] -+mem: storing 34 in location 2 - :(before "End Mu Types Initialization") // 'recipe' is a literal -Type_ordinal["recipe"] = 0; +put(Type_ordinal, "recipe", 0); // 'recipe-ordinal' is the literal that can store recipe literals -type_ordinal recipe_ordinal = Type_ordinal["recipe-ordinal"] = Next_type_ordinal++; -Type[recipe_ordinal].name = "recipe-ordinal"; +type_ordinal recipe_ordinal = put(Type_ordinal, "recipe-ordinal", Next_type_ordinal++); +get_or_insert(Type, recipe_ordinal).name = "recipe-ordinal"; :(before "End Reagent-parsing Exceptions") -if (!r.properties.at(0).second.empty() && r.properties.at(0).second.at(0) == "recipe") { - r.set_value(Recipe_ordinal[r.name]); +if (r.properties.at(0).second && r.properties.at(0).second->value == "recipe") { + r.set_value(get(Recipe_ordinal, r.name)); return; } -:(before "End Primitive Recipe Declarations") -CALL, -:(before "End Primitive Recipe Numbers") -Recipe_ordinal["call"] = CALL; -:(before "End Primitive Recipe Implementations") -case CALL: { - if (ingredients.empty()) { - raise << current_recipe_name() << ": 'call' requires at least one ingredient (the recipe to call)\n" << end(); - break; - } - // Begin Call - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'call' should be a recipe, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); - break; - } - // todo: when we start doing type checking this will be a prime point of - // attention, so we don't accidentally allow external data to a program to - // run as code. - Current_routine->calls.push_front(call(ingredients.at(0).at(0))); - ingredients.erase(ingredients.begin()); // drop the callee - goto call_housekeeping; +:(code) +bool is_mu_recipe(reagent r) { + if (!r.type) return false; + if (r.type->value == get(Type_ordinal, "recipe")) return true; + if (r.type->value == get(Type_ordinal, "recipe-ordinal")) return true; + // End is_mu_recipe Cases + return false; } </pre> </body> diff --git a/html/038scheduler.cc.html b/html/038scheduler.cc.html index 3a258741..16b3efbb 100644 --- a/html/038scheduler.cc.html +++ b/html/038scheduler.cc.html @@ -13,15 +13,15 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.SalientComment { color: #00ffff; } +.traceContains { color: #008000; } .traceAbsent { color: #c00000; } +.SalientComment { color: #00ffff; } .cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } .Identifier { color: #804000; } .Constant { color: #00a0a0; } -.traceContains { color: #008000; } --> </style> @@ -93,7 +93,7 @@ void run(routine* rr)</sp skip_to_next_routine(); assert(Current_routine); assert(Current_routine->state == RUNNING); - trace("schedule") << current_routine_label() << end(); + trace(9990, "schedule") << current_routine_label() << end(); run_current_routine(Scheduling_interval); // Scheduler State Transitions if (Current_routine->completed()) @@ -129,10 +129,10 @@ void skip_to_next_routine() () { ostringstream result; - call_stack calls = Current_routine->calls; - for (call_stack::iterator p = calls.begin(); p != calls.end(); ++p) { + const call_stack& calls = Current_routine->calls; + for (call_stack::const_iterator p = calls.begin(); p != calls.end(); ++p) { if (p != calls.begin()) result << '/'; - result << Recipe[p->running_recipe].name; + result << get(Recipe, p->running_recipe).name; } return result.str(); } @@ -141,22 +141,16 @@ string current_routine_label() (long long int i = 0; i < SIZE(Routines); ++i) delete Routines.at(i); Routines.clear(); +Current_routine = NULL; //: special case for the very first routine :(replace{} "void run_main(int argc, char* argv[])") void run_main(int argc, char* argv[]) { - recipe_ordinal r = Recipe_ordinal[string("main")]; + recipe_ordinal r = get(Recipe_ordinal, string("main")); if (r) { - // pass in commandline args as ingredients to main - // todo: test this - routine* rr = new routine(r); - Current_routine = rr; - for (long long int i = 1; i < argc; ++i) { - vector<double> arg; - arg.push_back(new_mu_string(argv[i])); - Current_routine->calls.front().ingredient_atoms.push_back(arg); - } - run(rr); + routine* main_routine = new routine(r); + // Update main_routine + run(main_routine); } } @@ -184,26 +178,31 @@ parent_index = -1; :(before "End Primitive Recipe Declarations") START_RUNNING, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["start-running"] = START_RUNNING; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "start-running", START_RUNNING); +:(before "End Primitive Recipe Checks") case START_RUNNING: { - if (ingredients.empty()) { - raise << "'start-running' requires at least one ingredient: the recipe to start running\n" << end(); + if (inst.ingredients.empty()) { + raise_error << maybe(get(Recipe, r).name) << "'start-running' requires at least one ingredient: the recipe to start running\n" << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << "first ingredient of 'start-running' should be a recipe, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); - break; - } - if (!ingredients.at(0).at(0)) { - raise << "'start-running' received non-existent recipe: '" << current_instruction().to_string() << "'\n" << end(); + if (!is_mu_recipe(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'start-running' should be a recipe, but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case START_RUNNING: { routine* new_routine = new routine(ingredients.at(0).at(0)); new_routine->parent_index = Current_routine_index; // populate ingredients - for (long long int i = 1; i < SIZE(current_instruction().ingredients); ++i) + for (long long int i = 1; i < SIZE(current_instruction().ingredients); ++i) { new_routine->calls.front().ingredient_atoms.push_back(ingredients.at(i)); + reagent ingredient = current_instruction().ingredients.at(i); + canonize_type(ingredient); + new_routine->calls.front().ingredient_types.push_back(ingredient.type); + ingredient.type = NULL; // release long-lived pointer + } Routines.push_back(new_routine); products.resize(1); products.at(0).push_back(new_routine->id); @@ -243,7 +242,7 @@ recipe f2 [ +schedule: f1 +run: 2:number <- copy 0 -:(scenario start_running_takes_args) +:(scenario start_running_takes_ingredients) recipe f1 [ start-running f2:recipe, 3 # wait for f2 to run @@ -296,6 +295,30 @@ recipe f1 [ +schedule: f1 -run: idle +//:: Errors in a routine cause it to terminate. + +:(scenario scheduler_terminates_routines_after_errors) +% Hide_errors = true; +% Scheduling_interval = 2; +recipe f1 [ + start-running f2:recipe + 1:number <- copy 0 + 2:number <- copy 0 +] +recipe f2 [ + # divide by 0 twice + 3:number <- divide-with-remainder 4, 0 + 4:number <- divide-with-remainder 4, 0 +] +# f2 should stop after first divide by 0 ++error: f2: divide by zero in '3:number <- divide-with-remainder 4, 0' +-error: f2: divide by zero in '4:number <- divide-with-remainder 4, 0' + +:(after "operator<<(ostream& os, unused end)") + if (Trace_stream && Trace_stream->curr_label == "error" && Current_routine) { + Current_routine->state = COMPLETED; + } + //:: Routines are marked completed when their parent completes. :(scenario scheduler_kills_orphans) @@ -346,17 +369,21 @@ recipe f2 [ :(before "End Primitive Recipe Declarations") ROUTINE_STATE, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["routine-state"] = ROUTINE_STATE; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "routine-state", ROUTINE_STATE); +:(before "End Primitive Recipe Checks") case ROUTINE_STATE: { - if (SIZE(ingredients) != 1) { - raise << current_recipe_name() << ": 'routine-state' requires exactly one ingredient, but got " << current_instruction().to_string() << '\n' << end(); + if (SIZE(inst.ingredients) != 1) { + raise_error << maybe(get(Recipe, r).name) << "'routine-state' requires exactly one ingredient, but got " << inst.to_string() << '\n' << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'routine-state' should be a routine id generated by 'start-running', but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_number(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'routine-state' should be a routine id generated by 'start-running', but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case ROUTINE_STATE: { long long int id = ingredients.at(0).at(0); long long int result = -1; for (long long int i = 0; i < SIZE(Routines); ++i) { @@ -375,17 +402,21 @@ case ROUTINE_STATE: { :(before "End Primitive Recipe Declarations") RESTART, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["restart"] = RESTART; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "restart", RESTART); +:(before "End Primitive Recipe Checks") case RESTART: { - if (SIZE(ingredients) != 1) { - raise << current_recipe_name() << ": 'restart' requires exactly one ingredient, but got " << current_instruction().to_string() << '\n' << end(); + if (SIZE(inst.ingredients) != 1) { + raise_error << maybe(get(Recipe, r).name) << "'restart' requires exactly one ingredient, but got " << inst.to_string() << '\n' << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'restart' should be a routine id generated by 'start-running', but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_number(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'restart' should be a routine id generated by 'start-running', but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case RESTART: { 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) { @@ -399,17 +430,21 @@ case RESTART: { :(before "End Primitive Recipe Declarations") STOP, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["stop"] = STOP; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "stop", STOP); +:(before "End Primitive Recipe Checks") case STOP: { - if (SIZE(ingredients) != 1) { - raise << current_recipe_name() << ": 'stop' requires exactly one ingredient, but got " << current_instruction().to_string() << '\n' << end(); + if (SIZE(inst.ingredients) != 1) { + raise_error << maybe(get(Recipe, r).name) << "'stop' requires exactly one ingredient, but got " << inst.to_string() << '\n' << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'stop' should be a routine id generated by 'start-running', but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_number(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'stop' should be a routine id generated by 'start-running', but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case STOP: { 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) { @@ -423,7 +458,11 @@ case STOP: { :(before "End Primitive Recipe Declarations") _DUMP_ROUTINES, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$dump-routines"] = _DUMP_ROUTINES; +put(Recipe_ordinal, "$dump-routines", _DUMP_ROUTINES); +:(before "End Primitive Recipe Checks") +case _DUMP_ROUTINES: { + break; +} :(before "End Primitive Recipe Implementations") case _DUMP_ROUTINES: { for (long long int i = 0; i < SIZE(Routines); ++i) { @@ -456,7 +495,7 @@ DISCONTINUED, :(before "End Scheduler State Transitions") if (Current_routine->limit >= 0) { if (Current_routine->limit <= Scheduling_interval) { - trace("schedule") << "discontinuing routine " << Current_routine->id << end(); + trace(9999, "schedule") << "discontinuing routine " << Current_routine->id << end(); Current_routine->state = DISCONTINUED; Current_routine->limit = 0; } @@ -473,21 +512,25 @@ limit = -1; :(before "End Primitive Recipe Declarations") LIMIT_TIME, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["limit-time"] = LIMIT_TIME; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "limit-time", LIMIT_TIME); +:(before "End Primitive Recipe Checks") case LIMIT_TIME: { - if (SIZE(ingredients) != 2) { - raise << current_recipe_name() << ": 'limit-time' requires exactly two ingredient, but got " << current_instruction().to_string() << '\n' << end(); + if (SIZE(inst.ingredients) != 2) { + raise_error << maybe(get(Recipe, r).name) << "'limit-time' requires exactly two ingredient, but got " << inst.to_string() << '\n' << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'limit-time' should be a routine id generated by 'start-running', but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_number(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'limit-time' should be a routine id generated by 'start-running', but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } - if (!scalar(ingredients.at(1))) { - raise << current_recipe_name() << ": second ingredient of 'limit-time' should be a number (of instructions to run for), but got " << current_instruction().ingredients.at(1).original_string << '\n' << end(); + if (!is_mu_number(inst.ingredients.at(1))) { + raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'limit-time' should be a number (of instructions to run for), but got " << inst.ingredients.at(1).original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case LIMIT_TIME: { 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) { diff --git a/html/039wait.cc.html b/html/039wait.cc.html index dc19a3b3..057c54b6 100644 --- a/html/039wait.cc.html +++ b/html/039wait.cc.html @@ -13,8 +13,8 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.cSpecial { color: #008000; } .traceContains { color: #008000; } +.cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } @@ -66,14 +66,19 @@ waiting_on_location = old_value_of_waiting_location = 0</ :(before "End Primitive Recipe Declarations") WAIT_FOR_LOCATION, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["wait-for-location"] = WAIT_FOR_LOCATION; +put(Recipe_ordinal, "wait-for-location", WAIT_FOR_LOCATION); +:(before "End Primitive Recipe Checks") +case WAIT_FOR_LOCATION: { + break; +} :(before "End Primitive Recipe Implementations") case WAIT_FOR_LOCATION: { - reagent loc = canonize(current_instruction().ingredients.at(0)); + reagent loc = current_instruction().ingredients.at(0); + canonize(loc); Current_routine->state = WAITING; Current_routine->waiting_on_location = loc.value; - Current_routine->old_value_of_waiting_location = Memory[loc.value]; - trace(Primitive_recipe_depth, "run") << "waiting for location " << loc.value << " to change from " << Memory[loc.value] << end(); + Current_routine->old_value_of_waiting_location = get_or_insert(Memory, loc.value); + trace(9998, "run") << "waiting for location " << loc.value << " to change from " << no_scientific(get_or_insert(Memory, loc.value)) << end(); break; } @@ -83,8 +88,8 @@ case WAIT_FOR_LOCATION: { for (long long int i = 0; i < SIZE(Routines); ++i) { if (Routines.at(i)->state != WAITING) continue; if (Routines.at(i)->waiting_on_location && - Memory[Routines.at(i)->waiting_on_location] != Routines.at(i)->old_value_of_waiting_location) { - trace("schedule") << "waking up routine\n" << end(); + get_or_insert(Memory, Routines.at(i)->waiting_on_location) != Routines.at(i)->old_value_of_waiting_location) { + trace(9999, "schedule") << "waking up routine\n" << end(); Routines.at(i)->state = RUNNING; Routines.at(i)->waiting_on_location = Routines.at(i)->old_value_of_waiting_location = 0; } @@ -120,24 +125,28 @@ waiting_on_routine = 0;</s :(before "End Primitive Recipe Declarations") WAIT_FOR_ROUTINE, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["wait-for-routine"] = WAIT_FOR_ROUTINE; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "wait-for-routine", WAIT_FOR_ROUTINE); +:(before "End Primitive Recipe Checks") case WAIT_FOR_ROUTINE: { - if (SIZE(ingredients) != 1) { - raise << current_recipe_name() << ": 'wait-for-routine' requires exactly one ingredient, but got " << current_instruction().to_string() << '\n' << end(); + if (SIZE(inst.ingredients) != 1) { + raise_error << maybe(get(Recipe, r).name) << "'wait-for-routine' requires exactly one ingredient, but got " << inst.to_string() << '\n' << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'wait-for-routine' should be a routine id generated by 'start-running', but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_number(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'wait-for-routine' should be a routine id generated by 'start-running', but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case WAIT_FOR_ROUTINE: { if (ingredients.at(0).at(0) == Current_routine->id) { - raise << current_recipe_name() << ": routine can't wait for itself! " << current_instruction().to_string() << '\n' << end(); + raise_error << maybe(current_recipe_name()) << "routine can't wait for itself! " << current_instruction().to_string() << '\n' << end(); break; } Current_routine->state = WAITING; Current_routine->waiting_on_routine = ingredients.at(0).at(0); - trace(Primitive_recipe_depth, "run") << "waiting for routine " << ingredients.at(0).at(0) << end(); + trace(9998, "run") << "waiting for routine " << ingredients.at(0).at(0) << end(); break; } @@ -152,7 +161,7 @@ for (long long int i = 0</ assert(id != Routines.at(i)->id); // routine can't wait on itself 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 << end(); + trace(9999, "schedule") << "waking up routine " << Routines.at(i)->id << end(); Routines.at(i)->state = RUNNING; Routines.at(i)->waiting_on_routine = 0; } @@ -162,7 +171,11 @@ for (long long int i = 0</ :(before "End Primitive Recipe Declarations") SWITCH, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["switch"] = SWITCH; +put(Recipe_ordinal, "switch", SWITCH); +:(before "End Primitive Recipe Checks") +case SWITCH: { + break; +} :(before "End Primitive Recipe Implementations") case SWITCH: { long long int id = some_other_running_routine(); diff --git a/html/040brace.cc.html b/html/040brace.cc.html index eb62a889..6f994e22 100644 --- a/html/040brace.cc.html +++ b/html/040brace.cc.html @@ -13,13 +13,14 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.traceContains { color: #008000; } .cSpecial { color: #008000; } +.CommentedCode { color: #6c6c6c; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } .Identifier { color: #804000; } .Constant { color: #00a0a0; } -.traceContains { color: #008000; } --> </style> @@ -60,99 +61,108 @@ recipe main [ 1:number <- copy 0 } ] -+after-brace: recipe main -+after-brace: jump 1:offset -+after-brace: copy ... ++transform: --- transform braces for recipe main ++transform: jump 1:offset ++transform: copy ... -//: one-time setup -:(after "int main") - Transform.push_back(transform_braces); +:(after "Begin Transforms") +Transform.push_back(transform_braces); // idempotent :(code) void transform_braces(const recipe_ordinal 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 < SIZE(Recipe[r].steps); ++index) { - const instruction& inst = Recipe[r].steps.at(index); + trace(9991, "transform") << "--- transform braces for recipe " << get(Recipe, r).name << end(); +//? cerr << "--- transform braces for recipe " << get(Recipe, r).name << '\n'; + for (long long int index = 0; index < SIZE(get(Recipe, r).steps); ++index) { + const instruction& inst = get(Recipe, r).steps.at(index); if (inst.label == "{") { - trace("brace") << Recipe[r].name << ": push (open, " << index << ")" << end(); + trace(9993, "transform") << maybe(get(Recipe, r).name) << "push (open, " << index << ")" << end(); braces.push_back(pair<int,long long int>(OPEN, index)); } if (inst.label == "}") { - trace("brace") << "push (close, " << index << ")" << end(); + trace(9993, "transform") << "push (close, " << index << ")" << end(); braces.push_back(pair<int,long long int>(CLOSE, index)); } } stack</*step*/long long int> open_braces; - trace("after-brace") << "recipe " << Recipe[r].name << end(); - for (long long int index = 0; index < SIZE(Recipe[r].steps); ++index) { - instruction& inst = Recipe[r].steps.at(index); + for (long long int index = 0; index < SIZE(get(Recipe, r).steps); ++index) { + instruction& inst = get(Recipe, r).steps.at(index); if (inst.label == "{") { open_braces.push(index); continue; } if (inst.label == "}") { + if (open_braces.empty()) { + raise << "missing '{' in " << get(Recipe, r).name << '\n'; + return; + } open_braces.pop(); continue; } if (inst.is_label) continue; - if (inst.operation != Recipe_ordinal["loop"] - && inst.operation != Recipe_ordinal["loop-if"] - && inst.operation != Recipe_ordinal["loop-unless"] - && inst.operation != Recipe_ordinal["break"] - && inst.operation != Recipe_ordinal["break-if"] - && inst.operation != Recipe_ordinal["break-unless"]) { - trace("after-brace") << inst.name << " ..." << end(); + if (inst.old_name != "loop" + && inst.old_name != "loop-if" + && inst.old_name != "loop-unless" + && inst.old_name != "break" + && inst.old_name != "break-if" + && inst.old_name != "break-unless") { + trace(9992, "transform") << inst.old_name << " ..." << end(); continue; } // check for errors - if (inst.name.find("-if") != string::npos || inst.name.find("-unless") != string::npos) { + if (inst.old_name.find("-if") != string::npos || inst.old_name.find("-unless") != string::npos) { if (inst.ingredients.empty()) { - raise << inst.name << " expects 1 or 2 ingredients, but got none\n" << end(); + raise_error << inst.old_name << " expects 1 or 2 ingredients, but got none\n" << end(); continue; } } // update instruction operation - if (inst.name.find("-if") != string::npos) - inst.operation = Recipe_ordinal["jump-if"]; - else if (inst.name.find("-unless") != string::npos) - inst.operation = Recipe_ordinal["jump-unless"]; - else - inst.operation = Recipe_ordinal["jump"]; + if (inst.old_name.find("-if") != string::npos) { + inst.name = "jump-if"; + inst.operation = JUMP_IF; + } + else if (inst.old_name.find("-unless") != string::npos) { + inst.name = "jump-unless"; + inst.operation = JUMP_UNLESS; + } + else { + inst.name = "jump"; + inst.operation = JUMP; + } // check for explicitly provided targets - if (inst.name.find("-if") != string::npos || inst.name.find("-unless") != string::npos) { + if (inst.old_name.find("-if") != string::npos || inst.old_name.find("-unless") != string::npos) { // conditional branches check arg 1 if (SIZE(inst.ingredients) > 1 && is_literal(inst.ingredients.at(1))) { - trace("after-brace") << "jump " << inst.ingredients.at(1).name << ":offset" << end(); + trace(9992, "transform") << inst.name << ' ' << inst.ingredients.at(1).name << ":offset" << end(); continue; } } else { // unconditional branches check arg 0 if (!inst.ingredients.empty() && is_literal(inst.ingredients.at(0))) { - trace("after-brace") << "jump " << inst.ingredients.at(0).name << ":offset" << end(); + trace(9992, "transform") << "jump " << inst.ingredients.at(0).name << ":offset" << end(); continue; } } // if implicit, compute target reagent target; - target.types.push_back(Type_ordinal["offset"]); + target.type = new type_tree(get(Type_ordinal, "offset")); + target.properties.at(0).second = new string_tree("offset"); target.set_value(0); if (open_braces.empty()) - raise << inst.name << " needs a '{' before\n" << end(); - else if (inst.name.find("loop") != string::npos) + raise_error << inst.old_name << " needs a '{' before\n" << end(); + else if (inst.old_name.find("loop") != string::npos) target.set_value(open_braces.top()-index); else // break instruction target.set_value(matching_brace(open_braces.top(), braces, r) - index - 1); inst.ingredients.push_back(target); // log computed target - if (inst.name.find("-if") != string::npos) - trace("after-brace") << "jump-if " << inst.ingredients.at(0).name << ", " << target.value << ":offset" << end(); - else if (inst.name.find("-unless") != string::npos) - trace("after-brace") << "jump-unless " << inst.ingredients.at(0).name << ", " << target.value << ":offset" << end(); + if (inst.name == "jump") + trace(9992, "transform") << "jump " << no_scientific(target.value) << ":offset" << end(); else - trace("after-brace") << "jump " << target.value << ":offset" << end(); + trace(9992, "transform") << inst.name << ' ' << inst.ingredients.at(0).name << ", " << no_scientific(target.value) << ":offset" << end(); } } @@ -165,34 +175,10 @@ long long int matching_brace(long long int index< stacksize += (p->first ? 1 : -1); if (stacksize == 0) return p->second; } - raise << Recipe[r].name << ": unbalanced '{'\n" << end(); - return SIZE(Recipe[r].steps); // exit current routine + raise_error << maybe(get(Recipe, r).name) << "unbalanced '{'\n" << end(); + return SIZE(get(Recipe, r).steps); // exit current routine } -// temporarily suppress run -void transform(string form) { - load(form); - transform_all(); -} - -//: Make sure these pseudo recipes get consistent numbers in all tests, even -//: though they aren't implemented. - -:(before "End Primitive Recipe Declarations") -BREAK, -BREAK_IF, -BREAK_UNLESS, -LOOP, -LOOP_IF, -LOOP_UNLESS, -:(before "End Primitive Recipe Numbers") -Recipe_ordinal["break"] = BREAK; -Recipe_ordinal["break-if"] = BREAK_IF; -Recipe_ordinal["break-unless"] = BREAK_UNLESS; -Recipe_ordinal["loop"] = LOOP; -Recipe_ordinal["loop-if"] = LOOP_IF; -Recipe_ordinal["loop-unless"] = LOOP_UNLESS; - :(scenario loop) recipe main [ 1:number <- copy 0 @@ -202,11 +188,11 @@ recipe main [ loop } ] -+after-brace: recipe main -+after-brace: copy ... -+after-brace: copy ... -+after-brace: copy ... -+after-brace: jump -2:offset ++transform: --- transform braces for recipe main ++transform: copy ... ++transform: copy ... ++transform: copy ... ++transform: jump -2:offset :(scenario break_empty_block) recipe main [ @@ -215,9 +201,9 @@ recipe main [ break } ] -+after-brace: recipe main -+after-brace: copy ... -+after-brace: jump 0:offset ++transform: --- transform braces for recipe main ++transform: copy ... ++transform: jump 0:offset :(scenario break_cascading) recipe main [ @@ -229,10 +215,10 @@ recipe main [ break } ] -+after-brace: recipe main -+after-brace: copy ... -+after-brace: jump 0:offset -+after-brace: jump 0:offset ++transform: --- transform braces for recipe main ++transform: copy ... ++transform: jump 0:offset ++transform: jump 0:offset :(scenario break_cascading_2) recipe main [ @@ -246,12 +232,12 @@ recipe main [ break } ] -+after-brace: recipe main -+after-brace: copy ... -+after-brace: copy ... -+after-brace: jump 1:offset -+after-brace: copy ... -+after-brace: jump 0:offset ++transform: --- transform braces for recipe main ++transform: copy ... ++transform: copy ... ++transform: jump 1:offset ++transform: copy ... ++transform: jump 0:offset :(scenario break_if) recipe main [ @@ -265,12 +251,12 @@ recipe main [ break } ] -+after-brace: recipe main -+after-brace: copy ... -+after-brace: copy ... -+after-brace: jump-if 2, 1:offset -+after-brace: copy ... -+after-brace: jump 0:offset ++transform: --- transform braces for recipe main ++transform: copy ... ++transform: copy ... ++transform: jump-if 2, 1:offset ++transform: copy ... ++transform: jump 0:offset :(scenario break_nested) recipe main [ @@ -284,7 +270,7 @@ recipe main [ 4:number <- copy 0 } ] -+after-brace: jump 4:offset ++transform: jump 4:offset :(scenario break_nested_degenerate) recipe main [ @@ -297,7 +283,7 @@ recipe main [ 4:number <- copy 0 } ] -+after-brace: jump 3:offset ++transform: jump 3:offset :(scenario break_nested_degenerate_2) recipe main [ @@ -309,17 +295,17 @@ recipe main [ } } ] -+after-brace: jump 2:offset ++transform: jump 2:offset :(scenario break_label) -% Hide_warnings = true; +% Hide_errors = true; recipe main [ 1:number <- copy 0 { break +foo:offset } ] -+after-brace: jump +foo:offset ++transform: jump +foo:offset :(scenario break_unless) recipe main [ @@ -330,11 +316,11 @@ recipe main [ 3:number <- copy 0 } ] -+after-brace: recipe main -+after-brace: copy ... -+after-brace: copy ... -+after-brace: jump-unless 2, 1:offset -+after-brace: copy ... ++transform: --- transform braces for recipe main ++transform: copy ... ++transform: copy ... ++transform: jump-unless 2, 1:offset ++transform: copy ... :(scenario loop_unless) recipe main [ @@ -345,11 +331,11 @@ recipe main [ 3:number <- copy 0 } ] -+after-brace: recipe main -+after-brace: copy ... -+after-brace: copy ... -+after-brace: jump-unless 2, -1:offset -+after-brace: copy ... ++transform: --- transform braces for recipe main ++transform: copy ... ++transform: copy ... ++transform: jump-unless 2, -1:offset ++transform: copy ... :(scenario loop_nested) recipe main [ @@ -363,8 +349,8 @@ recipe main [ 5:number <- copy 0 } ] -+after-brace: recipe main -+after-brace: jump-if 4, -5:offset ++transform: --- transform braces for recipe main ++transform: jump-if 4, -5:offset :(scenario loop_label) recipe main [ @@ -372,9 +358,9 @@ recipe main [ +foo 2:number <- copy 0 ] -+after-brace: recipe main -+after-brace: copy ... -+after-brace: copy ... ++transform: --- transform braces for recipe main ++transform: copy ... ++transform: copy ... //: test how things actually run :(scenarios run) @@ -394,21 +380,47 @@ recipe test-factorial [ ] +mem: location 2 is 120 -:(scenario break_outside_braces_warns) -% Hide_warnings = true; +:(scenario break_outside_braces_fails) +% Hide_errors = true; recipe main [ break ] -+warn: break needs a '{' before ++error: break needs a '{' before -:(scenario break_conditional_without_ingredient_warns) -% Hide_warnings = true; +:(scenario break_conditional_without_ingredient_fails) +% Hide_errors = true; recipe main [ { break-if } ] -+warn: break-if expects 1 or 2 ingredients, but got none ++error: break-if expects 1 or 2 ingredients, but got none + +//: Make sure these pseudo recipes get consistent numbers in all tests, even +//: though they aren't implemented. Allows greater flexibility in ordering +//: transforms. + +:(before "End Primitive Recipe Declarations") +BREAK, +BREAK_IF, +BREAK_UNLESS, +LOOP, +LOOP_IF, +LOOP_UNLESS, +:(before "End Primitive Recipe Numbers") +put(Recipe_ordinal, "break", BREAK); +put(Recipe_ordinal, "break-if", BREAK_IF); +put(Recipe_ordinal, "break-unless", BREAK_UNLESS); +put(Recipe_ordinal, "loop", LOOP); +put(Recipe_ordinal, "loop-if", LOOP_IF); +put(Recipe_ordinal, "loop-unless", LOOP_UNLESS); +:(before "End Primitive Recipe Checks") +case BREAK: break; +case BREAK_IF: break; +case BREAK_UNLESS: break; +case LOOP: break; +case LOOP_IF: break; +case LOOP_UNLESS: break; </pre> </body> </html> diff --git a/html/041jump_target.cc.html b/html/041jump_target.cc.html index 8c0ce0cf..53f93910 100644 --- a/html/041jump_target.cc.html +++ b/html/041jump_target.cc.html @@ -13,8 +13,8 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.traceAbsent { color: #c00000; } .traceContains { color: #008000; } +.traceAbsent { color: #c00000; } .cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } @@ -50,41 +50,41 @@ recipe main [ -mem: storing 0 in location 1 :(before "End Mu Types Initialization") -Type_ordinal["label"] = 0; +put(Type_ordinal, "label", 0); -:(after "int main") - Transform.push_back(transform_labels); +:(before "Transform.push_back(transform_braces)") +Transform.push_back(transform_labels); // idempotent :(code) void transform_labels(const recipe_ordinal r) { 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); + for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) { + const instruction& inst = get(Recipe, r).steps.at(i); if (!inst.label.empty() && inst.label.at(0) == '+') { - if (offset.find(inst.label) == offset.end()) { + if (!contains_key(offset, inst.label)) { offset[inst.label] = i; } else { - raise << Recipe[r].name << ": duplicate label '" << inst.label << "'" << end(); + raise_error << maybe(get(Recipe, r).name) << "duplicate label '" << inst.label << "'" << end(); // have all jumps skip some random but noticeable and deterministic amount of code offset[inst.label] = 9999; } } } - for (long long int i = 0; i < SIZE(Recipe[r].steps); ++i) { - instruction& inst = Recipe[r].steps.at(i); - if (inst.operation == Recipe_ordinal["jump"]) { + for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) { + instruction& inst = get(Recipe, r).steps.at(i); + if (inst.name == "jump") { replace_offset(inst.ingredients.at(0), offset, i, r); } - if (inst.operation == Recipe_ordinal["jump-if"] || inst.operation == Recipe_ordinal["jump-unless"]) { + if (inst.name == "jump-if" || inst.name == "jump-unless") { replace_offset(inst.ingredients.at(1), offset, i, r); } - if ((inst.operation == Recipe_ordinal["loop"] || inst.operation == Recipe_ordinal["break"]) + if ((inst.name == "loop" || inst.name == "break") && SIZE(inst.ingredients) == 1) { replace_offset(inst.ingredients.at(0), offset, i, r); } - if ((inst.operation == Recipe_ordinal["loop-if"] || inst.operation == Recipe_ordinal["loop-unless"] - || inst.operation == Recipe_ordinal["break-if"] || inst.operation == Recipe_ordinal["break-unless"]) + if ((inst.name == "loop-if" || inst.name == "loop-unless" + || inst.name == "break-if" || inst.name == "break-unless") && SIZE(inst.ingredients) == 2) { replace_offset(inst.ingredients.at(1), offset, i, r); } @@ -94,19 +94,19 @@ void transform_labels(const recipe_ordinal r:(code) void replace_offset(reagent& x, /*const*/ map<string, long long int>& offset, const long long int current_offset, const recipe_ordinal r) { if (!is_literal(x)) { - raise << Recipe[r].name << ": jump target must be offset or label but is " << x.original_string << '\n' << end(); + raise_error << maybe(get(Recipe, r).name) << "jump target must be offset or label but is " << x.original_string << '\n' << end(); x.set_value(0); // no jump by default return; } assert(!x.initialized); if (is_integer(x.name)) return; // non-labels will be handled like other number operands if (!is_jump_target(x.name)) { - raise << Recipe[r].name << ": can't jump to label " << x.name << '\n' << end(); + raise_error << maybe(get(Recipe, r).name) << "can't jump to label " << x.name << '\n' << end(); x.set_value(0); // no jump by default return; } - if (offset.find(x.name) == offset.end()) { - raise << Recipe[r].name << ": can't find label " << x.name << '\n' << end(); + if (!contains_key(offset, x.name)) { + raise_error << maybe(get(Recipe, r).name) << "can't find label " << x.name << '\n' << end(); x.set_value(0); // no jump by default return; } @@ -167,18 +167,18 @@ recipe main [ +mem: storing 0 in location 5 -mem: storing 0 in location 4 -:(scenario recipe_warns_on_duplicate_jump_target) -% Hide_warnings = true; +:(scenario recipe_fails_on_duplicate_jump_target) +% Hide_errors = true; recipe main [ +label 1:number <- copy 0 +label 2:number <- copy 0 ] -+warn: main: duplicate label '+label' ++error: main: duplicate label '+label' :(scenario jump_ignores_nontarget_label) -% Hide_warnings = true; +% Hide_errors = true; recipe main [ # first a few lines of padding to exercise the offset computation 1:number <- copy 0 @@ -189,7 +189,7 @@ recipe main [ $target 5:number <- copy 0 ] -+warn: main: can't jump to label $target ++error: main: can't jump to label $target </pre> </body> </html> diff --git a/html/042name.cc.html b/html/042name.cc.html index 16cf8117..da006079 100644 --- a/html/042name.cc.html +++ b/html/042name.cc.html @@ -13,15 +13,16 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.cSpecial { color: #008000; } -.SalientComment { color: #00ffff; } +.traceContains { color: #008000; } .traceAbsent { color: #c00000; } +.Identifier { color: #804000; } +.cSpecial { color: #008000; } .Constant { color: #00a0a0; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } -.Identifier { color: #804000; } -.traceContains { color: #008000; } +.CommentedCode { color: #6c6c6c; } +.SalientComment { color: #00ffff; } --> </style> @@ -45,15 +46,16 @@ recipe main [ +mem: storing 0 in location 1 :(scenarios transform) -:(scenario transform_names_warns) -% Hide_warnings = true; +:(scenario transform_names_fails_on_use_before_define) +% Hide_errors = true; recipe main [ x:number <- copy y:number ] -+warn: use before set: y in main ++error: main: use before set: y +# todo: detect conditional defines -:(after "int main") - Transform.push_back(transform_names); +:(after "Transform.push_back(check_or_set_invalid_types") // there'll be other transforms relating to types; they all need to happen first +Transform.push_back(transform_names); // idempotent :(before "End Globals") map<recipe_ordinal, map<string, long long int> > Name; @@ -64,31 +66,33 @@ for (long long int i = 0</ :(code) void transform_names(const recipe_ordinal r) { + trace(9991, "transform") << "--- transform names for recipe " << get(Recipe, r).name << end(); +//? cerr << "--- transform names for recipe " << get(Recipe, r).name << '\n'; bool names_used = false; bool numeric_locations_used = false; map<string, long long int>& names = Name[r]; // store the indices 'used' so far in the map long long int& curr_idx = names[""]; ++curr_idx; // avoid using index 0, benign skip in some other cases - for (long long int i = 0; i < SIZE(Recipe[r].steps); ++i) { - instruction& inst = Recipe[r].steps.at(i); - // Per-recipe Transforms + for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) { + instruction& inst = get(Recipe, r).steps.at(i); + // End transform_names(inst) Special-cases // map names to addresses 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), inst)) continue; + if (disqualified(inst.ingredients.at(in), inst, get(Recipe, r).name)) continue; if (!already_transformed(inst.ingredients.at(in), names)) { - raise << "use before set: " << inst.ingredients.at(in).name << " in " << Recipe[r].name << '\n' << end(); + raise_error << maybe(get(Recipe, r).name) << "use before set: " << inst.ingredients.at(in).name << '\n' << end(); } inst.ingredients.at(in).set_value(lookup_name(inst.ingredients.at(in), r)); } 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), inst)) continue; + if (disqualified(inst.products.at(out), inst, get(Recipe, r).name)) continue; if (names.find(inst.products.at(out).name) == names.end()) { - trace("name") << "assign " << inst.products.at(out).name << " " << curr_idx << end(); + trace(9993, "name") << "assign " << inst.products.at(out).name << " " << curr_idx << end(); names[inst.products.at(out).name] = curr_idx; curr_idx += size_of(inst.products.at(out)); } @@ -96,12 +100,12 @@ void transform_names(const recipe_ordinal r} } if (names_used && numeric_locations_used) - raise << "mixing variable names and numeric addresses in " << Recipe[r].name << '\n' << end(); + raise_error << maybe(get(Recipe, r).name) << "mixing variable names and numeric addresses\n" << end(); } -bool disqualified(/*mutable*/ reagent& x, const instruction& inst) { - if (x.types.empty()) { - raise << "missing type in '" << inst.to_string() << "'\n" << end(); +bool disqualified(/*mutable*/ reagent& x, const instruction& inst, const string& recipe_name) { + if (!x.type) { + raise_error << maybe(recipe_name) << "missing type for " << x.original_string << " in '" << inst.to_string() << "'\n" << end(); return true; } if (is_raw(x)) return true; @@ -113,27 +117,28 @@ bool disqualified(/* } bool already_transformed(const reagent& r, const map<string, long long int>& names) { - return names.find(r.name) != names.end(); + return contains_key(names, r.name); } long long int lookup_name(const reagent& r, const recipe_ordinal default_recipe) { return Name[default_recipe][r.name]; } -type_ordinal skip_addresses(const vector<type_ordinal>& types) { - for (long long int i = 0; i < SIZE(types); ++i) { - if (types.at(i) != Type_ordinal["address"]) return types.at(i); +type_ordinal skip_addresses(type_tree* type, const string& recipe_name) { + for (; type; type = type->right) { + if (type->value != get(Type_ordinal, "address")) + return type->value; } - raise << "expected a container" << '\n' << end(); + raise_error << maybe(recipe_name) << "expected a container" << '\n' << end(); return -1; } -int find_element_name(const type_ordinal t, const string& name) { - const type_info& container = Type[t]; +int find_element_name(const type_ordinal t, const string& name, const string& recipe_name) { + const type_info& container = get(Type, t); 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 " << Type[t].name << '\n' << end(); + raise_error << maybe(recipe_name) << "unknown element " << name << " in container " << get(Type, t).name << '\n' << end(); return -1; } @@ -151,13 +156,6 @@ bool is_named_location(const reagent& xreturn !is_integer(x.name); } -bool is_raw(const reagent& r) { - 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; -} - bool is_special_name(const string& s) { if (s == "_") return true; if (s == "0") return true; @@ -176,51 +174,51 @@ recipe main [ //: an escape hatch to suppress name conversion that we'll use later :(scenarios run) :(scenario transform_names_passes_raw) -% Hide_warnings = true; +% Hide_errors = true; recipe main [ x:number/raw <- copy 0 ] -name: assign x 1 -+warn: can't write to location 0 in 'x:number/raw <- copy 0' ++error: can't write to location 0 in 'x:number/raw <- copy 0' :(scenarios transform) -:(scenario transform_names_warns_when_mixing_names_and_numeric_locations) -% Hide_warnings = true; +:(scenario transform_names_fails_when_mixing_names_and_numeric_locations) +% Hide_errors = true; recipe main [ x:number <- copy 1:number ] -+warn: mixing variable names and numeric addresses in main ++error: main: mixing variable names and numeric addresses -:(scenario transform_names_warns_when_mixing_names_and_numeric_locations_2) -% Hide_warnings = true; +:(scenario transform_names_fails_when_mixing_names_and_numeric_locations_2) +% Hide_errors = true; recipe main [ x:number <- copy 1 1:number <- copy x:number ] -+warn: mixing variable names and numeric addresses in main ++error: main: mixing variable names and numeric addresses -:(scenario transform_names_does_not_warn_when_mixing_names_and_raw_locations) -% Hide_warnings = true; +:(scenario transform_names_does_not_fail_when_mixing_names_and_raw_locations) +% Hide_errors = true; recipe main [ x:number <- copy 1:number/raw ] --warn: mixing variable names and numeric addresses in main -$warn: 0 +-error: main: mixing variable names and numeric addresses +$error: 0 -:(scenario transform_names_does_not_warn_when_mixing_names_and_literals) -% Hide_warnings = true; +:(scenario transform_names_does_not_fail_when_mixing_names_and_literals) +% Hide_errors = true; recipe main [ x:number <- copy 1 ] --warn: mixing variable names and numeric addresses in main -$warn: 0 +-error: main: mixing variable names and numeric addresses +$error: 0 //:: Support element names for containers in 'get' and 'get-address'. //: update our running example container for the next test :(before "End Mu Types Initialization") -Type[point].element_names.push_back("x"); -Type[point].element_names.push_back("y"); +get(Type, point).element_names.push_back("x"); +get(Type, point).element_names.push_back("y"); :(scenario transform_names_transforms_container_elements) recipe main [ p:address:point <- copy 0 # unsafe @@ -230,21 +228,20 @@ recipe main [ +name: element y of type point is at offset 1 +name: element x of type point is at offset 0 -:(after "Per-recipe Transforms") +:(before "End transform_names(inst) Special-cases") // replace element names of containers with offsets -if (inst.operation == Recipe_ordinal["get"] - || inst.operation == Recipe_ordinal["get-address"]) { +if (inst.name == "get" || inst.name == "get-address") { if (SIZE(inst.ingredients) != 2) { - raise << Recipe[r].name << ": exactly 2 ingredients expected in '" << inst.to_string() << "'\n" << end(); + raise_error << maybe(get(Recipe, r).name) << "exactly 2 ingredients expected in '" << inst.to_string() << "'\n" << end(); break; } if (!is_literal(inst.ingredients.at(1))) - raise << Recipe[r].name << ": expected ingredient 1 of " << (inst.operation == Recipe_ordinal["get"] ? "'get'" : "'get-address'") << " to have type 'offset'; got " << inst.ingredients.at(1).original_string << '\n' << end(); + raise_error << maybe(get(Recipe, r).name) << "expected ingredient 1 of " << (inst.name == "get" ? "'get'" : "'get-address'") << " to have type 'offset'; got " << inst.ingredients.at(1).original_string << '\n' << end(); if (inst.ingredients.at(1).name.find_first_not_of("0123456789") != string::npos) { // since first non-address in base type must be a container, we don't have to canonize - type_ordinal 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)); - trace("name") << "element " << inst.ingredients.at(1).name << " of type " << Type[base_type].name << " is at offset " << inst.ingredients.at(1).value << end(); + type_ordinal base_type = skip_addresses(inst.ingredients.at(0).type, get(Recipe, r).name); + inst.ingredients.at(1).set_value(find_element_name(base_type, inst.ingredients.at(1).name, get(Recipe, r).name)); + trace(9993, "name") << "element " << inst.ingredients.at(1).name << " of type " << get(Type, base_type).name << " is at offset " << no_scientific(inst.ingredients.at(1).value) << end(); } } @@ -252,8 +249,8 @@ if (inst.operation :(scenarios transform) :(scenario transform_names_handles_containers) recipe main [ - a:point <- copy 0 - b:number <- copy 0 + a:point <- copy 0/raw + b:number <- copy 0/raw ] +name: assign a 1 +name: assign b 3 @@ -271,19 +268,19 @@ recipe main [ +name: variant p of type number-or-point has tag 1 +mem: storing 13 in location 20 -:(after "Per-recipe Transforms") +:(before "End transform_names(inst) Special-cases") // convert variant names of exclusive containers -if (inst.operation == Recipe_ordinal["maybe-convert"]) { +if (inst.name == "maybe-convert") { if (SIZE(inst.ingredients) != 2) { - raise << Recipe[r].name << ": exactly 2 ingredients expected in '" << current_instruction().to_string() << "'\n" << end(); + raise_error << maybe(get(Recipe, r).name) << "exactly 2 ingredients expected in '" << inst.to_string() << "'\n" << end(); break; } assert(is_literal(inst.ingredients.at(1))); if (inst.ingredients.at(1).name.find_first_not_of("0123456789") != string::npos) { // since first non-address in base type must be an exclusive container, we don't have to canonize - type_ordinal 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)); - trace("name") << "variant " << inst.ingredients.at(1).name << " of type " << Type[base_type].name << " has tag " << inst.ingredients.at(1).value << end(); + type_ordinal base_type = skip_addresses(inst.ingredients.at(0).type, get(Recipe, r).name); + inst.ingredients.at(1).set_value(find_element_name(base_type, inst.ingredients.at(1).name, get(Recipe, r).name)); + trace(9993, "name") << "variant " << inst.ingredients.at(1).name << " of type " << get(Type, base_type).name << " has tag " << no_scientific(inst.ingredients.at(1).value) << end(); } } </pre> diff --git a/html/043new.cc.html b/html/043new.cc.html index 82eaa244..35398d9f 100644 --- a/html/043new.cc.html +++ b/html/043new.cc.html @@ -13,9 +13,9 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.cSpecial { color: #008000; } -.SalientComment { color: #00ffff; } .traceContains { color: #008000; } +.SalientComment { color: #00ffff; } +.cSpecial { color: #008000; } .CommentedCode { color: #6c6c6c; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } @@ -57,81 +57,87 @@ long long int alloc, alloc_max; Memory_allocated_until += Initial_memory_per_routine; alloc_max = Memory_allocated_until; -trace(Primitive_recipe_depth, "new") << "routine allocated memory from " << alloc << " to " << alloc_max << end(); - -//:: First handle 'type' operands. +trace(9999, "new") << "routine allocated memory from " << alloc << " to " << alloc_max << end(); +//:: 'new' takes a weird 'type' as its first ingredient; don't error on it :(before "End Mu Types Initialization") -Type_ordinal["type"] = 0; -:(after "Per-recipe Transforms") -// replace type names with type_ordinals -if (inst.operation == Recipe_ordinal["new"]) { - // End NEW Transform Special-cases - // first arg must be of type 'type' - if (inst.ingredients.empty()) - raise << Recipe[r].name << ": 'new' expects one or two ingredients\n" << end(); - if (inst.ingredients.at(0).properties.empty() - || inst.ingredients.at(0).properties.at(0).second.empty() - || inst.ingredients.at(0).properties.at(0).second.at(0) != "type") - raise << Recipe[r].name << ": first ingredient of 'new' should be a type, but got " << inst.ingredients.at(0).original_string << '\n' << end(); - if (Type_ordinal.find(inst.ingredients.at(0).name) == Type_ordinal.end()) - raise << Recipe[r].name << ": unknown type " << inst.ingredients.at(0).name << '\n' << end(); - inst.ingredients.at(0).set_value(Type_ordinal[inst.ingredients.at(0).name]); - trace(Primitive_recipe_depth, "new") << inst.ingredients.at(0).name << " -> " << inst.ingredients.at(0).name << end(); - end_new_transform:; -} - -//:: Now implement the primitive recipe. -//: todo: build 'new' in mu itself +put(Type_ordinal, "type", 0); +//:: typecheck 'new' instructions :(before "End Primitive Recipe Declarations") NEW, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["new"] = NEW; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "new", NEW); +:(before "End Primitive Recipe Checks") case NEW: { - if (ingredients.empty() || SIZE(ingredients) > 2) { - raise << current_recipe_name() << ": 'new' requires one or two ingredients, but got " << current_instruction().to_string() << '\n' << end(); + if (inst.ingredients.empty() || SIZE(inst.ingredients) > 2) { + raise_error << maybe(get(Recipe, r).name) << "'new' requires one or two ingredients, but got " << inst.to_string() << '\n' << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'new' should be a type, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + // End NEW Check Special-cases + reagent type = inst.ingredients.at(0); + if (!is_mu_type_literal(type)) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'new' should be a type, but got " << type.original_string << '\n' << end(); break; } - // compute the space we need - long long int size = 0; - long long int array_length = 0; - { - vector<type_ordinal> type; - type.push_back(current_instruction().ingredients.at(0).value); - if (SIZE(current_instruction().ingredients) > 1) { - // array - array_length = ingredients.at(1).at(0); - trace(Primitive_recipe_depth, "mem") << "array size is " << array_length << end(); - size = array_length*size_of(type) + /*space for length*/1; - } - else { - // scalar - size = size_of(type); + break; +} + +//:: translate 'new' to 'allocate' instructions that take a size instead of a type +:(after "Transform.push_back(check_instruction)") // check_instruction will guard against direct 'allocate' instructions below +Transform.push_back(transform_new_to_allocate); // idempotent + +:(code) +void transform_new_to_allocate(const recipe_ordinal r) { + trace(9991, "transform") << "--- convert 'new' to 'allocate' for recipe " << get(Recipe, r).name << end(); +//? cerr << "--- convert 'new' to 'allocate' for recipe " << get(Recipe, r).name << '\n'; + for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) { + instruction& inst = get(Recipe, r).steps.at(i); + // Convert 'new' To 'allocate' + if (inst.name == "new") { + inst.operation = ALLOCATE; + string_tree* type_name = new string_tree(inst.ingredients.at(0).name); + // End Post-processing(type_name) When Converting 'new' + type_tree* type = new_type_tree(type_name); + inst.ingredients.at(0).set_value(size_of(type)); + trace(9992, "new") << "size of " << debug_string(type_name) << " is " << inst.ingredients.at(0).value << end(); + delete type; + delete type_name; } } +} + +//:: implement 'allocate' based on size + +:(before "End Primitive Recipe Declarations") +ALLOCATE, +:(before "End Primitive Recipe Numbers") +put(Recipe_ordinal, "allocate", ALLOCATE); +:(before "End Primitive Recipe Implementations") +case ALLOCATE: { + // compute the space we need + long long int size = ingredients.at(0).at(0); + if (SIZE(ingredients) > 1) { + // array + trace(9999, "mem") << "array size is " << ingredients.at(1).at(0) << end(); + size = /*space for length*/1 + size*ingredients.at(1).at(0); + } //? Total_alloc += size; //? Num_alloc++; // compute the region of memory to return // really crappy at the moment ensure_space(size); const long long int result = Current_routine->alloc; - trace(Primitive_recipe_depth, "mem") << "new alloc: " << result << end(); + trace(9999, "mem") << "new alloc: " << result << end(); // save result products.resize(1); products.at(0).push_back(result); // initialize allocated space - for (long long int address = result; address < result+size; ++address) { - Memory[address] = 0; - } - if (SIZE(current_instruction().ingredients) > 1) { - Memory[result] = array_length; - } + for (long long int address = result; address < result+size; ++address) + put(Memory, address, 0); + // initialize array length + if (SIZE(current_instruction().ingredients) > 1) + put(Memory, result, ingredients.at(1).at(0)); // bump Current_routine->alloc += size; // no support for reclaiming memory @@ -139,6 +145,20 @@ case NEW: { break; } +//:: ensure we never call 'allocate' directly; its types are not checked +:(before "End Primitive Recipe Checks") +case ALLOCATE: { + raise << "never call 'allocate' directly'; always use 'new'\n" << end(); + break; +} + +//:: ensure we never call 'new' without translating it (unless we add special-cases later) +:(before "End Primitive Recipe Implementations") +case NEW: { + raise << "no implementation for 'new'; why wasn't it translated to 'allocate'?\n" << end(); + break; +} + //? :(before "End Globals") //? long long int Total_alloc = 0; //? long long int Num_alloc = 0; @@ -163,13 +183,13 @@ void ensure_space(long long int size->alloc = Memory_allocated_until; Memory_allocated_until += Initial_memory_per_routine; Current_routine->alloc_max = Memory_allocated_until; - trace(Primitive_recipe_depth, "new") << "routine allocated memory from " << Current_routine->alloc << " to " << Current_routine->alloc_max << end(); + trace(9999, "new") << "routine allocated memory from " << Current_routine->alloc << " to " << Current_routine->alloc_max << end(); } } :(scenario new_initializes) % Memory_allocated_until = 10; -% Memory[Memory_allocated_until] = 1; +% put(Memory, Memory_allocated_until, 1); recipe main [ 1:address:number <- new number:type 2:number <- copy *1:address:number @@ -247,25 +267,31 @@ Free_list.clear(); :(before "End Primitive Recipe Declarations") ABANDON, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["abandon"] = ABANDON; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "abandon", ABANDON); +:(before "End Primitive Recipe Checks") case ABANDON: { - if (SIZE(ingredients) != 1) { - raise << current_recipe_name() << ": 'abandon' requires one ingredient, but got '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) != 1) { + raise_error << maybe(get(Recipe, r).name) << "'abandon' requires one ingredient, but got '" << inst.to_string() << "'\n" << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'abandon' should be an address, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + reagent types = inst.ingredients.at(0); + canonize_type(types); + if (!types.type || types.type->value != get(Type_ordinal, "address")) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'abandon' should be an address, but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case ABANDON: { long long int address = ingredients.at(0).at(0); - reagent types = canonize(current_instruction().ingredients.at(0)); - if (types.types.empty() || types.types.at(0) != Type_ordinal["address"]) { - raise << current_recipe_name() << ": first ingredient of 'abandon' should be an address, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); - break; - } - reagent target_type = lookup_memory(types); - abandon(address, size_of(target_type)); + reagent types = current_instruction().ingredients.at(0); + canonize(types); + // lookup_memory without drop_one_lookup { + types.set_value(get_or_insert(Memory, types.value)); + drop_address_from_type(types); + // } + abandon(address, size_of(types)); break; } @@ -276,26 +302,26 @@ void abandon(long long int address//? cerr << "abandon: " << size << '\n'; // clear memory for (long long int curr = address; curr < address+size; ++curr) - Memory[curr] = 0; + put(Memory, curr, 0); // append existing free list to address - Memory[address] = Free_list[size]; + put(Memory, address, Free_list[size]); Free_list[size] = address; } -:(before "ensure_space(size)" following "case NEW") +:(before "ensure_space(size)" following "case ALLOCATE") if (Free_list[size]) { long long int result = Free_list[size]; - Free_list[size] = Memory[result]; + Free_list[size] = get_or_insert(Memory, result); for (long long int curr = result+1; curr < result+size; ++curr) { - if (Memory[curr] != 0) { - raise << current_recipe_name() << ": memory in free list was not zeroed out: " << curr << '/' << result << "; somebody wrote to us after free!!!\n" << end(); + if (get_or_insert(Memory, curr) != 0) { + raise_error << maybe(current_recipe_name()) << "memory in free list was not zeroed out: " << curr << '/' << result << "; somebody wrote to us after free!!!\n" << end(); break; // always fatal } } if (SIZE(current_instruction().ingredients) > 1) - Memory[result] = array_length; + put(Memory, result, ingredients.at(1).at(0)); else - Memory[result] = 0; + put(Memory, result, 0); products.resize(1); products.at(0).push_back(result); break; @@ -341,23 +367,16 @@ recipe main [ # unicode for '«' +mem: storing 171 in location 3 -:(before "End NEW Transform Special-cases") - if (!inst.ingredients.empty() - && !inst.ingredients.at(0).properties.empty() - && !inst.ingredients.at(0).properties.at(0).second.empty() - && inst.ingredients.at(0).properties.at(0).second.at(0) == "literal-string") { - // skip transform - inst.ingredients.at(0).initialized = true; - goto end_new_transform; - } - +:(before "End NEW Check Special-cases") +if (is_literal_string(inst.ingredients.at(0))) break; +:(before "Convert 'new' To 'allocate'") +if (inst.name == "new" && is_literal_string(inst.ingredients.at(0))) continue; :(after "case NEW" following "Primitive Recipe Implementations") -if (is_literal(current_instruction().ingredients.at(0)) - && current_instruction().ingredients.at(0).properties.at(0).second.at(0) == "literal-string") { - products.resize(1); - products.at(0).push_back(new_mu_string(current_instruction().ingredients.at(0).name)); - break; -} + if (is_literal_string(current_instruction().ingredients.at(0))) { + products.resize(1); + products.at(0).push_back(new_mu_string(current_instruction().ingredients.at(0).name)); + break; + } :(code) long long int new_mu_string(const string& contents) { @@ -368,14 +387,14 @@ long long int new_mu_string(const string& con ensure_space(string_length+1); // don't forget the extra location for array size // initialize string long long int result = Current_routine->alloc; - Memory[Current_routine->alloc++] = string_length; + put(Memory, Current_routine->alloc++, string_length); long long int curr = 0; const char* raw_contents = contents.c_str(); for (long long int i = 0; i < string_length; ++i) { uint32_t curr_character; assert(curr < SIZE(contents)); tb_utf8_char_to_unicode(&curr_character, &raw_contents[curr]); - Memory[Current_routine->alloc] = curr_character; + put(Memory, Current_routine->alloc, curr_character); curr += tb_utf8_char_length(raw_contents[curr]); ++Current_routine->alloc; } @@ -383,6 +402,17 @@ long long int new_mu_string(const string& con return result; } +//: pass in commandline args as ingredients to main +//: todo: test this + +:(after "Update main_routine") +Current_routine = main_routine; +for (long long int i = 1; i < argc; ++i) { + vector<double> arg; + arg.push_back(new_mu_string(argv[i])); + current_call().ingredient_atoms.push_back(arg); +} + //: stash recognizes strings :(scenario stash_string) @@ -398,6 +428,13 @@ if (is_mu_string(r return read_mu_string(data.at(0)); } +:(scenario unicode_string) +recipe main [ + x:address:array:character <- new [♠] + stash [foo:], x:address:array:character +] ++app: foo: ♠ + //: Allocate more to routine when initializing a literal string :(scenario new_string_overflow) % Initial_memory_per_routine = 2; @@ -423,22 +460,30 @@ long long int unicode_length(const string& s< } bool is_mu_string(const reagent& x) { - return SIZE(x.types) == 3 - && x.types.at(0) == Type_ordinal["address"] - && x.types.at(1) == Type_ordinal["array"] - && x.types.at(2) == Type_ordinal["character"]; + return x.type + && x.type->value == get(Type_ordinal, "address") + && x.type->right + && x.type->right->value == get(Type_ordinal, "array") + && x.type->right->right + && x.type->right->right->value == get(Type_ordinal, "character") + && x.type->right->right->right == NULL; } string read_mu_string(long long int address) { - long long int size = Memory[address]; + long long int size = get_or_insert(Memory, address); if (size == 0) return ""; ostringstream tmp; for (long long int curr = address+1; curr <= address+size; ++curr) { - // todo: unicode - tmp << (char)(int)Memory[curr]; + tmp << to_unicode(static_cast<uint32_t>(get_or_insert(Memory, curr))); } return tmp.str(); } + +bool is_mu_type_literal(reagent r) { +//? if (!r.properties.empty()) +//? dump_property(r.properties.at(0).second, cerr); + return is_literal(r) && !r.properties.empty() && r.properties.at(0).second && r.properties.at(0).second->value == "type"; +} </pre> </body> </html> diff --git a/html/044space.cc.html b/html/044space.cc.html index 7c46d504..0bd414cb 100644 --- a/html/044space.cc.html +++ b/html/044space.cc.html @@ -13,9 +13,9 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.traceContains { color: #008000; } .traceAbsent { color: #c00000; } .SalientComment { color: #00ffff; } -.traceContains { color: #008000; } .cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } @@ -42,7 +42,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # then location 0 is really location 11, location 1 is really location 12, and so on. recipe main [ 10:number <- copy 5 # pretend array; in practice we'll use new - default-space:address:array:location <- copy 10 + default-space:address:array:location <- copy 10/raw 1:number <- copy 23 ] +mem: storing 23 in location 12 @@ -54,14 +54,15 @@ recipe main [ # pretend array 1000:number <- copy 5 # actual start of this recipe - default-space:address:array:location <- copy 1000 - 1:address:number <- copy 3 + default-space:address:array:location <- copy 1000/raw + 1:address:number <- copy 3/raw 8:number/raw <- copy *1:address:number ] +mem: storing 34 in location 8 //:: first disable name conversion for 'default-space' :(scenario convert_names_passes_default_space) +% Hide_errors = true; recipe main [ default-space:number, x:number <- copy 0, 1 ] @@ -80,24 +81,19 @@ long long int default_space; :(before "End call Constructor") default_space = 0; -:(replace "reagent r = x" following "reagent canonize(reagent x)") -reagent r = absolutize(x); +:(before "End canonize(x) Special-cases") + absolutize(x); :(code) -reagent absolutize(reagent x) { - if (is_raw(x) || is_dummy(x)) return x; - if (x.name == "default-space") return x; +void absolutize(reagent& x) { + if (is_raw(x) || is_dummy(x)) return; + if (x.name == "default-space") return; if (!x.initialized) { - raise << current_instruction().to_string() << ": reagent not initialized: " << x.original_string << '\n' << end(); - return x; + raise_error << current_instruction().to_string() << ": reagent not initialized: " << x.original_string << '\n' << end(); } - reagent r = x; - r.set_value(address(r.value, space_base(r))); - r.properties.push_back(pair<string, vector<string> >("raw", vector<string>())); - assert(is_raw(r)); - return r; + x.set_value(address(x.value, space_base(x))); + x.properties.push_back(pair<string, string_tree*>("raw", NULL)); + assert(is_raw(x)); } -:(before "return result" following "reagent lookup_memory(reagent x)") -result.properties.push_back(pair<string, vector<string> >("raw", vector<string>())); //:: fix 'get' @@ -109,14 +105,14 @@ recipe main [ # pretend array 1000:number <- copy 5 # actual start of this recipe - default-space:address:array:location <- copy 1000 - 1:address:point <- copy 12 + default-space:address:array:location <- copy 1000/raw + 1:address:point <- copy 12/raw 9:number/raw <- get *1:address:point, 1:offset ] +mem: storing 35 in location 9 :(after "reagent tmp" following "case GET:") -tmp.properties.push_back(pair<string, vector<string> >("raw", vector<string>())); +tmp.properties.push_back(pair<string, string_tree*>("raw", NULL)); //:: fix 'index' @@ -129,14 +125,14 @@ recipe main [ # pretend array 1000:number <- copy 5 # actual start of this recipe - default-space:address:array:location <- copy 1000 - 1:address:array:number <- copy 12 + default-space:address:array:location <- copy 1000/raw + 1:address:array:number <- copy 12/raw 9:number/raw <- index *1:address:array:number, 1 ] +mem: storing 35 in location 9 :(after "reagent tmp" following "case INDEX:") -tmp.properties.push_back(pair<string, vector<string> >("raw", vector<string>())); +tmp.properties.push_back(pair<string, string_tree*>("raw", NULL)); //:: convenience operation to automatically deduce the amount of space to //:: allocate in a default space with names @@ -156,7 +152,7 @@ if (x.name == <spa :(before "End is_special_name Cases") if (s == "number-of-locals") return true; -:(before "End Rewrite Instruction(curr)") +:(before "End Rewrite Instruction(curr, recipe result)") // rewrite `new-default-space` to // `default-space:address:array:location <- new location:type, number-of-locals:literal` // where N is Name[recipe][""] @@ -166,14 +162,14 @@ if (curr.name == < :(after "vector<double> read_memory(reagent x)") if (x.name == "number-of-locals") { vector<double> result; - result.push_back(Name[Recipe_ordinal[current_recipe_name()]][""]); + result.push_back(Name[get(Recipe_ordinal, current_recipe_name())][""]); if (result.back() == 0) - raise << "no space allocated for default-space in recipe " << current_recipe_name() << "; are you using names\n" << end(); + raise_error << "no space allocated for default-space in recipe " << current_recipe_name() << "; are you using names?\n" << end(); return result; } :(after "void write_memory(reagent x, vector<double> data)") if (x.name == "number-of-locals") { - raise << current_recipe_name() << ": can't write to special name 'number-of-locals'\n" << end(); + raise_error << maybe(current_recipe_name()) << "can't write to special name 'number-of-locals'\n" << end(); return; } @@ -201,7 +197,7 @@ try_reclaim_locals(); //: now 'local-scope' is identical to 'new-default-space' except that we'll //: reclaim the default-space when the routine exits -:(before "End Rewrite Instruction(curr)") +:(before "End Rewrite Instruction(curr, recipe result)") if (curr.name == "local-scope") { rewrite_default_space_instruction(curr); } @@ -209,22 +205,22 @@ if (curr.name == < :(code) void try_reclaim_locals() { // only reclaim routines starting with 'local-scope' - const recipe_ordinal r = Recipe_ordinal[current_recipe_name()]; - if (Recipe[r].steps.empty()) return; - const instruction& inst = Recipe[r].steps.at(0); - if (inst.name != "local-scope") return; - abandon(Current_routine->calls.front().default_space, + const recipe_ordinal r = get(Recipe_ordinal, current_recipe_name()); + if (get(Recipe, r).steps.empty()) return; + const instruction& inst = get(Recipe, r).steps.at(0); + if (inst.old_name != "local-scope") return; + abandon(current_call().default_space, /*array length*/1+/*number-of-locals*/Name[r][""]); } void rewrite_default_space_instruction(instruction& curr) { - curr.operation = Recipe_ordinal["new"]; if (!curr.ingredients.empty()) - raise << "new-default-space can't take any ingredients\n" << end(); + raise_error << curr.to_string() << " can't take any ingredients\n" << end(); + curr.name = "new"; curr.ingredients.push_back(reagent("location:type")); curr.ingredients.push_back(reagent("number-of-locals:literal")); if (!curr.products.empty()) - raise << "new-default-space can't take any results\n" << end(); + raise_error << "new-default-space can't take any results\n" << end(); curr.products.push_back(reagent("default-space:address:array:location")); } @@ -232,37 +228,46 @@ void rewrite_default_space_instruction(instructio :(code) long long int space_base(const reagent& x) { - return Current_routine->calls.front().default_space; + // temporary stub; will be replaced in a later layer + return current_call().default_space; } long long int address(long long int offset, long long int base) { if (base == 0) return offset; // raw - if (offset >= static_cast<long long int>(Memory[base])) { + if (offset >= static_cast<long long int>(get_or_insert(Memory, base))) { // todo: test - raise << "location " << offset << " is out of bounds " << Memory[base] << " at " << base << '\n' << end(); + raise_error << "location " << offset << " is out of bounds " << no_scientific(get_or_insert(Memory, base)) << " at " << base << '\n' << end(); } return base+1 + offset; } :(after "void write_memory(reagent x, vector<double> data)") if (x.name == "default-space") { - if (!scalar(data)) - raise << current_recipe_name() << ": 'default-space' should be of type address:array:location, but tried to write " << to_string(data) << '\n' << end(); - Current_routine->calls.front().default_space = data.at(0); + if (!scalar(data) + || !x.type + || x.type->value != get(Type_ordinal, "address") + || !x.type->right + || x.type->right->value != get(Type_ordinal, "array") + || !x.type->right->right + || x.type->right->right->value != get(Type_ordinal, "location") + || x.type->right->right->right) { + raise_error << maybe(current_recipe_name()) << "'default-space' should be of type address:array:location, but tried to write " << to_string(data) << '\n' << end(); + } + current_call().default_space = data.at(0); return; } :(scenario get_default_space) recipe main [ - default-space:address:array:location <- copy 10 - 1:number/raw <- copy default-space:address:array:location + default-space:address:array:location <- copy 10/raw + 1:address:array:location/raw <- copy default-space:address:array:location ] +mem: storing 10 in location 1 :(after "vector<double> read_memory(reagent x)") if (x.name == "default-space") { vector<double> result; - result.push_back(Current_routine->calls.front().default_space); + result.push_back(current_call().default_space); return result; } </pre> diff --git a/html/045space_surround.cc.html b/html/045space_surround.cc.html index 6ceb3696..da74d215 100644 --- a/html/045space_surround.cc.html +++ b/html/045space_surround.cc.html @@ -13,8 +13,8 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.cSpecial { color: #008000; } .traceContains { color: #008000; } +.cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } @@ -42,11 +42,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe main [ 10:number <- copy 5 # pretend array 20:number <- copy 5 # pretend array - default-space:address:array:location <- copy 10 - 0:address:array:location/names:dummy <- copy 20 # later layers will explain the /names: property + default-space:address:array:location <- copy 10/raw + 0:address:array:location/names:dummy <- copy 20/raw # later layers will explain the /names: property 1:number <- copy 32 1:number/space:1 <- copy 33 ] +recipe dummy [ +] # chain space +mem: storing 20 in location 11 # store to default-space @@ -60,23 +62,23 @@ recipe main [ :(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); + return space_base(x, space_index(x), current_call().default_space); } long long int space_base(const reagent& x, long long int space_index, long long int base) { if (space_index == 0) { return base; } - long long int result = space_base(x, space_index-1, Memory[base+1]); + long long int result = space_base(x, space_index-1, get_or_insert(Memory, base+1)); return result; } long long int space_index(const reagent& x) { for (long long int i = /*skip name:type*/1; i < SIZE(x.properties); ++i) { if (x.properties.at(i).first == "space") { - if (SIZE(x.properties.at(i).second) != 1) - raise << current_recipe_name() << ": /space metadata should take exactly one value in " << x.original_string << '\n' << end(); - return to_integer(x.properties.at(i).second.at(0)); + if (!x.properties.at(i).second || x.properties.at(i).second->right) + raise_error << maybe(current_recipe_name()) << "/space metadata should take exactly one value in " << x.original_string << '\n' << end(); + return to_integer(x.properties.at(i).second->value); } } return 0; diff --git a/html/046closure_name.cc.html b/html/046closure_name.cc.html index 4587a5aa..13c7ddd2 100644 --- a/html/046closure_name.cc.html +++ b/html/046closure_name.cc.html @@ -13,13 +13,14 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.traceContains { color: #008000; } +.Identifier { color: #804000; } .cSpecial { color: #008000; } .Constant { color: #00a0a0; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } -.Identifier { color: #804000; } -.traceContains { color: #008000; } +.CommentedCode { color: #6c6c6c; } --> </style> @@ -59,47 +60,58 @@ recipe increment-counter [ reply y:number/space:1 ] -+name: recipe increment-counter is surrounded by new-counter ++name: lexically surrounding space for recipe increment-counter comes from new-counter +mem: storing 5 in location 3 //: To make this work, compute the recipe that provides names for the -//: surrounding space of each recipe. This must happen before transform_names. +//: surrounding space of each recipe. :(before "End Globals") map<recipe_ordinal, recipe_ordinal> Surrounding_space; -:(after "int main") - Transform.push_back(collect_surrounding_spaces); +:(before "Transform.push_back(transform_names)") +Transform.push_back(collect_surrounding_spaces); // idempotent :(code) void collect_surrounding_spaces(const recipe_ordinal r) { - for (long long int i = 0; i < SIZE(Recipe[r].steps); ++i) { - const instruction& inst = Recipe[r].steps.at(i); + trace(9991, "transform") << "--- collect surrounding spaces for recipe " << get(Recipe, r).name << end(); +//? cerr << "--- collect surrounding spaces for recipe " << get(Recipe, r).name << '\n'; + for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) { + const instruction& inst = get(Recipe, r).steps.at(i); if (inst.is_label) continue; for (long long int j = 0; j < SIZE(inst.products); ++j) { if (is_literal(inst.products.at(j))) continue; if (inst.products.at(j).name != "0") continue; - if (SIZE(inst.products.at(j).types) != 3 - || inst.products.at(j).types.at(0) != Type_ordinal["address"] - || inst.products.at(j).types.at(1) != Type_ordinal["array"] - || inst.products.at(j).types.at(2) != Type_ordinal["location"]) { - raise << "slot 0 should always have type address:array:location, but is " << inst.products.at(j).to_string() << '\n' << end(); + type_tree* type = inst.products.at(j).type; + if (!type + || type->value != get(Type_ordinal, "address") + || !type->right + || type->right->value != get(Type_ordinal, "array") + || !type->right->right + || type->right->right->value != get(Type_ordinal, "location") + || type->right->right->right) { + raise_error << "slot 0 should always have type address:array:location, but is " << inst.products.at(j).to_string() << '\n' << end(); + continue; + } + string_tree* s = property(inst.products.at(j), "names"); + if (!s) { + raise_error << "slot 0 requires a /names property in recipe " << get(Recipe, r).name << end(); continue; } - vector<string> s = property(inst.products.at(j), "names"); - if (s.empty()) { - raise << "slot 0 requires a /names property in recipe " << Recipe[r].name << end(); + if (s->right) raise_error << "slot 0 should have a single value in /names, but got " << inst.products.at(j).to_string() << '\n' << end(); + const string& surrounding_recipe_name = s->value; + if (contains_key(Surrounding_space, r) + && Surrounding_space[r] != get(Recipe_ordinal, surrounding_recipe_name)) { + raise_error << "recipe " << get(Recipe, r).name << " can have only one 'surrounding' recipe but has " << get(Recipe, Surrounding_space[r]).name << " and " << surrounding_recipe_name << '\n' << end(); continue; } - if (SIZE(s) > 1) raise << "slot 0 should have a single value in /names, but got " << inst.products.at(j).to_string() << '\n' << end(); - string surrounding_recipe_name = s.at(0); - if (Surrounding_space.find(r) != Surrounding_space.end() - && Surrounding_space[r] != Recipe_ordinal[surrounding_recipe_name]) { - raise << "recipe " << Recipe[r].name << " can have only one 'surrounding' recipe but has " << Recipe[Surrounding_space[r]].name << " and " << surrounding_recipe_name << '\n' << end(); + trace(9993, "name") << "lexically surrounding space for recipe " << get(Recipe, r).name << " comes from " << surrounding_recipe_name << end(); +//? cerr << "lexically surrounding space for recipe " << get(Recipe, r).name << " comes from " << surrounding_recipe_name << '\n'; + if (!contains_key(Recipe_ordinal, surrounding_recipe_name)) { + raise << "can't find recipe providing surrounding space for " << get(Recipe, r).name << ": " << surrounding_recipe_name << '\n' << end(); continue; } - trace("name") << "recipe " << Recipe[r].name << " is surrounded by " << surrounding_recipe_name << end(); - Surrounding_space[r] = Recipe_ordinal[surrounding_recipe_name]; + Surrounding_space[r] = get(Recipe_ordinal, surrounding_recipe_name); } } } @@ -110,12 +122,12 @@ void collect_surrounding_spaces(const recipe_ordi :(replace{} "long long int lookup_name(const reagent& r, const recipe_ordinal default_recipe)") long long int lookup_name(const reagent& x, const recipe_ordinal default_recipe) { if (!has_property(x, "space")) { - if (Name[default_recipe].empty()) raise << "name not found: " << x.name << '\n' << end(); + if (Name[default_recipe].empty()) raise_error << "name not found: " << x.name << '\n' << end(); return Name[default_recipe][x.name]; } - vector<string> p = property(x, "space"); - if (SIZE(p) != 1) raise << "/space property should have exactly one (non-negative integer) value\n" << end(); - long long int n = to_integer(p.at(0)); + string_tree* p = property(x, "space"); + if (!p || p->right) raise_error << "/space property should have exactly one (non-negative integer) value\n" << end(); + long long int n = to_integer(p->value); assert(n >= 0); recipe_ordinal surrounding_recipe = lookup_surrounding_recipe(default_recipe, n); set<recipe_ordinal> done; @@ -127,12 +139,12 @@ long long int lookup_name(const reagent& x<sp // recursively call transform_names on it. long long int lookup_name(const reagent& x, const recipe_ordinal r, set<recipe_ordinal>& done, vector<recipe_ordinal>& 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 " << end(); + if (contains_key(done, r)) { + raise_error << "can't compute address of " << x.to_string() << " because " << end(); for (long long int i = 1; i < SIZE(path); ++i) { - raise << path.at(i-1) << " requires computing names of " << path.at(i) << '\n' << end(); + raise_error << path.at(i-1) << " requires computing names of " << path.at(i) << '\n' << end(); } - raise << path.at(SIZE(path)-1) << " requires computing names of " << r << "..ad infinitum\n" << end(); + raise_error << path.at(SIZE(path)-1) << " requires computing names of " << r << "..ad infinitum\n" << end(); return 0; } done.insert(r); @@ -144,26 +156,26 @@ long long int lookup_name(const reagent& x<sp recipe_ordinal lookup_surrounding_recipe(const recipe_ordinal 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' << end(); + if (!contains_key(Surrounding_space, r)) { + raise_error << "don't know surrounding recipe of " << get(Recipe, r).name << '\n' << end(); return 0; } assert(Surrounding_space[r]); return lookup_surrounding_recipe(Surrounding_space[r], n-1); } -//: weaken use-before-set warnings just a tad +//: weaken use-before-set detection just a tad :(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"); - if (SIZE(p) != 1) { - raise << "/space property should have exactly one (non-negative integer) value in " << r.original_string << '\n' << end(); + string_tree* p = property(r, "space"); + if (!p || p->right) { + raise_error << "/space property should have exactly one (non-negative integer) value in " << r.original_string << '\n' << end(); return false; } - if (p.at(0) != "0") return true; + if (p->value != "0") return true; } - return names.find(r.name) != names.end(); + return contains_key(names, r.name); } </pre> </body> diff --git a/html/047global.cc.html b/html/047global.cc.html index c90a4500..da8d790f 100644 --- a/html/047global.cc.html +++ b/html/047global.cc.html @@ -13,8 +13,8 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.cSpecial { color: #008000; } .traceContains { color: #008000; } +.cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } @@ -42,8 +42,8 @@ recipe main [ 10:number <- copy 5 20:number <- copy 5 # actual start of this recipe - global-space:address:array:location <- copy 20 - default-space:address:array:location <- copy 10 + global-space:address:array:location <- copy 20/raw + default-space:address:array:location <- copy 10/raw 1:number <- copy 23 1:number/space:global <- copy 24 ] @@ -64,10 +64,18 @@ long long int global_space; global_space = 0; :(after "void write_memory(reagent x, vector<double> data)") if (x.name == "global-space") { - if (!scalar(data)) - raise << current_recipe_name() << ": 'global-space' should be of type address:array:location, but tried to write " << to_string(data) << '\n' << end(); + if (!scalar(data) + || !x.type + || x.type->value != get(Type_ordinal, "address") + || !x.type->right + || x.type->right->value != get(Type_ordinal, "array") + || !x.type->right->right + || x.type->right->right->value != get(Type_ordinal, "location") + || x.type->right->right->right) { + raise_error << maybe(current_recipe_name()) << "'global-space' should be of type address:array:location, but tried to write " << to_string(data) << '\n' << end(); + } if (Current_routine->global_space) - raise << "routine already has a global-space; you can't over-write your globals" << end(); + raise_error << "routine already has a global-space; you can't over-write your globals" << end(); Current_routine->global_space = data.at(0); return; } @@ -76,7 +84,7 @@ global_space = 0; :(after "long long int space_base(const reagent& x)") if (is_global(x)) { if (!Current_routine->global_space) - raise << "routine has no global space\n" << end(); + raise_error << "routine has no global space\n" << end(); return Current_routine->global_space; } @@ -84,14 +92,14 @@ global_space = 0; //: don't want to make them too comfortable to use. :(scenario global_space_with_names) -% Hide_warnings = true; +% Hide_errors = true; recipe main [ global-space:address:array:location <- new location:type, 10 x:number <- copy 23 1:number/space:global <- copy 24 ] -# don't warn that we're mixing numeric addresses and names -$warn: 0 +# don't complain about mixing numeric addresses and names +$error: 0 :(after "bool is_numeric_location(const reagent& x)") if (is_global(x)) return false; @@ -102,7 +110,7 @@ $warn: 0 bool is_global(const reagent& x) { for (long long int i = /*skip name:type*/1; i < SIZE(x.properties); ++i) { if (x.properties.at(i).first == "space") - return !x.properties.at(i).second.empty() && x.properties.at(i).second.at(0) == "global"; + return x.properties.at(i).second && x.properties.at(i).second->value == "global"; } return false; } diff --git a/html/048check_type_by_name.cc.html b/html/048check_type_by_name.cc.html new file mode 100644 index 00000000..d091ba31 --- /dev/null +++ b/html/048check_type_by_name.cc.html @@ -0,0 +1,137 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> +<meta http-equiv="content-type" content="text/html; charset=UTF-8"> +<title>Mu - 048check_type_by_name.cc</title> +<meta name="Generator" content="Vim/7.4"> +<meta name="plugin-version" content="vim7.4_v1"> +<meta name="syntax" content="cpp"> +<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> +<meta name="colorscheme" content="minimal"> +<style type="text/css"> + +</style> + +<script type='text/javascript'> + +</script> +</head> +<body> +<pre id='vimCodeElement'> +//: Some simple sanity checks for types, and also attempts to guess them where +//: they aren't provided. +//: +//: You still have to provide the full type the first time you mention a +//: variable in a recipe. You have to explicitly name :offset and :variant +//: every single time. You can't use the same name with multiple types in a +//: single recipe. + +:(scenario transform_fails_on_reusing_name_with_different_type) +% Hide_errors = true; +recipe main [ + x:number <- copy 1 + x:boolean <- copy 1 +] ++error: main: x used with multiple types + +:(before "Transform.push_back(check_or_set_invalid_types)") +Transform.push_back(check_types_by_name); // idempotent + +:(code) +void check_types_by_name(const recipe_ordinal r) { + trace(9991, "transform") << "--- deduce types for recipe " << get(Recipe, r).name << end(); +//? cerr << "--- deduce types for recipe " << get(Recipe, r).name << '\n'; + map<string, type_tree*> type; + map<string, string_tree*> type_name; + for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) { + instruction& inst = get(Recipe, r).steps.at(i); + for (long long int in = 0; in < SIZE(inst.ingredients); ++in) { + deduce_missing_type(type, type_name, inst.ingredients.at(in)); + check_type(type, type_name, inst.ingredients.at(in), r); + } + for (long long int out = 0; out < SIZE(inst.products); ++out) { + deduce_missing_type(type, type_name, inst.products.at(out)); + check_type(type, type_name, inst.products.at(out), r); + } + } +} + +void deduce_missing_type(map<string, type_tree*>& type, map<string, string_tree*>& type_name, reagent& x) { + if (x.type) return; + if (!contains_key(type, x.name)) return; + x.type = new type_tree(*type[x.name]); + trace(9992, "transform") << x.name << " <= " << debug_string(x.type) << end(); + assert(!x.properties.at(0).second); + x.properties.at(0).second = new string_tree(*type_name[x.name]); +} + +void check_type(map<string, type_tree*>& type, map<string, string_tree*>& type_name, const reagent& x, const recipe_ordinal r) { + if (is_literal(x)) return; + if (is_raw(x)) return; // TODO: delete this + // if you use raw locations you're probably doing something unsafe + if (is_integer(x.name)) return; + if (!x.type) return; // will throw a more precise error elsewhere + if (!contains_key(type, x.name)) { + trace(9992, "transform") << x.name << " => " << debug_string(x.type) << end(); + type[x.name] = x.type; + } + if (!contains_key(type_name, x.name)) { + type_name[x.name] = x.properties.at(0).second; + } + if (!types_match(type[x.name], x.type)) + raise_error << maybe(get(Recipe, r).name) << x.name << " used with multiple types\n" << end(); +} + +:(scenario transform_fills_in_missing_types) +recipe main [ + x:number <- copy 1 + y:number <- add x, 1 +] + +:(scenario transform_fills_in_missing_types_in_product) +recipe main [ + x:number <- copy 1 + x <- copy 2 +] + +:(scenario transform_fills_in_missing_types_in_product_and_ingredient) +recipe main [ + x:number <- copy 1 + x <- add x, 1 +] ++mem: storing 2 in location 1 + +:(scenario transform_fails_on_missing_types_in_first_mention) +% Hide_errors = true; +recipe main [ + x <- copy 1 + x:number <- copy 2 +] ++error: main: missing type for x in 'x <- copy 1' + +:(scenario typo_in_address_type_fails) +% Hide_errors = true; +recipe main [ + y:address:charcter <- new character:type + *y <- copy 67 +] ++error: main: unknown type in 'y:address:charcter <- new character:type' +</pre> +</body> +</html> + diff --git a/html/048typecheck.cc.html b/html/048typecheck.cc.html deleted file mode 100644 index f39bc4bf..00000000 --- a/html/048typecheck.cc.html +++ /dev/null @@ -1,128 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> -<html> -<head> -<meta http-equiv="content-type" content="text/html; charset=UTF-8"> -<title>Mu - 048typecheck.cc</title> -<meta name="Generator" content="Vim/7.4"> -<meta name="plugin-version" content="vim7.4_v1"> -<meta name="syntax" content="cpp"> -<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> -<meta name="colorscheme" content="minimal"> -<style type="text/css"> - -</style> - -<script type='text/javascript'> - -</script> -</head> -<body> -<pre id='vimCodeElement'> -//: Some simple sanity checks for types, and also attempts to guess them where -//: they aren't provided. -//: -//: You still have to provide the full type the first time you mention a -//: variable in a recipe. You have to explicitly name :offset and :variant -//: every single time. You can't use the same name with multiple types in a -//: single recipe. - -:(scenario transform_types_warns_on_reusing_name_with_different_type) -% Hide_warnings = true; -recipe main [ - x:number <- copy 1 - x:boolean <- copy 1 -] -+warn: x used with multiple types in main - -:(after "int main") - Transform.push_back(transform_types); - -:(code) -void transform_types(const recipe_ordinal r) { - map<string, vector<type_ordinal> > metadata; - for (long long int i = 0; i < SIZE(Recipe[r].steps); ++i) { - instruction& inst = Recipe[r].steps.at(i); - for (long long int in = 0; in < SIZE(inst.ingredients); ++in) { - deduce_missing_type(metadata, inst.ingredients.at(in)); - check_metadata(metadata, inst.ingredients.at(in), r); - } - for (long long int out = 0; out < SIZE(inst.products); ++out) { - deduce_missing_type(metadata, inst.products.at(out)); - check_metadata(metadata, inst.products.at(out), r); - } - } -} - -void check_metadata(map<string, vector<type_ordinal> >& metadata, const reagent& x, const recipe_ordinal r) { - if (is_literal(x)) return; - if (is_raw(x)) return; - // if you use raw locations you're probably doing something unsafe - if (is_integer(x.name)) return; - if (x.types.empty()) return; // will throw a more precise warning elsewhere - if (metadata.find(x.name) == metadata.end()) - metadata[x.name] = x.types; - if (metadata[x.name] != x.types) - raise << x.name << " used with multiple types in " << Recipe[r].name << '\n' << end(); -} - -:(scenario transform_types_fills_in_missing_types) -recipe main [ - x:number <- copy 1 - y:number <- add x, 1 -] - -:(code) -void deduce_missing_type(map<string, vector<type_ordinal> >& metadata, reagent& x) { - if (!x.types.empty()) return; - if (metadata.find(x.name) == metadata.end()) return; - copy(metadata[x.name].begin(), metadata[x.name].end(), inserter(x.types, x.types.begin())); - assert(x.properties.at(0).second.empty()); - x.properties.at(0).second.resize(metadata[x.name].size()); - x.properties.push_back(pair<string, vector<string> >("as-before", vector<string>())); -} - -:(scenario transform_types_fills_in_missing_types_in_product) -recipe main [ - x:number <- copy 1 - x <- copy 2 -] - -:(scenario transform_types_fills_in_missing_types_in_product_and_ingredient) -recipe main [ - x:number <- copy 1 - x <- add x, 1 -] -+mem: storing 2 in location 1 - -:(scenario transform_warns_on_missing_types_in_first_mention) -% Hide_warnings = true; -recipe main [ - x <- copy 1 - x:number <- copy 2 -] -+warn: missing type in 'x <- copy 1' - -:(scenario typo_in_address_type_warns) -% Hide_warnings = true; -recipe main [ - y:address:charcter <- new character:type - *y <- copy 67 -] -+warn: unknown type: charcter -</pre> -</body> -</html> - diff --git a/html/050scenario.cc.html b/html/050scenario.cc.html index e6184407..c586b575 100644 --- a/html/050scenario.cc.html +++ b/html/050scenario.cc.html @@ -13,10 +13,10 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.cSpecial { color: #008000; } -.SalientComment { color: #00ffff; } .traceContains { color: #008000; } .CommentedCode { color: #6c6c6c; } +.SalientComment { color: #00ffff; } +.cSpecial { color: #008000; } .traceAbsent { color: #c00000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } @@ -110,8 +110,8 @@ else if (command == " scenario parse_scenario(istream& in) { scenario result; result.name = next_word(in); - if (Scenario_names.find(result.name) != Scenario_names.end()) - raise << "duplicate scenario name: " << result.name << '\n' << end(); + if (contains_key(Scenario_names, result.name)) + raise_error << "duplicate scenario name: " << result.name << '\n' << end(); Scenario_names.insert(result.name); skip_whitespace_and_comments(in); assert(in.peek() == '['); @@ -224,7 +224,11 @@ recipe main [ :(before "End Primitive Recipe Declarations") RUN, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["run"] = RUN; +put(Recipe_ordinal, "run", RUN); +:(before "End Primitive Recipe Checks") +case RUN: { + break; +} :(before "End Primitive Recipe Implementations") case RUN: { ostringstream tmp; @@ -232,6 +236,11 @@ case RUN: { vector<recipe_ordinal> tmp_recipe = load(tmp.str()); bind_special_scenario_names(tmp_recipe.at(0)); transform_all(); + if (Trace_stream) { + ++Trace_stream->callstack_depth; + trace(9998, "trace") << "run: incrementing callstack depth to " << Trace_stream->callstack_depth << end(); + assert(Trace_stream->callstack_depth < 9000); // 9998-101 plus cushion + } Current_routine->calls.push_front(call(tmp_recipe.at(0))); continue; // not done with caller; don't increment current_step_index() } @@ -256,7 +265,7 @@ recipe main [ +mem: storing 13 in location 1 +mem: storing 13 in location 2 -//: 'memory-should-contain' raises warnings if specific locations aren't as expected +//: 'memory-should-contain' raises errors if specific locations aren't as expected //: Also includes some special support for checking strings. :(before "End Globals") @@ -266,19 +275,23 @@ Scenario_testing_scenario = false:(scenario memory_check) % Scenario_testing_scenario = true; -% Hide_warnings = true; +% Hide_errors = true; recipe main [ memory-should-contain [ 1 <- 13 ] ] +run: checking location 1 -+warn: expected location 1 to contain 13 but saw 0 ++error: expected location 1 to contain 13 but saw 0 :(before "End Primitive Recipe Declarations") MEMORY_SHOULD_CONTAIN, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["memory-should-contain"] = MEMORY_SHOULD_CONTAIN; +put(Recipe_ordinal, "memory-should-contain", MEMORY_SHOULD_CONTAIN); +:(before "End Primitive Recipe Checks") +case MEMORY_SHOULD_CONTAIN: { + break; +} :(before "End Primitive Recipe Implementations") case MEMORY_SHOULD_CONTAIN: { if (!Passed) break; @@ -299,22 +312,22 @@ void check_memory(const string& s(lhs, in); continue; } - int address = to_integer(lhs); + long long int address = to_integer(lhs); skip_whitespace_and_comments(in); string _assign; in >> _assign; assert(_assign == "<-"); skip_whitespace_and_comments(in); - int value = 0; in >> value; - if (locations_checked.find(address) != locations_checked.end()) - raise << "duplicate expectation for location " << address << '\n' << end(); - trace(Primitive_recipe_depth, "run") << "checking location " << address << end(); - if (Memory[address] != value) { + double value = 0; in >> value; + if (contains_key(locations_checked, address)) + raise_error << "duplicate expectation for location " << address << '\n' << end(); + trace(9999, "run") << "checking location " << address << end(); + if (get_or_insert(Memory, address) != value) { if (Current_scenario && !Scenario_testing_scenario) { // genuine test in a mu file - raise << "\nF - " << Current_scenario->name << ": expected location " << address << " to contain " << value << " but saw " << Memory[address] << '\n' << end(); + raise_error << "\nF - " << Current_scenario->name << ": expected location " << address << " to contain " << no_scientific(value) << " but saw " << no_scientific(get_or_insert(Memory, address)) << '\n' << end(); } else { // just testing scenario support - raise << "expected location " << address << " to contain " << value << " but saw " << Memory[address] << '\n' << end(); + raise_error << "expected location " << address << " to contain " << no_scientific(value) << " but saw " << no_scientific(get_or_insert(Memory, address)) << '\n' << end(); } if (!Scenario_testing_scenario) { Passed = false; @@ -328,7 +341,7 @@ void check_memory(const string& s(const string& lhs, istream& in) { reagent x(lhs); - if (x.properties.at(0).second.at(0) == "string") { + if (x.properties.at(0).second->value == "string") { x.set_value(to_integer(x.name)); skip_whitespace_and_comments(in); string _assign = next_word(in); @@ -342,16 +355,16 @@ void check_type(const string& lhs(address, literal); return; } - raise << "don't know how to check memory for " << lhs << '\n' << end(); + raise_error << "don't know how to check memory for " << lhs << '\n' << end(); } void check_string(long long int address, const string& literal) { - trace(Primitive_recipe_depth, "run") << "checking string length at " << address << end(); - if (Memory[address] != SIZE(literal)) { + trace(9999, "run") << "checking string length at " << address << end(); + if (get_or_insert(Memory, address) != SIZE(literal)) { if (Current_scenario && !Scenario_testing_scenario) - raise << "\nF - " << Current_scenario->name << ": expected location " << address << " to contain length " << SIZE(literal) << " of string [" << literal << "] but saw " << Memory[address] << '\n' << end(); + raise_error << "\nF - " << Current_scenario->name << ": expected location " << address << " to contain length " << SIZE(literal) << " of string [" << literal << "] but saw " << no_scientific(get_or_insert(Memory, address)) << '\n' << end(); else - raise << "expected location " << address << " to contain length " << SIZE(literal) << " of string [" << literal << "] but saw " << Memory[address] << '\n' << end(); + raise_error << "expected location " << address << " to contain length " << SIZE(literal) << " of string [" << literal << "] but saw " << no_scientific(get_or_insert(Memory, address)) << '\n' << end(); if (!Scenario_testing_scenario) { Passed = false; ++Num_failures; @@ -360,15 +373,15 @@ void check_string(long long int address} ++address; // now skip length for (long long int i = 0; i < SIZE(literal); ++i) { - trace(Primitive_recipe_depth, "run") << "checking location " << address+i << end(); - if (Memory[address+i] != literal.at(i)) { + trace(9999, "run") << "checking location " << address+i << end(); + if (get_or_insert(Memory, address+i) != literal.at(i)) { if (Current_scenario && !Scenario_testing_scenario) { // genuine test in a mu file - raise << "\nF - " << Current_scenario->name << ": expected location " << (address+i) << " to contain " << literal.at(i) << " but saw " << Memory[address+i] << '\n' << end(); + raise_error << "\nF - " << Current_scenario->name << ": expected location " << (address+i) << " to contain " << literal.at(i) << " but saw " << no_scientific(get_or_insert(Memory, address+i)) << '\n' << end(); } else { // just testing scenario support - raise << "expected location " << (address+i) << " to contain " << literal.at(i) << " but saw " << Memory[address+i] << '\n' << end(); + raise_error << "expected location " << (address+i) << " to contain " << literal.at(i) << " but saw " << no_scientific(get_or_insert(Memory, address+i)) << '\n' << end(); } if (!Scenario_testing_scenario) { Passed = false; @@ -381,18 +394,18 @@ void check_string(long long int address:(scenario memory_check_multiple) % Scenario_testing_scenario = true; -% Hide_warnings = true; +% Hide_errors = true; recipe main [ memory-should-contain [ 1 <- 0 1 <- 0 ] ] -+warn: duplicate expectation for location 1 ++error: duplicate expectation for location 1 :(scenario memory_check_string_length) % Scenario_testing_scenario = true; -% Hide_warnings = true; +% Hide_errors = true; recipe main [ 1:number <- copy 3 2:number <- copy 97 # 'a' @@ -402,7 +415,7 @@ recipe main [ 1:string <- [ab] ] ] -+warn: expected location 1 to contain length 2 of string [ab] but saw 3 ++error: expected location 1 to contain length 2 of string [ab] but saw 3 :(scenario memory_check_string) recipe main [ @@ -425,21 +438,25 @@ recipe main [ // that the lines are present *and* in the specified sequence. (There can be // other lines in between.) -:(scenario trace_check_warns_on_failure) +:(scenario trace_check_fails) % Scenario_testing_scenario = true; -% Hide_warnings = true; +% Hide_errors = true; recipe main [ trace-should-contain [ a: b a: d ] ] -+warn: missing [b] in trace with label a ++error: missing [b] in trace with label a :(before "End Primitive Recipe Declarations") TRACE_SHOULD_CONTAIN, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["trace-should-contain"] = TRACE_SHOULD_CONTAIN; +put(Recipe_ordinal, "trace-should-contain", TRACE_SHOULD_CONTAIN); +:(before "End Primitive Recipe Checks") +case TRACE_SHOULD_CONTAIN: { + break; +} :(before "End Primitive Recipe Implementations") case TRACE_SHOULD_CONTAIN: { if (!Passed) break; @@ -448,7 +465,7 @@ case TRACE_SHOULD_CONTAIN: { } :(code) -// simplified version of check_trace_contents() that emits warnings rather +// simplified version of check_trace_contents() that emits errors rather // than just printing to stderr bool check_trace(const string& expected) { Trace_stream->newline(); @@ -465,8 +482,8 @@ bool check_trace(const string& expected} } - raise << "missing [" << expected_lines.at(curr_expected_line).contents << "] " - << "in trace with label " << expected_lines.at(curr_expected_line).label << '\n' << end(); + raise_error << "missing [" << expected_lines.at(curr_expected_line).contents << "] " + << "in trace with label " << expected_lines.at(curr_expected_line).label << '\n' << end(); Passed = false; return false; } @@ -483,9 +500,9 @@ vector<trace_line> parse_trace(const string return result; } -:(scenario trace_check_warns_on_failure_in_later_line) +:(scenario trace_check_fails_in_nonfirst_line) % Scenario_testing_scenario = true; -% Hide_warnings = true; +% Hide_errors = true; recipe main [ run [ trace 1, [a], [b] @@ -495,11 +512,11 @@ recipe main [ a: d ] ] -+warn: missing [d] in trace with label a ++error: missing [d] in trace with label a :(scenario trace_check_passes_silently) % Scenario_testing_scenario = true; -% Hide_warnings = true; +% Hide_errors = true; recipe main [ run [ trace 1, [a], [b] @@ -508,16 +525,16 @@ recipe main [ a: b ] ] --warn: missing [b] in trace with label a -$warn: 0 +-error: missing [b] in trace with label a +$error: 0 //: 'trace-should-not-contain' is like the '-' lines in our scenarios so far //: Each trace line is separately checked for absense. Order is *not* //: important, so you can't say things like "B should not exist after A." -:(scenario trace_negative_check_warns_on_failure) +:(scenario trace_negative_check_fails) % Scenario_testing_scenario = true; -% Hide_warnings = true; +% Hide_errors = true; recipe main [ run [ trace 1, [a], [b] @@ -526,12 +543,16 @@ recipe main [ a: b ] ] -+warn: unexpected [b] in trace with label a ++error: unexpected [b] in trace with label a :(before "End Primitive Recipe Declarations") TRACE_SHOULD_NOT_CONTAIN, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["trace-should-not-contain"] = TRACE_SHOULD_NOT_CONTAIN; +put(Recipe_ordinal, "trace-should-not-contain", TRACE_SHOULD_NOT_CONTAIN); +:(before "End Primitive Recipe Checks") +case TRACE_SHOULD_NOT_CONTAIN: { + break; +} :(before "End Primitive Recipe Implementations") case TRACE_SHOULD_NOT_CONTAIN: { if (!Passed) break; @@ -540,14 +561,14 @@ case TRACE_SHOULD_NOT_CONTAIN: { } :(code) -// simplified version of check_trace_contents() that emits warnings rather +// simplified version of check_trace_contents() that emits errors rather // than just printing to stderr bool check_trace_missing(const string& in) { Trace_stream->newline(); vector<trace_line> lines = parse_trace(in); for (long long int i = 0; i < SIZE(lines); ++i) { if (trace_count(lines.at(i).label, lines.at(i).contents) != 0) { - raise << "unexpected [" << lines.at(i).contents << "] in trace with label " << lines.at(i).label << '\n' << end(); + raise_error << "unexpected [" << lines.at(i).contents << "] in trace with label " << lines.at(i).label << '\n' << end(); Passed = false; return false; } @@ -557,18 +578,18 @@ bool check_trace_missing(const string& in<spa :(scenario trace_negative_check_passes_silently) % Scenario_testing_scenario = true; -% Hide_warnings = true; +% Hide_errors = true; recipe main [ trace-should-not-contain [ a: b ] ] --warn: unexpected [b] in trace with label a -$warn: 0 +-error: unexpected [b] in trace with label a +$error: 0 -:(scenario trace_negative_check_warns_on_any_unexpected_line) +:(scenario trace_negative_check_fails_on_any_unexpected_line) % Scenario_testing_scenario = true; -% Hide_warnings = true; +% Hide_errors = true; recipe main [ run [ trace 1, [a], [d] @@ -578,7 +599,7 @@ recipe main [ a: d ] ] -+warn: unexpected [d] in trace with label a ++error: unexpected [d] in trace with label a :(scenario trace_count_check) recipe main [ @@ -591,35 +612,39 @@ recipe main [ :(before "End Primitive Recipe Declarations") CHECK_TRACE_COUNT_FOR_LABEL, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["check-trace-count-for-label"] = CHECK_TRACE_COUNT_FOR_LABEL; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "check-trace-count-for-label", CHECK_TRACE_COUNT_FOR_LABEL); +:(before "End Primitive Recipe Checks") case CHECK_TRACE_COUNT_FOR_LABEL: { - if (!Passed) break; - if (SIZE(current_instruction().ingredients) != 2) { - raise << current_recipe_name() << ": 'check-trace-for-label' requires exactly two ingredients, but got '" << current_instruction().to_string() << "'\n" << end(); + if (SIZE(inst.ingredients) != 2) { + raise_error << maybe(get(Recipe, r).name) << "'check-trace-for-label' requires exactly two ingredients, but got '" << inst.to_string() << "'\n" << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'check-trace-for-label' should be a number (count), but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_number(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'check-trace-for-label' should be a number (count), but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } - long long int expected_count = ingredients.at(0).at(0); - if (!is_literal_string(current_instruction().ingredients.at(1))) { - raise << current_recipe_name() << ": second ingredient of 'check-trace-for-label' should be a literal string (label), but got " << current_instruction().ingredients.at(1).original_string << '\n' << end(); + if (!is_literal_string(inst.ingredients.at(1))) { + raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'check-trace-for-label' should be a literal string (label), but got " << inst.ingredients.at(1).original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case CHECK_TRACE_COUNT_FOR_LABEL: { + if (!Passed) break; + long long int expected_count = ingredients.at(0).at(0); string label = current_instruction().ingredients.at(1).name; long long int count = trace_count(label); if (count != expected_count) { if (Current_scenario && !Scenario_testing_scenario) { // genuine test in a mu file - raise << "\nF - " << Current_scenario->name << ": " << current_recipe_name() << ": expected " << expected_count << " lines in trace with label " << label << " in trace: "; + raise_error << "\nF - " << Current_scenario->name << ": " << maybe(current_recipe_name()) << "expected " << expected_count << " lines in trace with label " << label << " in trace: "; DUMP(label); - raise; + raise_error; } else { // just testing scenario support - raise << current_recipe_name() << ": expected " << expected_count << " lines in trace with label " << label << " in trace\n" << end(); + raise_error << maybe(current_recipe_name()) << "expected " << expected_count << " lines in trace with label " << label << " in trace\n" << end(); } if (!Scenario_testing_scenario) { Passed = false; @@ -631,14 +656,14 @@ case CHECK_TRACE_COUNT_FOR_LABEL: { :(scenario trace_count_check_2) % Scenario_testing_scenario = true; -% Hide_warnings = true; +% Hide_errors = true; recipe main [ run [ trace 1, [a], [foo] ] check-trace-count-for-label 2, [a] ] -+warn: main: expected 2 lines in trace with label a in trace ++error: main: expected 2 lines in trace with label a in trace //: Minor detail: ignore 'system' calls in scenarios, since anything we do //: with them is by definition impossible to test through mu. diff --git a/html/052tangle.cc.html b/html/052tangle.cc.html index 95fc502f..4fc37210 100644 --- a/html/052tangle.cc.html +++ b/html/052tangle.cc.html @@ -13,6 +13,7 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.traceContains { color: #008000; } .traceAbsent { color: #c00000; } .cSpecial { color: #008000; } .Comment { color: #9090ff; } @@ -20,7 +21,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } .Special { color: #ff6060; } .Identifier { color: #804000; } .Constant { color: #00a0a0; } -.traceContains { color: #008000; } --> </style> @@ -69,27 +69,29 @@ Fragments_used.clear();</ :(before "End Command Handlers") else if (command == "before") { string label = next_word(in); - recipe tmp = slurp_body(in); + recipe tmp; + slurp_body(in, tmp); if (is_waypoint(label)) Before_fragments[label].steps.insert(Before_fragments[label].steps.end(), tmp.steps.begin(), tmp.steps.end()); else - raise << "can't tangle before label " << label << '\n' << end(); + raise_error << "can't tangle before label " << label << '\n' << end(); } else if (command == "after") { string label = next_word(in); - recipe tmp = slurp_body(in); + recipe tmp; + slurp_body(in, tmp); if (is_waypoint(label)) After_fragments[label].steps.insert(After_fragments[label].steps.begin(), tmp.steps.begin(), tmp.steps.end()); else - raise << "can't tangle after label " << label << '\n' << end(); + raise_error << "can't tangle after label " << label << '\n' << end(); } //: after all recipes are loaded, insert fragments at appropriate labels. -:(after "int main") - Transform.push_back(insert_fragments); +:(after "Begin Transforms") +Transform.push_back(insert_fragments); // NOT idempotent -//; We might need to perform multiple passes, in case inserted fragments +//: We might need to perform multiple passes, in case inserted fragments //: include more labels that need further insertions. Track which labels we've //: already processed using an extra field. :(before "End instruction Fields") @@ -105,8 +107,8 @@ void insert_fragments(const recipe_ordinal rfalse; // create a new vector because insertions invalidate iterators vector<instruction> result; - for (long long int i = 0; i < SIZE(Recipe[r].steps); ++i) { - const instruction& inst = Recipe[r].steps.at(i); + for (long long int i = 0; i < SIZE(get(Recipe, r).steps); ++i) { + const instruction& inst = get(Recipe, r).steps.at(i); if (!inst.is_label || !is_waypoint(inst.label) || inst.tangle_done) { result.push_back(inst); continue; @@ -115,16 +117,16 @@ void insert_fragments(const recipe_ordinal rtrue; Fragments_used.insert(inst.label); ostringstream prefix; - prefix << '+' << Recipe[r].name << '_' << pass << '_' << i; - if (Before_fragments.find(inst.label) != Before_fragments.end()) { + prefix << '+' << get(Recipe, r).name << '_' << pass << '_' << i; + if (contains_key(Before_fragments, inst.label)) { append_fragment(result, Before_fragments[inst.label].steps, prefix.str()); } result.push_back(inst); - if (After_fragments.find(inst.label) != After_fragments.end()) { + if (contains_key(After_fragments, inst.label)) { append_fragment(result, After_fragments[inst.label].steps, prefix.str()); } } - Recipe[r].steps.swap(result); + get(Recipe, r).steps.swap(result); ++pass; } } @@ -145,7 +147,7 @@ void append_fragment(vector<instruction>&am for (long long int i = 0; i < SIZE(patch); ++i) { instruction inst = patch.at(i); if (inst.is_label) { - if (jump_targets.find(inst.label) != jump_targets.end()) + if (contains_key(jump_targets, inst.label)) inst.label = prefix+inst.label; base.push_back(inst); continue; @@ -153,7 +155,7 @@ void append_fragment(vector<instruction>&am for (long long int j = 0; j < SIZE(inst.ingredients); ++j) { reagent& x = inst.ingredients.at(j); if (!is_literal(x)) continue; - if (x.properties.at(0).second.at(0) == "label" && jump_targets.find(x.name) != jump_targets.end()) + if (x.properties.at(0).second->value == "label" && contains_key(jump_targets, x.name)) x.name = prefix+x.name; } base.push_back(inst); @@ -164,22 +166,22 @@ bool is_waypoint(string labelreturn *label.begin() == '<' && *label.rbegin() == '>'; } -//: warn about unapplied fragments +//: complain about unapplied fragments :(before "End Globals") bool Transform_check_insert_fragments_Ran = false; -:(before "End One-time Setup") -Transform.push_back(check_insert_fragments); // final transform +:(after "Transform.push_back(insert_fragments)") +Transform.push_back(check_insert_fragments); // idempotent :(code) void check_insert_fragments(unused recipe_ordinal) { if (Transform_check_insert_fragments_Ran) return; Transform_check_insert_fragments_Ran = true; for (map<string, recipe>::iterator p = Before_fragments.begin(); p != Before_fragments.end(); ++p) { - if (Fragments_used.find(p->first) == Fragments_used.end()) - raise << "could not locate insert before " << p->first << '\n' << end(); + if (!contains_key(Fragments_used, p->first)) + raise_error << "could not locate insert before " << p->first << '\n' << end(); } for (map<string, recipe>::iterator p = After_fragments.begin(); p != After_fragments.end(); ++p) { - if (Fragments_used.find(p->first) == Fragments_used.end()) - raise << "could not locate insert after " << p->first << '\n' << end(); + if (!contains_key(Fragments_used, p->first)) + raise_error << "could not locate insert after " << p->first << '\n' << end(); } } @@ -204,7 +206,7 @@ after <label1> [ $mem: 4 :(scenario tangle_ignores_jump_target) -% Hide_warnings = true; +% Hide_errors = true; recipe main [ 1:number <- copy 0 +label1 @@ -213,7 +215,7 @@ recipe main [ before +label1 [ 2:number <- copy 0 ] -+warn: can't tangle before label +label1 ++error: can't tangle before label +label1 +mem: storing 0 in location 1 +mem: storing 0 in location 4 # label1 diff --git a/html/053continuation.cc.html b/html/053continuation.cc.html deleted file mode 100644 index 7e3623fb..00000000 --- a/html/053continuation.cc.html +++ /dev/null @@ -1,278 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> -<html> -<head> -<meta http-equiv="content-type" content="text/html; charset=UTF-8"> -<title>Mu - 053continuation.cc</title> -<meta name="Generator" content="Vim/7.4"> -<meta name="plugin-version" content="vim7.4_v1"> -<meta name="syntax" content="cpp"> -<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> -<meta name="colorscheme" content="minimal"> -<style type="text/css"> - -</style> - -<script type='text/javascript'> - -</script> -</head> -<body> -<pre id='vimCodeElement'> -//: Continuations are a powerful primitive for constructing advanced kinds of -//: control *policies* like back-tracking. They're usually provided using a -//: primitive called 'call-cc': <a href="http://en.wikipedia.org/wiki/Call-with-current-continuation)">http://en.wikipedia.org/wiki/Call-with-current-continuation)</a> -//: But in mu 'call-cc' is constructed out of a combination of two primitives: -//: 'current-continuation', which returns a continuation, and -//: 'continue-from', which takes a continuation to switch to. - -//: todo: implement continuations in mu's memory -:(before "End Globals") -map<long long int, call_stack> Continuation; -long long int Next_continuation_id = 0; -:(before "End Setup") -Continuation.clear(); -Next_continuation_id = 0; - -:(before "End Mu Types Initialization") -type_ordinal continuation = Type_ordinal["continuation"] = Next_type_ordinal++; -Type[continuation].name = "continuation"; - -:(before "End Primitive Recipe Declarations") -CURRENT_CONTINUATION, -:(before "End Primitive Recipe Numbers") -Recipe_ordinal["current-continuation"] = CURRENT_CONTINUATION; -:(before "End Primitive Recipe Implementations") -case CURRENT_CONTINUATION: { - // copy the current call stack - Continuation[Next_continuation_id] = Current_routine->calls; // deep copy because calls have no pointers - // make sure calling the copy doesn't spawn the same continuation again - ++Continuation[Next_continuation_id].front().running_step_index; - products.resize(1); - products.at(0).push_back(Next_continuation_id); - ++Next_continuation_id; - trace("current-continuation") << "new continuation " << Next_continuation_id << end(); - break; -} - -:(before "End Primitive Recipe Declarations") -CONTINUE_FROM, -:(before "End Primitive Recipe Numbers") -Recipe_ordinal["continue-from"] = CONTINUE_FROM; -:(before "End Primitive Recipe Implementations") -case CONTINUE_FROM: { - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'continue-from' should be a continuation id generated by 'current-continuation', but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); - break; - } - long long int c = ingredients.at(0).at(0); - Current_routine->calls = Continuation[c]; // deep copy; calls have no pointers - continue; // skip rest of this instruction -} - -:(scenario continuation) -# simulate a loop using continuations -recipe main [ - 1:number <- copy 0 - 2:continuation <- current-continuation - { - 3:boolean <- greater-or-equal 1:number, 3 - break-if 3:boolean - 1:number <- add 1:number, 1 - continue-from 2:continuation # loop - } -] -+mem: storing 1 in location 1 -+mem: storing 2 in location 1 -+mem: storing 3 in location 1 --mem: storing 4 in location 1 -# ensure every iteration doesn't copy the stack over and over -$current-continuation: 1 - -:(scenario continuation_inside_caller) -recipe main [ - 1:number <- copy 0 - 2:continuation <- loop-body - { - 3:boolean <- greater-or-equal 1:number, 3 - break-if 3:boolean - continue-from 2:continuation # loop - } -] - -recipe loop-body [ - 4:continuation <- current-continuation - 1:number <- add 1:number, 1 -] -+mem: storing 1 in location 1 -+mem: storing 2 in location 1 -+mem: storing 3 in location 1 --mem: storing 4 in location 1 - -//:: A variant of continuations is the 'delimited' continuation that can be called like any other recipe. -//: -//: In mu, this is constructed out of two primitives: -//: -//: * 'create-delimited-continuation' lays down a mark on the call -//: stack and calls the provided function (it is sometimes called 'prompt') -//: * 'reply-current-continuation' copies the top of the stack until the -//: mark, and returns it as the response of create-delimited-continuation -//: (which might be a distant ancestor on the call stack; intervening calls -//: don't return) -//: -//: The resulting slice of the stack can now be called just like a regular -//: function. - -:(scenario delimited_continuation) -recipe main [ - 1:continuation <- create-delimited-continuation f:recipe 12 # 12 is an argument to f - 2:number <- copy 5 - { - 2:number <- call 1:continuation, 2:number # 2 is an argument to g, the 'top' of the continuation - 3:boolean <- greater-or-equal 2:number, 8 - break-if 3:boolean - loop - } -] - -recipe f [ - 11:number <- next-ingredient - 12:number <- g 11:number - reply 12:number -] - -recipe g [ - 21:number <- next-ingredient - rewind-ingredients - reply-delimited-continuation - # calls of the continuation start from here - 22:number <- next-ingredient - 23:number <- add 22:number, 1 - reply 23:number -] -# first call of 'g' executes the part before reply-delimited-continuation -+mem: storing 12 in location 21 -+run: 2:number <- copy 5 -+mem: storing 5 in location 2 -# calls of the continuation execute the part after reply-delimited-continuation -+run: 2:number <- call 1:continuation, 2:number -+mem: storing 5 in location 22 -+mem: storing 6 in location 2 -+run: 2:number <- call 1:continuation, 2:number -+mem: storing 6 in location 22 -+mem: storing 7 in location 2 -+run: 2:number <- call 1:continuation, 2:number -+mem: storing 7 in location 22 -+mem: storing 8 in location 2 -# first call of 'g' does not execute the part after reply-delimited-continuation --mem: storing 12 in location 22 -# calls of the continuation don't execute the part before reply-delimited-continuation --mem: storing 5 in location 21 --mem: storing 6 in location 21 --mem: storing 7 in location 21 -# termination --mem: storing 9 in location 2 - -//: 'create-delimited-continuation' is like 'call' except it adds a 'reset' mark to -//: the call stack - -:(before "End call Fields") -bool is_reset; -:(before "End call Constructor") -is_reset = false; - -//: like call, but mark the current call as a 'reset' call before pushing the next one on it - -:(before "End Primitive Recipe Declarations") -CREATE_DELIMITED_CONTINUATION, -:(before "End Primitive Recipe Numbers") -Recipe_ordinal["create-delimited-continuation"] = CREATE_DELIMITED_CONTINUATION; -:(before "End Primitive Recipe Implementations") -case CREATE_DELIMITED_CONTINUATION: { - Current_routine->calls.front().is_reset = true; - Current_routine->calls.push_front(call(Recipe_ordinal[current_instruction().ingredients.at(0).name])); - ingredients.erase(ingredients.begin()); // drop the callee - goto call_housekeeping; -} - -//: save the slice of current call stack until the 'create-delimited-continuation' -//: call, and return it as the result. -//: todo: implement delimited continuations in mu's memory -:(before "End Globals") -map<long long int, call_stack> Delimited_continuation; -long long int Next_delimited_continuation_id = 0; -:(before "End Setup") -Delimited_continuation.clear(); -Next_delimited_continuation_id = 0; - -:(before "End Primitive Recipe Declarations") -REPLY_DELIMITED_CONTINUATION, -:(before "End Primitive Recipe Numbers") -Recipe_ordinal["reply-delimited-continuation"] = REPLY_DELIMITED_CONTINUATION; -:(before "End Primitive Recipe Implementations") -case REPLY_DELIMITED_CONTINUATION: { - // first clear any existing ingredients, to isolate the creation of the - // continuation from its calls - Current_routine->calls.front().ingredient_atoms.clear(); - Current_routine->calls.front().next_ingredient_to_process = 0; - // copy the current call stack until the most recent 'reset' call - call_stack::iterator find_reset(call_stack& c); // manual prototype containing '::' - call_stack::iterator reset = find_reset(Current_routine->calls); - if (reset == Current_routine->calls.end()) { - raise << current_recipe_name() << ": couldn't find a 'reset' call to jump out to\n" << end(); - break; - } - Delimited_continuation[Next_delimited_continuation_id] = call_stack(Current_routine->calls.begin(), reset); - while (Current_routine->calls.begin() != reset) { - --Callstack_depth; - Current_routine->calls.pop_front(); - } - // return it as the result of the 'reset' call - products.resize(1); - products.at(0).push_back(Next_delimited_continuation_id); - ++Next_delimited_continuation_id; - break; // continue to process rest of 'reset' call -} - -:(code) -call_stack::iterator find_reset(call_stack& c) { - for (call_stack::iterator p = c.begin(); p != c.end(); ++p) - if (p->is_reset) return p; - return c.end(); -} - -//: overload 'call' for continuations -:(after "Begin Call") - if (!current_instruction().ingredients.at(0).properties.empty() - && !current_instruction().ingredients.at(0).properties.at(0).second.empty() - && current_instruction().ingredients.at(0).properties.at(0).second.at(0) == "continuation") { - // copy multiple calls on to current call stack - assert(scalar(ingredients.at(0))); - if (Delimited_continuation.find(ingredients.at(0).at(0)) == Delimited_continuation.end()) { - raise << current_recipe_name() << ": no such delimited continuation " << current_instruction().ingredients.at(0).original_string << '\n' << end(); - } - const call_stack& new_calls = Delimited_continuation[ingredients.at(0).at(0)]; - for (call_stack::const_reverse_iterator p = new_calls.rbegin(); p != new_calls.rend(); ++p) - Current_routine->calls.push_front(*p); - ++current_step_index(); // skip past the reply-delimited-continuation - ingredients.erase(ingredients.begin()); // drop the callee - goto call_housekeeping; - } -</pre> -</body> -</html> - diff --git a/html/054dilated_reagent.cc.html b/html/054dilated_reagent.cc.html new file mode 100644 index 00000000..84086d82 --- /dev/null +++ b/html/054dilated_reagent.cc.html @@ -0,0 +1,140 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> +<meta http-equiv="content-type" content="text/html; charset=UTF-8"> +<title>Mu - 054dilated_reagent.cc</title> +<meta name="Generator" content="Vim/7.4"> +<meta name="plugin-version" content="vim7.4_v1"> +<meta name="syntax" content="cpp"> +<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> +<meta name="colorscheme" content="minimal"> +<style type="text/css"> + +</style> + +<script type='text/javascript'> + +</script> +</head> +<body> +<pre id='vimCodeElement'> +//: An alternative syntax for reagents that permits whitespace in properties, +//: grouped by brackets. + +:(scenarios load) +:(scenario dilated_reagent) +recipe main [ + {1: number, foo: bar} <- copy 34 +] ++parse: product: {"1": "number", "foo": "bar"} + +//: First augment next_word to group balanced brackets together. + +:(before "End next_word Special-cases") + if (in.peek() == '(') + return slurp_balanced_bracket(in); + // treat curlies mostly like parens, but don't mess up labels + if (start_of_dilated_reagent(in)) + return slurp_balanced_bracket(in); + +:(code) +// A curly is considered a label if it's the last thing on a line. Dilated +// reagents should remain all on one line. +// +// Side-effect: This might delete some whitespace after an initial '{'. +bool start_of_dilated_reagent(istream& in) { + if (in.peek() != '{') return false; + in.get(); // slurp '{' + skip_whitespace(in); + char next = in.peek(); + in.putback('{'); + return next != '\n'; +} + +// Assume the first letter is an open bracket, and read everything until the +// matching close bracket. +// We balance {} () and []. And we skip one character after '\'. +string slurp_balanced_bracket(istream& in) { + ostringstream result; + char c; + list<char> open_brackets; + while (in >> c) { + if (c == '\\') { + // always silently skip the next character + result << c; + if (!(in >> c)) break; + result << c; + continue; + } + if (c == '(') open_brackets.push_back(c); + if (c == ')') { + assert(open_brackets.back() == '('); + open_brackets.pop_back(); + } + if (c == '[') open_brackets.push_back(c); + if (c == ']') { + assert(open_brackets.back() == '['); + open_brackets.pop_back(); + } + if (c == '{') open_brackets.push_back(c); + if (c == '}') { + assert(open_brackets.back() == '{'); + open_brackets.pop_back(); + } + result << c; + if (open_brackets.empty()) break; + } + return result.str(); +} + +:(after "Parsing reagent(string s)") +if (s.at(0) == '{') { + assert(properties.empty()); + istringstream in(s); + in >> std::noskipws; + in.get(); // skip '{' + while (!in.eof()) { + string key = slurp_key(in); + if (key.empty()) continue; + if (key == "}") continue; + string_tree* value = new string_tree(next_word(in)); + // End Parsing Reagent Property(value) + properties.push_back(pair<string, string_tree*>(key, value)); + } + // structures for the first row of properties + name = properties.at(0).first; + string type_name = properties.at(0).second->value; + if (!contains_key(Type_ordinal, type_name)) { + // this type can't be an integer literal + put(Type_ordinal, type_name, Next_type_ordinal++); + } + type = new type_tree(get(Type_ordinal, type_name)); + return; +} + +:(code) +string slurp_key(istream& in) { + string result = next_word(in); + while (!result.empty() && *result.rbegin() == ':') + strip_last(result); + while (isspace(in.peek()) || in.peek() == ':') + in.get(); + return result; +} +</pre> +</body> +</html> + diff --git a/html/055parse_tree.cc.html b/html/055parse_tree.cc.html new file mode 100644 index 00000000..7d9e158f --- /dev/null +++ b/html/055parse_tree.cc.html @@ -0,0 +1,117 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> +<meta http-equiv="content-type" content="text/html; charset=UTF-8"> +<title>Mu - 055parse_tree.cc</title> +<meta name="Generator" content="Vim/7.4"> +<meta name="plugin-version" content="vim7.4_v1"> +<meta name="syntax" content="cpp"> +<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> +<meta name="colorscheme" content="minimal"> +<style type="text/css"> + +</style> + +<script type='text/javascript'> + +</script> +</head> +<body> +<pre id='vimCodeElement'> +// So far instructions can only contain linear lists of properties. Now we add +// support for more complex trees of properties in dilated reagents. This will +// come in handy later for expressing complex types, like "a dictionary from +// (address to array of charaters) to (list of numbers)". + +:(scenario dilated_reagent_with_nested_brackets) +recipe main [ + {1: number, foo: (bar (baz quux))} <- copy 34 +] ++parse: product: {"1": "number", "foo": <"bar" : <<"baz" : <"quux" : <>>> : <>>>} + +:(before "End Parsing Reagent Property(value)") +value = parse_string_tree(value); + +:(code) +string_tree* parse_string_tree(string_tree* s) { + assert(!s->left && !s->right); + if (s->value.at(0) != '(') return s; + string_tree* result = parse_string_tree(s->value); + delete s; + return result; +} + +string_tree* parse_string_tree(const string& s) { + istringstream in(s); + in >> std::noskipws; + return parse_string_tree(in); +} + +string_tree* parse_string_tree(istream& in) { + skip_whitespace(in); + if (in.eof()) return NULL; + if (in.peek() == ')') { + in.get(); + return NULL; + } + if (in.peek() != '(') { + string_tree* result = new string_tree(next_word(in)); + return result; + } + in.get(); // skip '(' + string_tree* result = NULL; + string_tree** curr = &result; + while (in.peek() != ')') { + assert(!in.eof()); + *curr = new string_tree(""); + skip_whitespace(in); + skip_ignored_characters(in); + if (in.peek() == '(') + (*curr)->left = parse_string_tree(in); + else + (*curr)->value = next_word(in); + curr = &(*curr)->right; + } + in.get(); // skip ')' + return result; +} + +:(scenario dilated_reagent_with_type_tree) +% Hide_errors = true; // 'map' isn't defined yet +recipe main [ + {1: (foo (address array character) (bar number))} <- copy 34 +] +# just to avoid errors +container foo [ +] +container bar [ +] ++parse: product: {"1": <"foo" : <<"address" : <"array" : <"character" : <>>>> : <<"bar" : <"number" : <>>> : <>>>>} + +//: an exception is 'new', which takes a type tree as its ingredient *value* + +:(scenario dilated_reagent_with_new) +recipe main [ + x:address:number <- new {(foo bar): type} +] +# type isn't defined so size is meaningless, but at least we parse the type correctly ++new: size of <"foo" : <"bar" : <>>> is 1 + +:(before "End Post-processing(type_name) When Converting 'new'") +type_name = parse_string_tree(type_name); +</pre> +</body> +</html> + diff --git a/html/056recipe_header.cc.html b/html/056recipe_header.cc.html new file mode 100644 index 00000000..5000a703 --- /dev/null +++ b/html/056recipe_header.cc.html @@ -0,0 +1,395 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> +<meta http-equiv="content-type" content="text/html; charset=UTF-8"> +<title>Mu - 056recipe_header.cc</title> +<meta name="Generator" content="Vim/7.4"> +<meta name="plugin-version" content="vim7.4_v1"> +<meta name="syntax" content="cpp"> +<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> +<meta name="colorscheme" content="minimal"> +<style type="text/css"> + +</style> + +<script type='text/javascript'> + +</script> +</head> +<body> +<pre id='vimCodeElement'> +//: Advanced notation for the common/easy case where a recipe takes some fixed +//: number of ingredients and yields some fixed number of products. + +:(scenario recipe_with_header) +recipe main [ + 1:number/raw <- add2 3, 5 +] +recipe add2 x:number, y:number -> z:number [ + local-scope + load-ingredients + z:number <- add x, y + reply z +] ++mem: storing 8 in location 1 + +//: When loading recipes save any header. + +:(before "End recipe Fields") +bool has_header; +vector<reagent> ingredients; +vector<reagent> products; +:(before "End recipe Constructor") +has_header = false; + +:(before "End recipe Refinements") +skip_whitespace(in); +if (in.peek() != '[') { + trace(9999, "parse") << "recipe has a header; parsing" << end(); + load_recipe_header(in, result); +} + +:(code) +void load_recipe_header(istream& in, recipe& result) { + result.has_header = true; + while (in.peek() != '[') { + string s = next_word(in); + if (s == "->") break; + result.ingredients.push_back(reagent(s)); + trace(9999, "parse") << "header ingredient: " << result.ingredients.back().original_string << end(); + skip_whitespace_and_comments(in); + } + while (in.peek() != '[') { + string s = next_word(in); + result.products.push_back(reagent(s)); + trace(9999, "parse") << "header product: " << result.products.back().original_string << end(); + skip_whitespace_and_comments(in); + } + // End Load Recipe Header(result) +} + +:(scenario recipe_handles_stray_comma) +recipe main [ + 1:number/raw <- add2 3, 5 +] +recipe add2 x:number, y:number -> z:number, [ + local-scope + load-ingredients + z:number <- add x, y + reply z +] ++mem: storing 8 in location 1 + +:(scenario recipe_handles_stray_comma_2) +recipe main [ + foo +] +recipe foo, [ + 1:number/raw <- add 2, 2 +] +recipe bar [ + 1:number/raw <- add 2, 3 +] ++mem: storing 4 in location 1 + +:(after "Begin debug_string(recipe x)") +out << "ingredients:\n"; +for (long long int i = 0; i < SIZE(x.ingredients); ++i) + out << " " << debug_string(x.ingredients.at(i)) << '\n'; +out << "products:\n"; +for (long long int i = 0; i < SIZE(x.products); ++i) + out << " " << debug_string(x.products.at(i)) << '\n'; + +//: If a recipe never mentions any ingredients or products, assume it has a header. + +:(scenario recipe_without_ingredients_or_products_has_header) +recipe test [ + 1:number <- copy 34 +] ++parse: recipe test has a header + +:(before "End recipe Body(result)") +if (!result.has_header) { + result.has_header = true; + for (long long int i = 0; i < SIZE(result.steps); ++i) { + const instruction& inst = result.steps.at(i); + if ((inst.name == "reply" && !inst.ingredients.empty()) + || inst.name == "next-ingredient" + || inst.name == "ingredient" + || inst.name == "rewind-ingredients") { + result.has_header = false; + break; + } + } +} +if (result.has_header) { + trace(9999, "parse") << "recipe " << result.name << " has a header" << end(); +} + +//: Rewrite 'load-ingredients' to instructions to create all reagents in the header. + +:(before "End Rewrite Instruction(curr, recipe result)") +if (curr.name == "load-ingredients") { + curr.clear(); + for (long long int i = 0; i < SIZE(result.ingredients); ++i) { + curr.operation = get(Recipe_ordinal, "next-ingredient"); + curr.name = "next-ingredient"; + curr.products.push_back(result.ingredients.at(i)); + result.steps.push_back(curr); + curr.clear(); + } +} + +//:: Check types going in and out of all recipes with headers. + +:(scenarios transform) +:(scenario recipe_headers_are_checked) +% Hide_errors = true; +recipe add2 x:number, y:number -> z:number [ + local-scope + load-ingredients + z:address:number <- copy 0/raw + reply z +] ++error: add2: replied with the wrong type at 'reply z' + +:(after "Transform.push_back(check_types_by_name)") +Transform.push_back(check_reply_instructions_against_header); // idempotent + +:(code) +void check_reply_instructions_against_header(const recipe_ordinal r) { + const recipe& caller_recipe = get(Recipe, r); + if (caller_recipe.products.empty()) return; + trace(9991, "transform") << "--- checking reply instructions against header for " << caller_recipe.name << end(); +//? cerr << "--- checking reply instructions against header for " << caller_recipe.name << '\n'; + for (long long int i = 0; i < SIZE(caller_recipe.steps); ++i) { + const instruction& inst = caller_recipe.steps.at(i); + if (inst.name != "reply") continue; + if (SIZE(caller_recipe.products) != SIZE(inst.ingredients)) + raise_error << maybe(caller_recipe.name) << "tried to reply the wrong number of products in '" << inst.to_string() << "'\n" << end(); + for (long long int i = 0; i < SIZE(caller_recipe.products); ++i) { + if (!types_match(caller_recipe.products.at(i), inst.ingredients.at(i))) + raise_error << maybe(caller_recipe.name) << "replied with the wrong type at '" << inst.to_string() << "'\n" << end(); + } + } +} + +:(scenario recipe_headers_check_for_duplicate_names) +% Hide_errors = true; +recipe add2 x:number, x:number -> z:number [ + local-scope + load-ingredients + reply z +] ++error: add2: x can't repeat in the ingredients + +:(before "End recipe Fields") +map<string, int> ingredient_index; + +:(after "Transform.push_back(insert_fragments)") +Transform.push_back(check_and_update_header_reagents); // idempotent + +:(code) +void check_and_update_header_reagents(const recipe_ordinal r) { + recipe& caller_recipe = get(Recipe, r); + if (caller_recipe.products.empty()) return; + trace(9991, "transform") << "--- checking reply instructions against header for " << caller_recipe.name << end(); + for (long long int i = 0; i < SIZE(caller_recipe.ingredients); ++i) { + if (contains_key(caller_recipe.ingredient_index, caller_recipe.ingredients.at(i).name)) + raise_error << maybe(caller_recipe.name) << caller_recipe.ingredients.at(i).name << " can't repeat in the ingredients\n" << end(); + put(caller_recipe.ingredient_index, caller_recipe.ingredients.at(i).name, i); + } +} + +//: Deduce types from the header if possible. + +:(scenarios run) +:(scenario deduce_instruction_types_from_recipe_header) +recipe main [ + 1:number/raw <- add2 3, 5 +] +recipe add2 x:number, y:number -> z:number [ + local-scope + load-ingredients + z <- add x, y # no type for z + reply z +] ++mem: storing 8 in location 1 + +:(before "Transform.push_back(check_reply_instructions_against_header)") +Transform.push_back(deduce_types_from_header); // idempotent + +:(code) +void deduce_types_from_header(const recipe_ordinal r) { + recipe& caller_recipe = get(Recipe, r); + if (caller_recipe.products.empty()) return; + trace(9991, "transform") << "--- deduce types from header for " << caller_recipe.name << end(); +//? cerr << "--- deduce types from header for " << caller_recipe.name << '\n'; + map<string, const type_tree*> header_type; + map<string, const string_tree*> header_type_name; + for (long long int i = 0; i < SIZE(caller_recipe.ingredients); ++i) { + put(header_type, caller_recipe.ingredients.at(i).name, caller_recipe.ingredients.at(i).type); + put(header_type_name, caller_recipe.ingredients.at(i).name, caller_recipe.ingredients.at(i).properties.at(0).second); + trace(9993, "transform") << "type of " << caller_recipe.ingredients.at(i).name << " is " << debug_string(caller_recipe.ingredients.at(i).type) << end(); + } + for (long long int i = 0; i < SIZE(caller_recipe.products); ++i) { + put(header_type, caller_recipe.products.at(i).name, caller_recipe.products.at(i).type); + put(header_type_name, caller_recipe.products.at(i).name, caller_recipe.products.at(i).properties.at(0).second); + trace(9993, "transform") << "type of " << caller_recipe.products.at(i).name << " is " << debug_string(caller_recipe.products.at(i).type) << end(); + } + for (long long int i = 0; i < SIZE(caller_recipe.steps); ++i) { + instruction& inst = caller_recipe.steps.at(i); + trace(9992, "transform") << "instruction: " << inst.to_string() << end(); + for (long long int i = 0; i < SIZE(inst.ingredients); ++i) { + if (inst.ingredients.at(i).type) continue; + if (header_type.find(inst.ingredients.at(i).name) == header_type.end()) { + raise << maybe(caller_recipe.name) << "unknown variable " << inst.ingredients.at(i).name << " in '" << inst.to_string() << "'\n" << end(); + continue; + } + if (!inst.ingredients.at(i).type) + inst.ingredients.at(i).type = new type_tree(*get(header_type, inst.ingredients.at(i).name)); + if (!inst.ingredients.at(i).properties.at(0).second) + inst.ingredients.at(i).properties.at(0).second = new string_tree(*get(header_type_name, inst.ingredients.at(i).name)); + trace(9993, "transform") << "type of " << inst.ingredients.at(i).name << " is " << debug_string(inst.ingredients.at(i).type) << end(); + } + for (long long int i = 0; i < SIZE(inst.products); ++i) { + trace(9993, "transform") << " product: " << debug_string(inst.products.at(i)) << end(); + if (inst.products.at(i).type) continue; + if (header_type.find(inst.products.at(i).name) == header_type.end()) { + raise << maybe(caller_recipe.name) << "unknown variable " << inst.products.at(i).name << " in '" << inst.to_string() << "'\n" << end(); + continue; + } + if (!inst.products.at(i).type) + inst.products.at(i).type = new type_tree(*get(header_type, inst.products.at(i).name)); + if (!inst.products.at(i).properties.at(0).second) + inst.products.at(i).properties.at(0).second = new string_tree(*get(header_type_name, inst.products.at(i).name)); + trace(9993, "transform") << "type of " << inst.products.at(i).name << " is " << debug_string(inst.products.at(i).type) << end(); + } + } +} + +//: One final convenience: no need to say what to return if the information is +//: in the header. + +:(scenario reply_based_on_header) +recipe main [ + 1:number/raw <- add2 3, 5 +] +recipe add2 x:number, y:number -> z:number [ + local-scope + load-ingredients + z <- add x, y + reply +] ++mem: storing 8 in location 1 + +:(after "Transform.push_back(check_and_update_header_reagents)") +Transform.push_back(fill_in_reply_ingredients); // idempotent + +:(code) +void fill_in_reply_ingredients(recipe_ordinal r) { + recipe& caller_recipe = get(Recipe, r); + if (!caller_recipe.has_header) return; + trace(9991, "transform") << "--- fill in reply ingredients from header for recipe " << caller_recipe.name << end(); + for (long long int i = 0; i < SIZE(caller_recipe.steps); ++i) { + instruction& inst = caller_recipe.steps.at(i); + if (inst.name == "reply" && inst.ingredients.empty()) + add_header_products(inst, caller_recipe); + } + // fall through reply + if (caller_recipe.steps.at(SIZE(caller_recipe.steps)-1).name != "reply") { + instruction inst; + inst.name = "reply"; + add_header_products(inst, caller_recipe); + caller_recipe.steps.push_back(inst); + } +} + +void add_header_products(instruction& inst, const recipe& caller_recipe) { + assert(inst.name == "reply"); + // collect any products with the same names as ingredients + for (long long int i = 0; i < SIZE(caller_recipe.products); ++i) { + // if the ingredient is missing, add it from the header + if (SIZE(inst.ingredients) == i) + inst.ingredients.push_back(caller_recipe.products.at(i)); + // if it's missing /same_as_ingredient, try to fill it in + if (contains_key(caller_recipe.ingredient_index, caller_recipe.products.at(i).name) && !has_property(inst.ingredients.at(i), "same_as_ingredient")) { + ostringstream same_as_ingredient; + same_as_ingredient << get(caller_recipe.ingredient_index, caller_recipe.products.at(i).name); + inst.ingredients.at(i).properties.push_back(pair<string, string_tree*>("same-as-ingredient", new string_tree(same_as_ingredient.str()))); + } + } +} + +:(scenario explicit_reply_ignores_header) +recipe main [ + 1:number/raw, 2:number/raw <- add2 3, 5 +] +recipe add2 a:number, b:number -> y:number, z:number [ + local-scope + load-ingredients + y <- add a, b + z <- subtract a, b + reply a, z +] ++mem: storing 3 in location 1 ++mem: storing -2 in location 2 + +:(scenario reply_on_fallthrough_based_on_header) +recipe main [ + 1:number/raw <- add2 3, 5 +] +recipe add2 x:number, y:number -> z:number [ + local-scope + load-ingredients + z <- add x, y +] ++transform: instruction: reply z:number ++mem: storing 8 in location 1 + +:(scenario reply_on_fallthrough_already_exists) +recipe main [ + 1:number/raw <- add2 3, 5 +] +recipe add2 x:number, y:number -> z:number [ + local-scope + load-ingredients + z <- add x, y # no type for z + reply z +] ++transform: instruction: reply z +-transform: instruction: reply z:number ++mem: storing 8 in location 1 + +:(scenario recipe_headers_perform_same_ingredient_check) +% Hide_errors = true; +recipe main [ + 1:number <- copy 34 + 2:number <- copy 34 + 3:number <- add2 1:number, 2:number +] +recipe add2 x:number, y:number -> x:number [ + local-scope + load-ingredients +] ++error: main: '3:number <- add2 1:number, 2:number' should write to 1:number rather than 3:number +</pre> +</body> +</html> + diff --git a/html/057static_dispatch.cc.html b/html/057static_dispatch.cc.html new file mode 100644 index 00000000..ec362d4a --- /dev/null +++ b/html/057static_dispatch.cc.html @@ -0,0 +1,223 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> +<meta http-equiv="content-type" content="text/html; charset=UTF-8"> +<title>Mu - 057static_dispatch.cc</title> +<meta name="Generator" content="Vim/7.4"> +<meta name="plugin-version" content="vim7.4_v1"> +<meta name="syntax" content="cpp"> +<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> +<meta name="colorscheme" content="minimal"> +<style type="text/css"> + +</style> + +<script type='text/javascript'> + +</script> +</head> +<body> +<pre id='vimCodeElement'> +//: Transform to maintain multiple variants of a recipe depending on the +//: number and types of the ingredients and products. Allows us to use nice +//: names like 'print' or 'length' in many mutually extensible ways. + +:(scenario static_dispatch) +recipe main [ + 7:number/raw <- test 3 +] +recipe test a:number -> z:number [ + z <- copy 1 +] +recipe test a:number, b:number -> z:number [ + z <- copy 2 +] ++mem: storing 1 in location 7 + +//: When loading recipes, accumulate variants if headers don't collide, and +//: raise a warning if headers collide. + +:(before "End Globals") +map<string, vector<recipe_ordinal> > Recipe_variants; +:(before "End One-time Setup") +put(Recipe_variants, "main", vector<recipe_ordinal>()); // since we manually added main to Recipe_ordinal +:(before "End Setup") +for (map<string, vector<recipe_ordinal> >::iterator p = Recipe_variants.begin(); p != Recipe_variants.end(); ++p) { + for (long long int i = 0; i < SIZE(p->second); ++i) { + if (p->second.at(i) >= Reserved_for_tests) + p->second.at(i) = -1; // just leave a ghost + } +} + +:(before "End Load Recipe Header(result)") +if (contains_key(Recipe_ordinal, result.name)) { + const recipe_ordinal r = get(Recipe_ordinal, result.name); + if ((!contains_key(Recipe, r) || get(Recipe, r).has_header) + && !header_already_exists(result)) { + string new_name = next_unused_recipe_name(result.name); + put(Recipe_ordinal, new_name, Next_recipe_ordinal++); + get(Recipe_variants, result.name).push_back(get(Recipe_ordinal, new_name)); + result.name = new_name; + } +} +else { + // save first variant + put(Recipe_ordinal, result.name, Next_recipe_ordinal++); + get_or_insert(Recipe_variants, result.name).push_back(get(Recipe_ordinal, result.name)); +} + +:(code) +bool header_already_exists(const recipe& rr) { + const vector<recipe_ordinal>& variants = get(Recipe_variants, rr.name); + for (long long int i = 0; i < SIZE(variants); ++i) { + if (Recipe.find(variants.at(i)) != Recipe.end() + && all_reagents_match(rr, get(Recipe, variants.at(i)))) { + return true; + } + } + return false; +} + +bool all_reagents_match(const recipe& r1, const recipe& r2) { + if (SIZE(r1.ingredients) != SIZE(r2.ingredients)) return false; + if (SIZE(r1.products) != SIZE(r2.products)) return false; + for (long long int i = 0; i < SIZE(r1.ingredients); ++i) { + if (!exact_match(r1.ingredients.at(i).type, r2.ingredients.at(i).type)) + return false; + } + for (long long int i = 0; i < SIZE(r1.products); ++i) { + if (!exact_match(r1.products.at(i).type, r2.products.at(i).type)) + return false; + } + return true; +} + +bool exact_match(type_tree* a, type_tree* b) { + if (a == b) return true; + return a->value == b->value + && exact_match(a->left, b->left) + && exact_match(a->right, b->right); +} + +string next_unused_recipe_name(const string& recipe_name) { + for (long long int i = 2; ; ++i) { + ostringstream out; + out << recipe_name << '_' << i; + if (Recipe_ordinal.find(out.str()) == Recipe_ordinal.end()) + return out.str(); + } +} + +//: Once all the recipes are loaded, transform their bodies to replace each +//: call with the most suitable variant. + +:(scenario static_dispatch_picks_most_similar_variant) +recipe main [ + 7:number/raw <- test 3, 4, 5 +] +recipe test a:number -> z:number [ + z <- copy 1 +] +recipe test a:number, b:number -> z:number [ + z <- copy 2 +] ++mem: storing 2 in location 7 + +//: after insert_fragments (tangle) and before computing operation ids +//: after filling in all missing types (because we'll be introducing 'blank' types in this transform in a later layer, for shape-shifting recipes) +:(after "Transform.push_back(deduce_types_from_header)") +Transform.push_back(resolve_ambiguous_calls); // idempotent + +:(code) +void resolve_ambiguous_calls(recipe_ordinal r) { + recipe& caller_recipe = get(Recipe, r); + if (!caller_recipe.has_header) return; + trace(9991, "transform") << "--- resolve ambiguous calls for recipe " << caller_recipe.name << end(); + for (long long int index = 0; index < SIZE(caller_recipe.steps); ++index) { + instruction& inst = caller_recipe.steps.at(index); + if (inst.is_label) continue; + if (!contains_key(Recipe_variants, inst.name)) continue; + assert(!get(Recipe_variants, inst.name).empty()); + replace_best_variant(inst, caller_recipe); + } +} + +void replace_best_variant(instruction& inst, const recipe& caller_recipe) { + trace(9992, "transform") << "instruction " << inst.name << end(); + vector<recipe_ordinal>& variants = get(Recipe_variants, inst.name); + long long int best_score = variant_score(inst, get(Recipe_ordinal, inst.name)); + for (long long int i = 0; i < SIZE(variants); ++i) { + long long int current_score = variant_score(inst, variants.at(i)); + trace(9992, "transform") << "checking variant " <": " << current_score << end(); + if (current_score > best_score) { + inst.name = get(Recipe, variants.at(i)).name; + best_score = current_score; + } + } + // End Instruction Dispatch(inst, best_score) +} + +long long int variant_score(const instruction& inst, recipe_ordinal variant) { + if (variant == -1) return -1; // ghost from a previous test + const vector<reagent>& header_ingredients = get(Recipe, variant).ingredients; + if (SIZE(inst.ingredients) < SIZE(header_ingredients)) { + trace(9993, "transform") << "too few ingredients" << end(); + return -1; + } + for (long long int i = 0; i < SIZE(header_ingredients); ++i) { + if (!types_match(header_ingredients.at(i), inst.ingredients.at(i))) { + trace(9993, "transform") << "mismatch: ingredient " <(); + return -1; + } + } + if (SIZE(inst.products) > SIZE(get(Recipe, variant).products)) { + trace(9993, "transform") << "too few products" << end(); + return -1; + } + const vector<reagent>& header_products = get(Recipe, variant).products; + for (long long int i = 0; i < SIZE(inst.products); ++i) { + if (!types_match(header_products.at(i), inst.products.at(i))) { + trace(9993, "transform") << "mismatch: product " <(); + return -1; + } + } + // the greater the number of unused ingredients, the lower the score + return 100 - (SIZE(get(Recipe, variant).products)-SIZE(inst.products)) + - (SIZE(inst.ingredients)-SIZE(get(Recipe, variant).ingredients)); // ok to go negative +} + +:(scenario static_dispatch_disabled_on_headerless_definition) +% Hide_warnings = true; +recipe test a:number -> z:number [ + z <- copy 1 +] +recipe test [ + reply 34 +] ++warn: redefining recipe test + +:(scenario static_dispatch_disabled_on_headerless_definition_2) +% Hide_warnings = true; +recipe test [ + reply 34 +] +recipe test a:number -> z:number [ + z <- copy 1 +] ++warn: redefining recipe test +</pre> +</body> +</html> + diff --git a/html/058shape_shifting_container.cc.html b/html/058shape_shifting_container.cc.html new file mode 100644 index 00000000..4425953a --- /dev/null +++ b/html/058shape_shifting_container.cc.html @@ -0,0 +1,294 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> +<meta http-equiv="content-type" content="text/html; charset=UTF-8"> +<title>Mu - 058shape_shifting_container.cc</title> +<meta name="Generator" content="Vim/7.4"> +<meta name="plugin-version" content="vim7.4_v1"> +<meta name="syntax" content="cpp"> +<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> +<meta name="colorscheme" content="minimal"> +<style type="text/css"> + +</style> + +<script type='text/javascript'> + +</script> +</head> +<body> +<pre id='vimCodeElement'> +//:: Container definitions can contain type parameters. +//: +//: Extremely hacky initial implementation: +//: +//: a) We still don't support the full complexity of type trees inside +//: container definitions. So for example you can't have a container element +//: with this type: +//: (map (array address character) (list number)) +//: +//: b) We also can't include type parameters anywhere except at the top of the +//: type of a container element. + +:(scenario size_of_shape_shifting_container) +container foo:_t [ + x:_t + y:number +] +recipe main [ + 1:foo:number <- merge 12, 13 + 3:foo:point <- merge 14, 15, 16 +] ++mem: storing 12 in location 1 ++mem: storing 13 in location 2 ++mem: storing 14 in location 3 ++mem: storing 15 in location 4 ++mem: storing 16 in location 5 + +:(before "End Globals") +// We'll use large type ordinals to mean "the following type of the variable". +const int START_TYPE_INGREDIENTS = 2000; +:(before "End Test Run Initialization") +assert(Next_type_ordinal < START_TYPE_INGREDIENTS); + +:(before "End type_info Fields") +map<string, type_ordinal> type_ingredient_names; + +//: Suppress unknown type checks in shape-shifting containers. + +:(before "Check Container Field Types(info)") +if (!info.type_ingredient_names.empty()) continue; + +:(before "End container Name Refinements") +if (name.find(':') != string::npos) { + trace(9999, "parse") << "container has type ingredients; parsing" << end(); + read_type_ingredients(name); +} + +:(code) +void read_type_ingredients(string& name) { + string save_name = name; + istringstream in(save_name); + name = slurp_until(in, ':'); + if (!contains_key(Type_ordinal, name) || get(Type_ordinal, name) == 0) + put(Type_ordinal, name, Next_type_ordinal++); + type_info& info = get_or_insert(Type, get(Type_ordinal, name)); + long long int next_type_ordinal = START_TYPE_INGREDIENTS; + while (!in.eof()) { + string curr = slurp_until(in, ':'); + if (info.type_ingredient_names.find(curr) != info.type_ingredient_names.end()) { + raise_error << "can't repeat type ingredient names in a single container definition\n" << end(); + return; + } + put(info.type_ingredient_names, curr, next_type_ordinal++); + } +} + +:(before "End insert_container Special Uses(type_name)") +// check for use of type ingredients +if (type_name.at(0) == '_') { + *curr_type = new type_tree(get(info.type_ingredient_names, type_name)); + trace(9999, "parse") << " type: " << get(info.type_ingredient_names, type_name) << end(); + continue; +} + +:(before "End Container Type Checks") +if (type->value >= START_TYPE_INGREDIENTS + && (type->value - START_TYPE_INGREDIENTS) < SIZE(get(Type, type->value).type_ingredient_names)) + return; + +:(before "End size_of(type) Container Cases") +if (t.elements.at(i)->value >= START_TYPE_INGREDIENTS) { + trace(9999, "type") << "checking size of type ingredient\n" << end(); + long long int size = size_of_type_ingredient(t.elements.at(i), type->right); + if (!size) + raise_error << "illegal type '" << debug_string(type) << "' seems to be missing a type ingredient or three\n" << end(); + result += size; + continue; +} + +:(code) +// shape-shifting version of size_of +long long int size_of_type_ingredient(const type_tree* element_template, const type_tree* rest_of_use) { + long long int type_ingredient_index = element_template->value - START_TYPE_INGREDIENTS; + const type_tree* curr = rest_of_use; + if (!curr) return 0; + while (type_ingredient_index > 0) { + --type_ingredient_index; + curr = curr->right; + if (!curr) return 0; + } + assert(curr); + assert(!curr->left); // unimplemented + if (!contains_key(Type, curr->value)) { + // temporarily while we're still ironing out kinks; eventually replace with a raise_error + DUMP(""); + cerr << "missing type " << debug_string(curr) << '\n'; + exit(0); + } + assert(contains_key(Type, curr->value)); + trace(9999, "type") << "type deduced to be " << get(Type, curr->value).name << "$" << end(); + type_tree tmp(curr->value); + if (curr->right) + tmp.right = new type_tree(*curr->right); + return size_of(&tmp); +} + +:(scenario get_on_shape_shifting_container) +container foo:_t [ + x:_t + y:number +] +recipe main [ + 1:foo:point <- merge 14, 15, 16 + 2:number <- get 1:foo:point, y:offset +] ++mem: storing 16 in location 2 + +:(before "End GET field Cases") +const type_tree* type = get(Type, base_type).elements.at(i); +if (type->value >= START_TYPE_INGREDIENTS) { + long long int size = size_of_type_ingredient(type, base.type->right); + if (!size) + raise_error << "illegal field type '" << debug_string(type) << "' seems to be missing a type ingredient or three\n" << end(); + src += size; + continue; +} + +:(scenario get_on_shape_shifting_container_2) +container foo:_t [ + x:_t + y:number +] +recipe main [ + 1:foo:point <- merge 14, 15, 16 + 2:point <- get 1:foo:point, x:offset +] ++mem: storing 14 in location 2 ++mem: storing 15 in location 3 + +:(scenario get_on_shape_shifting_container_3) +container foo:_t [ + x:_t + y:number +] +recipe main [ + 1:foo:address:point <- merge 34, 48 # unsafe + 2:address:point <- get 1:foo:address:point, x:offset +] ++mem: storing 34 in location 2 + +:(before "End element_type Special-cases") +if (contains_type_ingredient(element)) { + if (!canonized_base.type->right) + raise_error << "illegal type '" << debug_string(canonized_base.type) << "' seems to be missing a type ingredient or three\n" << end(); + replace_type_ingredient(element.type, canonized_base.type->right); +} + +:(code) +bool contains_type_ingredient(const reagent& x) { + return contains_type_ingredient(x.type); +} + +bool contains_type_ingredient(const type_tree* type) { + if (!type) return false; + if (type->value >= START_TYPE_INGREDIENTS) return true; + return contains_type_ingredient(type->left) || contains_type_ingredient(type->right); +} + +void replace_type_ingredient(type_tree* element_type, const type_tree* callsite_type) { + if (!callsite_type) return; // error but it's already been raised above + if (!element_type) return; + if (element_type->value >= START_TYPE_INGREDIENTS) { + if (!has_nth_type(callsite_type, element_type->value-START_TYPE_INGREDIENTS)) { + raise_error << "illegal type '" << debug_string(callsite_type) << "' seems to be missing a type ingredient or three\n" << end(); + return; + } + const type_tree* replacement = nth_type(callsite_type, element_type->value-START_TYPE_INGREDIENTS); + element_type->value = replacement->value; + element_type->left = replacement->left ? new type_tree(*replacement->left) : NULL; + element_type->right = replacement->right ? new type_tree(*replacement->right) : NULL; + } + replace_type_ingredient(element_type->right, callsite_type); +} + +const type_tree* nth_type(const type_tree* base, long long int n) { + assert(n >= 0); + if (n == 0) return base; + return nth_type(base->right, n-1); +} + +bool has_nth_type(const type_tree* base, long long int n) { + assert(n >= 0); + if (base == NULL) return false; + if (n == 0) return true; + return has_nth_type(base->right, n-1); +} + +:(scenario get_on_shape_shifting_container_error) +% Hide_errors = true; +container foo:_t [ + x:_t + y:number +] +recipe main [ + 10:foo:point <- merge 14, 15, 16 + 1:number <- get 10:foo, 1:offset +] ++error: illegal type 'foo' seems to be missing a type ingredient or three + +//: get-address similarly + +:(scenario get_address_on_shape_shifting_container) +container foo:_t [ + x:_t + y:number +] +recipe main [ + 10:foo:point <- merge 14, 15, 16 + 1:address:number <- get-address 10:foo:point, 1:offset +] ++mem: storing 12 in location 1 + +:(before "End GET_ADDRESS field Cases") +const type_tree* type = get(Type, base_type).elements.at(i); +if (type->value >= START_TYPE_INGREDIENTS) { + long long int size = size_of_type_ingredient(type, base.type->right); + if (!size) + raise_error << "illegal type '" << debug_string(type) << "' seems to be missing a type ingredient or three\n" << end(); + result += size; + continue; +} + +:(scenario get_on_shape_shifting_container_inside_shape_shifting_container) +container foo:_t [ + x:_t + y:number +] +container bar [ + x:foo:point + y:number +] +recipe main [ + 1:bar <- merge 14, 15, 16, 17 + 2:number <- get 1:bar, 1:offset +] ++mem: storing 17 in location 2 +</pre> +</body> +</html> + diff --git a/html/059shape_shifting_recipe.cc.html b/html/059shape_shifting_recipe.cc.html new file mode 100644 index 00000000..2df37fa3 --- /dev/null +++ b/html/059shape_shifting_recipe.cc.html @@ -0,0 +1,482 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> +<meta http-equiv="content-type" content="text/html; charset=UTF-8"> +<title>Mu - 059shape_shifting_recipe.cc</title> +<meta name="Generator" content="Vim/7.4"> +<meta name="plugin-version" content="vim7.4_v1"> +<meta name="syntax" content="cpp"> +<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> +<meta name="colorscheme" content="minimal"> +<style type="text/css"> + +</style> + +<script type='text/javascript'> + +</script> +</head> +<body> +<pre id='vimCodeElement'> +//:: Like container definitions, recipes too can contain type parameters. + +:(scenario shape_shifting_recipe) +recipe main [ + 10:point <- merge 14, 15 + 11:point <- foo 10:point +] +# non-matching variant +recipe foo a:number -> result:number [ + local-scope + load-ingredients + result <- copy 34 +] +# matching shape-shifting variant +recipe foo a:_t -> result:_t [ + local-scope + load-ingredients + result <- copy a +] ++mem: storing 14 in location 11 ++mem: storing 15 in location 12 + +//: Before anything else, disable transforms for shape-shifting recipes. + +:(before "End Transform Checks") +if (any_type_ingredient_in_header(/*recipe_ordinal*/p->first)) continue; + +//: We'll be creating recipes without loading them from anywhere by +//: *specializing* existing recipes, so make sure we don't clear any of those +//: when we start running tests. +:(before "End Loading .mu Files") +recently_added_recipes.clear(); +recently_added_types.clear(); + +:(before "End Instruction Dispatch(inst, best_score)") +if (best_score == -1) { + trace(9992, "transform") << "no variant found; searching for variant with suitable type ingredients" << end(); + recipe_ordinal exemplar = pick_matching_shape_shifting_variant(variants, inst, best_score); + if (exemplar) { + trace(9992, "transform") << "found variant to specialize: " << exemplar << ' ' << get(Recipe, exemplar).name << end(); + variants.push_back(new_variant(exemplar, inst, caller_recipe)); + inst.name = get(Recipe, variants.back()).name; + trace(9992, "transform") << "new specialization: " << inst.name << end(); + } +} + +:(code) +recipe_ordinal pick_matching_shape_shifting_variant(vector<recipe_ordinal>& variants, const instruction& inst, long long int& best_score) { + recipe_ordinal result = 0; + for (long long int i = 0; i < SIZE(variants); ++i) { + if (variants.at(i) == -1) continue; // ghost from a previous test + trace(9992, "transform") << "checking shape-shifting variant " <(); + long long int current_score = shape_shifting_variant_score(inst, variants.at(i)); + trace(9992, "transform") << "final score: " << current_score << end(); + if (current_score > best_score) { + trace(9992, "transform") << "matches" << end(); + result = variants.at(i); + best_score = current_score; + } + } + return result; +} + +long long int shape_shifting_variant_score(const instruction& inst, recipe_ordinal variant) { + if (!any_type_ingredient_in_header(variant)) { + trace(9993, "transform") << "no type ingredients" << end(); + return -1; + } + const vector<reagent>& header_ingredients = get(Recipe, variant).ingredients; + if (SIZE(inst.ingredients) < SIZE(header_ingredients)) { + trace(9993, "transform") << "too few ingredients" << end(); + return -1; + } + for (long long int i = 0; i < SIZE(header_ingredients); ++i) { + if (!non_type_ingredients_match(header_ingredients.at(i), inst.ingredients.at(i))) { + trace(9993, "transform") << "mismatch: ingredient " <(); + return -1; + } + } + if (SIZE(inst.products) > SIZE(get(Recipe, variant).products)) { + trace(9993, "transform") << "too few products" << end(); + return -1; + } + const vector<reagent>& header_products = get(Recipe, variant).products; + for (long long int i = 0; i < SIZE(inst.products); ++i) { + if (!non_type_ingredients_match(header_products.at(i), inst.products.at(i))) { + trace(9993, "transform") << "mismatch: product " <(); + return -1; + } + } + // the greater the number of unused ingredients, the lower the score + return 100 - (SIZE(get(Recipe, variant).products)-SIZE(inst.products)) + - (SIZE(inst.ingredients)-SIZE(get(Recipe, variant).ingredients)); // ok to go negative +} + +bool any_type_ingredient_in_header(recipe_ordinal variant) { + for (long long int i = 0; i < SIZE(get(Recipe, variant).ingredients); ++i) { + if (contains_type_ingredient_name(get(Recipe, variant).ingredients.at(i))) + return true; + } + for (long long int i = 0; i < SIZE(get(Recipe, variant).products); ++i) { + if (contains_type_ingredient_name(get(Recipe, variant).products.at(i))) + return true; + } + return false; +} + +bool non_type_ingredients_match(const reagent& lhs, const reagent& rhs) { + if (contains_type_ingredient_name(lhs)) return true; + return types_match(lhs, rhs); +} + +bool contains_type_ingredient_name(const reagent& x) { + return contains_type_ingredient_name(x.properties.at(0).second); +} + +bool contains_type_ingredient_name(const string_tree* type) { + if (!type) return false; + if (is_type_ingredient_name(type->value)) return true; + return contains_type_ingredient_name(type->left) || contains_type_ingredient_name(type->right); +} + +bool is_type_ingredient_name(const string& type) { + return !type.empty() && type.at(0) == '_'; +} + +recipe_ordinal new_variant(recipe_ordinal exemplar, const instruction& inst, const recipe& caller_recipe) { + string new_name = next_unused_recipe_name(inst.name); + trace(9993, "transform") << "switching " << inst.name << " to " << new_name << end(); + assert(!contains_key(Recipe_ordinal, new_name)); + recipe_ordinal new_recipe_ordinal = put(Recipe_ordinal, new_name, Next_recipe_ordinal++); + // make a copy + assert(contains_key(Recipe, exemplar)); + assert(!contains_key(Recipe, new_recipe_ordinal)); + recently_added_recipes.push_back(new_recipe_ordinal); + put(Recipe, new_recipe_ordinal, get(Recipe, exemplar)); + recipe& new_recipe = get(Recipe, new_recipe_ordinal); + new_recipe.name = new_name; + // Since the exemplar never ran any transforms, we have to redo some of the + // work of the check_types_by_name transform while supporting type-ingredients. + compute_type_names(new_recipe); + // that gives enough information to replace type-ingredients with concrete types + { + map<string, const string_tree*> mappings; + bool error = false; + compute_type_ingredient_mappings(get(Recipe, exemplar), inst, mappings, caller_recipe, &error); + if (!error) replace_type_ingredients(new_recipe, mappings); + for (map<string, const string_tree*>::iterator p = mappings.begin(); p != mappings.end(); ++p) + delete p->second; + if (error) return exemplar; + } + ensure_all_concrete_types(new_recipe); + // finally, perform all transforms on the new specialization + for (long long int t = 0; t < SIZE(Transform); ++t) { + (*Transform.at(t))(new_recipe_ordinal); + } + new_recipe.transformed_until = SIZE(Transform)-1; + return new_recipe_ordinal; +} + +void compute_type_names(recipe& variant) { + trace(9993, "transform") << "compute type names: " << variant.name << end(); + map<string, string_tree*> type_names; + for (long long int i = 0; i < SIZE(variant.ingredients); ++i) + save_or_deduce_type_name(variant.ingredients.at(i), type_names); + for (long long int i = 0; i < SIZE(variant.products); ++i) + save_or_deduce_type_name(variant.products.at(i), type_names); + for (long long int i = 0; i < SIZE(variant.steps); ++i) { + instruction& inst = variant.steps.at(i); + trace(9993, "transform") << " instruction: " << inst.to_string() << end(); + for (long long int in = 0; in < SIZE(inst.ingredients); ++in) + save_or_deduce_type_name(inst.ingredients.at(in), type_names); + for (long long int out = 0; out < SIZE(inst.products); ++out) + save_or_deduce_type_name(inst.products.at(out), type_names); + } +} + +void save_or_deduce_type_name(reagent& x, map<string, string_tree*>& type_name) { + trace(9994, "transform") << " checking " << x.to_string() << ": " << debug_string(x.properties.at(0).second) << end(); + if (!x.properties.at(0).second && contains_key(type_name, x.name)) { + x.properties.at(0).second = new string_tree(*get(type_name, x.name)); + trace(9994, "transform") << " deducing type to " << debug_string(x.properties.at(0).second) << end(); + return; + } + if (!x.properties.at(0).second) { + raise << "unknown type for " << x.original_string << '\n' << end(); + return; + } + if (contains_key(type_name, x.name)) return; + if (x.properties.at(0).second->value == "offset" || x.properties.at(0).second->value == "variant") return; // special-case for container-access instructions + put(type_name, x.name, x.properties.at(0).second); + trace(9993, "transform") << "type of " << x.name << " is " << debug_string(x.properties.at(0).second) << end(); +} + +void compute_type_ingredient_mappings(const recipe& exemplar, const instruction& inst, map<string, const string_tree*>& mappings, const recipe& caller_recipe, bool* error) { + for (long long int i = 0; i < SIZE(exemplar.ingredients); ++i) { + const reagent& exemplar_reagent = exemplar.ingredients.at(i); + reagent ingredient = inst.ingredients.at(i); + assert(ingredient.properties.at(0).second); + canonize_type(ingredient); + accumulate_type_ingredients(exemplar_reagent, ingredient, mappings, exemplar, inst, caller_recipe, error); + } + for (long long int i = 0; i < SIZE(exemplar.products); ++i) { + const reagent& exemplar_reagent = exemplar.products.at(i); + reagent product = inst.products.at(i); + assert(product.properties.at(0).second); + canonize_type(product); + accumulate_type_ingredients(exemplar_reagent, product, mappings, exemplar, inst, caller_recipe, error); + } +} + +void accumulate_type_ingredients(const reagent& exemplar_reagent, reagent& refinement, map<string, const string_tree*>& mappings, const recipe& exemplar, const instruction& call_instruction, const recipe& caller_recipe, bool* error) { + assert(refinement.properties.at(0).second); + accumulate_type_ingredients(exemplar_reagent.properties.at(0).second, refinement.properties.at(0).second, mappings, exemplar, exemplar_reagent, call_instruction, caller_recipe, error); +} + +void accumulate_type_ingredients(const string_tree* exemplar_type, const string_tree* refinement_type, map<string, const string_tree*>& mappings, const recipe& exemplar, const reagent& exemplar_reagent, const instruction& call_instruction, const recipe& caller_recipe, bool* error) { + if (!exemplar_type) return; + if (!refinement_type) { + raise_error << maybe(exemplar.name) << "missing type ingredient in " << exemplar_reagent.original_string << '\n' << end(); + return; + } + if (!exemplar_type->value.empty() && exemplar_type->value.at(0) == '_') { + assert(!refinement_type->value.empty()); + if (exemplar_type->right) { + raise_error << "type_ingredients in non-last position not currently supported\n" << end(); + return; + } + if (!contains_key(mappings, exemplar_type->value)) { + trace(9993, "transform") << "adding mapping from " << exemplar_type->value << " to " << debug_string(refinement_type) << end(); + put(mappings, exemplar_type->value, new string_tree(*refinement_type)); + } + else { + if (!deeply_equal(get(mappings, exemplar_type->value), refinement_type)) { + raise_error << maybe(caller_recipe.name) << "no call found for '" << call_instruction.to_string() << "'\n" << end(); + *error = true; + return; + } + } + } + else { + accumulate_type_ingredients(exemplar_type->left, refinement_type->left, mappings, exemplar, exemplar_reagent, call_instruction, caller_recipe, error); + } + accumulate_type_ingredients(exemplar_type->right, refinement_type->right, mappings, exemplar, exemplar_reagent, call_instruction, caller_recipe, error); +} + +void replace_type_ingredients(recipe& new_recipe, const map<string, const string_tree*>& mappings) { + // update its header + if (mappings.empty()) return; + trace(9993, "transform") << "replacing in recipe header ingredients" << end(); + for (long long int i = 0; i < SIZE(new_recipe.ingredients); ++i) + replace_type_ingredients(new_recipe.ingredients.at(i), mappings); + trace(9993, "transform") << "replacing in recipe header products" << end(); + for (long long int i = 0; i < SIZE(new_recipe.products); ++i) + replace_type_ingredients(new_recipe.products.at(i), mappings); + // update its body + for (long long int i = 0; i < SIZE(new_recipe.steps); ++i) { + instruction& inst = new_recipe.steps.at(i); + trace(9993, "transform") << "replacing in instruction '" << inst.to_string() << "'" << end(); + for (long long int j = 0; j < SIZE(inst.ingredients); ++j) + replace_type_ingredients(inst.ingredients.at(j), mappings); + for (long long int j = 0; j < SIZE(inst.products); ++j) + replace_type_ingredients(inst.products.at(j), mappings); + // special-case for new: replace type ingredient in first ingredient *value* + if (inst.name == "new" && inst.ingredients.at(0).name.at(0) != '[') { + string_tree* type_name = parse_string_tree(inst.ingredients.at(0).name); + replace_type_ingredients(type_name, mappings); + inst.ingredients.at(0).name = type_name->to_string(); + delete type_name; + } + } +} + +void replace_type_ingredients(reagent& x, const map<string, const string_tree*>& mappings) { + trace(9993, "transform") << "replacing in ingredient " << x.original_string << end(); + // replace properties + assert(x.properties.at(0).second); + replace_type_ingredients(x.properties.at(0).second, mappings); + // refresh types from properties + delete x.type; + x.type = new_type_tree(x.properties.at(0).second); + if (x.type) + trace(9993, "transform") << " after: " << debug_string(x.type) << end(); +} + +void replace_type_ingredients(string_tree* type, const map<string, const string_tree*>& mappings) { + if (!type) return; + if (is_type_ingredient_name(type->value) && contains_key(mappings, type->value)) { + const string_tree* replacement = get(mappings, type->value); + trace(9993, "transform") << type->value << " => " << debug_string(replacement) << end(); + type->value = replacement->value; + if (replacement->left) type->left = new string_tree(*replacement->left); + if (replacement->right) type->right = new string_tree(*replacement->right); + } + replace_type_ingredients(type->left, mappings); + replace_type_ingredients(type->right, mappings); +} + +void ensure_all_concrete_types(const recipe& new_recipe) { + for (long long int i = 0; i < SIZE(new_recipe.ingredients); ++i) + ensure_all_concrete_types(new_recipe.ingredients.at(i).type); + for (long long int i = 0; i < SIZE(new_recipe.products); ++i) + ensure_all_concrete_types(new_recipe.products.at(i).type); + for (long long int i = 0; i < SIZE(new_recipe.steps); ++i) { + const instruction& inst = new_recipe.steps.at(i); + for (long long int j = 0; j < SIZE(inst.ingredients); ++j) + ensure_all_concrete_types(inst.ingredients.at(j).type); + for (long long int j = 0; j < SIZE(inst.products); ++j) + ensure_all_concrete_types(inst.products.at(j).type); + } +} + +void ensure_all_concrete_types(const type_tree* x) { + if (!x) { + raise << "null type\n" << end(); + return; + } + if (x->value == -1) { + raise << "unknown type\n" << end(); + return; + } +} + +:(scenario shape_shifting_recipe_2) +recipe main [ + 10:point <- merge 14, 15 + 11:point <- foo 10:point +] +# non-matching shape-shifting variant +recipe foo a:_t, b:_t -> result:number [ + local-scope + load-ingredients + result <- copy 34 +] +# matching shape-shifting variant +recipe foo a:_t -> result:_t [ + local-scope + load-ingredients + result <- copy a +] ++mem: storing 14 in location 11 ++mem: storing 15 in location 12 + +:(scenario shape_shifting_recipe_nonroot) +recipe main [ + 10:foo:point <- merge 14, 15, 16 + 20:point/raw <- bar 10:foo:point +] +# shape-shifting recipe with type ingredient following some other type +recipe bar a:foo:_t -> result:_t [ + local-scope + load-ingredients + result <- get a, x:offset +] +container foo:_t [ + x:_t + y:number +] ++mem: storing 14 in location 20 ++mem: storing 15 in location 21 + +:(scenario shape_shifting_recipe_type_deduction_ignores_offsets) +recipe main [ + 10:foo:point <- merge 14, 15, 16 + 20:point/raw <- bar 10:foo:point +] +recipe bar a:foo:_t -> result:_t [ + local-scope + load-ingredients + x:number <- copy 1 + result <- get a, x:offset # shouldn't collide with other variable +] +container foo:_t [ + x:_t + y:number +] ++mem: storing 14 in location 20 ++mem: storing 15 in location 21 + +:(scenario shape_shifting_recipe_handles_shape_shifting_new_ingredient) +recipe main [ + 1:address:foo:point <- bar 3 + 11:foo:point <- copy *1:address:foo:point +] +container foo:_t [ + x:_t + y:number +] +recipe bar x:number -> result:address:foo:_t [ + local-scope + load-ingredients + # new refers to _t in its ingredient *value* + result <- new {(foo _t) : type} +] ++mem: storing 0 in location 11 ++mem: storing 0 in location 12 ++mem: storing 0 in location 13 + +:(scenario shape_shifting_recipe_handles_shape_shifting_new_ingredient_2) +recipe main [ + 1:address:foo:point <- bar 3 + 11:foo:point <- copy *1:address:foo:point +] +recipe bar x:number -> result:address:foo:_t [ + local-scope + load-ingredients + # new refers to _t in its ingredient *value* + result <- new {(foo _t) : type} +] +# container defined after use +container foo:_t [ + x:_t + y:number +] ++mem: storing 0 in location 11 ++mem: storing 0 in location 12 ++mem: storing 0 in location 13 + +:(scenario shape_shifting_recipe_supports_compound_types) +recipe main [ + 1:address:point <- new point:type + 2:address:number <- get-address *1:address:point, y:offset + *2:address:number <- copy 34 + 3:address:point <- bar 1:address:point # specialize _t to address:point + 4:point <- copy *3:address:point +] +recipe bar a:_t -> result:_t [ + local-scope + load-ingredients + result <- copy a +] ++mem: storing 34 in location 5 + +:(scenario shape_shifting_recipe_error) +% Hide_errors = true; +recipe main [ + a:number <- copy 3 + b:address:number <- foo a +] +recipe foo a:_t -> b:_t [ + load-ingredients + b <- copy a +] ++error: main: no call found for 'b:address:number <- foo a' +</pre> +</body> +</html> + diff --git a/html/060string.mu.html b/html/060string.mu.html index a5cf9f7a..ae7a3e01 100644 --- a/html/060string.mu.html +++ b/html/060string.mu.html @@ -13,14 +13,14 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } -.muData { color: #ffff00; } .muScenario { color: #00af00; } +.muData { color: #ffff00; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .Special { color: #ff6060; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> @@ -447,7 +447,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } s:address:array:character <- next-ingredient oldc:character <- next-ingredient newc:character <- next-ingredient - from:number <- next-ingredient + from:number, _ <- next-ingredient # default to 0 len:number <- length *s i:number <- find-next s, oldc, from done?:boolean <- greater-or-equal i, len @@ -625,62 +625,60 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } c:character <- next-ingredient # most common case first result:boolean <- equal c, 32/space - jump-if result +reply:label + reply-if result, result result <- equal c, 10/newline - jump-if result, +reply:label + reply-if result, result result <- equal c, 9/tab - jump-if result, +reply:label + reply-if result, result result <- equal c, 13/carriage-return - jump-if result, +reply:label + reply-if result, result # remaining uncommon cases in sorted order # <a href="http://unicode.org">http://unicode.org</a> code-points in unicode-set Z and Pattern_White_Space result <- equal c, 11/ctrl-k - jump-if result, +reply:label + reply-if result, result result <- equal c, 12/ctrl-l - jump-if result, +reply:label + reply-if result, result result <- equal c, 133/ctrl-0085 - jump-if result, +reply:label + reply-if result, result result <- equal c, 160/no-break-space - jump-if result, +reply:label + reply-if result, result result <- equal c, 5760/ogham-space-mark - jump-if result, +reply:label + reply-if result, result result <- equal c, 8192/en-quad - jump-if result, +reply:label + reply-if result, result result <- equal c, 8193/em-quad - jump-if result, +reply:label + reply-if result, result result <- equal c, 8194/en-space - jump-if result, +reply:label + reply-if result, result result <- equal c, 8195/em-space - jump-if result, +reply:label + reply-if result, result result <- equal c, 8196/three-per-em-space - jump-if result, +reply:label + reply-if result, result result <- equal c, 8197/four-per-em-space - jump-if result, +reply:label + reply-if result, result result <- equal c, 8198/six-per-em-space - jump-if result, +reply:label + reply-if result, result result <- equal c, 8199/figure-space - jump-if result, +reply:label + reply-if result, result result <- equal c, 8200/punctuation-space - jump-if result, +reply:label + reply-if result, result result <- equal c, 8201/thin-space - jump-if result, +reply:label + reply-if result, result result <- equal c, 8202/hair-space - jump-if result, +reply:label + reply-if result, result result <- equal c, 8206/left-to-right - jump-if result, +reply:label + reply-if result, result result <- equal c, 8207/right-to-left - jump-if result, +reply:label + reply-if result, result result <- equal c, 8232/line-separator - jump-if result, +reply:label + reply-if result, result result <- equal c, 8233/paragraph-separator - jump-if result, +reply:label + reply-if result, result result <- equal c, 8239/narrow-no-break-space - jump-if result, +reply:label + reply-if result, result result <- equal c, 8287/medium-mathematical-space - jump-if result, +reply:label + reply-if result, result result <- equal c, 12288/ideographic-space - jump-if result, +reply:label - +reply reply result ] diff --git a/html/061channel.mu.html b/html/061channel.mu.html index a52d34f3..47a11e0f 100644 --- a/html/061channel.mu.html +++ b/html/061channel.mu.html @@ -13,15 +13,15 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } +.muRecipe { color: #ff8700; } .muScenario { color: #00af00; } .muData { color: #ffff00; } .SalientComment { color: #00ffff; } -.muRecipe { color: #ff8700; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .Special { color: #ff6060; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> @@ -47,7 +47,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } run [ 1:address:channel <- new-channel 3/capacity 1:address:channel <- write 1:address:channel, 34 - 2:number, 1:address:channel <- read 1:address:channel + 2:character, 1:address:channel <- read 1:address:channel ] memory-should-contain [ 2 <- 34 @@ -63,7 +63,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # A circular buffer contains values from index first-full up to (but not # including) index first-empty. The reader always modifies it at first-full, # while the writer always modifies it at first-empty. - data:address:array:location + data:address:array:character ] # result:address:channel <- new-channel capacity:number @@ -80,16 +80,16 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # result.data = new location[ingredient+1] capacity:number <- next-ingredient capacity <- add capacity, 1 # unused slot for 'full?' below - dest:address:address:array:location <- get-address *result, data:offset - *dest <- new location:type, capacity + dest:address:address:array:character <- get-address *result, data:offset + *dest <- new character:type, capacity reply result ] -# chan <- write chan:address:channel, val:location +# chan <- write chan:address:channel, val:character recipe write [ local-scope chan:address:channel <- next-ingredient - val:location <- next-ingredient + val:character <- next-ingredient { # block if chan is full full:boolean <- channel-full? chan @@ -98,9 +98,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } wait-for-location *full-address } # store val - circular-buffer:address:array:location <- get *chan, data:offset + circular-buffer:address:array:character <- get *chan, data:offset free:address:number <- get-address *chan, first-free:offset - dest:address:location <- index-address *circular-buffer, *free + dest:address:character <- index-address *circular-buffer, *free *dest <- copy val # mark its slot as filled *free <- add *free, 1 @@ -114,7 +114,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } reply chan/same-as-ingredient:0 ] -# result:location, chan <- read chan:address:channel +# result:character, chan <- read chan:address:channel recipe read [ local-scope chan:address:channel <- next-ingredient @@ -127,8 +127,8 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } # read result full:address:number <- get-address *chan, first-full:offset - circular-buffer:address:array:location <- get *chan, data:offset - result:location <- index *circular-buffer, *full + circular-buffer:address:array:character <- get *chan, data:offset + result:character <- index *circular-buffer, *full # mark its slot as empty *full <- add *full, 1 { @@ -254,7 +254,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe channel-capacity [ local-scope chan:address:channel <- next-ingredient - q:address:array:location <- get *chan, data:offset + q:address:array:character <- get *chan, data:offset result:number <- length *q reply result ] diff --git a/html/062array.mu.html b/html/062array.mu.html index b65da102..4f800098 100644 --- a/html/062array.mu.html +++ b/html/062array.mu.html @@ -13,13 +13,13 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.muScenario { color: #00af00; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } +.muScenario { color: #00af00; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .Special { color: #ff6060; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> @@ -33,8 +33,8 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } <pre id='vimCodeElement'> scenario array-from-args [ run [ - 1:address:array:location <- new-array 0, 1, 2 - 2:array:location <- copy *1:address:array:location + 1:address:array:character <- new-array 0, 1, 2 + 2:array:character <- copy *1:address:array:character ] memory-should-contain [ 2 <- 3 # array length @@ -50,21 +50,21 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } capacity:number <- copy 0 { # while read curr-value - curr-value:location, exists?:boolean <- next-ingredient + curr-value:character, exists?:boolean <- next-ingredient break-unless exists? capacity <- add capacity, 1 loop } - result:address:array:location <- new location:type, capacity + result:address:array:character <- new character:type, capacity rewind-ingredients i:number <- copy 0 { # while read curr-value done?:boolean <- greater-or-equal i, capacity break-if done? - curr-value:location, exists?:boolean <- next-ingredient + curr-value:character, exists?:boolean <- next-ingredient assert exists?, [error in rewinding ingredients to new-array] - tmp:address:location <- index-address *result, i + tmp:address:character <- index-address *result, i *tmp <- copy curr-value i <- add i, 1 loop diff --git a/html/063list.mu.html b/html/063list.mu.html index a4c4e02e..a3122c41 100644 --- a/html/063list.mu.html +++ b/html/063list.mu.html @@ -13,13 +13,14 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } -.muData { color: #ffff00; } .muScenario { color: #00af00; } +.muData { color: #ffff00; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .Special { color: #ff6060; } -.muControl { color: #c0a020; } +.Delimiter { color: #a04060; } --> </style> @@ -33,55 +34,58 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } <pre id='vimCodeElement'> # A list links up multiple objects together to make them easier to manage. # -# Try to make all objects in a single list of the same type, it'll help avoid bugs. -# If you want to store multiple types in a single list, use an exclusive-container. +# The objects must be of the same type. If you want to store multiple types in +# a single list, use an exclusive-container. -container list [ - value:location - next:address:list +container list:_elem [ + value:_elem + next:address:list:_elem ] -# result:address:list <- push x:location, in:address:list -recipe push [ +recipe push x:_elem, in:address:list:_elem -> result:address:list:_elem [ local-scope - x:location <- next-ingredient - in:address:list <- next-ingredient - result:address:list <- new list:type - val:address:location <- get-address *result, value:offset + load-ingredients + result <- new {(list _elem): type} + val:address:_elem <- get-address *result, value:offset *val <- copy x - next:address:address:list <- get-address *result, next:offset + next:address:address:list:_elem <- get-address *result, next:offset *next <- copy in reply result ] -# result:location <- first in:address:list -recipe first [ +recipe first in:address:list:_elem -> result:_elem [ local-scope - in:address:list <- next-ingredient - result:location <- get *in, value:offset - reply result + load-ingredients + result <- get *in, value:offset ] # result:address:list <- rest in:address:list -recipe rest [ +recipe rest in:address:list:_elem -> result:address:list:_elem [ local-scope - in:address:list <- next-ingredient - result:address:list <- get *in, next:offset - reply result + load-ingredients + result <- get *in, next:offset +] + +recipe force-specialization-list-number [ + 1:address:list:number <- push 2:number, 1:address:list:number + 2:number <- first 1:address:list:number + 1:address:list:number <- rest 1:address:list:number ] +# todo: automatically specialize code in scenarios scenario list-handling [ run [ - 1:address:list <- copy 0 - 1:address:list <- push 3, 1:address:list - 1:address:list <- push 4, 1:address:list - 1:address:list <- push 5, 1:address:list - 2:number <- first 1:address:list - 1:address:list <- rest 1:address:list - 3:number <- first 1:address:list - 1:address:list <- rest 1:address:list - 4:number <- first 1:address:list - 1:address:list <- rest 1:address:list + 1:address:list:number <- copy 0 + 2:number <- copy 3 + 1:address:list:number <- push 2:number, 1:address:list:number + 1:address:list:number <- push 4, 1:address:list:number + 1:address:list:number <- push 5, 1:address:list:number + 2:number <- first 1:address:list:number + 1:address:list:number <- rest 1:address:list:number + 3:number <- first 1:address:list:number + 1:address:list:number <- rest 1:address:list:number + 4:number <- first 1:address:list:number + 1:address:list:number <- rest 1:address:list:number ] memory-should-contain [ 1 <- 0 # empty to empty, dust to dust.. diff --git a/html/064random.cc.html b/html/064random.cc.html index e8a75626..bd176af3 100644 --- a/html/064random.cc.html +++ b/html/064random.cc.html @@ -13,8 +13,8 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.cSpecial { color: #008000; } .traceContains { color: #008000; } +.cSpecial { color: #008000; } .PreProc { color: #c000c0; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } @@ -35,7 +35,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } :(before "End Primitive Recipe Declarations") RANDOM, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["random"] = RANDOM; +put(Recipe_ordinal, "random", RANDOM); +:(before "End Primitive Recipe Checks") +case RANDOM: { + break; +} :(before "End Primitive Recipe Implementations") case RANDOM: { // todo: limited range of numbers, might be imperfectly random @@ -48,7 +52,11 @@ case RANDOM: { :(before "End Primitive Recipe Declarations") MAKE_RANDOM_NONDETERMINISTIC, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["make-random-nondeterministic"] = MAKE_RANDOM_NONDETERMINISTIC; +put(Recipe_ordinal, "make-random-nondeterministic", MAKE_RANDOM_NONDETERMINISTIC); +:(before "End Primitive Recipe Checks") +case MAKE_RANDOM_NONDETERMINISTIC: { + break; +} :(before "End Primitive Recipe Implementations") case MAKE_RANDOM_NONDETERMINISTIC: { srand(time(NULL)); @@ -58,17 +66,21 @@ case MAKE_RANDOM_NONDETERMINISTIC: { :(before "End Primitive Recipe Declarations") ROUND, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["round"] = ROUND; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "round", ROUND); +:(before "End Primitive Recipe Checks") case ROUND: { - if (SIZE(ingredients) != 1) { - raise << current_recipe_name() << ": 'round' requires exactly one ingredient, but got " << current_instruction().to_string() << '\n' << end(); + if (SIZE(inst.ingredients) != 1) { + raise_error << maybe(get(Recipe, r).name) << "'round' requires exactly one ingredient, but got " << inst.to_string() << '\n' << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'round' should be a number, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_number(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'round' should be a number, but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case ROUND: { products.resize(1); products.at(0).push_back(rint(ingredients.at(0).at(0))); break; diff --git a/html/065duplex_list.mu.html b/html/065duplex_list.mu.html index bf7634a0..4a9437ce 100644 --- a/html/065duplex_list.mu.html +++ b/html/065duplex_list.mu.html @@ -13,14 +13,14 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } -.muData { color: #ffff00; } .muScenario { color: #00af00; } +.muData { color: #ffff00; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .Special { color: #ff6060; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> @@ -34,52 +34,44 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } <pre id='vimCodeElement'> # A doubly linked list permits bidirectional traversal. -container duplex-list [ - value:location - next:address:duplex-list - prev:address:duplex-list +container duplex-list:_elem [ + value:_elem + next:address:duplex-list:_elem + prev:address:duplex-list:_elem ] -# result:address:duplex-list <- push-duplex x:location, in:address:duplex-list -recipe push-duplex [ +recipe push-duplex x:_elem, in:address:duplex-list:_elem -> result:address:duplex-list:_elem [ local-scope - x:location <- next-ingredient - in:address:duplex-list <- next-ingredient - result:address:duplex-list <- new duplex-list:type - val:address:location <- get-address *result, value:offset + load-ingredients + result <- new {(duplex-list _elem): type} + val:address:_elem <- get-address *result, value:offset *val <- copy x - next:address:address:duplex-list <- get-address *result, next:offset + next:address:address:duplex-list:_elem <- get-address *result, next:offset *next <- copy in - reply-unless in, result - prev:address:address:duplex-list <- get-address *in, prev:offset + reply-unless in + prev:address:address:duplex-list:_elem <- get-address *in, prev:offset *prev <- copy result - reply result ] -# result:location <- first-duplex in:address:duplex-list -recipe first-duplex [ +recipe first-duplex in:address:duplex-list:_elem -> result:_elem [ local-scope - in:address:duplex-list <- next-ingredient + load-ingredients reply-unless in, 0 - result:location <- get *in, value:offset - reply result + result <- get *in, value:offset ] -# result:address:duplex-list <- next-duplex in:address:duplex-list -recipe next-duplex [ +recipe next-duplex in:address:duplex-list:_elem -> result:address:duplex-list:_elem [ local-scope - in:address:duplex-list <- next-ingredient + load-ingredients reply-unless in, 0 - result:address:duplex-list <- get *in, next:offset - reply result + result <- get *in, next:offset ] -# result:address:duplex-list <- prev-duplex in:address:duplex-list -recipe prev-duplex [ +recipe prev-duplex in:address:duplex-list:_elem -> result:address:duplex-list:_elem [ local-scope - in:address:duplex-list <- next-ingredient + load-ingredients reply-unless in, 0 - result:address:duplex-list <- get *in, prev:offset + result <- get *in, prev:offset reply result ] @@ -88,25 +80,25 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # reserve locations 0, 1 and 2 to check for missing null check 1:number <- copy 34 2:number <- copy 35 - 3:address:duplex-list <- copy 0 - 3:address:duplex-list <- push-duplex 3, 3:address:duplex-list - 3:address:duplex-list <- push-duplex 4, 3:address:duplex-list - 3:address:duplex-list <- push-duplex 5, 3:address:duplex-list - 4:address:duplex-list <- copy 3:address:duplex-list - 5:number <- first-duplex 4:address:duplex-list - 4:address:duplex-list <- next-duplex 4:address:duplex-list - 6:number <- first-duplex 4:address:duplex-list - 4:address:duplex-list <- next-duplex 4:address:duplex-list - 7:number <- first-duplex 4:address:duplex-list - 8:address:duplex-list <- next-duplex 4:address:duplex-list - 9:number <- first-duplex 8:address:duplex-list - 10:address:duplex-list <- next-duplex 8:address:duplex-list - 11:address:duplex-list <- prev-duplex 8:address:duplex-list - 4:address:duplex-list <- prev-duplex 4:address:duplex-list - 12:number <- first-duplex 4:address:duplex-list - 4:address:duplex-list <- prev-duplex 4:address:duplex-list - 13:number <- first-duplex 4:address:duplex-list - 14:boolean <- equal 3:address:duplex-list, 4:address:duplex-list + 3:address:duplex-list:character <- copy 0 + 3:address:duplex-list:character <- push-duplex 3, 3:address:duplex-list:character + 3:address:duplex-list:character <- push-duplex 4, 3:address:duplex-list:character + 3:address:duplex-list:character <- push-duplex 5, 3:address:duplex-list:character + 4:address:duplex-list:character <- copy 3:address:duplex-list:character + 5:character <- first-duplex 4:address:duplex-list:character + 4:address:duplex-list:character <- next-duplex 4:address:duplex-list:character + 6:character <- first-duplex 4:address:duplex-list:character + 4:address:duplex-list:character <- next-duplex 4:address:duplex-list:character + 7:character <- first-duplex 4:address:duplex-list:character + 8:address:duplex-list:character <- next-duplex 4:address:duplex-list:character + 9:character <- first-duplex 8:address:duplex-list:character + 10:address:duplex-list:character <- next-duplex 8:address:duplex-list:character + 11:address:duplex-list:character <- prev-duplex 8:address:duplex-list:character + 4:address:duplex-list:character <- prev-duplex 4:address:duplex-list:character + 12:character <- first-duplex 4:address:duplex-list:character + 4:address:duplex-list:character <- prev-duplex 4:address:duplex-list:character + 13:character <- first-duplex 4:address:duplex-list:character + 14:boolean <- equal 3:address:duplex-list:character, 4:address:duplex-list:character ] memory-should-contain [ 0 <- 0 # no modifications to null pointers @@ -125,18 +117,16 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] ] -# l:address:duplex-list <- insert-duplex x:location, in:address:duplex-list # Inserts 'x' after 'in'. Returns some pointer into the list. -recipe insert-duplex [ +recipe insert-duplex x:_elem, in:address:duplex-list:_elem -> new-node:address:duplex-list:_elem [ local-scope - x:location <- next-ingredient - in:address:duplex-list <- next-ingredient - new-node:address:duplex-list <- new duplex-list:type - val:address:location <- get-address *new-node, value:offset + load-ingredients + new-node <- new {(duplex-list _elem): type} + val:address:_elem <- get-address *new-node, value:offset *val <- copy x - next-node:address:duplex-list <- get *in, next:offset + next-node:address:duplex-list:_elem <- get *in, next:offset # in.next = new-node - y:address:address:duplex-list <- get-address *in, next:offset + y:address:address:duplex-list:_elem <- get-address *in, next:offset *y <- copy new-node # new-node.prev = in y <- get-address *new-node, prev:offset @@ -154,28 +144,28 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario inserting-into-duplex-list [ run [ - 1:address:duplex-list <- copy 0 # 1 points to head of list - 1:address:duplex-list <- push-duplex 3, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 4, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 5, 1:address:duplex-list - 2:address:duplex-list <- next-duplex 1:address:duplex-list # 2 points inside list - 2:address:duplex-list <- insert-duplex 6, 2:address:duplex-list + 1:address:duplex-list:character <- copy 0 # 1 points to head of list + 1:address:duplex-list:character <- push-duplex 3, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 4, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 5, 1:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 1:address:duplex-list:character # 2 points inside list + 2:address:duplex-list:character <- insert-duplex 6, 2:address:duplex-list:character # check structure like before - 2:address:duplex-list <- copy 1:address:duplex-list - 3:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- next-duplex 2:address:duplex-list - 4:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- next-duplex 2:address:duplex-list - 5:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- next-duplex 2:address:duplex-list - 6:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- prev-duplex 2:address:duplex-list - 7:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- prev-duplex 2:address:duplex-list - 8:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- prev-duplex 2:address:duplex-list - 9:number <- first-duplex 2:address:duplex-list - 10:boolean <- equal 1:address:duplex-list, 2:address:duplex-list + 2:address:duplex-list:character <- copy 1:address:duplex-list:character + 3:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 4:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 5:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 6:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- prev-duplex 2:address:duplex-list:character + 7:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- prev-duplex 2:address:duplex-list:character + 8:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- prev-duplex 2:address:duplex-list:character + 9:character <- first-duplex 2:address:duplex-list:character + 10:boolean <- equal 1:address:duplex-list:character, 2:address:duplex-list:character ] memory-should-contain [ 3 <- 5 # scanning next @@ -191,29 +181,29 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario inserting-at-end-of-duplex-list [ run [ - 1:address:duplex-list <- copy 0 # 1 points to head of list - 1:address:duplex-list <- push-duplex 3, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 4, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 5, 1:address:duplex-list - 2:address:duplex-list <- next-duplex 1:address:duplex-list # 2 points inside list - 2:address:duplex-list <- next-duplex 2:address:duplex-list # now at end of list - 2:address:duplex-list <- insert-duplex 6, 2:address:duplex-list + 1:address:duplex-list:character <- copy 0 # 1 points to head of list + 1:address:duplex-list:character <- push-duplex 3, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 4, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 5, 1:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 1:address:duplex-list:character # 2 points inside list + 2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character # now at end of list + 2:address:duplex-list:character <- insert-duplex 6, 2:address:duplex-list:character # check structure like before - 2:address:duplex-list <- copy 1:address:duplex-list - 3:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- next-duplex 2:address:duplex-list - 4:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- next-duplex 2:address:duplex-list - 5:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- next-duplex 2:address:duplex-list - 6:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- prev-duplex 2:address:duplex-list - 7:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- prev-duplex 2:address:duplex-list - 8:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- prev-duplex 2:address:duplex-list - 9:number <- first-duplex 2:address:duplex-list - 10:boolean <- equal 1:address:duplex-list, 2:address:duplex-list + 2:address:duplex-list:character <- copy 1:address:duplex-list:character + 3:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 4:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 5:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 6:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- prev-duplex 2:address:duplex-list:character + 7:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- prev-duplex 2:address:duplex-list:character + 8:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- prev-duplex 2:address:duplex-list:character + 9:character <- first-duplex 2:address:duplex-list:character + 10:boolean <- equal 1:address:duplex-list:character, 2:address:duplex-list:character ] memory-should-contain [ 3 <- 5 # scanning next @@ -229,27 +219,27 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario inserting-after-start-of-duplex-list [ run [ - 1:address:duplex-list <- copy 0 # 1 points to head of list - 1:address:duplex-list <- push-duplex 3, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 4, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 5, 1:address:duplex-list - 2:address:duplex-list <- insert-duplex 6, 1:address:duplex-list + 1:address:duplex-list:character <- copy 0 # 1 points to head of list + 1:address:duplex-list:character <- push-duplex 3, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 4, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 5, 1:address:duplex-list:character + 2:address:duplex-list:character <- insert-duplex 6, 1:address:duplex-list:character # check structure like before - 2:address:duplex-list <- copy 1:address:duplex-list - 3:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- next-duplex 2:address:duplex-list - 4:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- next-duplex 2:address:duplex-list - 5:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- next-duplex 2:address:duplex-list - 6:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- prev-duplex 2:address:duplex-list - 7:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- prev-duplex 2:address:duplex-list - 8:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- prev-duplex 2:address:duplex-list - 9:number <- first-duplex 2:address:duplex-list - 10:boolean <- equal 1:address:duplex-list, 2:address:duplex-list + 2:address:duplex-list:character <- copy 1:address:duplex-list:character + 3:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 4:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 5:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 6:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- prev-duplex 2:address:duplex-list:character + 7:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- prev-duplex 2:address:duplex-list:character + 8:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- prev-duplex 2:address:duplex-list:character + 9:character <- first-duplex 2:address:duplex-list:character + 10:boolean <- equal 1:address:duplex-list:character, 2:address:duplex-list:character ] memory-should-contain [ 3 <- 5 # scanning next @@ -263,21 +253,20 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] ] -# l:address:duplex-list <- remove-duplex in:address:duplex-list # Removes 'in' from its surrounding list. Returns some valid pointer into the # rest of the list. # # Returns null if and only if list is empty. Beware: in that case any pointers # to the head are now invalid. -recipe remove-duplex [ +recipe remove-duplex in:address:duplex-list:_elem -> next-node:address:duplex-list:_elem [ local-scope - in:address:duplex-list <- next-ingredient + load-ingredients # if 'in' is null, return reply-unless in, in - next-node:address:duplex-list <- get *in, next:offset - prev-node:address:duplex-list <- get *in, prev:offset + next-node:address:duplex-list:_elem <- get *in, next:offset + prev-node:address:duplex-list:_elem <- get *in, prev:offset # null in's pointers - x:address:address:duplex-list <- get-address *in, next:offset + x:address:address:duplex-list:_elem <- get-address *in, next:offset *x <- copy 0 x <- get-address *in, prev:offset *x <- copy 0 @@ -301,22 +290,22 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario removing-from-duplex-list [ run [ - 1:address:duplex-list <- copy 0 # 1 points to head of list - 1:address:duplex-list <- push-duplex 3, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 4, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 5, 1:address:duplex-list - 2:address:duplex-list <- next-duplex 1:address:duplex-list # 2 points at second element - 2:address:duplex-list <- remove-duplex 2:address:duplex-list - 3:boolean <- equal 2:address:duplex-list, 0 + 1:address:duplex-list:character <- copy 0 # 1 points to head of list + 1:address:duplex-list:character <- push-duplex 3, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 4, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 5, 1:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 1:address:duplex-list:character # 2 points at second element + 2:address:duplex-list:character <- remove-duplex 2:address:duplex-list:character + 3:boolean <- equal 2:address:duplex-list:character, 0 # check structure like before - 2:address:duplex-list <- copy 1:address:duplex-list - 4:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- next-duplex 2:address:duplex-list - 5:number <- first-duplex 2:address:duplex-list - 6:address:duplex-list <- next-duplex 2:address:duplex-list - 2:address:duplex-list <- prev-duplex 2:address:duplex-list - 7:number <- first-duplex 2:address:duplex-list - 8:boolean <- equal 1:address:duplex-list, 2:address:duplex-list + 2:address:duplex-list:character <- copy 1:address:duplex-list:character + 4:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 5:character <- first-duplex 2:address:duplex-list:character + 6:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- prev-duplex 2:address:duplex-list:character + 7:character <- first-duplex 2:address:duplex-list:character + 8:boolean <- equal 1:address:duplex-list:character, 2:address:duplex-list:character ] memory-should-contain [ 3 <- 0 # remove returned non-null @@ -330,21 +319,21 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario removing-from-start-of-duplex-list [ run [ - 1:address:duplex-list <- copy 0 # 1 points to head of list - 1:address:duplex-list <- push-duplex 3, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 4, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 5, 1:address:duplex-list + 1:address:duplex-list:character <- copy 0 # 1 points to head of list + 1:address:duplex-list:character <- push-duplex 3, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 4, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 5, 1:address:duplex-list:character # removing from head? return value matters. - 1:address:duplex-list <- remove-duplex 1:address:duplex-list + 1:address:duplex-list:character <- remove-duplex 1:address:duplex-list:character # check structure like before - 2:address:duplex-list <- copy 1:address:duplex-list - 3:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- next-duplex 2:address:duplex-list - 4:number <- first-duplex 2:address:duplex-list - 5:address:duplex-list <- next-duplex 2:address:duplex-list - 2:address:duplex-list <- prev-duplex 2:address:duplex-list - 6:number <- first-duplex 2:address:duplex-list - 7:boolean <- equal 1:address:duplex-list, 2:address:duplex-list + 2:address:duplex-list:character <- copy 1:address:duplex-list:character + 3:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 4:character <- first-duplex 2:address:duplex-list:character + 5:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- prev-duplex 2:address:duplex-list:character + 6:character <- first-duplex 2:address:duplex-list:character + 7:boolean <- equal 1:address:duplex-list:character, 2:address:duplex-list:character ] memory-should-contain [ 3 <- 4 # scanning next, skipping deleted element @@ -357,24 +346,24 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario removing-from-end-of-duplex-list [ run [ - 1:address:duplex-list <- copy 0 # 1 points to head of list - 1:address:duplex-list <- push-duplex 3, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 4, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 5, 1:address:duplex-list + 1:address:duplex-list:character <- copy 0 # 1 points to head of list + 1:address:duplex-list:character <- push-duplex 3, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 4, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 5, 1:address:duplex-list:character # delete last element - 2:address:duplex-list <- next-duplex 1:address:duplex-list - 2:address:duplex-list <- next-duplex 2:address:duplex-list - 2:address:duplex-list <- remove-duplex 2:address:duplex-list - 3:boolean <- equal 2:address:duplex-list, 0 + 2:address:duplex-list:character <- next-duplex 1:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- remove-duplex 2:address:duplex-list:character + 3:boolean <- equal 2:address:duplex-list:character, 0 # check structure like before - 2:address:duplex-list <- copy 1:address:duplex-list - 4:number <- first-duplex 2:address:duplex-list - 2:address:duplex-list <- next-duplex 2:address:duplex-list - 5:number <- first-duplex 2:address:duplex-list - 6:address:duplex-list <- next-duplex 2:address:duplex-list - 2:address:duplex-list <- prev-duplex 2:address:duplex-list - 7:number <- first-duplex 2:address:duplex-list - 8:boolean <- equal 1:address:duplex-list, 2:address:duplex-list + 2:address:duplex-list:character <- copy 1:address:duplex-list:character + 4:character <- first-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 5:character <- first-duplex 2:address:duplex-list:character + 6:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- prev-duplex 2:address:duplex-list:character + 7:character <- first-duplex 2:address:duplex-list:character + 8:boolean <- equal 1:address:duplex-list:character, 2:address:duplex-list:character ] memory-should-contain [ 3 <- 0 # remove returned non-null @@ -388,11 +377,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario removing-from-singleton-list [ run [ - 1:address:duplex-list <- copy 0 # 1 points to singleton list - 1:address:duplex-list <- push-duplex 3, 1:address:duplex-list - 2:address:duplex-list <- remove-duplex 1:address:duplex-list - 3:address:duplex-list <- get *1:address:duplex-list, next:offset - 4:address:duplex-list <- get *1:address:duplex-list, prev:offset + 1:address:duplex-list:character <- copy 0 # 1 points to singleton list + 1:address:duplex-list:character <- push-duplex 3, 1:address:duplex-list:character + 2:address:duplex-list:character <- remove-duplex 1:address:duplex-list:character + 3:address:duplex-list:character <- get *1:address:duplex-list:character, next:offset + 4:address:duplex-list:character <- get *1:address:duplex-list:character, prev:offset ] memory-should-contain [ 2 <- 0 # remove returned null @@ -405,51 +394,49 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # Remove values between 'start' and 'end' (both exclusive). Returns some valid # pointer into the rest of the list. # Also clear pointers back out from start/end for hygiene. -recipe remove-duplex-between [ +recipe remove-duplex-between start:address:duplex-list:_elem, end:address:duplex-list:_elem -> start:address:duplex-list:_elem [ local-scope - start:address:duplex-list <- next-ingredient - end:address:duplex-list <- next-ingredient - reply-unless start, start + load-ingredients + reply-unless start # start->next->prev = 0 # start->next = end - next:address:address:duplex-list <- get-address *start, next:offset + next:address:address:duplex-list:_elem <- get-address *start, next:offset nothing-to-delete?:boolean <- equal *next, end - reply-if nothing-to-delete?, start - prev:address:address:duplex-list <- get-address **next, prev:offset + reply-if nothing-to-delete? + prev:address:address:duplex-list:_elem <- get-address **next, prev:offset *prev <- copy 0 *next <- copy end - reply-unless end, start + reply-unless end # end->prev->next = 0 # end->prev = start prev <- get-address *end, prev:offset next <- get-address **prev, next:offset *next <- copy 0 *prev <- copy start - reply start ] scenario remove-range [ # construct a duplex list with six elements [13, 14, 15, 16, 17, 18] - 1:address:duplex-list <- copy 0 # 1 points to singleton list - 1:address:duplex-list <- push-duplex 18, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 17, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 16, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 15, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 14, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 13, 1:address:duplex-list + 1:address:duplex-list:character <- copy 0 # 1 points to singleton list + 1:address:duplex-list:character <- push-duplex 18, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 17, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 16, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 15, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 14, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 13, 1:address:duplex-list:character run [ # delete 16 onwards # first pointer: to the third element - 2:address:duplex-list <- next-duplex 1:address:duplex-list - 2:address:duplex-list <- next-duplex 2:address:duplex-list - remove-duplex-between 2:address:duplex-list, 0 + 2:address:duplex-list:character <- next-duplex 1:address:duplex-list:character + 2:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 2:address:duplex-list:character <- remove-duplex-between 2:address:duplex-list:character, 0 # now check the list - 4:number <- get *1:address:duplex-list, value:offset - 5:address:duplex-list <- next-duplex 1:address:duplex-list - 6:number <- get *5:address:duplex-list, value:offset - 7:address:duplex-list <- next-duplex 5:address:duplex-list - 8:number <- get *7:address:duplex-list, value:offset - 9:address:duplex-list <- next-duplex 7:address:duplex-list + 4:character <- get *1:address:duplex-list:character, value:offset + 5:address:duplex-list:character <- next-duplex 1:address:duplex-list:character + 6:character <- get *5:address:duplex-list:character, value:offset + 7:address:duplex-list:character <- next-duplex 5:address:duplex-list:character + 8:character <- get *7:address:duplex-list:character, value:offset + 9:address:duplex-list:character <- next-duplex 7:address:duplex-list:character ] memory-should-contain [ 4 <- 13 @@ -461,30 +448,30 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario remove-range-to-end [ # construct a duplex list with six elements [13, 14, 15, 16, 17, 18] - 1:address:duplex-list <- copy 0 # 1 points to singleton list - 1:address:duplex-list <- push-duplex 18, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 17, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 16, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 15, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 14, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 13, 1:address:duplex-list + 1:address:duplex-list:character <- copy 0 # 1 points to singleton list + 1:address:duplex-list:character <- push-duplex 18, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 17, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 16, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 15, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 14, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 13, 1:address:duplex-list:character run [ # delete 15, 16 and 17 # first pointer: to the third element - 2:address:duplex-list <- next-duplex 1:address:duplex-list + 2:address:duplex-list:character <- next-duplex 1:address:duplex-list:character # second pointer: to the fifth element - 3:address:duplex-list <- next-duplex 2:address:duplex-list - 3:address:duplex-list <- next-duplex 3:address:duplex-list - 3:address:duplex-list <- next-duplex 3:address:duplex-list - 3:address:duplex-list <- next-duplex 3:address:duplex-list - remove-duplex-between 2:address:duplex-list, 3:address:duplex-list + 3:address:duplex-list:character <- next-duplex 2:address:duplex-list:character + 3:address:duplex-list:character <- next-duplex 3:address:duplex-list:character + 3:address:duplex-list:character <- next-duplex 3:address:duplex-list:character + 3:address:duplex-list:character <- next-duplex 3:address:duplex-list:character + remove-duplex-between 2:address:duplex-list:character, 3:address:duplex-list:character # now check the list - 4:number <- get *1:address:duplex-list, value:offset - 5:address:duplex-list <- next-duplex 1:address:duplex-list - 6:number <- get *5:address:duplex-list, value:offset - 7:address:duplex-list <- next-duplex 5:address:duplex-list - 8:number <- get *7:address:duplex-list, value:offset - 9:address:duplex-list <- next-duplex 7:address:duplex-list + 4:character <- get *1:address:duplex-list:character, value:offset + 5:address:duplex-list:character <- next-duplex 1:address:duplex-list:character + 6:character <- get *5:address:duplex-list:character, value:offset + 7:address:duplex-list:character <- next-duplex 5:address:duplex-list:character + 8:character <- get *7:address:duplex-list:character, value:offset + 9:address:duplex-list:character <- next-duplex 7:address:duplex-list:character ] memory-should-contain [ 4 <- 13 @@ -496,19 +483,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario remove-range-empty [ # construct a duplex list with six elements [13, 14, 15, 16, 17, 18] - 1:address:duplex-list <- copy 0 # 1 points to singleton list - 1:address:duplex-list <- push-duplex 14, 1:address:duplex-list - 1:address:duplex-list <- push-duplex 13, 1:address:duplex-list + 1:address:duplex-list:character <- copy 0 # 1 points to singleton list + 1:address:duplex-list:character <- push-duplex 14, 1:address:duplex-list:character + 1:address:duplex-list:character <- push-duplex 13, 1:address:duplex-list:character run [ # delete 16 onwards # first pointer: to the third element - 2:address:duplex-list <- next-duplex 1:address:duplex-list - remove-duplex-between 1:address:duplex-list, 2:address:duplex-list + 2:address:duplex-list:character <- next-duplex 1:address:duplex-list:character + remove-duplex-between 1:address:duplex-list:character, 2:address:duplex-list:character # now check the list - 4:number <- get *1:address:duplex-list, value:offset - 5:address:duplex-list <- next-duplex 1:address:duplex-list - 6:number <- get *5:address:duplex-list, value:offset - 7:address:duplex-list <- next-duplex 5:address:duplex-list + 4:character <- get *1:address:duplex-list:character, value:offset + 5:address:duplex-list:character <- next-duplex 1:address:duplex-list:character + 6:character <- get *5:address:duplex-list:character, value:offset + 7:address:duplex-list:character <- next-duplex 5:address:duplex-list:character ] memory-should-contain [ 4 <- 13 @@ -517,23 +504,21 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] ] -# l:address:duplex-list <- insert-duplex-range in:address:duplex-list, new:address:duplex-list # Inserts list beginning at 'new' after 'in'. Returns some pointer into the list. -recipe insert-duplex-range [ +recipe insert-duplex-range in:address:duplex-list:_elem, start:address:duplex-list:_elem -> in:address:duplex-list:_elem [ local-scope - in:address:duplex-list <- next-ingredient - start:address:duplex-list <- next-ingredient - reply-unless in, in - reply-unless start, in - end:address:duplex-list <- copy start + load-ingredients + reply-unless in + reply-unless start + end:address:duplex-list:_elem <- copy start { - next:address:duplex-list <- next-duplex end + next:address:duplex-list:_elem <- next-duplex end/insert-range break-unless next end <- copy next loop } - next:address:duplex-list <- next-duplex in - dest:address:address:duplex-list <- get-address *end, next:offset + next:address:duplex-list:_elem <- next-duplex in + dest:address:address:duplex-list:_elem <- get-address *end, next:offset *dest <- copy next { break-unless next @@ -544,43 +529,39 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } *dest <- copy start dest <- get-address *start, prev:offset *dest <- copy in - reply in ] -recipe append-duplex [ +recipe append-duplex in:address:duplex-list:_elem, new:address:duplex-list:_elem -> in:address:duplex-list:_elem [ local-scope - in:address:duplex-list <- next-ingredient - new:address:duplex-list <- next-ingredient - last:address:duplex-list <- last-duplex in - dest:address:address:duplex-list <- get-address *last, next:offset + load-ingredients + last:address:duplex-list:_elem <- last-duplex in + dest:address:address:duplex-list:_elem <- get-address *last, next:offset *dest <- copy new - reply-unless new, in/same-as-ingredient:0 + reply-unless new dest <- get-address *new, prev:offset *dest <- copy last - reply in/same-as-ingredient:0 ] -recipe last-duplex [ +recipe last-duplex in:address:duplex-list:_elem -> result:address:duplex-list:_elem [ local-scope - in:address:duplex-list <- next-ingredient - result:address:duplex-list <- copy in + load-ingredients + result <- copy in { - next:address:duplex-list <- next-duplex result + next:address:duplex-list:_elem <- next-duplex result break-unless next result <- copy next loop } - reply result ] # helper for debugging -recipe dump-duplex-from [ +recipe dump-duplex-from x:address:duplex-list:_elem [ local-scope - x:address:duplex-list <- next-ingredient + load-ingredients $print x, [: ] { break-unless x - c:character <- get *x, value:offset + c:_elem <- get *x, value:offset $print c, [ ] x <- next-duplex x { @@ -593,6 +574,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } $print 10/newline, [---], 10/newline ] + +recipe force-specialization-duplex-list-character [ + 1:address:duplex-list:character <- push-duplex 2:character, 1:address:duplex-list:character + 2:character <- first-duplex 1:address:duplex-list:character + 1:address:duplex-list:character <- next-duplex 1:address:duplex-list:character + 1:address:duplex-list:character <- prev-duplex 1:address:duplex-list:character + 1:address:duplex-list:character <- insert-duplex 2:character, 1:address:duplex-list:character + 1:address:duplex-list:character <- remove-duplex 1:address:duplex-list:character + 1:address:duplex-list:character <- remove-duplex-between 1:address:duplex-list:character, 1:address:duplex-list:character + 1:address:duplex-list:character <- insert-duplex-range 1:address:duplex-list:character, 1:address:duplex-list:character + 1:address:duplex-list:character <- append-duplex 1:address:duplex-list:character, 1:address:duplex-list:character + 1:address:duplex-list:character <- last-duplex 1:address:duplex-list:character +] </pre> </body> </html> diff --git a/html/066stream.mu.html b/html/066stream.mu.html index 23a019f6..54e65159 100644 --- a/html/066stream.mu.html +++ b/html/066stream.mu.html @@ -13,12 +13,12 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } .muData { color: #ffff00; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .Special { color: #ff6060; } -.muControl { color: #c0a020; } --> </style> @@ -68,7 +68,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe end-of-stream? [ local-scope in:address:stream <- next-ingredient - idx:address:number <- get *in, index:offset + idx:number <- get *in, index:offset s:address:array:character <- get *in, data:offset len:number <- length *s result:boolean <- greater-or-equal idx, len diff --git a/html/070display.cc.html b/html/070display.cc.html index 61a6395e..8fb46c4d 100644 --- a/html/070display.cc.html +++ b/html/070display.cc.html @@ -41,7 +41,11 @@ bool Autodisplay = true;</ :(before "End Primitive Recipe Declarations") OPEN_CONSOLE, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["open-console"] = OPEN_CONSOLE; +put(Recipe_ordinal, "open-console", OPEN_CONSOLE); +:(before "End Primitive Recipe Checks") +case OPEN_CONSOLE: { + break; +} :(before "End Primitive Recipe Implementations") case OPEN_CONSOLE: { tb_init(); @@ -50,16 +54,20 @@ case OPEN_CONSOLE: { long long int height = tb_height(); if (width > 222 || height > 222) tb_shutdown(); if (width > 222) - raise << "sorry, mu doesn't support windows wider than 222 characters. Please resize your window.\n" << end(); + raise_error << "sorry, mu doesn't support windows wider than 222 characters. Please resize your window.\n" << end(); if (height > 222) - raise << "sorry, mu doesn't support windows taller than 222 characters. Please resize your window.\n" << end(); + raise_error << "sorry, mu doesn't support windows taller than 222 characters. Please resize your window.\n" << end(); break; } :(before "End Primitive Recipe Declarations") CLOSE_CONSOLE, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["close-console"] = CLOSE_CONSOLE; +put(Recipe_ordinal, "close-console", CLOSE_CONSOLE); +:(before "End Primitive Recipe Checks") +case CLOSE_CONSOLE: { + break; +} :(before "End Primitive Recipe Implementations") case CLOSE_CONSOLE: { tb_shutdown(); @@ -72,7 +80,11 @@ tb_shutdown(); :(before "End Primitive Recipe Declarations") CLEAR_DISPLAY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["clear-display"] = CLEAR_DISPLAY; +put(Recipe_ordinal, "clear-display", CLEAR_DISPLAY); +:(before "End Primitive Recipe Checks") +case CLEAR_DISPLAY: { + break; +} :(before "End Primitive Recipe Implementations") case CLEAR_DISPLAY: { tb_clear(); @@ -83,7 +95,11 @@ case CLEAR_DISPLAY: { :(before "End Primitive Recipe Declarations") SYNC_DISPLAY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["sync-display"] = SYNC_DISPLAY; +put(Recipe_ordinal, "sync-display", SYNC_DISPLAY); +:(before "End Primitive Recipe Checks") +case SYNC_DISPLAY: { + break; +} :(before "End Primitive Recipe Implementations") case SYNC_DISPLAY: { tb_sync(); @@ -93,7 +109,11 @@ case SYNC_DISPLAY: { :(before "End Primitive Recipe Declarations") CLEAR_LINE_ON_DISPLAY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["clear-line-on-display"] = CLEAR_LINE_ON_DISPLAY; +put(Recipe_ordinal, "clear-line-on-display", CLEAR_LINE_ON_DISPLAY); +:(before "End Primitive Recipe Checks") +case CLEAR_LINE_ON_DISPLAY: { + break; +} :(before "End Primitive Recipe Implementations") case CLEAR_LINE_ON_DISPLAY: { long long int width = tb_width(); @@ -108,35 +128,43 @@ case CLEAR_LINE_ON_DISPLAY: { :(before "End Primitive Recipe Declarations") PRINT_CHARACTER_TO_DISPLAY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["print-character-to-display"] = PRINT_CHARACTER_TO_DISPLAY; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "print-character-to-display", PRINT_CHARACTER_TO_DISPLAY); +:(before "End Primitive Recipe Checks") case PRINT_CHARACTER_TO_DISPLAY: { - int h=tb_height(), w=tb_width(); - long long int height = (h >= 0) ? h : 0; - long long int width = (w >= 0) ? w : 0; - if (ingredients.empty()) { - raise << current_recipe_name() << ": 'print-character-to-display' requires at least one ingredient, but got " << current_instruction().to_string() << '\n' << end(); + if (inst.ingredients.empty()) { + raise_error << maybe(get(Recipe, r).name) << "'print-character-to-display' requires at least one ingredient, but got " << inst.to_string() << '\n' << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'print-character-to-display' should be a character, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_number(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'print-character-to-display' should be a character, but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } + if (SIZE(inst.ingredients) > 1) { + if (!is_mu_number(inst.ingredients.at(1))) { + raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'print-character-to-display' should be a foreground color number, but got " << inst.ingredients.at(1).original_string << '\n' << end(); + break; + } + } + if (SIZE(inst.ingredients) > 2) { + if (!is_mu_number(inst.ingredients.at(2))) { + raise_error << maybe(get(Recipe, r).name) << "third ingredient of 'print-character-to-display' should be a background color number, but got " << inst.ingredients.at(2).original_string << '\n' << end(); + break; + } + } + break; +} +:(before "End Primitive Recipe Implementations") +case PRINT_CHARACTER_TO_DISPLAY: { + int h=tb_height(), w=tb_width(); + long long int height = (h >= 0) ? h : 0; + long long int width = (w >= 0) ? w : 0; long long int c = ingredients.at(0).at(0); int color = TB_BLACK; if (SIZE(ingredients) > 1) { - if (!scalar(ingredients.at(1))) { - raise << current_recipe_name() << ": second ingredient of 'print-character-to-display' should be a foreground color number, but got " << current_instruction().ingredients.at(1).original_string << '\n' << end(); - break; - } color = ingredients.at(1).at(0); } int bg_color = TB_BLACK; if (SIZE(ingredients) > 2) { - if (!scalar(ingredients.at(2))) { - raise << current_recipe_name() << ": third ingredient of 'print-character-to-display' should be a background color number, but got " << current_instruction().ingredients.at(2).original_string << '\n' << end(); - break; - } bg_color = ingredients.at(2).at(0); if (bg_color == 0) bg_color = TB_BLACK; } @@ -170,7 +198,11 @@ case PRINT_CHARACTER_TO_DISPLAY: { :(before "End Primitive Recipe Declarations") CURSOR_POSITION_ON_DISPLAY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["cursor-position-on-display"] = CURSOR_POSITION_ON_DISPLAY; +put(Recipe_ordinal, "cursor-position-on-display", CURSOR_POSITION_ON_DISPLAY); +:(before "End Primitive Recipe Checks") +case CURSOR_POSITION_ON_DISPLAY: { + break; +} :(before "End Primitive Recipe Implementations") case CURSOR_POSITION_ON_DISPLAY: { products.resize(2); @@ -182,22 +214,26 @@ case CURSOR_POSITION_ON_DISPLAY: { :(before "End Primitive Recipe Declarations") MOVE_CURSOR_ON_DISPLAY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["move-cursor-on-display"] = MOVE_CURSOR_ON_DISPLAY; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "move-cursor-on-display", MOVE_CURSOR_ON_DISPLAY); +:(before "End Primitive Recipe Checks") case MOVE_CURSOR_ON_DISPLAY: { - if (SIZE(ingredients) != 2) { - raise << current_recipe_name() << ": 'move-cursor-on-display' requires two ingredients, but got " << current_instruction().to_string() << '\n' << end(); + if (SIZE(inst.ingredients) != 2) { + raise_error << maybe(get(Recipe, r).name) << "'move-cursor-on-display' requires two ingredients, but got " << inst.to_string() << '\n' << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'move-cursor-on-display' should be a row number, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_number(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'move-cursor-on-display' should be a row number, but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } - Display_row = ingredients.at(0).at(0); - if (!scalar(ingredients.at(1))) { - raise << current_recipe_name() << ": second ingredient of 'move-cursor-on-display' should be a column number, but got " << current_instruction().ingredients.at(1).original_string << '\n' << end(); + if (!is_mu_number(inst.ingredients.at(1))) { + raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'move-cursor-on-display' should be a column number, but got " << inst.ingredients.at(1).original_string << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case MOVE_CURSOR_ON_DISPLAY: { + Display_row = ingredients.at(0).at(0); Display_column = ingredients.at(1).at(0); tb_set_cursor(Display_column, Display_row); if (Autodisplay) tb_present(); @@ -207,7 +243,11 @@ case MOVE_CURSOR_ON_DISPLAY: { :(before "End Primitive Recipe Declarations") MOVE_CURSOR_DOWN_ON_DISPLAY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["move-cursor-down-on-display"] = MOVE_CURSOR_DOWN_ON_DISPLAY; +put(Recipe_ordinal, "move-cursor-down-on-display", MOVE_CURSOR_DOWN_ON_DISPLAY); +:(before "End Primitive Recipe Checks") +case MOVE_CURSOR_DOWN_ON_DISPLAY: { + break; +} :(before "End Primitive Recipe Implementations") case MOVE_CURSOR_DOWN_ON_DISPLAY: { int h=tb_height(); @@ -223,7 +263,11 @@ case MOVE_CURSOR_DOWN_ON_DISPLAY: { :(before "End Primitive Recipe Declarations") MOVE_CURSOR_UP_ON_DISPLAY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["move-cursor-up-on-display"] = MOVE_CURSOR_UP_ON_DISPLAY; +put(Recipe_ordinal, "move-cursor-up-on-display", MOVE_CURSOR_UP_ON_DISPLAY); +:(before "End Primitive Recipe Checks") +case MOVE_CURSOR_UP_ON_DISPLAY: { + break; +} :(before "End Primitive Recipe Implementations") case MOVE_CURSOR_UP_ON_DISPLAY: { if (Display_row > 0) { @@ -237,7 +281,11 @@ case MOVE_CURSOR_UP_ON_DISPLAY: { :(before "End Primitive Recipe Declarations") MOVE_CURSOR_RIGHT_ON_DISPLAY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["move-cursor-right-on-display"] = MOVE_CURSOR_RIGHT_ON_DISPLAY; +put(Recipe_ordinal, "move-cursor-right-on-display", MOVE_CURSOR_RIGHT_ON_DISPLAY); +:(before "End Primitive Recipe Checks") +case MOVE_CURSOR_RIGHT_ON_DISPLAY: { + break; +} :(before "End Primitive Recipe Implementations") case MOVE_CURSOR_RIGHT_ON_DISPLAY: { int w=tb_width(); @@ -253,7 +301,11 @@ case MOVE_CURSOR_RIGHT_ON_DISPLAY: { :(before "End Primitive Recipe Declarations") MOVE_CURSOR_LEFT_ON_DISPLAY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["move-cursor-left-on-display"] = MOVE_CURSOR_LEFT_ON_DISPLAY; +put(Recipe_ordinal, "move-cursor-left-on-display", MOVE_CURSOR_LEFT_ON_DISPLAY); +:(before "End Primitive Recipe Checks") +case MOVE_CURSOR_LEFT_ON_DISPLAY: { + break; +} :(before "End Primitive Recipe Implementations") case MOVE_CURSOR_LEFT_ON_DISPLAY: { if (Display_column > 0) { @@ -267,7 +319,11 @@ case MOVE_CURSOR_LEFT_ON_DISPLAY: { :(before "End Primitive Recipe Declarations") DISPLAY_WIDTH, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["display-width"] = DISPLAY_WIDTH; +put(Recipe_ordinal, "display-width", DISPLAY_WIDTH); +:(before "End Primitive Recipe Checks") +case DISPLAY_WIDTH: { + break; +} :(before "End Primitive Recipe Implementations") case DISPLAY_WIDTH: { products.resize(1); @@ -278,7 +334,11 @@ case DISPLAY_WIDTH: { :(before "End Primitive Recipe Declarations") DISPLAY_HEIGHT, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["display-height"] = DISPLAY_HEIGHT; +put(Recipe_ordinal, "display-height", DISPLAY_HEIGHT); +:(before "End Primitive Recipe Checks") +case DISPLAY_HEIGHT: { + break; +} :(before "End Primitive Recipe Implementations") case DISPLAY_HEIGHT: { products.resize(1); @@ -289,7 +349,11 @@ case DISPLAY_HEIGHT: { :(before "End Primitive Recipe Declarations") HIDE_CURSOR_ON_DISPLAY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["hide-cursor-on-display"] = HIDE_CURSOR_ON_DISPLAY; +put(Recipe_ordinal, "hide-cursor-on-display", HIDE_CURSOR_ON_DISPLAY); +:(before "End Primitive Recipe Checks") +case HIDE_CURSOR_ON_DISPLAY: { + break; +} :(before "End Primitive Recipe Implementations") case HIDE_CURSOR_ON_DISPLAY: { tb_set_cursor(TB_HIDE_CURSOR, TB_HIDE_CURSOR); @@ -299,7 +363,11 @@ case HIDE_CURSOR_ON_DISPLAY: { :(before "End Primitive Recipe Declarations") SHOW_CURSOR_ON_DISPLAY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["show-cursor-on-display"] = SHOW_CURSOR_ON_DISPLAY; +put(Recipe_ordinal, "show-cursor-on-display", SHOW_CURSOR_ON_DISPLAY); +:(before "End Primitive Recipe Checks") +case SHOW_CURSOR_ON_DISPLAY: { + break; +} :(before "End Primitive Recipe Implementations") case SHOW_CURSOR_ON_DISPLAY: { tb_set_cursor(Display_row, Display_column); @@ -309,7 +377,11 @@ case SHOW_CURSOR_ON_DISPLAY: { :(before "End Primitive Recipe Declarations") HIDE_DISPLAY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["hide-display"] = HIDE_DISPLAY; +put(Recipe_ordinal, "hide-display", HIDE_DISPLAY); +:(before "End Primitive Recipe Checks") +case HIDE_DISPLAY: { + break; +} :(before "End Primitive Recipe Implementations") case HIDE_DISPLAY: { Autodisplay = false; @@ -319,7 +391,11 @@ case HIDE_DISPLAY: { :(before "End Primitive Recipe Declarations") SHOW_DISPLAY, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["show-display"] = SHOW_DISPLAY; +put(Recipe_ordinal, "show-display", SHOW_DISPLAY); +:(before "End Primitive Recipe Checks") +case SHOW_DISPLAY: { + break; +} :(before "End Primitive Recipe Implementations") case SHOW_DISPLAY: { Autodisplay = true; @@ -332,7 +408,11 @@ case SHOW_DISPLAY: { :(before "End Primitive Recipe Declarations") WAIT_FOR_SOME_INTERACTION, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["wait-for-some-interaction"] = WAIT_FOR_SOME_INTERACTION; +put(Recipe_ordinal, "wait-for-some-interaction", WAIT_FOR_SOME_INTERACTION); +:(before "End Primitive Recipe Checks") +case WAIT_FOR_SOME_INTERACTION: { + break; +} :(before "End Primitive Recipe Implementations") case WAIT_FOR_SOME_INTERACTION: { tb_event event; @@ -343,7 +423,11 @@ case WAIT_FOR_SOME_INTERACTION: { :(before "End Primitive Recipe Declarations") CHECK_FOR_INTERACTION, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["check-for-interaction"] = CHECK_FOR_INTERACTION; +put(Recipe_ordinal, "check-for-interaction", CHECK_FOR_INTERACTION); +:(before "End Primitive Recipe Checks") +case CHECK_FOR_INTERACTION: { + break; +} :(before "End Primitive Recipe Implementations") case CHECK_FOR_INTERACTION: { products.resize(2); // result and status @@ -406,7 +490,11 @@ case CHECK_FOR_INTERACTION: { :(before "End Primitive Recipe Declarations") INTERACTIONS_LEFT, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["interactions-left?"] = INTERACTIONS_LEFT; +put(Recipe_ordinal, "interactions-left?", INTERACTIONS_LEFT); +:(before "End Primitive Recipe Checks") +case INTERACTIONS_LEFT: { + break; +} :(before "End Primitive Recipe Implementations") case INTERACTIONS_LEFT: { products.resize(1); @@ -419,7 +507,11 @@ case INTERACTIONS_LEFT: { :(before "End Primitive Recipe Declarations") CLEAR_DISPLAY_FROM, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["clear-display-from"] = CLEAR_DISPLAY_FROM; +put(Recipe_ordinal, "clear-display-from", CLEAR_DISPLAY_FROM); +:(before "End Primitive Recipe Checks") +case CLEAR_DISPLAY_FROM: { + break; +} :(before "End Primitive Recipe Implementations") case CLEAR_DISPLAY_FROM: { // todo: error checking diff --git a/html/071print.mu.html b/html/071print.mu.html index c4334f55..444a8359 100644 --- a/html/071print.mu.html +++ b/html/071print.mu.html @@ -13,14 +13,14 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } -.muData { color: #ffff00; } .muScenario { color: #00af00; } +.muData { color: #ffff00; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .Special { color: #ff6060; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> @@ -81,8 +81,8 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } break-if done? curr:address:screen-cell <- index-address *buf, i curr-content:address:character <- get-address *curr, contents:offset - *curr-content <- copy [ ] - curr-color:address:character <- get-address *curr, color:offset + *curr-content <- copy 0/empty + curr-color:address:number <- get-address *curr, color:offset *curr-color <- copy 7/white i <- add i, 1 loop @@ -558,7 +558,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe cursor-to-next-line [ local-scope - screen:address <- next-ingredient + screen:address:screen <- next-ingredient screen <- cursor-down screen screen <- cursor-to-start-of-line screen reply screen/same-as-ingredient:0 @@ -594,7 +594,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe hide-cursor [ local-scope - screen:address <- next-ingredient + screen:address:screen <- next-ingredient # if x exists (not real display), do nothing { break-unless screen @@ -607,7 +607,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe show-cursor [ local-scope - screen:address <- next-ingredient + screen:address:screen <- next-ingredient # if x exists (not real display), do nothing { break-unless screen @@ -620,7 +620,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe hide-screen [ local-scope - screen:address <- next-ingredient + screen:address:screen <- next-ingredient # if x exists (not real display), do nothing # todo: help test this { @@ -634,7 +634,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe show-screen [ local-scope - screen:address <- next-ingredient + screen:address:screen <- next-ingredient # if x exists (not real display), do nothing # todo: help test this { @@ -648,7 +648,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe print-string [ local-scope - screen:address <- next-ingredient + screen:address:screen <- next-ingredient s:address:array:character <- next-ingredient color:number, color-found?:boolean <- next-ingredient { @@ -697,7 +697,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe print-integer [ local-scope - screen:address <- next-ingredient + screen:address:screen <- next-ingredient n:number <- next-ingredient color:number, color-found?:boolean <- next-ingredient { diff --git a/html/072scenario_screen.cc.html b/html/072scenario_screen.cc.html index 5100c44c..ade20fff 100644 --- a/html/072scenario_screen.cc.html +++ b/html/072scenario_screen.cc.html @@ -13,8 +13,8 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.traceAbsent { color: #c00000; } .traceContains { color: #008000; } +.traceAbsent { color: #c00000; } .cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } @@ -43,7 +43,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario screen-in-scenario [ assume-screen 5/width, 3/height run [ - screen:address <- print-character screen:address, 97 # 'a' + screen:address:screen <- print-character screen:address:screen, 97 # 'a' ] screen-should-contain [ # 01234 @@ -57,8 +57,8 @@ scenario screen-in-scenario [ scenario screen-in-scenario-unicode-color [ assume-screen 5/width, 3/height run [ - screen:address <- print-character screen:address, 955/greek-small-lambda, 1/red - screen:address <- print-character screen:address, 97/a + screen:address:screen <- print-character screen:address:screen, 955/greek-small-lambda, 1/red + screen:address:screen <- print-character screen:address:screen, 97/a ] screen-should-contain [ # 01234 @@ -73,8 +73,8 @@ scenario screen-in-scenario-unicode-color [ scenario screen-in-scenario-color [ assume-screen 5/width, 3/height run [ - screen:address <- print-character screen:address, 955/greek-small-lambda, 1/red - screen:address <- print-character screen:address, 97/a, 7/white + screen:address:screen <- print-character screen:address:screen, 955/greek-small-lambda, 1/red + screen:address:screen <- print-character screen:address:screen, 97/a, 7/white ] # screen-should-contain shows everything screen-should-contain [ @@ -102,11 +102,11 @@ scenario screen-in-scenario-color [ :(scenario screen_in_scenario_error) % Scenario_testing_scenario = true; -% Hide_warnings = true; +% Hide_errors = true; scenario screen-in-scenario-error [ assume-screen 5/width, 3/height run [ - screen:address <- print-character screen:address, 97 # 'a' + screen:address:screen <- print-character screen:address:screen, 97 # 'a' ] screen-should-contain [ # 01234 @@ -115,16 +115,16 @@ scenario screen-in-scenario-error [ . . ] ] -+warn: expected screen location (0, 0) to contain 98 ('b') instead of 97 ('a') ++error: expected screen location (0, 0) to contain 98 ('b') instead of 97 ('a') :(scenario screen_in_scenario_color_error) % Scenario_testing_scenario = true; -% Hide_warnings = true; +% Hide_errors = true; # screen-should-contain can check unicode characters in the fake screen scenario screen-in-scenario-color [ assume-screen 5/width, 3/height run [ - screen:address <- print-character screen:address, 97/a, 1/red + screen:address:screen <- print-character screen:address:screen, 97/a, 1/red ] screen-should-contain-in-color 2/green, [ # 01234 @@ -133,21 +133,21 @@ scenario screen-in-scenario-color [ . . ] ] -+warn: expected screen location (0, 0) to be in color 2 instead of 1 ++error: expected screen location (0, 0) to be in color 2 instead of 1 //: allow naming just for 'screen' :(before "End is_special_name Cases") if (s == "screen") return true; :(scenarios run) -:(scenario convert_names_does_not_warn_when_mixing_special_names_and_numeric_locations) +:(scenario convert_names_does_not_fail_when_mixing_special_names_and_numeric_locations) % Scenario_testing_scenario = true; -% Hide_warnings = true; +% Hide_errors = true; recipe main [ screen:number <- copy 1:number ] --warn: mixing variable names and numeric addresses in main -$warn: 0 +-error: mixing variable names and numeric addresses in main +$error: 0 :(scenarios run_mu_scenario) :(before "End Globals") @@ -171,15 +171,13 @@ const long long int SCREEN = Next_predefined_global_for_scenarios++:(before "End Special Scenario Variable Names(r)") Name[r]["screen"] = SCREEN; -:(before "End Rewrite Instruction(curr)") +:(before "End Rewrite Instruction(curr, recipe result)") // rewrite `assume-screen width, height` to -// `screen:address <- new-fake-screen width, height` +// `screen:address:screen <- new-fake-screen width, height` if (curr.name == "assume-screen") { - curr.operation = Recipe_ordinal["new-fake-screen"]; curr.name = "new-fake-screen"; - assert(curr.operation); assert(curr.products.empty()); - curr.products.push_back(reagent("screen:address")); + curr.products.push_back(reagent("screen:address:screen")); curr.products.at(0).set_value(SCREEN); } @@ -187,7 +185,11 @@ if (curr.name == < :(before "End Primitive Recipe Declarations") SCREEN_SHOULD_CONTAIN, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["screen-should-contain"] = SCREEN_SHOULD_CONTAIN; +put(Recipe_ordinal, "screen-should-contain", SCREEN_SHOULD_CONTAIN); +:(before "End Primitive Recipe Checks") +case SCREEN_SHOULD_CONTAIN: { + break; +} :(before "End Primitive Recipe Implementations") case SCREEN_SHOULD_CONTAIN: { if (!Passed) break; @@ -198,7 +200,11 @@ case SCREEN_SHOULD_CONTAIN: { :(before "End Primitive Recipe Declarations") SCREEN_SHOULD_CONTAIN_IN_COLOR, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["screen-should-contain-in-color"] = SCREEN_SHOULD_CONTAIN_IN_COLOR; +put(Recipe_ordinal, "screen-should-contain-in-color", SCREEN_SHOULD_CONTAIN_IN_COLOR); +:(before "End Primitive Recipe Checks") +case SCREEN_SHOULD_CONTAIN_IN_COLOR: { + break; +} :(before "End Primitive Recipe Implementations") case SCREEN_SHOULD_CONTAIN_IN_COLOR: { if (!Passed) break; @@ -223,16 +229,16 @@ struct raw_string_stream { :(code) void check_screen(const string& expected_contents, const int color) { - assert(!Current_routine->calls.front().default_space); // not supported - long long int screen_location = Memory[SCREEN]; - int data_offset = find_element_name(Type_ordinal["screen"], "data"); + assert(!current_call().default_space); // not supported + long long int screen_location = get_or_insert(Memory, SCREEN); + int data_offset = find_element_name(get(Type_ordinal, "screen"), "data", ""); assert(data_offset >= 0); 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_ordinal["screen"], "num-columns"); - long long int screen_width = Memory[screen_location+width_offset]; - int height_offset = find_element_name(Type_ordinal["screen"], "num-rows"); - long long int screen_height = Memory[screen_location+height_offset]; + long long int screen_data_start = get_or_insert(Memory, screen_data_location); // type: array:character + int width_offset = find_element_name(get(Type_ordinal, "screen"), "num-columns", ""); + long long int screen_width = get_or_insert(Memory, screen_location+width_offset); + int height_offset = find_element_name(get(Type_ordinal, "screen"), "num-rows", ""); + long long int screen_height = get_or_insert(Memory, screen_location+height_offset); raw_string_stream cursor(expected_contents); // todo: too-long expected_contents should fail long long int addr = screen_data_start+1; // skip length @@ -243,21 +249,21 @@ void check_screen(const string& expected_cont for (long long int column = 0; column < screen_width; ++column, addr+= /*size of screen-cell*/2) { const int cell_color_offset = 1; uint32_t curr = cursor.get(); - if (Memory[addr] == 0 && isspace(curr)) continue; - if (curr == ' ' && color != -1 && color != Memory[addr+cell_color_offset]) { + if (get_or_insert(Memory, addr) == 0 && isspace(curr)) continue; + if (curr == ' ' && color != -1 && color != get_or_insert(Memory, addr+cell_color_offset)) { // filter out other colors continue; } - if (Memory[addr] != 0 && Memory[addr] == curr) { - if (color == -1 || color == Memory[addr+cell_color_offset]) continue; + if (get_or_insert(Memory, addr) != 0 && Memory[addr] == curr) { + if (color == -1 || color == get_or_insert(Memory, addr+cell_color_offset)) continue; // contents match but color is off if (Current_scenario && !Scenario_testing_scenario) { // genuine test in a mu file - raise << "\nF - " << Current_scenario->name << ": expected screen location (" << row << ", " << column << ", address " << addr << ", value " << Memory[addr] << ") to be in color " << color << " instead of " << Memory[addr+cell_color_offset] << "\n" << end(); + raise_error << "\nF - " << Current_scenario->name << ": expected screen location (" << row << ", " << column << ", address " << addr << ", value " << no_scientific(get_or_insert(Memory, addr)) << ") to be in color " << color << " instead of " << no_scientific(Memory[addr+cell_color_offset]) << "\n" << end(); } else { // just testing check_screen - raise << "expected screen location (" << row << ", " << column << ") to be in color " << color << " instead of " << Memory[addr+cell_color_offset] << '\n' << end(); + raise_error << "expected screen location (" << row << ", " << column << ") to be in color " << color << " instead of " << no_scientific(get_or_insert(Memory, addr+cell_color_offset)) << '\n' << end(); } if (!Scenario_testing_scenario) { Passed = false; @@ -267,26 +273,28 @@ void check_screen(const string& expected_cont } // really a mismatch - // can't print multi-byte unicode characters in warnings just yet. not very useful for debugging anyway. + // can't print multi-byte unicode characters in errors just yet. not very useful for debugging anyway. char expected_pretty[10] = {0}; if (curr < 256 && !iscntrl(curr)) { // " ('<curr>')" expected_pretty[0] = ' ', expected_pretty[1] = '(', expected_pretty[2] = '\'', expected_pretty[3] = static_cast<unsigned char>(curr), expected_pretty[4] = '\'', expected_pretty[5] = ')', expected_pretty[6] = '\0'; } char actual_pretty[10] = {0}; - if (Memory[addr] < 256 && !iscntrl(Memory[addr])) { + if (get_or_insert(Memory, addr) < 256 && !iscntrl(Memory[addr])) { // " ('<curr>')" - actual_pretty[0] = ' ', actual_pretty[1] = '(', actual_pretty[2] = '\'', actual_pretty[3] = static_cast<unsigned char>(Memory[addr]), actual_pretty[4] = '\'', actual_pretty[5] = ')', actual_pretty[6] = '\0'; + actual_pretty[0] = ' ', actual_pretty[1] = '(', actual_pretty[2] = '\'', actual_pretty[3] = static_cast<unsigned char>(get_or_insert(Memory, addr)), actual_pretty[4] = '\'', actual_pretty[5] = ')', actual_pretty[6] = '\0'; } + ostringstream color_phrase; + if (color != -1) color_phrase << " in color " << color; if (Current_scenario && !Scenario_testing_scenario) { // genuine test in a mu file - raise << "\nF - " << Current_scenario->name << ": expected screen location (" << row << ", " << column << ") to contain " << curr << expected_pretty << " instead of " << Memory[addr] << actual_pretty << '\n' << end(); + raise_error << "\nF - " << Current_scenario->name << ": expected screen location (" << row << ", " << column << ") to contain " << curr << expected_pretty << color_phrase.str() << " instead of " << no_scientific(get_or_insert(Memory, addr)) << actual_pretty << '\n' << end(); dump_screen(); } else { // just testing check_screen - raise << "expected screen location (" << row << ", " << column << ") to contain " << curr << expected_pretty << " instead of " << Memory[addr] << actual_pretty << '\n' << end(); + raise_error << "expected screen location (" << row << ", " << column << ") to contain " << curr << expected_pretty << color_phrase.str() << " instead of " << no_scientific(get_or_insert(Memory, addr)) << actual_pretty << '\n' << end(); } if (!Scenario_testing_scenario) { Passed = false; @@ -305,7 +313,7 @@ raw_string_stream::raw_string_stream(const string bool raw_string_stream::at_end() const { if (index >= max) return true; if (tb_utf8_char_length(buf[index]) > max-index) { - raise << "unicode string seems corrupted at index "<< index << " character " << static_cast<int>(buf[index]) << '\n' << end(); + raise_error << "unicode string seems corrupted at index "<< index << " character " << static_cast<int>(buf[index]) << '\n' << end(); return true; } return false; @@ -343,7 +351,11 @@ void raw_string_stream::skip_whitespace_and_comments()</ :(before "End Primitive Recipe Declarations") _DUMP_SCREEN, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$dump-screen"] = _DUMP_SCREEN; +put(Recipe_ordinal, "$dump-screen", _DUMP_SCREEN); +:(before "End Primitive Recipe Checks") +case _DUMP_SCREEN: { + break; +} :(before "End Primitive Recipe Implementations") case _DUMP_SCREEN: { dump_screen(); @@ -352,23 +364,23 @@ case _DUMP_SCREEN: { :(code) void dump_screen() { - assert(!Current_routine->calls.front().default_space); // not supported - long long int screen_location = Memory[SCREEN]; - int width_offset = find_element_name(Type_ordinal["screen"], "num-columns"); - long long int screen_width = Memory[screen_location+width_offset]; - int height_offset = find_element_name(Type_ordinal["screen"], "num-rows"); - long long int screen_height = Memory[screen_location+height_offset]; - int data_offset = find_element_name(Type_ordinal["screen"], "data"); + assert(!current_call().default_space); // not supported + long long int screen_location = get_or_insert(Memory, SCREEN); + int width_offset = find_element_name(get(Type_ordinal, "screen"), "num-columns", ""); + long long int screen_width = get_or_insert(Memory, screen_location+width_offset); + int height_offset = find_element_name(get(Type_ordinal, "screen"), "num-rows", ""); + long long int screen_height = get_or_insert(Memory, screen_location+height_offset); + int data_offset = find_element_name(get(Type_ordinal, "screen"), "data", ""); assert(data_offset >= 0); 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 - assert(Memory[screen_data_start] == screen_width*screen_height); + long long int screen_data_start = get_or_insert(Memory, screen_data_location); // type: array:character + assert(get_or_insert(Memory, screen_data_start) == screen_width*screen_height); long long int curr = screen_data_start+1; // skip length for (long long int row = 0; row < screen_height; ++row) { cerr << '.'; for (long long int col = 0; col < screen_width; ++col) { - if (Memory[curr]) - cerr << to_unicode(Memory[curr]); + if (get_or_insert(Memory, curr)) + cerr << to_unicode(static_cast<uint32_t>(get_or_insert(Memory, curr))); else cerr << ' '; curr += /*size of screen-cell*/2; diff --git a/html/073scenario_screen_test.mu.html b/html/073scenario_screen_test.mu.html index aa6f42b9..ba50c80e 100644 --- a/html/073scenario_screen_test.mu.html +++ b/html/073scenario_screen_test.mu.html @@ -33,7 +33,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario print-character-at-top-left-2 [ assume-screen 3/width, 2/height run [ - screen:address <- print-character screen:address, 97/a + screen:address:screen <- print-character screen:address:screen, 97/a ] screen-should-contain [ .a . @@ -45,11 +45,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 5/width, 3/height run [ # print a character - screen:address <- print-character screen:address, 97/a + screen:address:screen <- print-character screen:address:screen, 97/a # move cursor to start of line - screen:address <- move-cursor screen:address, 0/row, 0/column + screen:address:screen <- move-cursor screen:address:screen, 0/row, 0/column # clear line - screen:address <- clear-line screen:address + screen:address:screen <- clear-line screen:address:screen ] screen-should-contain [ . . diff --git a/html/074console.mu.html b/html/074console.mu.html index 191c33e8..62f88c3a 100644 --- a/html/074console.mu.html +++ b/html/074console.mu.html @@ -13,13 +13,13 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } .muData { color: #ffff00; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .Special { color: #ff6060; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> @@ -61,7 +61,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe new-fake-console [ local-scope result:address:console <- new console:type - buf:address:address:array:character <- get-address *result, data:offset + buf:address:address:array:event <- get-address *result, data:offset *buf <- next-ingredient idx:address:number <- get-address *result, index:offset *idx <- copy 0 @@ -96,7 +96,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # newlines, tabs, ctrl-d.. recipe read-key [ local-scope - console:address <- next-ingredient + console:address:console <- next-ingredient x:event, console, found?:boolean, quit?:boolean <- read-event console reply-if quit?, 0, console/same-as-ingredient:0, found?, quit? reply-unless found?, 0, console/same-as-ingredient:0, found?, quit? @@ -107,9 +107,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe send-keys-to-channel [ local-scope - console:address <- next-ingredient + console:address:console <- next-ingredient chan:address:channel <- next-ingredient - screen:address <- next-ingredient + screen:address:screen <- next-ingredient { c:character, console, found?:boolean, quit?:boolean <- read-key console loop-unless found? @@ -124,7 +124,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe wait-for-event [ local-scope - console:address <- next-ingredient + console:address:console <- next-ingredient { _, console, found?:boolean <- read-event console loop-unless found? @@ -135,7 +135,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # use this helper to skip rendering if there's lots of other events queued up recipe has-more-events? [ local-scope - console:address <- next-ingredient + console:address:console <- next-ingredient { break-unless console # fake consoles should be plenty fast; never skip diff --git a/html/075scenario_console.cc.html b/html/075scenario_console.cc.html index c578c2a8..6ef48e09 100644 --- a/html/075scenario_console.cc.html +++ b/html/075scenario_console.cc.html @@ -43,10 +43,10 @@ scenario keyboard-in-scenario [ type [abc] ] run [ - 1:character, console:address, 2:boolean <- read-key console:address - 3:character, console:address, 4:boolean <- read-key console:address - 5:character, console:address, 6:boolean <- read-key console:address - 7:character, console:address, 8:boolean, 9:boolean <- read-key console:address + 1:character, console:address:console, 2:boolean <- read-key console:address:console + 3:character, console:address:console, 4:boolean <- read-key console:address:console + 5:character, console:address:console, 6:boolean <- read-key console:address:console + 7:character, console:address:console, 8:boolean, 9:boolean <- read-key console:address:console ] memory-should-contain [ 1 <- 97 # 'a' @@ -70,47 +70,50 @@ Name[r]["console"] = CONSOLE:(before "End is_special_name Cases") if (s == "console") return true; -//: Unlike assume-keyboard, assume-console is easiest to implement as just a -//: primitive recipe. :(before "End Primitive Recipe Declarations") ASSUME_CONSOLE, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["assume-console"] = ASSUME_CONSOLE; +put(Recipe_ordinal, "assume-console", ASSUME_CONSOLE); +:(before "End Primitive Recipe Checks") +case ASSUME_CONSOLE: { + break; +} :(before "End Primitive Recipe Implementations") case ASSUME_CONSOLE: { // create a temporary recipe just for parsing; it won't contain valid instructions istringstream in("[" + current_instruction().ingredients.at(0).name + "]"); - recipe r = slurp_body(in); + recipe r; + slurp_body(in, r); long long int num_events = count_events(r); - // initialize the events + // initialize the events like in new-fake-console long long int size = num_events*size_of_event() + /*space for length*/1; ensure_space(size); long long int event_data_address = Current_routine->alloc; - Memory[event_data_address] = num_events; + put(Memory, event_data_address, num_events); ++Current_routine->alloc; for (long long int i = 0; i < SIZE(r.steps); ++i) { const instruction& curr = r.steps.at(i); if (curr.name == "left-click") { - Memory[Current_routine->alloc] = /*tag for 'touch-event' variant of 'event' exclusive-container*/2; - Memory[Current_routine->alloc+1+/*offset of 'type' in 'mouse-event'*/0] = TB_KEY_MOUSE_LEFT; - Memory[Current_routine->alloc+1+/*offset of 'row' in 'mouse-event'*/1] = to_integer(curr.ingredients.at(0).name); - Memory[Current_routine->alloc+1+/*offset of 'column' in 'mouse-event'*/2] = to_integer(curr.ingredients.at(1).name); + put(Memory, Current_routine->alloc, /*tag for 'touch-event' variant of 'event' exclusive-container*/2); + put(Memory, Current_routine->alloc+1+/*offset of 'type' in 'mouse-event'*/0, TB_KEY_MOUSE_LEFT); + put(Memory, Current_routine->alloc+1+/*offset of 'row' in 'mouse-event'*/1, to_integer(curr.ingredients.at(0).name)); + put(Memory, Current_routine->alloc+1+/*offset of 'column' in 'mouse-event'*/2, to_integer(curr.ingredients.at(1).name)); Current_routine->alloc += size_of_event(); } else if (curr.name == "press") { string key = curr.ingredients.at(0).name; if (is_integer(key)) - Memory[Current_routine->alloc+1] = to_integer(key); - else if (Key.find(key) != Key.end()) - Memory[Current_routine->alloc+1] = Key[key]; + put(Memory, Current_routine->alloc+1, to_integer(key)); + else if (contains_key(Key, key)) + put(Memory, Current_routine->alloc+1, Key[key]); else - raise << "assume-console: can't press " << key << '\n' << end(); - if (Memory[Current_routine->alloc+1] < 256) + raise_error << "assume-console: can't press " << key << '\n' << end(); + if (get_or_insert(Memory, Current_routine->alloc+1) < 256) // these keys are in ascii - Memory[Current_routine->alloc] = /*tag for 'text' variant of 'event' exclusive-container*/0; + put(Memory, Current_routine->alloc, /*tag for 'text' variant of 'event' exclusive-container*/0); else { // distinguish from unicode - Memory[Current_routine->alloc] = /*tag for 'keycode' variant of 'event' exclusive-container*/1; + put(Memory, Current_routine->alloc, /*tag for 'keycode' variant of 'event' exclusive-container*/1); } Current_routine->alloc += size_of_event(); } @@ -123,22 +126,23 @@ case ASSUME_CONSOLE: { long long int num_keyboard_events = unicode_length(contents); long long int curr = 0; for (long long int i = 0; i < num_keyboard_events; ++i) { - Memory[Current_routine->alloc] = /*tag for 'text' variant of 'event' exclusive-container*/0; + put(Memory, Current_routine->alloc, /*tag for 'text' variant of 'event' exclusive-container*/0); uint32_t curr_character; assert(curr < SIZE(contents)); tb_utf8_char_to_unicode(&curr_character, &raw_contents[curr]); - Memory[Current_routine->alloc+/*skip exclusive container tag*/1] = curr_character; + put(Memory, Current_routine->alloc+/*skip exclusive container tag*/1, curr_character); curr += tb_utf8_char_length(raw_contents[curr]); Current_routine->alloc += size_of_event(); } } } assert(Current_routine->alloc == event_data_address+size); - // wrap the array of events in an event object - ensure_space(size_of_events()); - Memory[CONSOLE] = Current_routine->alloc; - Current_routine->alloc += size_of_events(); - Memory[Memory[CONSOLE]+/*offset of 'data' in container 'events'*/1] = event_data_address; + // wrap the array of events in a console object + ensure_space(size_of_console()); + put(Memory, CONSOLE, Current_routine->alloc); + Current_routine->alloc += size_of_console(); + long long int console_address = get_or_insert(Memory, CONSOLE); + put(Memory, console_address+/*offset of 'data' in container 'events'*/1, event_data_address); break; } @@ -212,15 +216,15 @@ scenario events-in-scenario [ ] run [ # 3 keyboard events; each event occupies 4 locations - 1:event <- read-event console:address - 5:event <- read-event console:address - 9:event <- read-event console:address + 1:event <- read-event console:address:console + 5:event <- read-event console:address:console + 9:event <- read-event console:address:console # mouse click - 13:event <- read-event console:address + 13:event <- read-event console:address:console # non-character keycode - 17:event <- read-event console:address + 17:event <- read-event console:address:console # final keyboard event - 21:event <- read-event console:address + 21:event <- read-event console:address:console ] memory-should-contain [ 1 <- 0 # 'text' @@ -256,21 +260,26 @@ scenario events-in-scenario [ :(before "End Primitive Recipe Declarations") REPLACE_IN_CONSOLE, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["replace-in-console"] = REPLACE_IN_CONSOLE; +put(Recipe_ordinal, "replace-in-console", REPLACE_IN_CONSOLE); +:(before "End Primitive Recipe Checks") +case REPLACE_IN_CONSOLE: { + break; +} :(before "End Primitive Recipe Implementations") case REPLACE_IN_CONSOLE: { assert(scalar(ingredients.at(0))); - if (!Memory[CONSOLE]) { - raise << "console not initialized\n" << end(); + if (!get_or_insert(Memory, CONSOLE)) { + raise_error << "console not initialized\n" << end(); break; } - long long int console_data = Memory[Memory[CONSOLE]+1]; - long long int size = Memory[console_data]; // array size + long long int console_address = get_or_insert(Memory, CONSOLE); + long long int console_data = get_or_insert(Memory, console_address+1); + long long int size = get_or_insert(Memory, console_data); // array size for (long long int i = 0, curr = console_data+1; i < size; ++i, curr+=size_of_event()) { - if (Memory[curr] != /*text*/0) continue; - if (Memory[curr+1] != ingredients.at(0).at(0)) continue; + if (get_or_insert(Memory, curr) != /*text*/0) continue; + if (get_or_insert(Memory, curr+1) != ingredients.at(0).at(0)) continue; for (long long int n = 0; n < size_of_event(); ++n) - Memory[curr+n] = ingredients.at(1).at(n); + put(Memory, curr+n, ingredients.at(1).at(n)); } break; } @@ -292,20 +301,20 @@ long long int size_of_event() // memoize result if already computed static long long int result = 0; if (result) return result; - vector<type_ordinal> type; - type.push_back(Type_ordinal["event"]); + type_tree* type = new type_tree(get(Type_ordinal, "event")); result = size_of(type); + delete type; return result; } -long long int size_of_events() { +long long int size_of_console() { // memoize result if already computed static long long int result = 0; if (result) return result; - vector<type_ordinal> type; - assert(Type_ordinal["console"]); - type.push_back(Type_ordinal["console"]); + assert(get(Type_ordinal, "console")); + type_tree* type = new type_tree(get(Type_ordinal, "console")); result = size_of(type); + delete type; return result; } </pre> diff --git a/html/076scenario_console_test.mu.html b/html/076scenario_console_test.mu.html index b33cb4cd..bc0f6688 100644 --- a/html/076scenario_console_test.mu.html +++ b/html/076scenario_console_test.mu.html @@ -37,10 +37,10 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [abc] ] run [ - 1:character, console:address, 2:boolean <- read-key console:address - 3:character, console:address, 4:boolean <- read-key console:address - 5:character, console:address, 6:boolean <- read-key console:address - 7:character, console:address, 8:boolean <- read-key console:address + 1:character, console:address:console, 2:boolean <- read-key console:address:console + 3:character, console:address:console, 4:boolean <- read-key console:address:console + 5:character, console:address:console, 6:boolean <- read-key console:address:console + 7:character, console:address:console, 8:boolean <- read-key console:address:console ] memory-should-contain [ 1 <- 97 # 'a' diff --git a/html/080trace_browser.cc.html b/html/080trace_browser.cc.html index 9ac50591..d209225b 100644 --- a/html/080trace_browser.cc.html +++ b/html/080trace_browser.cc.html @@ -32,7 +32,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } :(before "End Primitive Recipe Declarations") _BROWSE_TRACE, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$browse-trace"] = _BROWSE_TRACE; +put(Recipe_ordinal, "$browse-trace", _BROWSE_TRACE); +:(before "End Primitive Recipe Checks") +case _BROWSE_TRACE: { + break; +} :(before "End Primitive Recipe Implementations") case _BROWSE_TRACE: { start_trace_browser(); @@ -105,7 +109,7 @@ void start_trace_browser() (int screen_row = tb_height(); screen_row > 0 && Top_of_screen > 0; --screen_row) { --Top_of_screen; if (Top_of_screen <= 0) break; - while (Top_of_screen > 0 && Visible.find(Top_of_screen) == Visible.end()) + while (Top_of_screen > 0 && !contains_key(Visible, Top_of_screen)) --Top_of_screen; } if (Top_of_screen > 0) @@ -117,7 +121,7 @@ void start_trace_browser() (int screen_row = tb_height(); screen_row > 0 && Top_of_screen > 0; --screen_row) { --Top_of_screen; if (Top_of_screen <= 0) break; - while (Top_of_screen > 0 && Visible.find(Top_of_screen) == Visible.end()) + while (Top_of_screen > 0 && !contains_key(Visible, Top_of_screen)) --Top_of_screen; } refresh_screen_rows(); @@ -127,13 +131,13 @@ void start_trace_browser() } if (key == TB_KEY_CARRIAGE_RETURN) { // expand lines under current by one level - assert(Trace_index.find(Display_row) != Trace_index.end()); + assert(contains_key(Trace_index, Display_row)); long long int start_index = Trace_index[Display_row]; long long int index = 0; // simultaneously compute end_index and min_depth int min_depth = 9999; for (index = start_index+1; index < SIZE(Trace_stream->past_lines); ++index) { - if (Visible.find(index) != Visible.end()) break; + if (contains_key(Visible, index)) break; trace_line& curr_line = Trace_stream->past_lines.at(index); if (curr_line.depth == 0) continue; assert(curr_line.depth > Trace_stream->past_lines.at(start_index).depth); @@ -151,13 +155,13 @@ void start_trace_browser() } if (key == TB_KEY_BACKSPACE || key == TB_KEY_BACKSPACE2) { // collapse all lines under current - assert(Trace_index.find(Display_row) != Trace_index.end()); + assert(contains_key(Trace_index, Display_row)); long long int start_index = Trace_index[Display_row]; long long int index = 0; // end_index is the next line at a depth same as or lower than start_index int initial_depth = Trace_stream->past_lines.at(start_index).depth; for (index = start_index+1; index < SIZE(Trace_stream->past_lines); ++index) { - if (Visible.find(index) == Visible.end()) continue; + if (!contains_key(Visible, index)) continue; trace_line& curr_line = Trace_stream->past_lines.at(index); if (curr_line.depth == 0) continue; if (curr_line.depth <= initial_depth) break; @@ -179,7 +183,7 @@ void refresh_screen_rows() .clear(); for (screen_row = 0, index = Top_of_screen; screen_row < tb_height() && index < SIZE(Trace_stream->past_lines); ++screen_row, ++index) { // skip lines without depth for now - while (Visible.find(index) == Visible.end()) { + while (!contains_key(Visible, index)) { ++index; if (index >= SIZE(Trace_stream->past_lines)) goto done; } @@ -192,7 +196,7 @@ done:; void render() { long long int screen_row = 0; for (screen_row = 0; screen_row < tb_height(); ++screen_row) { - if (Trace_index.find(screen_row) == Trace_index.end()) break; + if (!contains_key(Trace_index, screen_row)) break; trace_line& curr_line = Trace_stream->past_lines.at(Trace_index[screen_row]); ostringstream out; out << std::setw(4) << curr_line.depth << ' ' << curr_line.label << ": " << curr_line.contents; @@ -216,8 +220,8 @@ void render() { } long long int lines_hidden(long long int screen_row) { - assert(Trace_index.find(screen_row) != Trace_index.end()); - if (Trace_index.find(screen_row+1) == Trace_index.end()) + assert(contains_key(Trace_index, screen_row)); + if (!contains_key(Trace_index, screen_row+1)) return SIZE(Trace_stream->past_lines)-Trace_index[screen_row]; else return Trace_index[screen_row+1] - Trace_index[screen_row]; diff --git a/html/081run_interactive.cc.html b/html/081run_interactive.cc.html index 79db9059..3802f61a 100644 --- a/html/081run_interactive.cc.html +++ b/html/081run_interactive.cc.html @@ -13,8 +13,8 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.cSpecial { color: #008000; } .traceContains { color: #008000; } +.cSpecial { color: #008000; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } @@ -36,46 +36,53 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } :(scenario run_interactive_code) recipe main [ + 1:number/raw <- copy 0 2:address:array:character <- new [1:number/raw <- copy 34] run-interactive 2:address:array:character + 3:number/raw <- copy 1:number/raw ] -+mem: storing 34 in location 1 ++mem: storing 34 in location 3 :(scenario run_interactive_empty) recipe main [ - 1:address:array:character <- run-interactive 0 + 1:address:array:character <- copy 0/raw + 2:address:array:character <- run-interactive 1:address:array:character ] # result is null -+mem: storing 0 in location 1 ++mem: storing 0 in location 2 -//: run code in 'interactive mode', i.e. with warnings off and return: +//: run code in 'interactive mode', i.e. with errors+warnings off and return: //: stringified output in case we want to print it to screen -//: any warnings encountered +//: any errors+warnings encountered //: simulated screen any prints went to //: any 'app' layer traces generated :(before "End Primitive Recipe Declarations") RUN_INTERACTIVE, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["run-interactive"] = RUN_INTERACTIVE; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "run-interactive", RUN_INTERACTIVE); +:(before "End Primitive Recipe Checks") case RUN_INTERACTIVE: { - if (SIZE(ingredients) != 1) { - raise << current_recipe_name() << ": 'run-interactive' requires exactly one ingredient, but got " << current_instruction().to_string() << '\n' << end(); + if (SIZE(inst.ingredients) != 1) { + raise_error << maybe(get(Recipe, r).name) << "'run-interactive' requires exactly one ingredient, but got " << inst.to_string() << '\n' << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'run-interactive' should be a string, but got " << current_instruction().ingredients.at(0).to_string() << '\n' << end(); + if (!is_mu_string(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'run-interactive' should be a string, but got " << inst.ingredients.at(0).to_string() << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case RUN_INTERACTIVE: { bool new_code_pushed_to_stack = run_interactive(ingredients.at(0).at(0)); if (!new_code_pushed_to_stack) { products.resize(5); products.at(0).push_back(0); - products.at(1).push_back(trace_contents("warn")); + products.at(1).push_back(trace_error_warning_contents()); products.at(2).push_back(0); - products.at(3).push_back(trace_contents("app")); + products.at(3).push_back(trace_app_contents()); products.at(4).push_back(1); // completed - cleanup_run_interactive(); + run_code_end(); break; // done with this instruction } else { @@ -85,6 +92,9 @@ case RUN_INTERACTIVE: { :(before "End Globals") bool Track_most_recent_products = false; +:(before "End Tracing") +trace_stream* Save_trace_stream = NULL; +string Save_trace_file; :(before "End Setup") Track_most_recent_products = false; :(code) @@ -92,7 +102,7 @@ Track_most_recent_products = false// all warnings. // returns true if successfully called (no errors found during load and transform) bool run_interactive(long long int address) { - assert(Recipe_ordinal.find("interactive") != Recipe_ordinal.end() && Recipe_ordinal["interactive"] != 0); + assert(contains_key(Recipe_ordinal, "interactive") && get(Recipe_ordinal, "interactive") != 0); // try to sandbox the run as best you can // todo: test this if (!Current_scenario) { @@ -101,54 +111,83 @@ bool run_interactive(long long int address} string command = trim(strip_comments(read_mu_string(address))); if (command.empty()) return false; - Recipe.erase(Recipe_ordinal["interactive"]); - Name[Recipe_ordinal["interactive"]].clear(); - // stuff to undo later, in cleanup_run_interactive() - Hide_warnings = true; - if (!Trace_stream) { - Trace_file = ""; // if there wasn't already a stream we don't want to save it - Trace_stream = new trace_stream; - Trace_stream->collect_layers.insert("warn"); - Trace_stream->collect_layers.insert("app"); - } + Recipe.erase(get(Recipe_ordinal, "interactive")); + Name[get(Recipe_ordinal, "interactive")].clear(); + run_code_begin(); + // don't kill the current routine on parse errors + routine* save_current_routine = Current_routine; + Current_routine = NULL; // call run(string) but without the scheduling load(string("recipe interactive [\n") + "local-scope\n" + - "screen:address <- next-ingredient\n" + + "screen:address:screen <- next-ingredient\n" + "$start-tracking-products\n" + command + "\n" + "$stop-tracking-products\n" + "reply screen\n" + "]\n"); transform_all(); - if (trace_count("warn") > 0) return false; + Current_routine = save_current_routine; + if (trace_count("error") > 0) return false; // now call 'sandbox' which will run 'interactive' in a separate routine, // and wait for it - Current_routine->calls.push_front(call(Recipe_ordinal["sandbox"])); + if (Save_trace_stream) { + ++Save_trace_stream->callstack_depth; + trace(9999, "trace") << "run-interactive: incrementing callstack depth to " << Save_trace_stream->callstack_depth << end(); + assert(Save_trace_stream->callstack_depth < 9000); // 9998-101 plus cushion + } + Current_routine->calls.push_front(call(get(Recipe_ordinal, "sandbox"))); return true; } +void run_code_begin() { + // stuff to undo later, in run_code_end() + Hide_warnings = true; + Hide_errors = true; + Disable_redefine_warnings = true; + Save_trace_stream = Trace_stream; + Save_trace_file = Trace_file; + Trace_file = ""; + Trace_stream = new trace_stream; + Trace_stream->collect_depth = App_depth; +} + +void run_code_end() { + Hide_warnings = false; + Hide_errors = false; + Disable_redefine_warnings = false; + delete Trace_stream; + Trace_stream = Save_trace_stream; + Save_trace_stream = NULL; + Trace_file = Save_trace_file; + Save_trace_file.clear(); +} + :(before "End Load Recipes") load(string( "recipe interactive [\n") + // just a dummy version to initialize the Recipe_ordinal and so on "]\n" + "recipe sandbox [\n" + "local-scope\n" + - "screen:address/shared <- new-fake-screen 30, 5\n" + - "r:number/routine_id <- start-running interactive:recipe, screen:address\n" + + "screen:address:screen/shared <- new-fake-screen 30, 5\n" + + "r:number/routine_id <- start-running interactive:recipe, screen\n" + "limit-time r, 100000/instructions\n" + "wait-for-routine r\n" + "sandbox-state:number <- routine-state r/routine_id\n" + "completed?:boolean <- equal sandbox-state, 1/completed\n" + "output:address:array:character <- $most-recent-products\n" + - "warnings:address:array:character <- save-trace [warn]\n" + - "stashes:address:array:character <- save-trace [app]\n" + + "warnings:address:array:character <- save-errors-warnings\n" + + "stashes:address:array:character <- save-app-trace\n" + "$cleanup-run-interactive\n" + "reply output, warnings, screen, stashes, completed?\n" + "]\n"); transform_all(); recently_added_recipes.clear(); +//: adjust errors/warnings in the sandbox +:(after "string maybe(string s)") + if (s == "interactive") return ""; + :(scenario run_interactive_comments) recipe main [ 1:address:array:character <- new [# ab @@ -158,19 +197,14 @@ add 2, +mem: storing 52 in location 4 -:(scenario run_interactive_just_comments_without_trace) -recipe main [ - $close-trace - 1:address:array:character <- new [# ab -] - 2:address:array:character <- run-interactive 1:address:array:character - 3:array:character <- copy *2:address:array:character -] - :(before "End Primitive Recipe Declarations") _START_TRACKING_PRODUCTS, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$start-tracking-products"] = _START_TRACKING_PRODUCTS; +put(Recipe_ordinal, "$start-tracking-products", _START_TRACKING_PRODUCTS); +:(before "End Primitive Recipe Checks") +case _START_TRACKING_PRODUCTS: { + break; +} :(before "End Primitive Recipe Implementations") case _START_TRACKING_PRODUCTS: { Track_most_recent_products = true; @@ -180,7 +214,11 @@ case _START_TRACKING_PRODUCTS: { :(before "End Primitive Recipe Declarations") _STOP_TRACKING_PRODUCTS, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$stop-tracking-products"] = _STOP_TRACKING_PRODUCTS; +put(Recipe_ordinal, "$stop-tracking-products", _STOP_TRACKING_PRODUCTS); +:(before "End Primitive Recipe Checks") +case _STOP_TRACKING_PRODUCTS: { + break; +} :(before "End Primitive Recipe Implementations") case _STOP_TRACKING_PRODUCTS: { Track_most_recent_products = false; @@ -190,7 +228,11 @@ case _STOP_TRACKING_PRODUCTS: { :(before "End Primitive Recipe Declarations") _MOST_RECENT_PRODUCTS, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$most-recent-products"] = _MOST_RECENT_PRODUCTS; +put(Recipe_ordinal, "$most-recent-products", _MOST_RECENT_PRODUCTS); +:(before "End Primitive Recipe Checks") +case _MOST_RECENT_PRODUCTS: { + break; +} :(before "End Primitive Recipe Implementations") case _MOST_RECENT_PRODUCTS: { products.resize(1); @@ -199,33 +241,47 @@ case _MOST_RECENT_PRODUCTS: { } :(before "End Primitive Recipe Declarations") -SAVE_TRACE, +SAVE_ERRORS_WARNINGS, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["save-trace"] = SAVE_TRACE; +put(Recipe_ordinal, "save-errors-warnings", SAVE_ERRORS_WARNINGS); +:(before "End Primitive Recipe Checks") +case SAVE_ERRORS_WARNINGS: { + break; +} :(before "End Primitive Recipe Implementations") -case SAVE_TRACE: { +case SAVE_ERRORS_WARNINGS: { products.resize(1); - products.at(0).push_back(trace_contents(current_instruction().ingredients.at(0).name)); + products.at(0).push_back(trace_error_warning_contents()); break; } :(before "End Primitive Recipe Declarations") -_CLEANUP_RUN_INTERACTIVE, +SAVE_APP_TRACE, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["$cleanup-run-interactive"] = _CLEANUP_RUN_INTERACTIVE; +put(Recipe_ordinal, "save-app-trace", SAVE_APP_TRACE); +:(before "End Primitive Recipe Checks") +case SAVE_APP_TRACE: { + break; +} :(before "End Primitive Recipe Implementations") -case _CLEANUP_RUN_INTERACTIVE: { - cleanup_run_interactive(); +case SAVE_APP_TRACE: { + products.resize(1); + products.at(0).push_back(trace_app_contents()); break; } -:(code) -void cleanup_run_interactive() { - Hide_warnings = false; - if (Trace_stream && Trace_stream->is_narrowly_collecting("warn")) { // hack - delete Trace_stream; - Trace_stream = NULL; - } +:(before "End Primitive Recipe Declarations") +_CLEANUP_RUN_INTERACTIVE, +:(before "End Primitive Recipe Numbers") +put(Recipe_ordinal, "$cleanup-run-interactive", _CLEANUP_RUN_INTERACTIVE); +:(before "End Primitive Recipe Checks") +case _CLEANUP_RUN_INTERACTIVE: { + break; +} +:(before "End Primitive Recipe Implementations") +case _CLEANUP_RUN_INTERACTIVE: { + run_code_end(); + break; } :(scenario "run_interactive_returns_stringified_result") @@ -242,9 +298,9 @@ recipe main [ recipe main [ # try to interactively add 2 and 2 1:address:array:character <- new [ - 100:address:array:character <- new [a] - 101:address:array:character <- new [b] - 102:address:array:character <- string-append 100:address:array:character, 101:address:array:character + x:address:array:character <- new [a] + y:address:array:character <- new [b] + z:address:array:character <- string-append x:address:array:character, y:address:array:character ] 2:address:array:character <- run-interactive 1:address:array:character 10:array:character <- copy 2:address:array:character/lookup @@ -253,18 +309,31 @@ recipe main [ +mem: storing 97 in location 11 +mem: storing 98 in location 12 -:(scenario "run_interactive_returns_warnings") +:(scenario "run_interactive_returns_errors") recipe main [ - # run a command that generates a warning - 1:address:array:character <- new [get 1234:number, foo:offset] + # run a command that generates an error + 1:address:array:character <- new [x:number <- copy 34 +get x:number, foo:offset] 2:address:array:character, 3:address:array:character <- run-interactive 1:address:array:character 10:array:character <- copy 3:address:array:character/lookup ] -# warning should be "unknown element foo in container number" +# error should be "unknown element foo in container number" +mem: storing 117 in location 11 +mem: storing 110 in location 12 +mem: storing 107 in location 13 +mem: storing 110 in location 14 +# ... + +:(scenario run_interactive_with_comment) +recipe main [ + # 2 instructions, with a comment after the first + 1:address:array:number <- new [a:number <- copy 0 # abc +b:number <- copy 0 +] + 2:address:array:character, 3:address:array:character <- run-interactive 1:address:array:character +] +# no errors ++mem: storing 0 in location 3 :(before "End Globals") string Most_recent_products; @@ -283,10 +352,10 @@ void track_most_recent_products(const instruction if (is_mu_string(instruction.products.at(i))) { if (!scalar(products.at(i))) { tb_shutdown(); - cerr << read_mu_string(trace_contents("warn")) << '\n'; + cerr << read_mu_string(trace_error_warning_contents()) << '\n'; cerr << SIZE(products.at(i)) << ": "; for (long long int j = 0; j < SIZE(products.at(i)); ++j) - cerr << products.at(i).at(j) << ' '; + cerr << no_scientific(products.at(i).at(j)) << ' '; cerr << '\n'; } assert(scalar(products.at(i))); @@ -296,7 +365,7 @@ void track_most_recent_products(const instruction // End Record Product Special-cases } for (long long int j = 0; j < SIZE(products.at(i)); ++j) - out << products.at(i).at(j) << ' '; + out << no_scientific(products.at(i).at(j)) << ' '; out << '\n'; } Most_recent_products = out.str(); @@ -310,7 +379,7 @@ string strip_comments(string in.at(i); } else { - while (i < SIZE(in) && in.at(i) != '\n') + while (i+1 < SIZE(in) && in.at(i+1) != '\n') ++i; } } @@ -320,21 +389,34 @@ string strip_comments(string in(long long int address) { // convert to string ostringstream out; - out << Memory[address]; + out << no_scientific(get_or_insert(Memory, address)); return new_mu_string(out.str()); } -long long int trace_contents(const string& layer) { +long long int trace_error_warning_contents() { + if (!Trace_stream) return 0; + ostringstream out; + for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) { + if (p->depth > Warning_depth) continue; + out << p->contents; + if (*--p->contents.end() != '\n') out << '\n'; + } + string result = out.str(); + if (result.empty()) return 0; + truncate(result); + return new_mu_string(result); +} + +long long int trace_app_contents() { if (!Trace_stream) return 0; - if (trace_count(layer) <= 0) return 0; ostringstream out; for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin(); p != Trace_stream->past_lines.end(); ++p) { - if (p->label != layer) continue; + if (p->depth != App_depth) continue; out << p->contents; if (*--p->contents.end() != '\n') out << '\n'; } string result = out.str(); - assert(!result.empty()); + if (result.empty()) return 0; truncate(result); return new_mu_string(result); } @@ -349,51 +431,58 @@ void truncate(string& x} //: simpler version of run-interactive: doesn't do any running, just loads -//: recipes and reports warnings. +//: recipes and reports errors+warnings. + :(before "End Primitive Recipe Declarations") RELOAD, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["reload"] = RELOAD; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "reload", RELOAD); +:(before "End Primitive Recipe Checks") case RELOAD: { - if (SIZE(ingredients) != 1) { - raise << current_recipe_name() << ": 'reload' requires exactly one ingredient, but got " << current_instruction().to_string() << '\n' << end(); + if (SIZE(inst.ingredients) != 1) { + raise_error << maybe(get(Recipe, r).name) << "'reload' requires exactly one ingredient, but got " << inst.to_string() << '\n' << end(); break; } - if (!scalar(ingredients.at(0))) { - raise << current_recipe_name() << ": first ingredient of 'reload' should be a literal string, but got " << current_instruction().ingredients.at(0).original_string << '\n' << end(); + if (!is_mu_string(inst.ingredients.at(0))) { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'reload' should be a string, but got " << inst.ingredients.at(0).original_string << '\n' << end(); break; } - if (!Trace_stream) { - Trace_file = ""; // if there wasn't already a stream we don't want to save it - Trace_stream = new trace_stream; - Trace_stream->collect_layers.insert("warn"); - } - Hide_warnings = true; - Disable_redefine_warnings = true; + break; +} +:(before "End Primitive Recipe Implementations") +case RELOAD: { // clear any containers in advance for (long long int i = 0; i < SIZE(recently_added_types); ++i) { - Type_ordinal.erase(Type[recently_added_types.at(i)].name); + Type_ordinal.erase(get(Type, recently_added_types.at(i)).name); Type.erase(recently_added_types.at(i)); } string code = read_mu_string(ingredients.at(0).at(0)); + run_code_begin(); + routine* save_current_routine = Current_routine; + Current_routine = NULL; vector<recipe_ordinal> recipes_reloaded = load(code); for (long long int i = 0; i < SIZE(recipes_reloaded); ++i) { Name.erase(recipes_reloaded.at(i)); } transform_all(); Trace_stream->newline(); // flush trace - Disable_redefine_warnings = false; - Hide_warnings = false; + Current_routine = save_current_routine; products.resize(1); - products.at(0).push_back(trace_contents("warn")); - // hack: assume collect_layers isn't set anywhere else - if (Trace_stream->is_narrowly_collecting("warn")) { - delete Trace_stream; - Trace_stream = NULL; - } + products.at(0).push_back(trace_error_warning_contents()); + run_code_end(); // wait until we're done with the trace contents break; } + +:(scenario reload_continues_past_error) +recipe main [ + local-scope + x:address:array:character <- new [recipe foo [ + get 1234:number, foo:offset +]] + reload x + 1:number/raw <- copy 34 +] ++mem: storing 34 in location 1 </pre> </body> </html> diff --git a/html/082persist.cc.html b/html/082persist.cc.html index 01788333..1f6ed24f 100644 --- a/html/082persist.cc.html +++ b/html/082persist.cc.html @@ -14,7 +14,6 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background- body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } .cSpecial { color: #008000; } -.PreProc { color: #c000c0; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Identifier { color: #804000; } @@ -37,13 +36,28 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } :(before "End Primitive Recipe Declarations") RESTORE, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["restore"] = RESTORE; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "restore", RESTORE); +:(before "End Primitive Recipe Checks") case RESTORE: { - if (SIZE(ingredients) != 1) { - raise << current_recipe_name() << ": 'restore' requires exactly one ingredient, but got " << current_instruction().to_string() << '\n' << end(); + if (SIZE(inst.ingredients) != 1) { + raise_error << maybe(get(Recipe, r).name) << "'restore' requires exactly one ingredient, but got " << inst.to_string() << '\n' << end(); + break; + } + string filename; + if (is_literal_string(inst.ingredients.at(0))) { + ; + } + else if (is_mu_string(inst.ingredients.at(0))) { + ; + } + else { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'restore' should be a string, but got " << inst.ingredients.at(0).to_string() << '\n' << end(); break; } + break; +} +:(before "End Primitive Recipe Implementations") +case RESTORE: { string filename; if (is_literal_string(current_instruction().ingredients.at(0))) { filename = current_instruction().ingredients.at(0).name; @@ -51,11 +65,12 @@ case RESTORE: { else if (is_mu_string(current_instruction().ingredients.at(0))) { filename = read_mu_string(ingredients.at(0).at(0)); } - else { - raise << current_recipe_name() << ": first ingredient of 'restore' should be a string, but got " << current_instruction().ingredients.at(0).to_string() << '\n' << end(); + if (Current_scenario) { + // do nothing in tests + products.resize(1); + products.at(0).push_back(0); break; } - if (Current_scenario) break; // do nothing in tests string contents = slurp("lesson/"+filename); products.resize(1); if (contents.empty()) @@ -85,13 +100,31 @@ string slurp(const string& filename:(before "End Primitive Recipe Declarations") SAVE, :(before "End Primitive Recipe Numbers") -Recipe_ordinal["save"] = SAVE; -:(before "End Primitive Recipe Implementations") +put(Recipe_ordinal, "save", SAVE); +:(before "End Primitive Recipe Checks") case SAVE: { - if (SIZE(ingredients) != 2) { - raise << current_recipe_name() << ": 'save' requires exactly two ingredients, but got " << current_instruction().to_string() << '\n' << end(); + if (SIZE(inst.ingredients) != 2) { + raise_error << maybe(get(Recipe, r).name) << "'save' requires exactly two ingredients, but got " << inst.to_string() << '\n' << end(); + break; + } + if (is_literal_string(inst.ingredients.at(0))) { + ; + } + else if (is_mu_string(inst.ingredients.at(0))) { + ; + } + else { + raise_error << maybe(get(Recipe, r).name) << "first ingredient of 'save' should be a string, but got " << inst.ingredients.at(0).to_string() << '\n' << end(); break; } + if (!is_mu_string(inst.ingredients.at(1))) { + raise_error << maybe(get(Recipe, r).name) << "second ingredient of 'save' should be an address:array:character, but got " << inst.ingredients.at(1).to_string() << '\n' << end(); + break; + } + break; +} +:(before "End Primitive Recipe Implementations") +case SAVE: { if (Current_scenario) break; // do nothing in tests string filename; if (is_literal_string(current_instruction().ingredients.at(0))) { @@ -100,14 +133,6 @@ case SAVE: { else if (is_mu_string(current_instruction().ingredients.at(0))) { filename = read_mu_string(ingredients.at(0).at(0)); } - else { - raise << current_recipe_name() << ": first ingredient of 'save' should be a string, but got " << current_instruction().ingredients.at(0).to_string() << '\n' << end(); - break; - } - if (!scalar(ingredients.at(1))) { - raise << current_recipe_name() << ": second ingredient of 'save' should be an address:array:character, but got " << current_instruction().ingredients.at(1).to_string() << '\n' << end(); - break; - } ofstream fout(("lesson/"+filename).c_str()); string contents = read_mu_string(ingredients.at(1).at(0)); fout << contents; @@ -117,7 +142,7 @@ case SAVE: { // explicitly say '--all' for git 1.9 int status = system("cd lesson; git add --all .; git diff HEAD --exit-code >/dev/null || git commit -a -m . >/dev/null"); if (status != 0) - raise << "error in commit: contents " << contents << '\n' << end(); + raise_error << "error in commit: contents " << contents << '\n' << end(); break; } @@ -126,9 +151,6 @@ bool exists(const string& filename; return 0 == stat(filename.c_str(), &dummy); } - -:(before "End Includes") -#include<sys/stat.h> </pre> </body> </html> diff --git a/html/098check_type_pointers.cc.html b/html/098check_type_pointers.cc.html new file mode 100644 index 00000000..74de0da6 --- /dev/null +++ b/html/098check_type_pointers.cc.html @@ -0,0 +1,67 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> +<meta http-equiv="content-type" content="text/html; charset=UTF-8"> +<title>Mu - 098check_type_pointers.cc</title> +<meta name="Generator" content="Vim/7.4"> +<meta name="plugin-version" content="vim7.4_v1"> +<meta name="syntax" content="cpp"> +<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> +<meta name="colorscheme" content="minimal"> +<style type="text/css"> + +</style> + +<script type='text/javascript'> + +</script> +</head> +<body> +<pre id='vimCodeElement'> +:(before "End Transform All") +check_type_pointers(); + +:(code) +void check_type_pointers() { + for (map<recipe_ordinal, recipe>::iterator p = Recipe.begin(); p != Recipe.end(); ++p) { + if (any_type_ingredient_in_header(p->first)) continue; + const recipe& r = p->second; + for (long long int i = 0; i < SIZE(r.steps); ++i) { + const instruction& inst = r.steps.at(i); + for (long long int j = 0; j < SIZE(inst.ingredients); ++j) { + if (!inst.ingredients.at(j).type) { + raise_error << maybe(r.name) << " '" << inst.to_string() << "' -- " << inst.ingredients.at(j).to_string() << " has no type\n" << end(); + return; + } + if (!inst.ingredients.at(j).properties.at(0).second) { + raise_error << maybe(r.name) << " '" << inst.to_string() << "' -- " << inst.ingredients.at(j).to_string() << " has no type name\n" << end(); + return; + } + } + for (long long int j = 0; j < SIZE(inst.products); ++j) { + if (!inst.products.at(j).type) { + raise_error << maybe(r.name) << " '" << inst.to_string() << "' -- " << inst.products.at(j).to_string() << " has no type\n" << end(); + return; + } + if (!inst.products.at(j).properties.at(0).second) { + raise_error << maybe(r.name) << " '" << inst.to_string() << "' -- " << inst.products.at(j).to_string() << " has no type name\n" << end(); + return; + } + } + } + } +} +</pre> +</body> +</html> + diff --git a/html/999spaces.cc.html b/html/999spaces.cc.html index dbcc31d2..dac58e9d 100644 --- a/html/999spaces.cc.html +++ b/html/999spaces.cc.html @@ -56,14 +56,11 @@ assert(Next_recipe_ordinal == //:: Depths for tracing //: //: 0 - unused -//: 1-99 - app-level trace statements in mu -//: 100 - schedule -assert(Scheduling_depth == 100); -//: 101-9998 - call-stack statements (mostly label run) +//: 1-100 - app-level trace statements in mu +//: 101-9989 - call-stack statements (mostly label run) assert(Initial_callstack_depth == 101); -assert(Max_callstack_depth == 9998); -//: 9999 - intra-instruction lines (mostly label mem) -assert(Primitive_recipe_depth == 9999); +assert(Max_callstack_depth == 9989); +//: 9990-9999 - intra-instruction lines (mostly label mem) </pre> </body> </html> diff --git a/html/channel.mu.html b/html/channel.mu.html index 420eed5e..12babbde 100644 --- a/html/channel.mu.html +++ b/html/channel.mu.html @@ -13,12 +13,12 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .Special { color: #ff6060; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> @@ -33,11 +33,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # example program: communicating between routines using channels recipe producer [ - # produce numbers 1 to 5 on a channel + # produce characters 1 to 5 on a channel local-scope chan:address:channel <- next-ingredient # n = 0 - n:number <- copy 0 + n:character <- copy 0 { done?:boolean <- lesser-than n, 5 break-unless done? @@ -56,9 +56,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } chan:address:channel <- next-ingredient { # read an integer from the channel - n:number, chan:address:channel <- read chan + n:character, chan:address:channel <- read chan # other threads might get between these prints - $print [consume: ], n:number, [ + $print [consume: ], n:character, [ ] loop } @@ -68,8 +68,8 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } local-scope chan:address:channel <- new-channel 3 # create two background 'routines' that communicate by a channel - routine1:number <- start-running producer:recipe, chan - routine2:number <- start-running consumer:recipe, chan + routine1:character <- start-running producer:recipe, chan + routine2:character <- start-running consumer:recipe, chan wait-for-routine routine1 wait-for-routine routine2 ] diff --git a/html/chessboard.mu.html b/html/chessboard.mu.html index 56b4842e..5e11ad01 100644 --- a/html/chessboard.mu.html +++ b/html/chessboard.mu.html @@ -13,16 +13,16 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } -.muData { color: #ffff00; } .SalientComment { color: #00ffff; } -.muScenario { color: #00af00; } +.muData { color: #ffff00; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .Special { color: #ff6060; } .CommentedCode { color: #6c6c6c; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } +.muScenario { color: #00af00; } --> </style> @@ -61,7 +61,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ## But enough about mu. Here's what it looks like to run the chessboard program. scenario print-board-and-read-move [ - $close-trace # administrivia: most scenarios save and check traces, but this one gets too large/slow + trace-until 100/app # we'll make the screen really wide because the program currently prints out a long line assume-screen 120/width, 20/height # initialize keyboard to type in a move @@ -70,7 +70,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] ] run [ - screen:address, console:address <- chessboard screen:address, console:address + screen:address:screen, console:address:console <- chessboard screen:address:screen, console:address:console # icon for the cursor screen <- print-character screen, 9251/␣ ] @@ -104,8 +104,8 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe chessboard [ local-scope - screen:address <- next-ingredient - console:address <- next-ingredient + screen:address:screen <- next-ingredient + console:address:console <- next-ingredient board:address:array:address:array:character <- initial-position # hook up stdin stdin:address:channel <- new-channel 10/capacity @@ -147,7 +147,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe new-board [ local-scope - initial-position:address:array:number <- next-ingredient + initial-position:address:array:character <- next-ingredient # assert(length(initial-position) == 64) len:number <- length *initial-position correct-length?:boolean <- equal len, 64 @@ -168,7 +168,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe new-file [ local-scope - position:address:array:number <- next-ingredient + position:address:array:character <- next-ingredient index:number <- next-ingredient index <- multiply index, 8 result:address:array:character <- new character:type, 8 @@ -187,7 +187,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } recipe print-board [ local-scope - screen:address <- next-ingredient + screen:address:screen <- next-ingredient board:address:array:address:array:character <- next-ingredient row:number <- copy 7 # start printing from the top of the board # print each row @@ -236,7 +236,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # B P _ _ _ _ p B # N P _ _ _ _ p n # R P _ _ _ _ p r - initial-position:address:array:number <- new-array 82/R, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 114/r, 78/N, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 110/n, 66/B, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 98/b, 81/Q, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 113/q, 75/K, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 107/k, 66/B, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 98/b, 78/N, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 110/n, 82/R, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 114/r + initial-position:address:array:character <- new-array 82/R, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 114/r, 78/N, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 110/n, 66/B, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 98/b, 81/Q, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 113/q, 75/K, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 107/k, 66/B, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 98/b, 78/N, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 110/n, 82/R, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 114/r #? 82/R, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 114/r, #? 78/N, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 110/n, #? 66/B, 80/P, 32/blank, 32/blank, 32/blank, 32/blank, 112/p, 98/b, @@ -253,7 +253,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 30/width, 12/height run [ 1:address:array:address:array:character/board <- initial-position - screen:address <- print-board screen:address, 1:address:array:address:array:character/board + screen:address:screen <- print-board screen:address:screen, 1:address:array:address:array:character/board ] screen-should-contain [ # 012345678901234567890123456789 @@ -282,12 +282,12 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } to-rank:number ] -# result:address:move, quit?:boolean, error?:boolean <- read-move stdin:address:channel, screen:address +# result:address:move, quit?:boolean, error?:boolean <- read-move stdin:address:channel, screen:address:screen # prints only error messages to screen recipe read-move [ local-scope stdin:address:channel <- next-ingredient - screen:address <- next-ingredient + screen:address:screen <- next-ingredient from-file:number, quit?:boolean, error?:boolean <- read-file stdin, screen reply-if quit?, 0/dummy, quit?, error? reply-if error?, 0/dummy, quit?, error? @@ -314,12 +314,12 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } reply result, quit?, error? ] -# file:number, quit:boolean, error:boolean <- read-file stdin:address:channel, screen:address +# file:number, quit:boolean, error:boolean <- read-file stdin:address:channel, screen:address:screen # valid values for file: 0-7 recipe read-file [ local-scope stdin:address:channel <- next-ingredient - screen:address <- next-ingredient + screen:address:screen <- next-ingredient c:character, stdin <- read stdin { q-pressed?:boolean <- equal c, 81/Q @@ -365,12 +365,12 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } reply file, 0/quit, 0/error ] -# rank:number <- read-rank stdin:address:channel, screen:address +# rank:number <- read-rank stdin:address:channel, screen:address:screen # valid values: 0-7, -1 (quit), -2 (error) recipe read-rank [ local-scope stdin:address:channel <- next-ingredient - screen:address <- next-ingredient + screen:address:screen <- next-ingredient c:character, stdin <- read stdin { q-pressed?:boolean <- equal c, 8/Q @@ -416,7 +416,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } local-scope stdin:address:channel <- next-ingredient expected:character <- next-ingredient - screen:address <- next-ingredient + screen:address:screen <- next-ingredient c:character, stdin <- read stdin { match?:boolean <- equal c, expected @@ -432,7 +432,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 20/width, 2/height run [ 1:address:channel <- new-channel 2 - 2:number/routine <- start-running read-move:recipe, 1:address:channel, screen:address + 2:number/routine <- start-running read-move:recipe, 1:address:channel, screen:address:screen # 'read-move' is waiting for input wait-for-routine 2:number 3:number <- routine-state 2:number/id @@ -504,7 +504,7 @@ F read-move-blocking: routine failed to terminate on newline] assume-screen 20/width, 2/height run [ 1:address:channel <- new-channel 2 - 2:number/routine <- start-running read-move:recipe, 1:address:channel, screen:address + 2:number/routine <- start-running read-move:recipe, 1:address:channel, screen:address:screen # 'read-move' is waiting for input wait-for-routine 2:number 3:number <- routine-state 2:number/id @@ -531,7 +531,7 @@ F read-move-quit: routine failed to terminate on 'q'] assume-screen 20/width, 2/height run [ 1:address:channel <- new-channel 2 - 2:number/routine <- start-running read-move:recipe, 1:address:channel, screen:address + 2:number/routine <- start-running read-move:recipe, 1:address:channel, screen:address:screen # 'read-move' is waiting for input wait-for-routine 2:number 3:number <- routine-state 2:number/id @@ -552,7 +552,7 @@ F read-move-file: routine failed to pause after co assume-screen 20/width, 2/height run [ 1:address:channel <- new-channel 2 - 2:number/routine <- start-running read-move:recipe, 1:address:channel, screen:address + 2:number/routine <- start-running read-move:recipe, 1:address:channel, screen:address:screen # 'read-move' is waiting for input wait-for-routine 2:number 3:number <- routine-state 2:number/id @@ -574,7 +574,7 @@ F read-move-file: routine failed to pause after co assume-screen 20/width, 2/height run [ 1:address:channel <- new-channel 2 - 2:number/routine <- start-running read-move:recipe, 1:address:channel, screen:address + 2:number/routine <- start-running read-move:recipe, 1:address:channel, screen:address:screen # 'read-move' is waiting for input wait-for-routine 2:number 3:number <- routine-state 2:number/id @@ -623,7 +623,7 @@ F read-move-file: routine failed to pause after co 7:address:number <- get-address *3:address:move, to-rank:offset *7:address:number <- copy 3/'4' 2:address:array:address:array:character/board <- make-move 2:address:array:address:array:character/board, 3:address:move - screen:address <- print-board screen:address, 2:address:array:address:array:character/board + screen:address:screen <- print-board screen:address:screen, 2:address:array:address:array:character/board ] screen-should-contain [ # 012345678901234567890123456789 diff --git a/html/console.mu.html b/html/console.mu.html index 116fb450..1a14d4ed 100644 --- a/html/console.mu.html +++ b/html/console.mu.html @@ -13,12 +13,12 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .Special { color: #ff6060; } .Constant { color: #00a0a0; } -.muControl { color: #c0a020; } --> </style> diff --git a/html/counters.mu.html b/html/counters.mu.html index 9a02adca..495def81 100644 --- a/html/counters.mu.html +++ b/html/counters.mu.html @@ -17,7 +17,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .Special { color: #ff6060; } -.muControl { color: #c0a020; } --> </style> @@ -32,18 +31,16 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # example program: maintain multiple counters with isolated lexical scopes # (spaces) -recipe new-counter [ - default-space:address:array:location <- new location:type, 30 - n:number <- next-ingredient - reply default-space +recipe new-counter n:number -> default-space:address:array:location [ + default-space <- new location:type, 30 + load-ingredients ] -recipe increment-counter [ +recipe increment-counter outer:address:array:location/names:new-counter, x:number -> n:number/space:1 [ local-scope - 0:address:array:location/names:new-counter <- next-ingredient # setup outer space; it *must* come from 'new-counter' - x:number <- next-ingredient - n:number/space:1 <- add n:number/space:1, x - reply n:number/space:1 + load-ingredients + 0:address:array:location/names:new-counter <- copy outer # setup outer space; it *must* come from 'new-counter' + n/space:1 <- add n/space:1, x ] recipe main [ diff --git a/html/edit/001-editor.mu.html b/html/edit/001-editor.mu.html index be568c9d..916e93c6 100644 --- a/html/edit/001-editor.mu.html +++ b/html/edit/001-editor.mu.html @@ -13,15 +13,15 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } +.muScenario { color: #00af00; } .muData { color: #ffff00; } .Special { color: #ff6060; } -.muScenario { color: #00af00; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .SalientComment { color: #00ffff; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> @@ -37,9 +37,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # temporary main for this layer: just render the given string at the given # screen dimensions, then stop -recipe! main [ +recipe! main text:address:array:character [ local-scope - text:address:array:character <- next-ingredient + load-ingredients open-console hide-screen 0/screen new-editor text, 0/screen, 0/left, 5/right @@ -52,7 +52,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 10/width, 5/height run [ 1:address:array:character <- new [abc] - new-editor 1:address:array:character, screen:address, 0/left, 10/right + new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right ] screen-should-contain [ # top line of screen reserved for menu @@ -79,19 +79,15 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } cursor-column:number ] -# editor:address, screen <- new-editor s:address:array:character, screen:address, left:number, right:number -# creates a new editor widget and renders its initial appearance to screen. -# top/left/right constrain the screen area available to the new editor. -# right is exclusive. -recipe new-editor [ +# creates a new editor widget and renders its initial appearance to screen +# top/left/right constrain the screen area available to the new editor +# right is exclusive +recipe new-editor s:address:array:character, screen:address:screen, left:number, right:number -> result:address:editor-data [ local-scope - s:address:array:character <- next-ingredient - screen:address <- next-ingredient + load-ingredients # no clipping of bounds - left:number <- next-ingredient - right:number <- next-ingredient right <- subtract right, 1 - result:address:editor-data <- new editor-data:type + result <- new editor-data:type # initialize screen-related fields x:address:number <- get-address *result, left:offset *x <- copy left @@ -102,11 +98,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } *x <- copy 1/top x <- get-address *result, cursor-column:offset *x <- copy left - init:address:address:duplex-list <- get-address *result, data:offset + init:address:address:duplex-list:character <- get-address *result, data:offset *init <- push-duplex 167/§, 0/tail - top-of-screen:address:address:duplex-list <- get-address *result, top-of-screen:offset + top-of-screen:address:address:duplex-list:character <- get-address *result, top-of-screen:offset *top-of-screen <- copy *init - y:address:address:duplex-list <- get-address *result, before-cursor:offset + y:address:address:duplex-list:character <- get-address *result, before-cursor:offset *y <- copy *init result <- insert-text result, s # initialize cursor to top of screen @@ -115,20 +111,18 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # initial render to screen, just for some old tests _, _, screen, result <- render screen, result <editor-initialization> - reply result ] -recipe insert-text [ +recipe insert-text editor:address:editor-data, text:address:array:character -> editor:address:editor-data [ local-scope - editor:address:editor-data <- next-ingredient - text:address:array:character <- next-ingredient + load-ingredients # early exit if text is empty reply-unless text, editor/same-as-ingredient:0 len:number <- length *text reply-unless len, editor/same-as-ingredient:0 idx:number <- copy 0 # now we can start appending the rest, character by character - curr:address:duplex-list <- get *editor, data:offset + curr:address:duplex-list:character <- get *editor, data:offset { done?:boolean <- greater-or-equal idx, len break-if done? @@ -145,7 +139,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-initializes-without-data [ assume-screen 5/width, 3/height run [ - 1:address:editor-data <- new-editor 0/data, screen:address, 2/left, 5/right + 1:address:editor-data <- new-editor 0/data, screen:address:screen, 2/left, 5/right 2:editor-data <- copy *1:address:editor-data ] memory-should-contain [ @@ -165,22 +159,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] ] -# last-row:number, last-column:number, screen, editor <- render screen:address, editor:address:editor-data -# # Assumes cursor should be at coordinates (cursor-row, cursor-column) and # updates before-cursor to match. Might also move coordinates if they're # outside text. -recipe render [ +recipe render screen:address:screen, editor:address:editor-data -> last-row:number, last-column:number, screen:address:screen, editor:address:editor-data [ local-scope - screen:address <- next-ingredient - editor:address:editor-data <- next-ingredient + load-ingredients reply-unless editor, 1/top, 0/left, screen/same-as-ingredient:0, editor/same-as-ingredient:1 left:number <- get *editor, left:offset screen-height:number <- screen-height screen right:number <- get *editor, right:offset # traversing editor - curr:address:duplex-list <- get *editor, top-of-screen:offset - prev:address:duplex-list <- copy curr # just in case curr becomes null and we can't compute prev-duplex + curr:address:duplex-list:character <- get *editor, top-of-screen:offset + prev:address:duplex-list:character <- copy curr # just in case curr becomes null and we can't compute prev-duplex curr <- next-duplex curr # traversing screen +render-loop-initialization @@ -189,7 +180,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } column:number <- copy left cursor-row:address:number <- get-address *editor, cursor-row:offset cursor-column:address:number <- get-address *editor, cursor-column:offset - before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset + before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset screen <- move-cursor screen, row, column { +next-character @@ -251,7 +242,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } loop } # save first character off-screen - bottom-of-screen:address:address:duplex-list <- get-address *editor, bottom-of-screen:offset + bottom-of-screen:address:address:duplex-list:character <- get-address *editor, bottom-of-screen:offset *bottom-of-screen <- copy curr # is cursor to the right of the last line? move to end { @@ -268,11 +259,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } reply row, column, screen/same-as-ingredient:0, editor/same-as-ingredient:1 ] -recipe clear-line-delimited [ +recipe clear-line-delimited screen:address:screen, column:number, right:number [ local-scope - screen:address <- next-ingredient - column:number <- next-ingredient - right:number <- next-ingredient + load-ingredients { done?:boolean <- greater-than column, right break-if done? @@ -282,13 +271,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } ] -recipe clear-screen-from [ +recipe clear-screen-from screen:address:screen, row:number, column:number, left:number, right:number -> screen:address:screen [ local-scope - screen:address <- next-ingredient - row:number <- next-ingredient - column:number <- next-ingredient - left:number <- next-ingredient - right:number <- next-ingredient + load-ingredients # if it's the real screen, use the optimized primitive { break-if screen @@ -302,12 +287,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } reply screen/same-as-ingredient:0 ] -recipe clear-rest-of-screen [ +recipe clear-rest-of-screen screen:address:screen, row:number, left:number, right:number [ local-scope - screen:address <- next-ingredient - row:number <- next-ingredient - left:number <- next-ingredient - right:number <- next-ingredient + load-ingredients row <- add row, 1 screen <- move-cursor screen, row, left screen-height:number <- screen-height screen @@ -326,7 +308,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } run [ s:address:array:character <- new [abc def] - new-editor s:address:array:character, screen:address, 0/left, 5/right + new-editor s:address:array:character, screen:address:screen, 0/left, 5/right ] screen-should-contain [ . . @@ -340,7 +322,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 5/width, 5/height run [ s:address:array:character <- new [abc] - new-editor s:address:array:character, screen:address, 1/left, 5/right + new-editor s:address:array:character, screen:address:screen, 1/left, 5/right ] screen-should-contain [ . . @@ -354,7 +336,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } run [ s:address:array:character <- new [abc def] - new-editor s:address:array:character, screen:address, 1/left, 5/right + new-editor s:address:array:character, screen:address:screen, 1/left, 5/right ] screen-should-contain [ . . @@ -368,7 +350,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 5/width, 5/height run [ s:address:array:character <- new [abc def] - new-editor s:address:array:character, screen:address, 0/left, 5/right + new-editor s:address:array:character, screen:address:screen, 0/left, 5/right ] screen-should-contain [ . . @@ -388,7 +370,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 5/width, 5/height run [ s:address:array:character <- new [abcde] - new-editor s:address:array:character, screen:address, 0/left, 5/right + new-editor s:address:array:character, screen:address:screen, 0/left, 5/right ] # still wrap, even though the line would fit. We need room to click on the # end of the line @@ -410,7 +392,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 5/width, 5/height run [ 1:address:array:character <- new [] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -433,7 +415,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } s:address:array:character <- new [abc # de f] - new-editor s:address:array:character, screen:address, 0/left, 5/right + new-editor s:address:array:character, screen:address:screen, 0/left, 5/right ] screen-should-contain [ . . @@ -462,12 +444,10 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } color <- get-color color, c ] -# color <- get-color color:number, c:character # so far the previous color is all the information we need; that may change -recipe get-color [ +recipe get-color color:number, c:character -> color:number [ local-scope - color:number <- next-ingredient - c:character <- next-ingredient + load-ingredients color-is-white?:boolean <- equal color, 7/white # if color is white and next character is '#', switch color to blue { @@ -516,7 +496,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } s:address:array:character <- new [abc d <- e f] - new-editor s:address:array:character, screen:address, 0/left, 8/right + new-editor s:address:array:character, screen:address:screen, 0/left, 8/right ] screen-should-contain [ . . diff --git a/html/edit/002-typing.mu.html b/html/edit/002-typing.mu.html index 787e3a4e..c1f1128f 100644 --- a/html/edit/002-typing.mu.html +++ b/html/edit/002-typing.mu.html @@ -13,15 +13,15 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } -.muData { color: #ffff00; } .Special { color: #ff6060; } -.muScenario { color: #00af00; } +.muData { color: #ffff00; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .SalientComment { color: #00ffff; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } +.muScenario { color: #00af00; } --> </style> @@ -37,27 +37,25 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # temporary main: interactive editor # hit ctrl-c to exit -recipe! main [ +recipe! main text:address:array:character [ local-scope - text:address:array:character <- next-ingredient + load-ingredients open-console editor:address:editor-data <- new-editor text, 0/screen, 5/left, 45/right editor-event-loop 0/screen, 0/console, editor close-console ] -recipe editor-event-loop [ +recipe editor-event-loop screen:address:screen, console:address:console, editor:address:editor-data [ local-scope - screen:address <- next-ingredient - console:address <- next-ingredient - editor:address:editor-data <- next-ingredient + load-ingredients { # looping over each (keyboard or touch) event as it occurs +next-event cursor-row:number <- get *editor, cursor-row:offset cursor-column:number <- get *editor, cursor-column:offset screen <- move-cursor screen, cursor-row, cursor-column - e:event, console:address, found?:boolean, quit?:boolean <- read-event console + e:event, console:address:console, found?:boolean, quit?:boolean <- read-event console loop-unless found? break-if quit? # only in tests trace 10, [app], [next-event] @@ -82,11 +80,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] # process click, return if it was on current editor -recipe move-cursor-in-editor [ +recipe move-cursor-in-editor screen:address:screen, editor:address:editor-data, t:touch-event -> in-focus?:boolean [ local-scope - screen:address <- next-ingredient - editor:address:editor-data <- next-ingredient - t:touch-event <- next-ingredient + load-ingredients reply-unless editor, 0/false click-row:number <- get t, row:offset reply-unless click-row, 0/false # ignore clicks on 'menu' @@ -106,24 +102,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } reply 1/true ] -# editor <- snap-cursor screen:address, editor:address:editor-data, target-row:number, target-column:number -# # Variant of 'render' that only moves the cursor (coordinates and # before-cursor). If it's past the end of a line, it 'slides' it left. If it's # past the last line it positions at end of last line. -recipe snap-cursor [ +recipe snap-cursor screen:address:screen, editor:address:editor-data, target-row:number, target-column:number -> editor:address:editor-data [ local-scope - screen:address <- next-ingredient - editor:address:editor-data <- next-ingredient - target-row:number <- next-ingredient - target-column:number <- next-ingredient - reply-unless editor, 1/top, editor/same-as-ingredient:1 + load-ingredients + reply-unless editor left:number <- get *editor, left:offset right:number <- get *editor, right:offset screen-height:number <- screen-height screen # count newlines until screen row - curr:address:duplex-list <- get *editor, top-of-screen:offset - prev:address:duplex-list <- copy curr # just in case curr becomes null and we can't compute prev-duplex + curr:address:duplex-list:character <- get *editor, top-of-screen:offset + prev:address:duplex-list:character <- copy curr # just in case curr becomes null and we can't compute prev-duplex curr <- next-duplex curr row:number <- copy 1/top column:number <- copy left @@ -131,7 +122,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } *cursor-row <- copy target-row cursor-column:address:number <- get-address *editor, cursor-column:offset *cursor-column <- copy target-column - before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset + before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset { +next-character break-unless curr @@ -195,23 +186,20 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } *cursor-column <- copy column *before-cursor <- copy prev } - reply editor/same-as-ingredient:1 ] -# screen, editor, go-render?:boolean <- handle-keyboard-event screen:address, editor:address:editor-data, e:event # Process an event 'e' and try to minimally update the screen. # Set 'go-render?' to true to indicate the caller must perform a non-minimal update. -recipe handle-keyboard-event [ +recipe handle-keyboard-event screen:address:screen, editor:address:editor-data, e:event -> screen:address:screen, editor:address:editor-data, go-render?:boolean [ local-scope - screen:address <- next-ingredient - editor:address:editor-data <- next-ingredient - e:event <- next-ingredient - reply-unless editor, screen/same-as-ingredient:0, editor/same-as-ingredient:1, 0/no-more-render + load-ingredients + go-render? <- copy 0/false + reply-unless editor screen-width:number <- screen-width screen screen-height:number <- screen-height screen left:number <- get *editor, left:offset right:number <- get *editor, right:offset - before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset + before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset cursor-row:address:number <- get-address *editor, cursor-row:offset cursor-column:address:number <- get-address *editor, cursor-column:offset save-row:number <- copy *cursor-row @@ -225,27 +213,27 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } <handle-special-character> # ignore any other special characters regular-character?:boolean <- greater-or-equal *c, 32/space - reply-unless regular-character?, screen/same-as-ingredient:0, editor/same-as-ingredient:1, 0/no-more-render + go-render? <- copy 0/false + reply-unless regular-character? # otherwise type it in <insert-character-begin> editor, screen, go-render?:boolean <- insert-at-cursor editor, *c, screen <insert-character-end> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, go-render? + reply } # special key to modify the text or move the cursor k:address:number <- maybe-convert e:event, keycode:variant assert k, [event was of unknown type; neither keyboard nor mouse] # handlers for each special key will go here <handle-special-key> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 1/go-render + go-render? <- copy 1/true + reply ] -recipe insert-at-cursor [ +recipe insert-at-cursor editor:address:editor-data, c:character, screen:address:screen -> editor:address:editor-data, screen:address:screen, go-render?:boolean [ local-scope - editor:address:editor-data <- next-ingredient - c:character <- next-ingredient - screen:address <- next-ingredient - before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset + load-ingredients + before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset insert-duplex c, *before-cursor *before-cursor <- next-duplex *before-cursor cursor-row:address:number <- get-address *editor, cursor-row:offset @@ -260,7 +248,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } <insert-character-special-case> # but mostly we'll just move the cursor right *cursor-column <- add *cursor-column, 1 - next:address:duplex-list <- next-duplex *before-cursor + next:address:duplex-list:character <- next-duplex *before-cursor { # at end of all text? no need to scroll? just print the character and leave at-end?:boolean <- equal next, 0/null @@ -272,20 +260,22 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } break-if overflow? move-cursor screen, save-row, save-column print-character screen, c - reply editor/same-as-ingredient:0, screen/same-as-ingredient:2, 0/no-more-render + go-render? <- copy 0/false + reply } { # not at right margin? print the character and rest of line break-unless next at-right?:boolean <- greater-or-equal *cursor-column, screen-width break-if at-right? - curr:address:duplex-list <- copy *before-cursor + curr:address:duplex-list:character <- copy *before-cursor move-cursor screen, save-row, save-column curr-column:number <- copy save-column { # hit right margin? give up and let caller render + go-render? <- copy 1/true at-right?:boolean <- greater-than curr-column, right - reply-if at-right?, editor/same-as-ingredient:0, screen/same-as-ingredient:2, 1/go-render + reply-if at-right? break-unless curr # newline? done. currc:character <- get *curr, value:offset @@ -296,16 +286,17 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } curr <- next-duplex curr loop } - reply editor/same-as-ingredient:0, screen/same-as-ingredient:2, 0/no-more-render + go-render? <- copy 0/false + reply } - reply editor/same-as-ingredient:0, screen/same-as-ingredient:2, 1/go-render + go-render? <- copy 1/true + reply ] # helper for tests -recipe editor-render [ +recipe editor-render screen:address:screen, editor:address:editor-data -> screen:address:screen [ local-scope - screen:address <- next-ingredient - editor:address:editor-data <- next-ingredient + load-ingredients left:number <- get *editor, left:offset right:number <- get *editor, right:offset row:number, column:number <- render screen, editor @@ -319,11 +310,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-handles-empty-event-queue [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data assume-console [] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -336,14 +327,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-handles-mouse-clicks [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ left-click 1, 1 # on the 'b' ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -363,13 +354,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-handles-mouse-clicks-outside-text [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right $clear-trace assume-console [ left-click 1, 7 # last line, to the right of text ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -384,13 +375,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 10/width, 5/height 1:address:array:character <- new [abc def] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right $clear-trace assume-console [ left-click 1, 7 # interior line, to the right of text ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -405,13 +396,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 10/width, 5/height 1:address:array:character <- new [abc def] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right $clear-trace assume-console [ left-click 3, 7 # below text ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -426,7 +417,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 10/width, 5/height 1:address:array:character <- new [abc] # editor occupies only left half of screen - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -434,7 +425,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } left-click 3, 8 ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -454,7 +445,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-handles-mouse-clicks-in-menu-area [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -462,7 +453,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } left-click 0, 3 ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -476,14 +467,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-inserts-characters-into-empty-editor [ assume-screen 10/width, 5/height 1:address:array:character <- new [] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ type [abc] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -497,7 +488,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-inserts-characters-at-cursor [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # type two letters at different places @@ -507,7 +498,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [d] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -521,7 +512,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-inserts-characters-at-cursor-2 [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -529,7 +520,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [d] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -544,7 +535,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 10/width, 5/height 1:address:array:character <- new [abc d] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -552,7 +543,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [e] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -567,7 +558,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-inserts-characters-at-cursor-3 [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -575,7 +566,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [d] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -590,7 +581,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 10/width, 5/height 1:address:array:character <- new [abc d] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -598,7 +589,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [e] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -614,7 +605,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 10/width, 5/height 1:address:array:character <- new [abc d] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -622,7 +613,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [ef] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -637,13 +628,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-moves-cursor-after-inserting-characters [ assume-screen 10/width, 5/height 1:address:array:character <- new [ab] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right editor-render screen, 2:address:editor-data assume-console [ type [01] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -658,14 +649,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-wraps-line-on-insert [ assume-screen 5/width, 5/height 1:address:array:character <- new [abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right editor-render screen, 2:address:editor-data # type a letter assume-console [ type [e] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # no wrap yet screen-should-contain [ @@ -680,7 +671,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [f] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # now wrap screen-should-contain [ @@ -697,7 +688,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 10/width, 5/height 1:address:array:character <- new [abcdefg defg] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right editor-render screen, 2:address:editor-data # type more text at the start assume-console [ @@ -705,7 +696,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [abc] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -740,20 +731,21 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } break-unless below-screen? <scroll-down> } - reply editor/same-as-ingredient:0, screen/same-as-ingredient:2, 1/go-render + go-render? <- copy 1/true + reply } ] scenario editor-wraps-cursor-after-inserting-characters [ assume-screen 10/width, 5/height 1:address:array:character <- new [abcde] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right assume-console [ left-click 1, 4 # line is full; no wrap icon yet type [f] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -773,13 +765,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-wraps-cursor-after-inserting-characters-2 [ assume-screen 10/width, 5/height 1:address:array:character <- new [abcde] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right assume-console [ left-click 1, 3 # right before the wrap icon type [f] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -799,13 +791,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-wraps-cursor-to-left-margin [ assume-screen 10/width, 5/height 1:address:array:character <- new [abcde] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 2/left, 7/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 2/left, 7/right assume-console [ left-click 1, 5 # line is full; no wrap icon yet type [01] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -836,13 +828,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-moves-cursor-down-after-inserting-newline [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right assume-console [ type [0 1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -860,17 +852,17 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } <insert-enter-begin> editor <- insert-new-line-and-indent editor, screen <insert-enter-end> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 1/go-render + go-render? <- copy 1/true + reply } ] -recipe insert-new-line-and-indent [ +recipe insert-new-line-and-indent editor:address:editor-data, screen:address:screen -> editor:address:editor-data, screen:address:screen, go-render?:boolean [ local-scope - editor:address:editor-data <- next-ingredient - screen:address <- next-ingredient + load-ingredients cursor-row:address:number <- get-address *editor, cursor-row:offset cursor-column:address:number <- get-address *editor, cursor-column:offset - before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset + before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset left:number <- get *editor, left:offset right:number <- get *editor, right:offset screen-height:number <- screen-height screen @@ -884,13 +876,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } below-screen?:boolean <- greater-or-equal *cursor-row, screen-height # must be equal, never greater break-unless below-screen? <scroll-down> + go-render? <- copy 1/true *cursor-row <- subtract *cursor-row, 1 # bring back into screen range } # indent if necessary indent?:boolean <- get *editor, indent?:offset - reply-unless indent?, editor/same-as-ingredient:0, screen/same-as-ingredient:1 - d:address:duplex-list <- get *editor, data:offset - end-of-previous-line:address:duplex-list <- prev-duplex *before-cursor + reply-unless indent? + d:address:duplex-list:character <- get *editor, data:offset + end-of-previous-line:address:duplex-list:character <- prev-duplex *before-cursor indent:number <- line-indent end-of-previous-line, d i:number <- copy 0 { @@ -900,19 +893,17 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } i <- add i, 1 loop } - reply editor/same-as-ingredient:0, screen/same-as-ingredient:1 ] # takes a pointer 'curr' into the doubly-linked list and its sentinel, counts # the number of spaces at the start of the line containing 'curr'. -recipe line-indent [ +recipe line-indent curr:address:duplex-list:character, start:address:duplex-list:character -> result:number [ local-scope - curr:address:duplex-list <- next-ingredient - start:address:duplex-list <- next-ingredient + load-ingredients result:number <- copy 0 - reply-unless curr, result + reply-unless curr at-start?:boolean <- equal curr, start - reply-if at-start?, result + reply-if at-start? { curr <- prev-duplex curr break-unless curr @@ -934,19 +925,18 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } loop } - reply result ] scenario editor-moves-cursor-down-after-inserting-newline-2 [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 1/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 1/left, 10/right assume-console [ type [0 1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -960,7 +950,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-clears-previous-line-completely-after-inserting-newline [ assume-screen 10/width, 5/height 1:address:array:character <- new [abcde] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right assume-console [ press enter ] @@ -972,7 +962,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } . . ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # line should be fully cleared screen-should-contain [ @@ -989,7 +979,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [ab cd ef] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right # position cursor after 'cd' and hit 'newline' assume-console [ left-click 2, 8 @@ -997,7 +987,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1013,7 +1003,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [ab cd ef] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right # position cursor after 'cd' and hit 'newline' surrounded by paste markers assume-console [ left-click 2, 8 @@ -1022,7 +1012,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press 65506 # end paste ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1039,7 +1029,8 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } break-unless paste-start? indent?:address:boolean <- get-address *editor, indent?:offset *indent? <- copy 0/false - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 1/go-render + go-render? <- copy 1/true + reply } ] @@ -1049,18 +1040,16 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } break-unless paste-end? indent?:address:boolean <- get-address *editor, indent?:offset *indent? <- copy 1/true - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 1/go-render + go-render? <- copy 1/true + reply } ] ## helpers -recipe draw-horizontal [ +recipe draw-horizontal screen:address:screen, row:number, x:number, right:number [ local-scope - screen:address <- next-ingredient - row:number <- next-ingredient - x:number <- next-ingredient - right:number <- next-ingredient + load-ingredients style:character, style-found?:boolean <- next-ingredient { break-if style-found? diff --git a/html/edit/003-shortcuts.mu.html b/html/edit/003-shortcuts.mu.html index 82273ba7..023f8448 100644 --- a/html/edit/003-shortcuts.mu.html +++ b/html/edit/003-shortcuts.mu.html @@ -13,14 +13,14 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } +.muRecipe { color: #ff8700; } .muScenario { color: #00af00; } .Special { color: #ff6060; } -.muRecipe { color: #ff8700; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .SalientComment { color: #00ffff; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> @@ -43,12 +43,12 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # just one character in final line 1:address:array:character <- new [ab cd] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right assume-console [ press tab ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -65,7 +65,8 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } editor, screen, go-render?:boolean <- insert-at-cursor editor, 32/space, screen editor, screen, go-render?:boolean <- insert-at-cursor editor, 32/space, screen <insert-character-end> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 1/go-render + go-render? <- copy 1/true + reply } ] @@ -74,7 +75,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-handles-backspace-key [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -82,7 +83,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press backspace ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 4:number <- get *2:address:editor-data, cursor-row:offset 5:number <- get *2:address:editor-data, cursor-column:offset ] @@ -104,46 +105,48 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } delete-previous-character?:boolean <- equal *c, 8/backspace break-unless delete-previous-character? <backspace-character-begin> - editor, screen, go-render?:boolean, backspaced-cell:address:duplex-list <- delete-before-cursor editor, screen + editor, screen, go-render?:boolean, backspaced-cell:address:duplex-list:character <- delete-before-cursor editor, screen <backspace-character-end> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, go-render? + reply } ] -# editor, screen, go-render?:boolean, backspaced-cell:address:duplex-list <- delete-before-cursor editor:address:editor-data, screen # return values: # go-render? - whether caller needs to update the screen # backspaced-cell - value deleted (or 0 if nothing was deleted) so we can save it for undo, etc. -recipe delete-before-cursor [ +recipe delete-before-cursor editor:address:editor-data, screen:address:screen -> editor:address:editor-data, screen:address:screen, go-render?:boolean, backspaced-cell:address:duplex-list:character [ local-scope - editor:address:editor-data <- next-ingredient - screen:address <- next-ingredient - before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset + load-ingredients + before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset # if at start of text (before-cursor at § sentinel), return - prev:address:duplex-list <- prev-duplex *before-cursor - reply-unless prev, editor/same-as-ingredient:0, screen/same-as-ingredient:1, 0/no-more-render, 0/nothing-deleted + prev:address:duplex-list:character <- prev-duplex *before-cursor + go-render?, backspaced-cell <- copy 0/no-more-render, 0/nothing-deleted + reply-unless prev trace 10, [app], [delete-before-cursor] original-row:number <- get *editor, cursor-row:offset editor, scroll?:boolean <- move-cursor-coordinates-left editor - backspaced-cell:address:duplex-list <- copy *before-cursor + backspaced-cell:address:duplex-list:character <- copy *before-cursor remove-duplex *before-cursor # will also neatly trim next/prev pointers in backspaced-cell/*before-cursor *before-cursor <- copy prev - reply-if scroll?, editor/same-as-ingredient:0, 1/go-render, backspaced-cell + go-render? <- copy 1/true + reply-if scroll? screen-width:number <- screen-width screen cursor-row:number <- get *editor, cursor-row:offset cursor-column:number <- get *editor, cursor-column:offset # did we just backspace over a newline? same-row?:boolean <- equal cursor-row, original-row - reply-unless same-row?, editor/same-as-ingredient:0, screen/same-as-ingredient:1, 1/go-render, backspaced-cell + go-render? <- copy 1/true + reply-unless same-row? left:number <- get *editor, left:offset right:number <- get *editor, right:offset - curr:address:duplex-list <- next-duplex *before-cursor + curr:address:duplex-list:character <- next-duplex *before-cursor screen <- move-cursor screen, cursor-row, cursor-column curr-column:number <- copy cursor-column { # hit right margin? give up and let caller render - at-right?:boolean <- greater-or-equal curr-column, screen-width - reply-if at-right?, editor/same-as-ingredient:0, screen/same-as-ingredient:1, 1/go-render, backspaced-cell + at-right?:boolean <- greater-or-equal curr-column, right + go-render? <- copy 1/true + reply-if at-right? break-unless curr # newline? done. currc:character <- get *curr, value:offset @@ -156,13 +159,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } # we're guaranteed not to be at the right margin screen <- print-character screen, 32/space - reply editor/same-as-ingredient:0, screen/same-as-ingredient:1, 0/no-more-render, backspaced-cell + go-render? <- copy 0/false ] -recipe move-cursor-coordinates-left [ +recipe move-cursor-coordinates-left editor:address:editor-data -> editor:address:editor-data, go-render?:boolean [ local-scope - editor:address:editor-data <- next-ingredient - before-cursor:address:duplex-list <- get *editor, before-cursor:offset + load-ingredients + before-cursor:address:duplex-list:character <- get *editor, before-cursor:offset cursor-row:address:number <- get-address *editor, cursor-row:offset cursor-column:address:number <- get-address *editor, cursor-column:offset left:number <- get *editor, left:offset @@ -172,7 +175,8 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } break-if at-left-margin? trace 10, [app], [decrementing cursor column] *cursor-column <- subtract *cursor-column, 1 - reply editor/same-as-ingredient:0, 0/no-more-render + go-render? <- copy 0/false + reply } # if at left margin, we must move to previous row: top-of-screen?:boolean <- equal *cursor-row, 1 # exclude menu bar @@ -193,28 +197,26 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } break-unless previous-character-is-newline? # compute length of previous line trace 10, [app], [switching to previous line] - d:address:duplex-list <- get *editor, data:offset + d:address:duplex-list:character <- get *editor, data:offset end-of-line:number <- previous-line-length before-cursor, d *cursor-column <- add left, end-of-line - reply editor/same-as-ingredient:0, go-render? + reply } # case 2: if previous-character was not newline, we're just at a wrapped line trace 10, [app], [wrapping to previous line] right:number <- get *editor, right:offset *cursor-column <- subtract right, 1 # leave room for wrap icon - reply editor/same-as-ingredient:0, go-render? ] # takes a pointer 'curr' into the doubly-linked list and its sentinel, counts # the length of the previous line before the 'curr' pointer. -recipe previous-line-length [ +recipe previous-line-length curr:address:duplex-list:character, start:address:duplex-list:character -> result:number [ local-scope - curr:address:duplex-list <- next-ingredient - start:address:duplex-list <- next-ingredient + load-ingredients result:number <- copy 0 - reply-unless curr, result + reply-unless curr at-start?:boolean <- equal curr, start - reply-if at-start?, result + reply-if at-start? { curr <- prev-duplex curr break-unless curr @@ -226,7 +228,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } result <- add result, 1 loop } - reply result ] scenario editor-clears-last-line-on-backspace [ @@ -234,13 +235,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # just one character in final line 1:address:array:character <- new [ab cd] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right assume-console [ left-click 2, 0 # cursor at only character in final line press backspace ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 4:number <- get *2:address:editor-data, cursor-row:offset 5:number <- get *2:address:editor-data, cursor-column:offset ] @@ -256,19 +257,77 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] ] +scenario editor-joins-and-wraps-lines-on-backspace [ + assume-screen 10/width, 5/height + # initialize editor with two long-ish but non-wrapping lines + 1:address:array:character <- new [abc def +ghi jkl] + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right + editor-render screen, 2:address:editor-data + $clear-trace + # position the cursor at the start of the second and hit backspace + assume-console [ + left-click 2, 0 + press backspace + ] + run [ + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data + ] + # resulting single line should wrap correctly + screen-should-contain [ + . . + .abc defgh↩. + .i jkl . + .┈┈┈┈┈┈┈┈┈┈. + . . + ] +] + +scenario editor-wraps-long-lines-on-backspace [ + assume-screen 10/width, 5/height + # initialize editor in part of the screen with a long line + 1:address:array:character <- new [abc def ghij] + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 8/right + editor-render screen, 2:address:editor-data + # confirm that it wraps + screen-should-contain [ + . . + .abc def↩ . + . ghij . + .┈┈┈┈┈┈┈┈ . + ] + $clear-trace + # position the cursor somewhere in the middle of the top screen line and hit backspace + assume-console [ + left-click 1, 4 + press backspace + ] + run [ + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data + ] + # resulting single line should wrap correctly and not overflow its bounds + screen-should-contain [ + . . + .abcdef ↩ . + .ghij . + .┈┈┈┈┈┈┈┈ . + . . + ] +] + # delete - delete character at cursor scenario editor-handles-delete-key [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ press delete ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -282,7 +341,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press delete ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -298,25 +357,26 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } delete-next-character?:boolean <- equal *k, 65522/delete break-unless delete-next-character? <delete-character-begin> - editor, screen, go-render?:boolean, deleted-cell:address:duplex-list <- delete-at-cursor editor, screen + editor, screen, go-render?:boolean, deleted-cell:address:duplex-list:character <- delete-at-cursor editor, screen <delete-character-end> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, go-render? + reply } ] -recipe delete-at-cursor [ +recipe delete-at-cursor editor:address:editor-data, screen:address:screen -> editor:address:editor-data, screen:address:screen, go-render?:boolean, deleted-cell:address:duplex-list:character [ local-scope - editor:address:editor-data <- next-ingredient - screen:address <- next-ingredient - before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset - candidate:address:duplex-list <- next-duplex *before-cursor - reply-unless candidate, editor/same-as-ingredient:0, screen/same-as-ingredient:1, 0/no-more-render, 0/nothing-deleted - currc:character <- get *candidate, value:offset - remove-duplex candidate + load-ingredients + before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset + deleted-cell:address:duplex-list:character <- next-duplex *before-cursor + go-render? <- copy 0/false + reply-unless deleted-cell + currc:character <- get *deleted-cell, value:offset + remove-duplex deleted-cell deleted-newline?:boolean <- equal currc, 10/newline - reply-if deleted-newline?, editor/same-as-ingredient:0, screen/same-as-ingredient:1, 1/go-render, candidate/deleted-cell + go-render? <- copy 1/true + reply-if deleted-newline? # wasn't a newline? render rest of line - curr:address:duplex-list <- next-duplex *before-cursor # refresh after remove-duplex above + curr:address:duplex-list:character <- next-duplex *before-cursor # refresh after remove-duplex above cursor-row:address:number <- get-address *editor, cursor-row:offset cursor-column:address:number <- get-address *editor, cursor-column:offset screen <- move-cursor screen, *cursor-row, *cursor-column @@ -325,7 +385,8 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } { # hit right margin? give up and let caller render at-right?:boolean <- greater-or-equal curr-column, screen-width - reply-if at-right?, editor/same-as-ingredient:0, screen/same-as-ingredient:1, 1/go-render, candidate/deleted-cell + go-render? <- copy 1/true + reply-if at-right? break-unless curr # newline? done. currc:character <- get *curr, value:offset @@ -338,7 +399,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } # we're guaranteed not to be at the right margin screen <- print-character screen, 32/space - reply editor/same-as-ingredient:0, screen/same-as-ingredient:1, 0/no-more-render, candidate/deleted-cell + go-render? <- copy 0/false ] # right arrow @@ -346,7 +407,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-moves-cursor-right-with-key [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -354,7 +415,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [0] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -370,7 +431,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } move-to-next-character?:boolean <- equal *k, 65514/right-arrow break-unless move-to-next-character? # if not at end of text - next-cursor:address:duplex-list <- next-duplex *before-cursor + next-cursor:address:duplex-list:character <- next-duplex *before-cursor break-unless next-cursor # scan to next character <move-cursor-begin> @@ -379,15 +440,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } screen <- move-cursor screen, *cursor-row, *cursor-column undo-coalesce-tag:number <- copy 2/right-arrow <move-cursor-end> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, go-render? + reply } ] -recipe move-cursor-coordinates-right [ +recipe move-cursor-coordinates-right editor:address:editor-data, screen-height:number -> editor:address:editor-data, go-render?:boolean [ local-scope - editor:address:editor-data <- next-ingredient - screen-height:number <- next-ingredient - before-cursor:address:duplex-list <- get *editor before-cursor:offset + load-ingredients + before-cursor:address:duplex-list:character <- get *editor before-cursor:offset cursor-row:address:number <- get-address *editor, cursor-row:offset cursor-column:address:number <- get-address *editor, cursor-column:offset left:number <- get *editor, left:offset @@ -400,10 +460,12 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } *cursor-row <- add *cursor-row, 1 *cursor-column <- copy left below-screen?:boolean <- greater-or-equal *cursor-row, screen-height # must be equal - reply-unless below-screen?, editor/same-as-ingredient:0, 0/no-more-render + go-render? <- copy 0/false + reply-unless below-screen? <scroll-down> *cursor-row <- subtract *cursor-row, 1 # bring back into screen range - reply editor/same-as-ingredient:0, 1/go-render + go-render? <- copy 1/true + reply } # if the line wraps, move cursor to start of next row { @@ -412,7 +474,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } at-wrap?:boolean <- equal *cursor-column, wrap-column break-unless at-wrap? # and if next character isn't newline - next:address:duplex-list <- next-duplex before-cursor + next:address:duplex-list:character <- next-duplex before-cursor break-unless next next-character:character <- get *next, value:offset newline?:boolean <- equal next-character, 10/newline @@ -423,18 +485,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } reply-unless below-screen?, editor/same-as-ingredient:0, 0/no-more-render <scroll-down> *cursor-row <- subtract *cursor-row, 1 # bring back into screen range - reply editor/same-as-ingredient:0, 1/go-render + go-render? <- copy 1/true + reply } # otherwise move cursor one character right *cursor-column <- add *cursor-column, 1 - reply editor/same-as-ingredient:0, 0/no-more-render + go-render? <- copy 0/false ] scenario editor-moves-cursor-to-next-line-with-right-arrow [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc d] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # type right-arrow a few times to get to start of second line @@ -445,7 +508,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press right-arrow # next line ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] check-trace-count-for-label 0, [print-character] # type something and ensure it goes where it should @@ -453,7 +516,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [0] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -469,7 +532,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 10/width, 5/height 1:address:array:character <- new [abc d] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 1/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 1/left, 10/right editor-render screen, 2:address:editor-data assume-console [ press right-arrow @@ -479,7 +542,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [0] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -493,7 +556,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-moves-cursor-to-next-wrapped-line-with-right-arrow [ assume-screen 10/width, 5/height 1:address:array:character <- new [abcdef] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -501,7 +564,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press right-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -523,7 +586,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 10/width, 5/height # line just barely wrapping 1:address:array:character <- new [abcde] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right editor-render screen, 2:address:editor-data $clear-trace # position cursor at last character before wrap and hit right-arrow @@ -532,7 +595,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press right-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -545,7 +608,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press right-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -559,7 +622,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-moves-cursor-to-next-wrapped-line-with-right-arrow-3 [ assume-screen 10/width, 5/height 1:address:array:character <- new [abcdef] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 1/left, 6/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 1/left, 6/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -567,7 +630,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press right-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -589,7 +652,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 10/width, 5/height 1:address:array:character <- new [abc d] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # move to end of line, press right-arrow, type a character @@ -599,7 +662,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [0] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # new character should be in next line screen-should-contain [ @@ -619,7 +682,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } scenario editor-moves-cursor-left-with-key [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -628,7 +691,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [0] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -645,14 +708,15 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } break-unless move-to-previous-character? trace 10, [app], [left arrow] # if not at start of text (before-cursor at § sentinel) - prev:address:duplex-list <- prev-duplex *before-cursor - reply-unless prev, screen/same-as-ingredient:0, editor/same-as-ingredient:1, 0/no-more-render + prev:address:duplex-list:character <- prev-duplex *before-cursor + go-render? <- copy 0/false + reply-unless prev <move-cursor-begin> editor, go-render? <- move-cursor-coordinates-left editor *before-cursor <- copy prev undo-coalesce-tag:number <- copy 1/left-arrow <move-cursor-end> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, go-render? + reply } ] @@ -661,7 +725,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # initialize editor with two lines 1:address:array:character <- new [abc d] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # position cursor at start of second line (so there's no previous newline) @@ -670,7 +734,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press left-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -687,7 +751,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [abc def g] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # position cursor further down (so there's a newline before the character at @@ -698,7 +762,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [0] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -715,7 +779,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [abc def g] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # position cursor at start of text, press left-arrow, then type a character @@ -725,7 +789,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [0] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # left-arrow should have had no effect screen-should-contain [ @@ -744,7 +808,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [abc d] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # position cursor right after empty line @@ -754,7 +818,7 @@ d] type [0] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -770,7 +834,7 @@ d] assume-screen 10/width, 5/height # initialize editor with text containing an empty line 1:address:array:character <- new [abcdef] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right editor-render screen, 2:address:editor-data $clear-trace screen-should-contain [ @@ -786,7 +850,7 @@ d] press left-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -805,7 +869,7 @@ d] assume-screen 10/width, 5/height 1:address:array:character <- new [abc def] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -813,7 +877,7 @@ d] press up-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -826,7 +890,7 @@ d] type [0] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -845,16 +909,16 @@ d] editor, go-render? <- move-to-previous-line editor undo-coalesce-tag:number <- copy 3/up-arrow <move-cursor-end> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, go-render? + reply } ] -recipe move-to-previous-line [ +recipe move-to-previous-line editor:address:editor-data -> editor:address:editor-data, go-render?:boolean [ local-scope - editor:address:editor-data <- next-ingredient + load-ingredients cursor-row:address:number <- get-address *editor, cursor-row:offset cursor-column:address:number <- get-address *editor, cursor-column:offset - before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset + before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset left:number <- get *editor, left:offset right:number <- get *editor, right:offset already-at-top?:boolean <- lesser-or-equal *cursor-row, 1/top @@ -864,21 +928,23 @@ d] # if not at newline, move to start of line (previous newline) # then scan back another line # if either step fails, give up without modifying cursor or coordinates - curr:address:duplex-list <- copy *before-cursor + curr:address:duplex-list:character <- copy *before-cursor { - old:address:duplex-list <- copy curr + old:address:duplex-list:character <- copy curr c2:character <- get *curr, value:offset at-newline?:boolean <- equal c2, 10/newline break-if at-newline? - curr:address:duplex-list <- before-previous-line curr, editor + curr:address:duplex-list:character <- before-previous-line curr, editor no-motion?:boolean <- equal curr, old - reply-if no-motion?, editor/same-as-ingredient:0, 0/no-more-render + go-render? <- copy 0/false + reply-if no-motion? } { old <- copy curr curr <- before-previous-line curr, editor no-motion?:boolean <- equal curr, old - reply-if no-motion?, editor/same-as-ingredient:0, 0/no-more-render + go-render? <- copy 0/false + reply-if no-motion? } *before-cursor <- copy curr *cursor-row <- subtract *cursor-row, 1 @@ -888,7 +954,7 @@ d] { done?:boolean <- greater-or-equal *cursor-column, target-column break-if done? - curr:address:duplex-list <- next-duplex *before-cursor + curr:address:duplex-list:character <- next-duplex *before-cursor break-unless curr currc:character <- get *curr, value:offset at-newline?:boolean <- equal currc, 10/newline @@ -898,13 +964,15 @@ d] *cursor-column <- add *cursor-column, 1 loop } - reply editor/same-as-ingredient:0, 0/no-more-render + go-render? <- copy 0/false + reply } { # if cursor already at top, scroll up break-unless already-at-top? <scroll-up> - reply editor/same-as-ingredient:0, 1/go-render + go-render? <- copy 1/true + reply } ] @@ -912,7 +980,7 @@ d] assume-screen 10/width, 5/height 1:address:array:character <- new [ab def] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -920,7 +988,7 @@ d] press up-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -933,7 +1001,7 @@ d] type [0] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -948,7 +1016,7 @@ d] assume-screen 10/width, 5/height 1:address:array:character <- new [ def] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -956,7 +1024,7 @@ def] press up-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -969,7 +1037,7 @@ def] type [0] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -986,7 +1054,7 @@ def] 1:address:array:character <- new [abc def ghi] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # click on the third line and hit up-arrow, so you end up just after a newline @@ -995,7 +1063,7 @@ def] press up-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1008,7 +1076,7 @@ def] type [0] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -1025,7 +1093,7 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [abc def] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # cursor starts out at (1, 0) @@ -1033,7 +1101,7 @@ def] press down-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1047,7 +1115,7 @@ def] type [0] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -1066,17 +1134,16 @@ def] editor, go-render? <- move-to-next-line editor, screen-height undo-coalesce-tag:number <- copy 4/down-arrow <move-cursor-end> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, go-render? + reply } ] -recipe move-to-next-line [ +recipe move-to-next-line editor:address:editor-data, screen-height:number -> editor:address:editor-data, go-render?:boolean [ local-scope - editor:address:editor-data <- next-ingredient - screen-height:number <- next-ingredient + load-ingredients cursor-row:address:number <- get-address *editor, cursor-row:offset cursor-column:address:number <- get-address *editor, cursor-column:offset - before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset + before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset left:number <- get *editor, left:offset right:number <- get *editor, right:offset last-line:number <- subtract screen-height, 1 @@ -1086,7 +1153,7 @@ def] break-if already-at-bottom? # scan to start of next line, then to right column or until end of line max:number <- subtract right, left - next-line:address:duplex-list <- before-start-of-next-line *before-cursor, max + next-line:address:duplex-list:character <- before-start-of-next-line *before-cursor, max { # already at end of buffer? try to scroll up (so we can see more # warnings or sandboxes below) @@ -1094,7 +1161,8 @@ def] break-unless no-motion? scroll?:boolean <- greater-than *cursor-row, 1 break-if scroll?, +try-to-scroll:label - reply editor/same-as-ingredient:0, 0/no-more-render + go-render? <- copy 0/false + reply } *cursor-row <- add *cursor-row, 1 *before-cursor <- copy next-line @@ -1103,7 +1171,7 @@ def] { done?:boolean <- greater-or-equal *cursor-column, target-column break-if done? - curr:address:duplex-list <- next-duplex *before-cursor + curr:address:duplex-list:character <- next-duplex *before-cursor break-unless curr currc:character <- get *curr, value:offset at-newline?:boolean <- equal currc, 10/newline @@ -1113,18 +1181,19 @@ def] *cursor-column <- add *cursor-column, 1 loop } - reply editor/same-as-ingredient:0, 0/no-more-render + go-render? <- copy 0/false + reply } +try-to-scroll <scroll-down> - reply editor/same-as-ingredient:0, 1/go-render + go-render? <- copy 1/true ] scenario editor-adjusts-column-at-next-line [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc de] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace assume-console [ @@ -1132,7 +1201,7 @@ def] press down-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1145,7 +1214,7 @@ def] type [0] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -1156,78 +1225,13 @@ def] ] ] -scenario editor-scrolls-at-end-on-down-arrow [ - assume-screen 10/width, 5/height - 1:address:array:character <- new [abc -de] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right - editor-render screen, 2:address:editor-data - $clear-trace - # try to move down past end of text - assume-console [ - left-click 2, 0 - press down-arrow - ] - run [ - editor-event-loop screen:address, console:address, 2:address:editor-data - 3:number <- get *2:address:editor-data, cursor-row:offset - 4:number <- get *2:address:editor-data, cursor-column:offset - ] - # screen should scroll, moving cursor to end of text - memory-should-contain [ - 3 <- 1 - 4 <- 2 - ] - assume-console [ - type [0] - ] - run [ - editor-event-loop screen:address, console:address, 2:address:editor-data - ] - screen-should-contain [ - . . - .de0 . - .┈┈┈┈┈┈┈┈┈┈. - . . - ] - # try to move down again - $clear-trace - assume-console [ - left-click 2, 0 - press down-arrow - ] - run [ - editor-event-loop screen:address, console:address, 2:address:editor-data - 3:number <- get *2:address:editor-data, cursor-row:offset - 4:number <- get *2:address:editor-data, cursor-column:offset - ] - # screen stops scrolling because cursor is already at top - memory-should-contain [ - 3 <- 1 - 4 <- 3 - ] - check-trace-count-for-label 0, [print-character] - assume-console [ - type [1] - ] - run [ - editor-event-loop screen:address, console:address, 2:address:editor-data - ] - screen-should-contain [ - . . - .de01 . - .┈┈┈┈┈┈┈┈┈┈. - . . - ] -] - # ctrl-a/home - move cursor to start of line scenario editor-moves-to-start-of-line-with-ctrl-a [ assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # start on second line, press ctrl-a @@ -1236,7 +1240,7 @@ def] press ctrl-a ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 4:number <- get *2:address:editor-data, cursor-row:offset 5:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1256,7 +1260,8 @@ def] move-to-start-of-line editor undo-coalesce-tag:number <- copy 0/never <move-cursor-end> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 0/no-more-render + go-render? <- copy 0/false + reply } ] @@ -1268,20 +1273,21 @@ def] move-to-start-of-line editor undo-coalesce-tag:number <- copy 0/never <move-cursor-end> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 0/no-more-render + go-render? <- copy 0/false + reply } ] -recipe move-to-start-of-line [ +recipe move-to-start-of-line editor:address:editor-data [ local-scope - editor:address:editor-data <- next-ingredient + load-ingredients # update cursor column left:number <- get *editor, left:offset cursor-column:address:number <- get-address *editor, cursor-column:offset *cursor-column <- copy left # update before-cursor - before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset - init:address:duplex-list <- get *editor, data:offset + before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset + init:address:duplex-list:character <- get *editor, data:offset # while not at start of line, move { at-start-of-text?:boolean <- equal *before-cursor, init @@ -1299,7 +1305,7 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # start on first line (no newline before), press ctrl-a @@ -1308,7 +1314,7 @@ def] press ctrl-a ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 4:number <- get *2:address:editor-data, cursor-row:offset 5:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1324,7 +1330,7 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right $clear-trace # start on second line, press 'home' assume-console [ @@ -1332,7 +1338,7 @@ def] press home ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1348,7 +1354,7 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # start on first line (no newline before), press 'home' @@ -1357,7 +1363,7 @@ def] press home ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1375,7 +1381,7 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # start on first line, press ctrl-e @@ -1384,7 +1390,7 @@ def] press ctrl-e ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 4:number <- get *2:address:editor-data, cursor-row:offset 5:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1399,7 +1405,7 @@ def] type [z] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 4:number <- get *2:address:editor-data, cursor-row:offset 5:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1425,7 +1431,8 @@ def] move-to-end-of-line editor undo-coalesce-tag:number <- copy 0/never <move-cursor-end> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 0/no-more-render + go-render? <- copy 0/false + reply } ] @@ -1437,18 +1444,19 @@ def] move-to-end-of-line editor undo-coalesce-tag:number <- copy 0/never <move-cursor-end> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 0/no-more-render + go-render? <- copy 0/false + reply } ] -recipe move-to-end-of-line [ +recipe move-to-end-of-line editor:address:editor-data [ local-scope - editor:address:editor-data <- next-ingredient - before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset + load-ingredients + before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset cursor-column:address:number <- get-address *editor, cursor-column:offset # while not at start of line, move { - next:address:duplex-list <- next-duplex *before-cursor + next:address:duplex-list:character <- next-duplex *before-cursor break-unless next # end of text nextc:character <- get *next, value:offset at-end-of-line?:boolean <- equal nextc, 10/newline @@ -1463,7 +1471,7 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # start on second line (no newline after), press ctrl-e @@ -1472,7 +1480,7 @@ def] press ctrl-e ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 4:number <- get *2:address:editor-data, cursor-row:offset 5:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1488,7 +1496,7 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # start on first line, press 'end' @@ -1497,7 +1505,7 @@ def] press end ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1513,7 +1521,7 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data $clear-trace # start on second line (no newline after), press 'end' @@ -1522,7 +1530,7 @@ def] press end ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1540,14 +1548,14 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right # start on second line, press ctrl-u assume-console [ left-click 2, 2 press ctrl-u ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # cursor deletes to start of line screen-should-contain [ @@ -1564,20 +1572,21 @@ def] delete-to-start-of-line?:boolean <- equal *c, 21/ctrl-u break-unless delete-to-start-of-line? <delete-to-start-of-line-begin> - deleted-cells:address:duplex-list <- delete-to-start-of-line editor + deleted-cells:address:duplex-list:character <- delete-to-start-of-line editor <delete-to-start-of-line-end> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 1/go-render + go-render? <- copy 1/true + reply } ] -recipe delete-to-start-of-line [ +recipe delete-to-start-of-line editor:address:editor-data -> result:address:duplex-list:character [ local-scope - editor:address:editor-data <- next-ingredient + load-ingredients # compute range to delete - init:address:duplex-list <- get *editor, data:offset - before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset - start:address:duplex-list <- copy *before-cursor - end:address:duplex-list <- next-duplex *before-cursor + init:address:duplex-list:character <- get *editor, data:offset + before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset + start:address:duplex-list:character <- copy *before-cursor + end:address:duplex-list:character <- next-duplex *before-cursor { at-start-of-text?:boolean <- equal start, init break-if at-start-of-text? @@ -1589,28 +1598,27 @@ def] loop } # snip it out - result:address:duplex-list <- next-duplex start + result:address:duplex-list:character <- next-duplex start remove-duplex-between start, end # adjust cursor - *before-cursor <- prev-duplex end + *before-cursor <- copy start left:number <- get *editor, left:offset cursor-column:address:number <- get-address *editor, cursor-column:offset *cursor-column <- copy left - reply result ] scenario editor-deletes-to-start-of-line-with-ctrl-u-2 [ assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right # start on first line (no newline before), press ctrl-u assume-console [ left-click 1, 2 press ctrl-u ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # cursor deletes to start of line screen-should-contain [ @@ -1626,14 +1634,14 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right # start past end of line, press ctrl-u assume-console [ left-click 1, 3 press ctrl-u ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # cursor deletes to start of line screen-should-contain [ @@ -1649,14 +1657,14 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right # start past end of final line, press ctrl-u assume-console [ left-click 2, 3 press ctrl-u ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # cursor deletes to start of line screen-should-contain [ @@ -1674,14 +1682,14 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right # start on first line, press ctrl-k assume-console [ left-click 1, 1 press ctrl-k ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # cursor deletes to end of line screen-should-contain [ @@ -1698,18 +1706,19 @@ def] delete-to-end-of-line?:boolean <- equal *c, 11/ctrl-k break-unless delete-to-end-of-line? <delete-to-end-of-line-begin> - deleted-cells:address:duplex-list <- delete-to-end-of-line editor + deleted-cells:address:duplex-list:character <- delete-to-end-of-line editor <delete-to-end-of-line-end> - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 1/go-render + go-render? <- copy 1/true + reply } ] -recipe delete-to-end-of-line [ +recipe delete-to-end-of-line editor:address:editor-data -> result:address:duplex-list:character [ local-scope - editor:address:editor-data <- next-ingredient + load-ingredients # compute range to delete - start:address:duplex-list <- get *editor, before-cursor:offset - end:address:duplex-list <- next-duplex start + start:address:duplex-list:character <- get *editor, before-cursor:offset + end:address:duplex-list:character <- next-duplex start { at-end-of-text?:boolean <- equal end, 0/null break-if at-end-of-text? @@ -1720,23 +1729,22 @@ def] loop } # snip it out - result:address:duplex-list <- next-duplex start + result <- next-duplex start remove-duplex-between start, end - reply result ] scenario editor-deletes-to-end-of-line-with-ctrl-k-2 [ assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right # start on second line (no newline after), press ctrl-k assume-console [ left-click 2, 1 press ctrl-k ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # cursor deletes to end of line screen-should-contain [ @@ -1752,14 +1760,14 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right # start at end of line assume-console [ left-click 1, 2 press ctrl-k ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # cursor deletes just last character screen-should-contain [ @@ -1775,14 +1783,14 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right # start past end of line assume-console [ left-click 1, 3 press ctrl-k ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # cursor deletes nothing screen-should-contain [ @@ -1798,14 +1806,14 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right # start at end of text assume-console [ left-click 2, 2 press ctrl-k ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # cursor deletes just the final character screen-should-contain [ @@ -1821,14 +1829,14 @@ def] assume-screen 10/width, 5/height 1:address:array:character <- new [123 456] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right # start past end of text assume-console [ left-click 2, 3 press ctrl-k ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # cursor deletes nothing screen-should-contain [ @@ -1850,7 +1858,7 @@ def] b c d] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right screen-should-contain [ . . .a . @@ -1863,7 +1871,7 @@ def] press down-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen slides by one line screen-should-contain [ @@ -1876,29 +1884,25 @@ def] after <scroll-down> [ trace 10, [app], [scroll down] - top-of-screen:address:address:duplex-list <- get-address *editor, top-of-screen:offset + top-of-screen:address:address:duplex-list:character <- get-address *editor, top-of-screen:offset left:number <- get *editor, left:offset right:number <- get *editor, right:offset max:number <- subtract right, left - old-top:address:duplex-list <- copy *top-of-screen + old-top:address:duplex-list:character <- copy *top-of-screen *top-of-screen <- before-start-of-next-line *top-of-screen, max no-movement?:boolean <- equal old-top, *top-of-screen - # Hack: this reply doesn't match one of the locations of <scroll-down>, - # directly within insert-at-cursor. However, I'm unable to trigger the - # error.. If necessary create a duplicate copy of <scroll-down> with the - # right 'reply-if'. - reply-if no-movement?, editor/same-as-ingredient:0, 0/no-more-render + go-render? <- copy 0/false + reply-if no-movement? ] # takes a pointer into the doubly-linked list, scans ahead at most 'max' # positions until the next newline # beware: never return null pointer. -recipe before-start-of-next-line [ +recipe before-start-of-next-line original:address:duplex-list:character, max:number -> curr:address:duplex-list:character [ local-scope - original:address:duplex-list <- next-ingredient - max:number <- next-ingredient + load-ingredients count:number <- copy 0 - curr:address:duplex-list <- copy original + curr:address:duplex-list:character <- copy original # skip the initial newline if it exists { c:character <- get *curr, value:offset @@ -1931,7 +1935,7 @@ def] g h i] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right screen-should-contain [ . . .abcd↩ . @@ -1944,7 +1948,7 @@ def] press down-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows partial wrapped line screen-should-contain [ @@ -1963,14 +1967,14 @@ def] k l m] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right # position cursor at last line, then try to move further down assume-console [ left-click 3, 0 press down-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows partial wrapped line containing a wrap icon screen-should-contain [ @@ -1984,7 +1988,7 @@ def] press down-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows partial wrapped line screen-should-contain [ @@ -2002,14 +2006,14 @@ def] 1:address:array:character <- new [a b cdef] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right # position cursor at end, type a character assume-console [ left-click 3, 4 type [g] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -2032,14 +2036,14 @@ def] 1:address:array:character <- new [a b c] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right assume-console [ left-click 3, 4 type [ ] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -2063,14 +2067,14 @@ def] 1:address:array:character <- new [a b cdefgh] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right # position cursor at end of screen and try to move right assume-console [ left-click 3, 3 press right-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -2095,14 +2099,14 @@ def] b c d] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right # position cursor at end of screen and try to move right assume-console [ left-click 3, 3 press right-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -2119,6 +2123,71 @@ def] ] ] +scenario editor-scrolls-at-end-on-down-arrow [ + assume-screen 10/width, 5/height + 1:address:array:character <- new [abc +de] + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right + editor-render screen, 2:address:editor-data + $clear-trace + # try to move down past end of text + assume-console [ + left-click 2, 0 + press down-arrow + ] + run [ + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data + 3:number <- get *2:address:editor-data, cursor-row:offset + 4:number <- get *2:address:editor-data, cursor-column:offset + ] + # screen should scroll, moving cursor to end of text + memory-should-contain [ + 3 <- 1 + 4 <- 2 + ] + assume-console [ + type [0] + ] + run [ + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data + ] + screen-should-contain [ + . . + .de0 . + .┈┈┈┈┈┈┈┈┈┈. + . . + ] + # try to move down again + $clear-trace + assume-console [ + left-click 2, 0 + press down-arrow + ] + run [ + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data + 3:number <- get *2:address:editor-data, cursor-row:offset + 4:number <- get *2:address:editor-data, cursor-column:offset + ] + # screen stops scrolling because cursor is already at top + memory-should-contain [ + 3 <- 1 + 4 <- 3 + ] + check-trace-count-for-label 0, [print-character] + assume-console [ + type [1] + ] + run [ + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data + ] + screen-should-contain [ + . . + .de01 . + .┈┈┈┈┈┈┈┈┈┈. + . . + ] +] + scenario editor-combines-page-and-line-scroll [ # screen has 1 line for menu + 3 lines assume-screen 10/width, 4/height @@ -2130,7 +2199,7 @@ def] e f g] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right # scroll down one page and one line assume-console [ press page-down @@ -2138,7 +2207,7 @@ def] press down-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen scrolls down 3 lines screen-should-contain [ @@ -2159,7 +2228,7 @@ def] b c d] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right screen-should-contain [ . . .a . @@ -2172,7 +2241,7 @@ def] press up-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen slides by one line screen-should-contain [ @@ -2185,33 +2254,33 @@ def] after <scroll-up> [ trace 10, [app], [scroll up] - top-of-screen:address:address:duplex-list <- get-address *editor, top-of-screen:offset - old-top:address:duplex-list <- copy *top-of-screen + top-of-screen:address:address:duplex-list:character <- get-address *editor, top-of-screen:offset + old-top:address:duplex-list:character <- copy *top-of-screen *top-of-screen <- before-previous-line *top-of-screen, editor no-movement?:boolean <- equal old-top, *top-of-screen - reply-if no-movement?, editor/same-as-ingredient:0, 0/no-more-render + go-render? <- copy 0/false + reply-if no-movement? ] # takes a pointer into the doubly-linked list, scans back to before start of # previous *wrapped* line # beware: never return null pointer -recipe before-previous-line [ +recipe before-previous-line curr:address:duplex-list:character, editor:address:editor-data -> curr:address:duplex-list:character [ local-scope - curr:address:duplex-list <- next-ingredient + load-ingredients c:character <- get *curr, value:offset # compute max, number of characters to skip # 1 + len%(width-1) # except rotate second term to vary from 1 to width-1 rather than 0 to width-2 - editor:address:editor-data <- next-ingredient left:number <- get *editor, left:offset right:number <- get *editor, right:offset max-line-length:number <- subtract right, left, -1/exclusive-right, 1/wrap-icon - sentinel:address:duplex-list <- get *editor, data:offset + sentinel:address:duplex-list:character <- get *editor, data:offset len:number <- previous-line-length curr, sentinel { break-if len # empty line; just skip this newline - prev:address:duplex-list <- prev-duplex curr + prev:address:duplex-list:character <- prev-duplex curr reply-unless prev, curr reply prev } @@ -2227,7 +2296,7 @@ def] { done?:boolean <- greater-or-equal count, max break-if done? - prev:address:duplex-list <- prev-duplex curr + prev:address:duplex-list:character <- prev-duplex curr break-unless prev curr <- copy prev count <- add count, 1 @@ -2245,7 +2314,7 @@ def] g h i] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right screen-should-contain [ . . .abcd↩ . @@ -2257,7 +2326,7 @@ def] press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -2270,7 +2339,7 @@ def] press up-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows partial wrapped line screen-should-contain [ @@ -2289,13 +2358,13 @@ def] k l m] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right # position cursor at top of second page assume-console [ press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -2309,7 +2378,7 @@ def] press up-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows partial wrapped line screen-should-contain [ @@ -2324,7 +2393,7 @@ def] press up-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows partial wrapped line screen-should-contain [ @@ -2339,7 +2408,7 @@ def] press up-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows partial wrapped line screen-should-contain [ @@ -2362,7 +2431,7 @@ def] g h i] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 6/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 6/right screen-should-contain [ . . .abcde↩ . @@ -2374,7 +2443,7 @@ def] press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -2387,7 +2456,7 @@ def] press up-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows partial wrapped line screen-should-contain [ @@ -2408,12 +2477,12 @@ def] c d e] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 6/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 6/right assume-console [ press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -2425,7 +2494,7 @@ e] press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -2437,7 +2506,7 @@ e] press page-up ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -2456,13 +2525,13 @@ e] c d e] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right # position cursor at top of second page assume-console [ press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -2475,7 +2544,7 @@ e] press left-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -2500,7 +2569,7 @@ e] b c d] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right screen-should-contain [ . . .a . @@ -2515,7 +2584,7 @@ e] press up-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen slides by one line screen-should-contain [ @@ -2529,7 +2598,7 @@ e] press up-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen remains unchanged screen-should-contain [ @@ -2548,7 +2617,7 @@ e] b c d] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right screen-should-contain [ . . .a . @@ -2560,7 +2629,7 @@ e] press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows next page screen-should-contain [ @@ -2575,15 +2644,15 @@ e] { page-down?:boolean <- equal *c, 6/ctrl-f break-unless page-down? - top-of-screen:address:address:duplex-list <- get-address *editor, top-of-screen:offset - old-top:address:duplex-list <- copy *top-of-screen + top-of-screen:address:address:duplex-list:character <- get-address *editor, top-of-screen:offset + old-top:address:duplex-list:character <- copy *top-of-screen <move-cursor-begin> page-down editor undo-coalesce-tag:number <- copy 0/never <move-cursor-end> no-movement?:boolean <- equal *top-of-screen, old-top - reply-if no-movement?, screen/same-as-ingredient:0, editor/same-as-ingredient:1, 0/no-more-render - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 1/go-render + go-render? <- not no-movement? + reply } ] @@ -2591,28 +2660,28 @@ e] { page-down?:boolean <- equal *k, 65518/page-down break-unless page-down? - top-of-screen:address:address:duplex-list <- get-address *editor, top-of-screen:offset - old-top:address:duplex-list <- copy *top-of-screen + top-of-screen:address:address:duplex-list:character <- get-address *editor, top-of-screen:offset + old-top:address:duplex-list:character <- copy *top-of-screen <move-cursor-begin> page-down editor undo-coalesce-tag:number <- copy 0/never <move-cursor-end> no-movement?:boolean <- equal *top-of-screen, old-top - reply-if no-movement?, screen/same-as-ingredient:0, editor/same-as-ingredient:1, 0/no-more-render - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 1/go-render + go-render? <- not no-movement? + reply } ] # page-down skips entire wrapped lines, so it can't scroll past lines # taking up the entire screen -recipe page-down [ +recipe page-down editor:address:editor-data -> editor:address:editor-data [ local-scope - editor:address:editor-data <- next-ingredient + load-ingredients # if editor contents don't overflow screen, do nothing - bottom-of-screen:address:duplex-list <- get *editor, bottom-of-screen:offset - reply-unless bottom-of-screen, editor/same-as-ingredient:0 + bottom-of-screen:address:duplex-list:character <- get *editor, bottom-of-screen:offset + reply-unless bottom-of-screen # if not, position cursor at final character - before-cursor:address:address:duplex-list <- get-address *editor, before-cursor:offset + before-cursor:address:address:duplex-list:character <- get-address *editor, before-cursor:offset *before-cursor <- prev-duplex bottom-of-screen # keep one line in common with previous page { @@ -2623,16 +2692,15 @@ e] } # move cursor and top-of-screen to start of that line move-to-start-of-line editor - top-of-screen:address:address:duplex-list <- get-address *editor, top-of-screen:offset + top-of-screen:address:address:duplex-list:character <- get-address *editor, top-of-screen:offset *top-of-screen <- copy *before-cursor - reply editor/same-as-ingredient:0 ] scenario editor-does-not-scroll-past-end [ assume-screen 10/width, 4/height 1:address:array:character <- new [a b] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data screen-should-contain [ . . @@ -2645,7 +2713,7 @@ e] press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen remains unmodified screen-should-contain [ @@ -2664,7 +2732,7 @@ e] b cdefgh] # editor screen triggers wrap of last line - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 4/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 4/right # some part of last line is not displayed screen-should-contain [ . . @@ -2677,7 +2745,7 @@ e] press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows entire wrapped line screen-should-contain [ @@ -2695,7 +2763,7 @@ e] # and still has something left over 1:address:array:character <- new [a bcdefgh] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 4/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 4/right # some part of last line is not displayed screen-should-contain [ . . @@ -2708,7 +2776,7 @@ e] press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows entire wrapped line screen-should-contain [ @@ -2727,7 +2795,7 @@ e] b c d] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right screen-should-contain [ . . .a . @@ -2739,7 +2807,7 @@ e] press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows next page screen-should-contain [ @@ -2753,7 +2821,7 @@ e] press page-up ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows original page again screen-should-contain [ @@ -2768,15 +2836,15 @@ e] { page-up?:boolean <- equal *c, 2/ctrl-b break-unless page-up? - top-of-screen:address:address:duplex-list <- get-address *editor, top-of-screen:offset - old-top:address:duplex-list <- copy *top-of-screen + top-of-screen:address:address:duplex-list:character <- get-address *editor, top-of-screen:offset + old-top:address:duplex-list:character <- copy *top-of-screen <move-cursor-begin> editor <- page-up editor, screen-height undo-coalesce-tag:number <- copy 0/never <move-cursor-end> no-movement?:boolean <- equal *top-of-screen, old-top - reply-if no-movement?, screen/same-as-ingredient:0, editor/same-as-ingredient:1, 0/no-more-render - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 1/go-render + go-render? <- not no-movement? + reply } ] @@ -2784,36 +2852,34 @@ e] { page-up?:boolean <- equal *k, 65519/page-up break-unless page-up? - top-of-screen:address:address:duplex-list <- get-address *editor, top-of-screen:offset - old-top:address:duplex-list <- copy *top-of-screen + top-of-screen:address:address:duplex-list:character <- get-address *editor, top-of-screen:offset + old-top:address:duplex-list:character <- copy *top-of-screen <move-cursor-begin> editor <- page-up editor, screen-height undo-coalesce-tag:number <- copy 0/never <move-cursor-end> no-movement?:boolean <- equal *top-of-screen, old-top # don't bother re-rendering if nothing changed. todo: test this - reply-if no-movement?, screen/same-as-ingredient:0, editor/same-as-ingredient:1, 0/no-more-render - reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 1/go-render + go-render? <- not no-movement? + reply } ] -recipe page-up [ +recipe page-up editor:address:editor-data, screen-height:number -> editor:address:editor-data [ local-scope - editor:address:editor-data <- next-ingredient - screen-height:number <- next-ingredient + load-ingredients max:number <- subtract screen-height, 1/menu-bar, 1/overlapping-line count:number <- copy 0 - top-of-screen:address:address:duplex-list <- get-address *editor, top-of-screen:offset + top-of-screen:address:address:duplex-list:character <- get-address *editor, top-of-screen:offset { done?:boolean <- greater-or-equal count, max break-if done? - prev:address:duplex-list <- before-previous-line *top-of-screen, editor + prev:address:duplex-list:character <- before-previous-line *top-of-screen, editor break-unless prev *top-of-screen <- copy prev count <- add count, 1 loop } - reply editor/same-as-ingredient:0 ] scenario editor-can-scroll-up-multiple-pages [ @@ -2828,7 +2894,7 @@ e] f g h] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right screen-should-contain [ . . .a . @@ -2841,7 +2907,7 @@ e] press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows third page screen-should-contain [ @@ -2855,7 +2921,7 @@ e] press page-up ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows second page screen-should-contain [ @@ -2869,7 +2935,7 @@ e] press page-up ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows original page again screen-should-contain [ @@ -2895,7 +2961,7 @@ e] n o] # editor screen triggers wrap of last line - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 4/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 4/right # some part of last line is not displayed screen-should-contain [ . . @@ -2912,7 +2978,7 @@ e] press down-arrow ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows entire wrapped line screen-should-contain [ @@ -2928,7 +2994,7 @@ e] press page-up ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen resets screen-should-contain [ @@ -2948,7 +3014,7 @@ e] # and still has something left over 1:address:array:character <- new [a bcdefgh] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 4/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 4/right # some part of last line is not displayed screen-should-contain [ . . @@ -2961,7 +3027,7 @@ e] press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen shows entire wrapped line screen-should-contain [ @@ -2975,7 +3041,7 @@ e] press page-up ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # screen resets screen-should-contain [ @@ -2998,7 +3064,7 @@ e] gxx hxx ] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 4/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 4/right screen-should-contain [ . . .axx . @@ -3009,7 +3075,7 @@ e] press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -3021,7 +3087,7 @@ e] press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -3034,7 +3100,7 @@ e] press page-up ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -3056,7 +3122,7 @@ exy fxy gxy ] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 4/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 4/right screen-should-contain [ . . .axy . @@ -3067,7 +3133,7 @@ gxy press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -3079,7 +3145,7 @@ gxy press page-down ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -3092,7 +3158,7 @@ gxy press page-up ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . diff --git a/html/edit/004-programming-environment.mu.html b/html/edit/004-programming-environment.mu.html index 406c19a9..172b1dcc 100644 --- a/html/edit/004-programming-environment.mu.html +++ b/html/edit/004-programming-environment.mu.html @@ -13,16 +13,16 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } -.muData { color: #ffff00; } .Special { color: #ff6060; } -.muScenario { color: #00af00; } +.muData { color: #ffff00; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .SalientComment { color: #00ffff; } .CommentedCode { color: #6c6c6c; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } +.muScenario { color: #00af00; } --> </style> @@ -46,7 +46,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } initial-sandbox:address:array:character <- new [] hide-screen 0/screen env:address:programming-environment-data <- new-programming-environment 0/screen, initial-recipe, initial-sandbox - env <- restore-sandboxes env render-all 0/screen, env event-loop 0/screen, 0/console, env # never gets here @@ -58,15 +57,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } sandbox-in-focus?:boolean # false => cursor in recipes; true => cursor in current-sandbox ] -recipe new-programming-environment [ +recipe new-programming-environment screen:address:screen, initial-recipe-contents:address:array:character, initial-sandbox-contents:address:array:character -> result:address:programming-environment-data [ local-scope - screen:address <- next-ingredient - initial-recipe-contents:address:array:character <- next-ingredient - initial-sandbox-contents:address:array:character <- next-ingredient + load-ingredients width:number <- screen-width screen height:number <- screen-height screen # top menu - result:address:programming-environment-data <- new programming-environment-data:type + result <- new programming-environment-data:type draw-horizontal screen, 0, 0/left, width, 32/space, 0/black, 238/grey button-start:number <- subtract width, 20 button-on-screen?:boolean <- greater-or-equal button-start, 0 @@ -84,15 +81,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } new-left:number <- add divider, 1 current-sandbox:address:address:editor-data <- get-address *result, current-sandbox:offset *current-sandbox <- new-editor initial-sandbox-contents, screen, new-left, width/right - +programming-environment-initialization - reply result ] -recipe event-loop [ +recipe event-loop screen:address:screen, console:address:console, env:address:programming-environment-data [ local-scope - screen:address <- next-ingredient - console:address <- next-ingredient - env:address:programming-environment-data <- next-ingredient + load-ingredients recipes:address:editor-data <- get *env, recipes:offset current-sandbox:address:editor-data <- get *env, current-sandbox:offset sandbox-in-focus?:address:boolean <- get-address *env, sandbox-in-focus?:offset @@ -222,10 +215,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } ] -recipe resize [ +recipe resize screen:address:screen, env:address:programming-environment-data -> env:address:programming-environment-data [ local-scope - screen:address <- next-ingredient - env:address:programming-environment-data <- next-ingredient + load-ingredients clear-screen screen # update screen dimensions width:number <- screen-width screen divider:number, _ <- divide-with-remainder width, 2 @@ -249,16 +241,15 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } *cursor-row <- copy 1 cursor-column:address:number <- get-address *current-sandbox, cursor-column:offset *cursor-column <- copy *left - reply env/same-as-ingredient:1 ] scenario point-at-multiple-editors [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 30/width, 5/height # initialize both halves of screen 1:address:array:character <- new [abc] 2:address:array:character <- new [def] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character # focus on both sides assume-console [ left-click 1, 1 @@ -266,7 +257,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] # check cursor column in each run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data 4:address:editor-data <- get *3:address:programming-environment-data, recipes:offset 5:number <- get *4:address:editor-data, cursor-column:offset 6:address:editor-data <- get *3:address:programming-environment-data, current-sandbox:offset @@ -279,12 +270,12 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] scenario edit-multiple-editors [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 30/width, 5/height # initialize both halves of screen 1:address:array:character <- new [abc] 2:address:array:character <- new [def] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character render-all screen, 3:address:programming-environment-data # type one letter in each of them assume-console [ @@ -294,7 +285,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [1] ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data 4:address:editor-data <- get *3:address:programming-environment-data, recipes:offset 5:number <- get *4:address:editor-data, cursor-column:offset 6:address:editor-data <- get *3:address:programming-environment-data, current-sandbox:offset @@ -312,7 +303,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] # show the cursor at the right window run [ - print-character screen:address, 9251/␣/cursor + print-character screen:address:screen, 9251/␣/cursor ] screen-should-contain [ . run (F4) . @@ -323,12 +314,12 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] scenario multiple-editors-cover-only-their-own-areas [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 60/width, 10/height run [ 1:address:array:character <- new [abc] 2:address:array:character <- new [def] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character render-all screen, 3:address:programming-environment-data ] # divider isn't messed up @@ -342,17 +333,17 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] scenario editor-in-focus-keeps-cursor [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 30/width, 5/height 1:address:array:character <- new [abc] 2:address:array:character <- new [def] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character render-all screen, 3:address:programming-environment-data # initialize programming environment and highlight cursor assume-console [] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data - print-character screen:address, 9251/␣/cursor + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data + print-character screen:address:screen, 9251/␣/cursor ] # is cursor at the right place? screen-should-contain [ @@ -366,8 +357,8 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [z] ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data - print-character screen:address, 9251/␣/cursor + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data + print-character screen:address:screen, 9251/␣/cursor ] # cursor should still be right screen-should-contain [ @@ -379,13 +370,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] scenario backspace-in-sandbox-editor-joins-lines [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 30/width, 5/height # initialize sandbox side with two lines 1:address:array:character <- new [] 2:address:array:character <- new [abc def] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character render-all screen, 3:address:programming-environment-data screen-should-contain [ . run (F4) . @@ -400,8 +391,8 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press backspace ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data - print-character screen:address, 9251/␣/cursor + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data + print-character screen:address:screen, 9251/␣/cursor ] # cursor moves to end of old line screen-should-contain [ @@ -412,10 +403,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] ] -recipe render-all [ +recipe render-all screen:address:screen, env:address:programming-environment-data -> screen:address:screen [ local-scope - screen:address <- next-ingredient - env:address:programming-environment-data <- next-ingredient + load-ingredients trace 10, [app], [render all] hide-screen screen # top menu @@ -444,13 +434,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } screen <- update-cursor screen, recipes, current-sandbox, sandbox-in-focus? # show-screen screen - reply screen/same-as-ingredient:0 ] -recipe render-recipes [ +recipe render-recipes screen:address:screen, env:address:programming-environment-data -> screen:address:screen [ local-scope - screen:address <- next-ingredient - env:address:programming-environment-data <- next-ingredient + load-ingredients trace 11, [app], [render recipes] recipes:address:editor-data <- get *env, recipes:offset # render recipes @@ -464,33 +452,27 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } draw-horizontal screen, row, left, right, 9480/horizontal-dotted row <- add row, 1 clear-screen-from screen, row, left, left, right - reply screen/same-as-ingredient:0 ] # replaced in a later layer -recipe render-sandbox-side [ +recipe render-sandbox-side screen:address:screen, env:address:programming-environment-data -> screen:address:screen [ local-scope - screen:address <- next-ingredient - env:address:programming-environment-data <- next-ingredient + load-ingredients current-sandbox:address:editor-data <- get *env, current-sandbox:offset left:number <- get *current-sandbox, left:offset right:number <- get *current-sandbox, right:offset row:number, column:number, screen, current-sandbox <- render screen, current-sandbox clear-line-delimited screen, column, right row <- add row, 1 - # draw solid line after recipes (you'll see why in later layers) + # draw solid line after code (you'll see why in later layers) draw-horizontal screen, row, left, right, 9473/horizontal row <- add row, 1 clear-screen-from screen, row, left, left, right - reply screen/same-as-ingredient:0 ] -recipe update-cursor [ +recipe update-cursor screen:address:screen, recipes:address:editor-data, current-sandbox:address:editor-data, sandbox-in-focus?:boolean -> screen:address:screen [ local-scope - screen:address <- next-ingredient - recipes:address:editor-data <- next-ingredient - current-sandbox:address:editor-data <- next-ingredient - sandbox-in-focus?:boolean <- next-ingredient + load-ingredients { break-if sandbox-in-focus? cursor-row:number <- get *recipes, cursor-row:offset @@ -502,21 +484,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } cursor-column:number <- get *current-sandbox, cursor-column:offset } screen <- move-cursor screen, cursor-row, cursor-column - reply screen/same-as-ingredient:0 ] -# row, screen <- render-string screen:address, s:address:array:character, left:number, right:number, color:number, row:number # print a string 's' to 'editor' in 'color' starting at 'row' # clear rest of last line, move cursor to next line -recipe render-string [ +recipe render-string screen:address:screen, s:address:array:character, left:number, right:number, color:number, row:number -> row:number, screen:address:screen [ local-scope - screen:address <- next-ingredient - s:address:array:character <- next-ingredient - left:number <- next-ingredient - right:number <- next-ingredient - color:number <- next-ingredient - row:number <- next-ingredient - reply-unless s, row/same-as-ingredient:5, screen/same-as-ingredient:0 + load-ingredients + reply-unless s column:number <- copy left screen <- move-cursor screen, row, column screen-height:number <- screen-height screen @@ -568,20 +543,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } break-if was-at-left? row <- add row, 1 } - move-cursor row, left - reply row/same-as-ingredient:5, screen/same-as-ingredient:0 + move-cursor screen, row, left ] -# row, screen <- render-code-string screen:address, s:address:array:character, left:number, right:number, row:number # like 'render-string' but with colorization for comments like in the editor -recipe render-code-string [ +recipe render-code-string screen:address:screen, s:address:array:character, left:number, right:number, row:number -> row:number, screen:address:screen [ local-scope - screen:address <- next-ingredient - s:address:array:character <- next-ingredient - left:number <- next-ingredient - right:number <- next-ingredient - row:number <- next-ingredient - reply-unless s, row/same-as-ingredient:4, screen/same-as-ingredient:0 + load-ingredients + reply-unless s color:number <- copy 7/white column:number <- copy left screen <- move-cursor screen, row, column @@ -635,8 +604,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } break-if was-at-left? row <- add row, 1 } - move-cursor row, left - reply row/same-as-ingredient:4, screen/same-as-ingredient:0 + move-cursor screen, row, left ] # ctrl-l - redraw screen (just in case it printed junk somehow) @@ -667,12 +635,12 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # ctrl-x - maximize/unmaximize the side with focus scenario maximize-side [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 30/width, 5/height # initialize both halves of screen 1:address:array:character <- new [abc] 2:address:array:character <- new [def] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character screen <- render-all screen, 3:address:programming-environment-data screen-should-contain [ . run (F4) . @@ -685,7 +653,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-x ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] # only left side visible screen-should-contain [ @@ -699,7 +667,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-x ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] screen-should-contain [ . run (F4) . @@ -733,11 +701,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } ] -recipe maximize [ +recipe maximize screen:address:screen, console:address:console, env:address:programming-environment-data -> screen:address:screen, console:address:console [ local-scope - screen:address <- next-ingredient - console:address <- next-ingredient - env:address:programming-environment-data <- next-ingredient + load-ingredients hide-screen screen # maximize one of the sides maximized?:address:boolean <- get-address *env, maximized?:offset @@ -760,7 +726,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } screen <- render-sandbox-side screen, env } show-screen screen - reply screen/same-as-ingredient:0, console/same-as-ingredient:1 ] # when maximized, wait for any event and simply unmaximize @@ -794,12 +759,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ## helpers -recipe draw-vertical [ +recipe draw-vertical screen:address:screen, col:number, y:number, bottom:number [ local-scope - screen:address <- next-ingredient - col:number <- next-ingredient - y:number <- next-ingredient - bottom:number <- next-ingredient + load-ingredients style:character, style-found?:boolean <- next-ingredient { break-if style-found? diff --git a/html/edit/005-sandbox.mu.html b/html/edit/005-sandbox.mu.html index 7115ca00..3fdab8a0 100644 --- a/html/edit/005-sandbox.mu.html +++ b/html/edit/005-sandbox.mu.html @@ -13,15 +13,15 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } -.muScenario { color: #00af00; } -.muData { color: #ffff00; } -.Special { color: #ff6060; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } +.Special { color: #ff6060; } +.muData { color: #ffff00; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .SalientComment { color: #00ffff; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } +.muScenario { color: #00af00; } --> </style> @@ -39,6 +39,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # (non-editable) sandboxes below the editor, showing the result and a maybe # few other things. +recipe! main [ + local-scope + open-console + initial-recipe:address:array:character <- restore [recipes.mu] + initial-sandbox:address:array:character <- new [] + hide-screen 0/screen + env:address:programming-environment-data <- new-programming-environment 0/screen, initial-recipe, initial-sandbox + env <- restore-sandboxes env + render-all 0/screen, env + event-loop 0/screen, 0/console, env + # never gets here +] + container programming-environment-data [ sandbox:address:sandbox-data # list of sandboxes, from top to bottom ] @@ -56,19 +69,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] scenario run-and-show-results [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 100/width, 15/height # recipe editor is empty 1:address:array:character <- new [] # sandbox editor contains an instruction without storing outputs 2:address:array:character <- new [divide-with-remainder 11, 3] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character # run the code in the editors assume-console [ press F4 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] # check that screen prints the results screen-should-contain [ @@ -111,7 +124,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press F4 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] # check that screen prints the results screen-should-contain [ @@ -131,8 +144,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] ] -# hook into event-loop recipe: read non-unicode keypress from k, process it if -# necessary, then go to next level after <global-keypress> [ # F4? load all code and run all sandboxes. { @@ -153,12 +164,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } ] -recipe run-sandboxes [ +recipe run-sandboxes env:address:programming-environment-data, screen:address:screen -> errors-found?:boolean, env:address:programming-environment-data, screen:address:screen [ local-scope - env:address:programming-environment-data <- next-ingredient - screen:address <- next-ingredient - stop?:boolean, env, screen <- update-recipes env, screen - reply-if stop?, 1/errors-found, env/same-as-ingredient:0, screen/same-as-ingredient:1 + load-ingredients + errors-found?:boolean, env, screen <- update-recipes env, screen + reply-if errors-found? # check contents of right editor (sandbox) current-sandbox:address:editor-data <- get *env, current-sandbox:offset { @@ -175,9 +185,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } *next <- copy *dest *dest <- copy new-sandbox # clear sandbox editor - init:address:address:duplex-list <- get-address *current-sandbox, data:offset + init:address:address:duplex-list:character <- get-address *current-sandbox, data:offset *init <- push-duplex 167/§, 0/tail - top-of-screen:address:address:duplex-list <- get-address *current-sandbox, top-of-screen:offset + top-of-screen:address:address:duplex-list:character <- get-address *current-sandbox, top-of-screen:offset *top-of-screen <- copy *init } # save all sandboxes before running, just in case we die when running @@ -186,49 +196,45 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } curr:address:sandbox-data <- get *env, sandbox:offset { break-unless curr - update-sandbox curr + curr <- update-sandbox curr curr <- get *curr, next-sandbox:offset loop } - reply 0/no-errors-found, env/same-as-ingredient:0, screen/same-as-ingredient:1 + errors-found? <- copy 0/false ] # copy code from recipe editor, persist, load into mu -# replaced in a later layer -recipe update-recipes [ +# replaced in a later layer (whereupon errors-found? will actually be set) +recipe update-recipes env:address:programming-environment-data, screen:address:screen -> errors-found?:boolean, env:address:programming-environment-data, screen:address:screen [ local-scope - env:address:programming-environment-data <- next-ingredient - screen:address <- next-ingredient + load-ingredients recipes:address:editor-data <- get *env, recipes:offset in:address:array:character <- editor-contents recipes - save [recipes.mu], in + save [recipes.mu], in # newlayer: persistence reload in - reply 0/no-errors-found, env/same-as-ingredient:0, screen/same-as-ingredient:1 + errors-found? <- copy 0/false ] # replaced in a later layer -recipe update-sandbox [ +recipe update-sandbox sandbox:address:sandbox-data -> sandbox:address:sandbox-data [ local-scope - sandbox:address:sandbox-data <- next-ingredient + load-ingredients data:address:array:character <- get *sandbox, data:offset response:address:address:array:character <- get-address *sandbox, response:offset fake-screen:address:address:screen <- get-address *sandbox, screen:offset *response, _, *fake-screen <- run-interactive data ] -recipe update-status [ +recipe update-status screen:address:screen, msg:address:array:character, color:number -> screen:address:screen [ local-scope - screen:address <- next-ingredient - msg:address:array:character <- next-ingredient - color:number <- next-ingredient + load-ingredients screen <- move-cursor screen, 0, 2 screen <- print-string screen, msg, color, 238/grey/background - reply screen/same-as-ingredient:0 ] -recipe save-sandboxes [ +recipe save-sandboxes env:address:programming-environment-data [ local-scope - env:address:programming-environment-data <- next-ingredient + load-ingredients current-sandbox:address:editor-data <- get *env, current-sandbox:offset # first clear previous versions, in case we deleted some sandbox $system [rm lesson/[0-9]* >/dev/null 2>/dev/null] # some shells can't handle '>&' @@ -252,10 +258,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } ] -recipe! render-sandbox-side [ +recipe! render-sandbox-side screen:address:screen, env:address:programming-environment-data -> screen:address:screen [ local-scope - screen:address <- next-ingredient - env:address:programming-environment-data <- next-ingredient + load-ingredients trace 11, [app], [render sandbox side] current-sandbox:address:editor-data <- get *env, current-sandbox:offset left:number <- get *current-sandbox, left:offset @@ -267,20 +272,15 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } sandbox:address:sandbox-data <- get *env, sandbox:offset row, screen <- render-sandboxes screen, sandbox, left, right, row clear-rest-of-screen screen, row, left, left, right - reply screen/same-as-ingredient:0 ] -recipe render-sandboxes [ +recipe render-sandboxes screen:address:screen, sandbox:address:sandbox-data, left:number, right:number, row:number -> row:number, screen:address:screen [ local-scope - screen:address <- next-ingredient - sandbox:address:sandbox-data <- next-ingredient - left:number <- next-ingredient - right:number <- next-ingredient - row:number <- next-ingredient - reply-unless sandbox, row/same-as-ingredient:4, screen/same-as-ingredient:0 + load-ingredients + reply-unless sandbox screen-height:number <- screen-height screen at-bottom?:boolean <- greater-or-equal row, screen-height - reply-if at-bottom?:boolean, row/same-as-ingredient:4, screen/same-as-ingredient:0 + reply-if at-bottom?:boolean # render sandbox menu row <- add row, 1 screen <- move-cursor screen, row, left @@ -301,7 +301,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } sandbox-response:address:array:character <- get *sandbox, response:offset <render-sandbox-results> { - sandbox-screen:address <- get *sandbox, screen:offset + sandbox-screen:address:screen <- get *sandbox, screen:offset empty-screen?:boolean <- fake-screen-is-empty? sandbox-screen break-if empty-screen? row, screen <- render-screen screen, sandbox-screen, left, right, row @@ -314,19 +314,18 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } +render-sandbox-end at-bottom?:boolean <- greater-or-equal row, screen-height - reply-if at-bottom?, row/same-as-ingredient:4, screen/same-as-ingredient:0 + reply-if at-bottom? # draw solid line after sandbox draw-horizontal screen, row, left, right, 9473/horizontal-double # draw next sandbox next-sandbox:address:sandbox-data <- get *sandbox, next-sandbox:offset row, screen <- render-sandboxes screen, next-sandbox, left, right, row - reply row/same-as-ingredient:4, screen/same-as-ingredient:0 ] # assumes programming environment has no sandboxes; restores them from previous session -recipe restore-sandboxes [ +recipe restore-sandboxes env:address:programming-environment-data -> env:address:programming-environment-data [ local-scope - env:address:programming-environment-data <- next-ingredient + load-ingredients # read all scenarios, pushing them to end of a list of scenarios suffix:address:array:character <- new [.out] idx:number <- copy 0 @@ -352,29 +351,23 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } curr <- get-address **curr, next-sandbox:offset loop } - reply env/same-as-ingredient:0 ] -# row, screen <- render-screen screen:address, sandbox-screen:address, left:number, right:number, row:number # print the fake sandbox screen to 'screen' with appropriate delimiters # leave cursor at start of next line -recipe render-screen [ +recipe render-screen screen:address:screen, sandbox-screen:address:screen, left:number, right:number, row:number -> row:number, screen:address:screen [ local-scope - screen:address <- next-ingredient - s:address:screen <- next-ingredient - left:number <- next-ingredient - right:number <- next-ingredient - row:number <- next-ingredient - reply-unless s, row/same-as-ingredient:4, screen/same-as-ingredient:0 + load-ingredients + reply-unless sandbox-screen # print 'screen:' header:address:array:character <- new [screen:] row <- render-string screen, header, left, right, 245/grey, row screen <- move-cursor screen, row, left - # start printing s + # start printing sandbox-screen column:number <- copy left - s-width:number <- screen-width s - s-height:number <- screen-height s - buf:address:array:screen-cell <- get *s, data:offset + s-width:number <- screen-width sandbox-screen + s-height:number <- screen-height sandbox-screen + buf:address:array:screen-cell <- get *sandbox-screen, data:offset stop-printing:number <- add left, s-width, 3 max-column:number <- min stop-printing, right i:number <- copy 0 @@ -424,36 +417,33 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } row <- add row, 1 loop } - reply row/same-as-ingredient:4, screen/same-as-ingredient:0 ] scenario run-updates-results [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 100/width, 12/height # define a recipe (no indent for the 'add' line below so column numbers are more obvious) 1:address:array:character <- new [ recipe foo [ z:number <- add 2, 2 +reply z ]] # sandbox editor contains an instruction without storing outputs 2:address:array:character <- new [foo] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character # run the code in the editors assume-console [ press F4 ] - run [ - event-loop screen:address, console:address, 3:address:programming-environment-data - ] - # check that screen prints the results + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data screen-should-contain [ . run (F4) . . ┊ . .recipe foo [ ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. .z:number <- add 2, 2 ┊ x. - .] ┊foo . - .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊4 . - . ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. + .reply z ┊foo . + .] ┊4 . + .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. . ┊ . ] # make a change (incrementing one of the args to 'add'), then rerun @@ -464,7 +454,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press F4 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] # check that screen updates the result on the right screen-should-contain [ @@ -472,27 +462,27 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } . ┊ . .recipe foo [ ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. .z:number <- add 2, 3 ┊ x. - .] ┊foo . - .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊5 . - . ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. + .reply z ┊foo . + .] ┊5 . + .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. . ┊ . ] ] scenario run-instruction-manages-screen-per-sandbox [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 100/width, 20/height # left editor is empty 1:address:array:character <- new [] # right editor contains an instruction - 2:address:array:character <- new [print-integer screen:address, 4] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 2:address:array:character <- new [print-integer screen, 4] + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character # run the code in the editor assume-console [ press F4 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] # check that it prints a little toy screen screen-should-contain [ @@ -500,7 +490,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } . ┊ . .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. . ┊ x. - . ┊print-integer screen:address, 4 . + . ┊print-integer screen, 4 . . ┊screen: . . ┊ .4 . . . ┊ . . . @@ -512,11 +502,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] ] -recipe editor-contents [ +recipe editor-contents editor:address:editor-data -> result:address:array:character [ local-scope - editor:address:editor-data <- next-ingredient + load-ingredients buf:address:buffer <- new-buffer 80 - curr:address:duplex-list <- get *editor, data:offset + curr:address:duplex-list:character <- get *editor, data:offset # skip § sentinel assert curr, [editor without data is illegal; must have at least a sentinel] curr <- next-duplex curr @@ -528,20 +518,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } curr <- next-duplex curr loop } - result:address:array:character <- buffer-to-array buf - reply result + result <- buffer-to-array buf ] scenario editor-provides-edited-contents [ assume-screen 10/width, 5/height 1:address:array:character <- new [abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right assume-console [ left-click 1, 2 type [def] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:address:array:character <- editor-contents 2:address:editor-data 4:array:character <- copy *3:address:array:character ] diff --git a/html/edit/006-sandbox-edit.mu.html b/html/edit/006-sandbox-edit.mu.html index e5c2d430..a1e3bb2f 100644 --- a/html/edit/006-sandbox-edit.mu.html +++ b/html/edit/006-sandbox-edit.mu.html @@ -13,14 +13,14 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } +.muRecipe { color: #ff8700; } .muScenario { color: #00af00; } .Special { color: #ff6060; } -.muRecipe { color: #ff8700; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .SalientComment { color: #00ffff; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> @@ -35,25 +35,25 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ## editing sandboxes after they've been created scenario clicking-on-a-sandbox-moves-it-to-editor [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 40/width, 10/height # basic recipe 1:address:array:character <- new [ recipe foo [ - add 2, 2 + reply 4 ]] # run it 2:address:array:character <- new [foo] assume-console [ press F4 ] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character - event-loop screen:address, console:address, 3:address:programming-environment-data + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data screen-should-contain [ . run (F4) . . ┊ . .recipe foo [ ┊━━━━━━━━━━━━━━━━━━━. - . add 2, 2 ┊ x. + . reply 4 ┊ x. .] ┊foo . .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊4 . . ┊━━━━━━━━━━━━━━━━━━━. @@ -64,14 +64,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } left-click 3, 30 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] # it pops back into editor screen-should-contain [ . run (F4) . . ┊foo . .recipe foo [ ┊━━━━━━━━━━━━━━━━━━━. - . add 2, 2 ┊ . + . reply 4 ┊ . .] ┊ . .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊ . . ┊ . @@ -82,13 +82,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [0] ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] screen-should-contain [ . run (F4) . . ┊0foo . .recipe foo [ ┊━━━━━━━━━━━━━━━━━━━. - . add 2, 2 ┊ . + . reply 4 ┊ . .] ┊ . .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊ . . ┊ . @@ -97,8 +97,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] after <global-touch> [ - # right side of screen and below sandbox editor? pop appropriate sandbox - # contents back into sandbox editor provided it's empty + # below sandbox editor? pop appropriate sandbox contents back into sandbox editor { sandbox-left-margin:number <- get *current-sandbox, left:offset click-column:number <- get *t, column:offset @@ -111,7 +110,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } below-sandbox-editor?:boolean <- greater-or-equal click-row, first-sandbox-begins break-unless below-sandbox-editor? empty-sandbox-editor?:boolean <- empty-editor? current-sandbox - break-unless empty-sandbox-editor? # make the user hit F4 before editing a new sandbox + break-unless empty-sandbox-editor? # don't clobber existing contents # identify the sandbox to edit and remove it from the sandbox list sandbox:address:sandbox-data <- extract-sandbox env, click-row text:address:array:character <- get *sandbox, data:offset @@ -124,19 +123,17 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } ] -recipe empty-editor? [ +recipe empty-editor? editor:address:editor-data -> result:boolean [ local-scope - editor:address:editor-data <- next-ingredient - head:address:duplex-list <- get *editor, data:offset - first:address:duplex-list <- next-duplex head - result:boolean <- not first - reply result + load-ingredients + head:address:duplex-list:character <- get *editor, data:offset + first:address:duplex-list:character <- next-duplex head + result <- not first ] -recipe extract-sandbox [ +recipe extract-sandbox env:address:programming-environment-data, click-row:number -> result:address:sandbox-data [ local-scope - env:address:programming-environment-data <- next-ingredient - click-row:number <- next-ingredient + load-ingredients # assert click-row >= sandbox.starting-row-on-screen sandbox:address:address:sandbox-data <- get-address *env, sandbox:offset start:number <- get **sandbox, starting-row-on-screen:offset @@ -153,7 +150,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } loop } # snip sandbox out of its list - result:address:sandbox-data <- copy *sandbox + result <- copy *sandbox *sandbox <- copy next-sandbox # position cursor in sandbox editor sandbox-in-focus?:address:boolean <- get-address *env, sandbox-in-focus?:offset @@ -162,26 +159,24 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] scenario sandbox-with-print-can-be-edited [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 100/width, 20/height # left editor is empty 1:address:array:character <- new [] # right editor contains an instruction - 2:address:array:character <- new [print-integer screen:address, 4] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 2:address:array:character <- new [print-integer screen, 4] + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character # run the sandbox assume-console [ press F4 ] - run [ - event-loop screen:address, console:address, 3:address:programming-environment-data - ] + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data screen-should-contain [ . run (F4) . . ┊ . .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. . ┊ x. - . ┊print-integer screen:address, 4 . + . ┊print-integer screen, 4 . . ┊screen: . . ┊ .4 . . . ┊ . . . @@ -196,11 +191,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } left-click 3, 70 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] screen-should-contain [ . run (F4) . - . ┊print-integer screen:address, 4 . + . ┊print-integer screen, 4 . .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. . ┊ . . ┊ . diff --git a/html/edit/007-sandbox-delete.mu.html b/html/edit/007-sandbox-delete.mu.html index 5f3cdfcf..f563b266 100644 --- a/html/edit/007-sandbox-delete.mu.html +++ b/html/edit/007-sandbox-delete.mu.html @@ -13,14 +13,14 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } +.muRecipe { color: #ff8700; } .muScenario { color: #00af00; } .Special { color: #ff6060; } -.muRecipe { color: #ff8700; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .SalientComment { color: #00ffff; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> @@ -35,11 +35,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ## deleting sandboxes scenario deleting-sandboxes [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 100/width, 15/height 1:address:array:character <- new [] 2:address:array:character <- new [] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character # run a few commands assume-console [ left-click 1, 80 @@ -48,9 +48,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [add 2, 2] press F4 ] - run [ - event-loop screen:address, console:address, 3:address:programming-environment-data - ] + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data screen-should-contain [ . run (F4) . . ┊ . @@ -71,7 +69,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } left-click 7, 99 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] screen-should-contain [ . run (F4) . @@ -89,7 +87,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } left-click 3, 99 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] screen-should-contain [ . run (F4) . @@ -113,11 +111,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } ] -# was-deleted?:boolean <- delete-sandbox t:touch-event, env:address:programming-environment-data -recipe delete-sandbox [ +recipe delete-sandbox t:touch-event, env:address:programming-environment-data -> was-delete?:boolean [ local-scope - t:touch-event <- next-ingredient - env:address:programming-environment-data <- next-ingredient + load-ingredients click-column:number <- get t, column:offset current-sandbox:address:editor-data <- get *env, current-sandbox:offset right:number <- get *current-sandbox, right:offset diff --git a/html/edit/008-sandbox-test.mu.html b/html/edit/008-sandbox-test.mu.html index 0cdd6a08..08b62ddc 100644 --- a/html/edit/008-sandbox-test.mu.html +++ b/html/edit/008-sandbox-test.mu.html @@ -13,14 +13,14 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } +.muRecipe { color: #ff8700; } .muScenario { color: #00af00; } .Special { color: #ff6060; } -.muRecipe { color: #ff8700; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .SalientComment { color: #00ffff; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> @@ -35,25 +35,25 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ## clicking on sandbox results to 'fix' them and turn sandboxes into tests scenario sandbox-click-on-result-toggles-color-to-green [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 40/width, 10/height # basic recipe 1:address:array:character <- new [ recipe foo [ - add 2, 2 + reply 4 ]] # run it 2:address:array:character <- new [foo] assume-console [ press F4 ] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character - event-loop screen:address, console:address, 3:address:programming-environment-data + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data screen-should-contain [ . run (F4) . . ┊ . .recipe foo [ ┊━━━━━━━━━━━━━━━━━━━. - . add 2, 2 ┊ x. + . reply 4 ┊ x. .] ┊foo . .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊4 . . ┊━━━━━━━━━━━━━━━━━━━. @@ -64,7 +64,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } left-click 5, 21 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] # color toggles to green screen-should-contain-in-color 2/green, [ @@ -79,19 +79,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] # cursor should remain unmoved run [ - print-character screen:address, 9251/␣/cursor + print-character screen:address:screen, 9251/␣/cursor ] screen-should-contain [ . run (F4) . .␣ ┊ . .recipe foo [ ┊━━━━━━━━━━━━━━━━━━━. - . add 2, 2 ┊ x. + . reply 4 ┊ x. .] ┊foo . .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊4 . . ┊━━━━━━━━━━━━━━━━━━━. . ┊ . ] - # now change the second arg of the 'add' + # now change the result # then rerun assume-console [ left-click 3, 11 # cursor to end of line @@ -100,7 +100,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press F4 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] # result turns red screen-should-contain-in-color 1/red, [ @@ -109,7 +109,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } . . . . . . - . 5 . + . 3 . . . . . ] @@ -117,7 +117,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # clicks on sandbox responses save it as 'expected' after <global-touch> [ - # right side of screen? check if it's inside the output of any sandbox + # check if it's inside the output of any sandbox { sandbox-left-margin:number <- get *current-sandbox, left:offset click-column:number <- get *t, column:offset @@ -144,10 +144,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } ] -recipe find-click-in-sandbox-output [ +recipe find-click-in-sandbox-output env:address:programming-environment-data, click-row:number -> sandbox:address:sandbox-data [ local-scope - env:address:programming-environment-data <- next-ingredient - click-row:number <- next-ingredient + load-ingredients # assert click-row >= sandbox.starting-row-on-screen sandbox:address:sandbox-data <- get *env, sandbox:offset start:number <- get *sandbox, starting-row-on-screen:offset @@ -171,9 +170,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } reply sandbox ] -recipe toggle-expected-response [ +recipe toggle-expected-response sandbox:address:sandbox-data -> sandbox:address:sandbox-data [ local-scope - sandbox:address:sandbox-data <- next-ingredient + load-ingredients expected-response:address:address:array:character <- get-address *sandbox, expected-response:offset { # if expected-response is set, reset @@ -184,7 +183,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # if not, current response is the expected response response:address:array:character <- get *sandbox, response:offset *expected-response <- copy response - reply sandbox/same-as-ingredient:0 ] # when rendering a sandbox, color it in red/green if expected response exists diff --git a/html/edit/009-sandbox-trace.mu.html b/html/edit/009-sandbox-trace.mu.html index b73fbee6..071f62af 100644 --- a/html/edit/009-sandbox-trace.mu.html +++ b/html/edit/009-sandbox-trace.mu.html @@ -13,15 +13,15 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } +.muRecipe { color: #ff8700; } .muScenario { color: #00af00; } .muData { color: #ffff00; } .Special { color: #ff6060; } -.muRecipe { color: #ff8700; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .SalientComment { color: #00ffff; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> @@ -36,7 +36,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ## clicking on the code typed into a sandbox toggles its trace scenario sandbox-click-on-code-toggles-app-trace [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 40/width, 10/height # basic recipe 1:address:array:character <- new [ @@ -48,8 +48,8 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-console [ press F4 ] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character - event-loop screen:address, console:address, 3:address:programming-environment-data + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data screen-should-contain [ . run (F4) . . ┊ . @@ -59,13 +59,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊━━━━━━━━━━━━━━━━━━━. . ┊ . ] - # click on the 'foo' line in the sandbox + # click on the code in the sandbox assume-console [ left-click 4, 21 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data - print-character screen:address, 9251/␣/cursor + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data + print-character screen:address:screen, 9251/␣/cursor ] # trace now printed and cursor shouldn't have budged screen-should-contain [ @@ -93,8 +93,8 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } left-click 4, 25 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data - print-character screen:address, 9251/␣/cursor + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data + print-character screen:address:screen, 9251/␣/cursor ] # trace hidden again screen-should-contain [ @@ -109,45 +109,45 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] scenario sandbox-shows-app-trace-and-result [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 40/width, 10/height # basic recipe 1:address:array:character <- new [ recipe foo [ stash [abc] - add 2, 2 + reply 4 ]] # run it 2:address:array:character <- new [foo] assume-console [ press F4 ] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character - event-loop screen:address, console:address, 3:address:programming-environment-data + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data screen-should-contain [ . run (F4) . . ┊ . .recipe foo [ ┊━━━━━━━━━━━━━━━━━━━. . stash [abc] ┊ x. - . add 2, 2 ┊foo . + . reply 4 ┊foo . .] ┊4 . .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊━━━━━━━━━━━━━━━━━━━. . ┊ . ] - # click on the 'foo' line in the sandbox + # click on the code in the sandbox assume-console [ left-click 4, 21 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] - # trace now printed + # trace now printed above result screen-should-contain [ . run (F4) . . ┊ . .recipe foo [ ┊━━━━━━━━━━━━━━━━━━━. . stash [abc] ┊ x. - . add 2, 2 ┊foo . + . reply 4 ┊foo . .] ┊abc . .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊4 . . ┊━━━━━━━━━━━━━━━━━━━. @@ -161,9 +161,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] # replaced in a later layer -recipe! update-sandbox [ +recipe! update-sandbox sandbox:address:sandbox-data -> sandbox:address:sandbox-data [ local-scope - sandbox:address:sandbox-data <- next-ingredient + load-ingredients data:address:array:character <- get *sandbox, data:offset response:address:address:array:character <- get-address *sandbox, response:offset trace:address:address:array:character <- get-address *sandbox, trace:offset @@ -173,7 +173,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # clicks on sandbox code toggle its display-trace? flag after <global-touch> [ - # right side of screen? check if it's inside the code of any sandbox + # check if it's inside the code of any sandbox { sandbox-left-margin:number <- get *current-sandbox, left:offset click-column:number <- get *t, column:offset @@ -200,12 +200,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } ] -recipe find-click-in-sandbox-code [ +recipe find-click-in-sandbox-code env:address:programming-environment-data, click-row:number -> sandbox:address:sandbox-data [ local-scope - env:address:programming-environment-data <- next-ingredient - click-row:number <- next-ingredient + load-ingredients # assert click-row >= sandbox.starting-row-on-screen - sandbox:address:sandbox-data <- get *env, sandbox:offset + sandbox <- get *env, sandbox:offset start:number <- get *sandbox, starting-row-on-screen:offset clicked-on-sandboxes?:boolean <- greater-or-equal click-row, start assert clicked-on-sandboxes?, [extract-sandbox called on click to sandbox editor] @@ -241,6 +240,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } break-unless sandbox-trace # nothing to print; move on row, screen <- render-string, screen, sandbox-trace, left, right, 245/grey, row } + <render-sandbox-trace-done> ] </pre> </body> diff --git a/html/edit/010-warnings.mu.html b/html/edit/010-warnings.mu.html index ca9008b7..335bfb42 100644 --- a/html/edit/010-warnings.mu.html +++ b/html/edit/010-warnings.mu.html @@ -13,15 +13,15 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } -.muData { color: #ffff00; } .Special { color: #ff6060; } -.muScenario { color: #00af00; } +.muData { color: #ffff00; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .SalientComment { color: #00ffff; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } +.muScenario { color: #00af00; } --> </style> @@ -40,10 +40,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] # copy code from recipe editor, persist, load into mu, save any warnings -recipe! update-recipes [ +recipe! update-recipes env:address:programming-environment-data, screen:address:screen -> errors-found?:boolean, env:address:programming-environment-data, screen:address:screen [ local-scope - env:address:programming-environment-data <- next-ingredient - screen:address <- next-ingredient + load-ingredients recipes:address:editor-data <- get *env, recipes:offset in:address:array:character <- editor-contents recipes save [recipes.mu], in @@ -54,9 +53,10 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } break-unless *recipe-warnings status:address:array:character <- new [errors found] update-status screen, status, 1/red - reply 1/errors-found, env/same-as-ingredient:0, screen/same-as-ingredient:1 + errors-found? <- copy 1/true + reply } - reply 0/no-errors-found, env/same-as-ingredient:0, screen/same-as-ingredient:1 + errors-found? <- copy 0/false ] before <render-components-end> [ @@ -81,9 +81,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } warnings:address:array:character ] -recipe! update-sandbox [ +recipe! update-sandbox sandbox:address:sandbox-data -> sandbox:address:sandbox-data [ local-scope - sandbox:address:sandbox-data <- next-ingredient + load-ingredients data:address:array:character <- get *sandbox, data:offset response:address:address:array:character <- get-address *sandbox, response:offset warnings:address:address:array:character <- get-address *sandbox, warnings:offset @@ -98,30 +98,32 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } } ] -after <render-sandbox-results> [ +# make sure we render any trace +after <render-sandbox-trace-done> [ { sandbox-warnings:address:array:character <- get *sandbox, warnings:offset break-unless sandbox-warnings *response-starting-row <- copy 0 # no response row, screen <- render-string screen, sandbox-warnings, left, right, 1/red, row + # don't try to print anything more for this sandbox jump +render-sandbox-end:label } ] scenario run-shows-warnings-in-get [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 100/width, 15/height 1:address:array:character <- new [ recipe foo [ get 123:number, foo:offset ]] 2:address:array:character <- new [foo] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character assume-console [ press F4 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] screen-should-contain [ . errors found run (F4) . @@ -129,7 +131,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } .recipe foo [ ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. . get 123:number, foo:offset ┊ . .] ┊ . - .unknown element foo in container number ┊ . + .foo: unknown element foo in container number ┊ . + .foo: first ingredient of 'get' should be a contai↩┊ . + .ner, but got 123:number ┊ . .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊ . . ┊ . ] @@ -139,25 +143,27 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } . . . . . . - .unknown element foo in container number . + .foo: unknown element foo in container number . + .foo: first ingredient of 'get' should be a contai . + .ner, but got 123:number . . . ] ] scenario run-shows-missing-type-warnings [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 100/width, 15/height 1:address:array:character <- new [ recipe foo [ x <- copy 0 ]] 2:address:array:character <- new [foo] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character assume-console [ press F4 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] screen-should-contain [ . errors found run (F4) . @@ -165,14 +171,12 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } .recipe foo [ ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. . x <- copy 0 ┊ . .] ┊ . - .missing type in 'x <- copy 0' ┊ . - .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊ . - . ┊ . + .foo: missing type for x in 'x <- copy 0' ┊ . ] ] scenario run-shows-unbalanced-bracket-warnings [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 100/width, 15/height # recipe is incomplete (unbalanced '[') 1:address:array:character <- new [ @@ -181,12 +185,12 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] string-replace 1:address:array:character, 171/«, 91 # '[' 2:address:array:character <- new [foo] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character assume-console [ press F4 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] screen-should-contain [ . errors found run (F4) . @@ -201,7 +205,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] scenario run-shows-get-on-non-container-warnings [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 100/width, 15/height 1:address:array:character <- new [ recipe foo [ @@ -209,28 +213,29 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } get x:address:point, 1:offset ]] 2:address:array:character <- new [foo] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character assume-console [ press F4 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] screen-should-contain [ - . run (F4) . - . ┊ . + . errors found run (F4) . + . ┊foo . .recipe foo [ ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. - . x:address:point <- new point:type ┊ x. - . get x:address:point, 1:offset ┊foo . - .] ┊foo: first ingredient of 'get' should be a conta↩. - .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊iner, but got x:address:point . - . ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. + . x:address:point <- new point:type ┊ . + . get x:address:point, 1:offset ┊ . + .] ┊ . + .foo: first ingredient of 'get' should be a contai↩┊ . + .ner, but got x:address:point ┊ . + .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊ . . ┊ . ] ] scenario run-shows-non-literal-get-argument-warnings [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 100/width, 15/height 1:address:array:character <- new [ recipe foo [ @@ -239,12 +244,12 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } get *y:address:point, x:number ]] 2:address:array:character <- new [foo] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character assume-console [ press F4 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] screen-should-contain [ . errors found run (F4) . @@ -256,13 +261,15 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } .] ┊ . .foo: expected ingredient 1 of 'get' to have type ↩┊ . .'offset'; got x:number ┊ . + .foo: second ingredient of 'get' should have type ↩┊ . + .'offset', but got x:number ┊ . .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊ . . ┊ . ] ] scenario run-shows-warnings-everytime [ - $close-trace # trace too long + trace-until 100/app # trace too long # try to run a file with an error assume-screen 100/width, 15/height 1:address:array:character <- new [ @@ -270,12 +277,12 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } x:number <- copy y:number ]] 2:address:array:character <- new [foo] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character assume-console [ press F4 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] screen-should-contain [ . errors found run (F4) . @@ -283,7 +290,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } .recipe foo [ ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. . x:number <- copy y:number ┊ . .] ┊ . - .use before set: y in foo ┊ . + .foo: use before set: y ┊ . .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊ . . ┊ . ] @@ -292,7 +299,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press F4 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] screen-should-contain [ . errors found run (F4) . @@ -300,26 +307,26 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } .recipe foo [ ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. . x:number <- copy y:number ┊ . .] ┊ . - .use before set: y in foo ┊ . + .foo: use before set: y ┊ . .┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┊ . . ┊ . ] ] scenario run-instruction-and-print-warnings [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 100/width, 10/height # left editor is empty 1:address:array:character <- new [] # right editor contains an illegal instruction 2:address:array:character <- new [get 1234:number, foo:offset] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character # run the code in the editors assume-console [ press F4 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] # check that screen prints error message in red screen-should-contain [ @@ -329,6 +336,8 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } . ┊ x. . ┊get 1234:number, foo:offset . . ┊unknown element foo in container number . + . ┊first ingredient of 'get' should be a container,↩. + . ┊ but got 1234:number . . ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. . ┊ . ] @@ -349,6 +358,8 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } . . . . . unknown element foo in container number . + . first ingredient of 'get' should be a container, . + . but got 1234:number . . . ] screen-should-contain-in-color 245/grey, [ @@ -358,26 +369,28 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } . ┊ x. . ┊ . . ┊ . + . ┊ ↩. + . ┊ . . ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. . ┊ . ] ] scenario run-instruction-and-print-warnings-only-once [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 100/width, 10/height # left editor is empty 1:address:array:character <- new [] # right editor contains an illegal instruction 2:address:array:character <- new [get 1234:number, foo:offset] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character # run the code in the editors multiple times assume-console [ press F4 press F4 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] # check that screen prints error message just once screen-should-contain [ @@ -387,13 +400,15 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } . ┊ x. . ┊get 1234:number, foo:offset . . ┊unknown element foo in container number . + . ┊first ingredient of 'get' should be a container,↩. + . ┊ but got 1234:number . . ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. . ┊ . ] ] scenario sandbox-can-handle-infinite-loop [ - $close-trace # trace too long + trace-until 100/app # trace too long assume-screen 100/width, 20/height # left editor is empty 1:address:array:character <- new [recipe foo [ @@ -403,13 +418,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ]] # right editor contains an instruction 2:address:array:character <- new [foo] - 3:address:programming-environment-data <- new-programming-environment screen:address, 1:address:array:character, 2:address:array:character + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character # run the sandbox assume-console [ press F4 ] run [ - event-loop screen:address, console:address, 3:address:programming-environment-data + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data ] screen-should-contain [ . run (F4) . @@ -422,6 +437,55 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } . ┊ . ] ] + +scenario sandbox-with-warnings-shows-trace [ + trace-until 100/app # trace too long + assume-screen 100/width, 10/height + # generate a stash and a warning + 1:address:array:character <- new [recipe foo [ +local-scope +a:number <- next-ingredient +b:number <- next-ingredient +stash [dividing by], b +_, c:number <- divide-with-remainder a, b +reply b +]] + 2:address:array:character <- new [foo 4, 0] + 3:address:programming-environment-data <- new-programming-environment screen:address:screen, 1:address:array:character, 2:address:array:character + # run + assume-console [ + press F4 + ] + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data + # screen prints error message + screen-should-contain [ + . run (F4) . + .recipe foo \\\[ ┊ . + .local-scope ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. + .a:number <- next-ingredient ┊ x. + .b:number <- next-ingredient ┊foo 4, 0 . + .stash [dividing by], b ┊foo: divide by zero in '_, c:number <- divide-wi↩. + ._, c:number <- divide-with-remainder a, b ┊th-remainder a, b' . + ] + # click on the call in the sandbox + assume-console [ + left-click 4, 55 + ] + run [ + event-loop screen:address:screen, console:address:console, 3:address:programming-environment-data + ] + # screen should expand trace + screen-should-contain [ + . run (F4) . + .recipe foo \\\[ ┊ . + .local-scope ┊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━. + .a:number <- next-ingredient ┊ x. + .b:number <- next-ingredient ┊foo 4, 0 . + .stash [dividing by], b ┊dividing by 0 . + ._, c:number <- divide-with-remainder a, b ┊foo: divide by zero in '_, c:number <- divide-wi↩. + .reply b ┊th-remainder a, b' . + ] +] </pre> </body> </html> diff --git a/html/edit/011-editor-undo.mu.html b/html/edit/011-editor-undo.mu.html index 37417b7f..b50f0063 100644 --- a/html/edit/011-editor-undo.mu.html +++ b/html/edit/011-editor-undo.mu.html @@ -13,15 +13,15 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } -.muData { color: #ffff00; } .Special { color: #ff6060; } -.muScenario { color: #00af00; } +.muData { color: #ffff00; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .SalientComment { color: #00ffff; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } +.muScenario { color: #00af00; } --> </style> @@ -100,11 +100,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } { undo?:boolean <- equal *c, 26/ctrl-z break-unless undo? - undo:address:address:list <- get-address *editor, undo:offset + undo:address:address:list:address:operation <- get-address *editor, undo:offset break-unless *undo op:address:operation <- first *undo *undo <- rest *undo - redo:address:address:list <- get-address *editor, redo:offset + redo:address:address:list:address:operation <- get-address *editor, redo:offset *redo <- push op, *redo <handle-undo> reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 1/go-render @@ -116,11 +116,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } { redo?:boolean <- equal *c, 25/ctrl-y break-unless redo? - redo:address:address:list <- get-address *editor, redo:offset + redo:address:address:list:address:operation <- get-address *editor, redo:offset break-unless *redo op:address:operation <- first *redo *redo <- rest *redo - undo:address:address:list <- get-address *editor, undo:offset + undo:address:address:list:address:operation <- get-address *editor, undo:offset *undo <- push op, *undo <handle-redo> reply screen/same-as-ingredient:0, editor/same-as-ingredient:1, 1/go-render @@ -133,18 +133,18 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # create an editor and type a character assume-screen 10/width, 5/height 1:address:array:character <- new [] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data assume-console [ type [0] ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data # undo assume-console [ press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # character should be gone screen-should-contain [ @@ -158,7 +158,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -170,12 +170,12 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # save operation to undo after <insert-character-begin> [ - top-before:address:duplex-list <- get *editor, top-of-screen:offset - cursor-before:address:duplex-list <- copy *before-cursor + top-before:address:duplex-list:character <- get *editor, top-of-screen:offset + cursor-before:address:duplex-list:character <- copy *before-cursor ] before <insert-character-end> [ - top-after:address:duplex-list <- get *editor, top-of-screen:offset - undo:address:address:list <- get-address *editor, undo:offset + top-after:address:duplex-list:character <- get *editor, top-of-screen:offset + undo:address:address:list:address:operation <- get-address *editor, undo:offset { # if previous operation was an insert, coalesce this operation with it break-unless *undo @@ -184,19 +184,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } break-unless typing previous-coalesce-tag:number <- get *typing, tag:offset break-unless previous-coalesce-tag - insert-until:address:address:duplex-list <- get-address *typing, insert-until:offset + insert-until:address:address:duplex-list:character <- get-address *typing, insert-until:offset *insert-until <- next-duplex *before-cursor after-row:address:number <- get-address *typing, after-row:offset *after-row <- copy *cursor-row after-column:address:number <- get-address *typing, after-column:offset *after-column <- copy *cursor-column - after-top:address:number <- get-address *typing, after-top-of-screen:offset + after-top:address:address:duplex-list:character <- get-address *typing, after-top-of-screen:offset *after-top <- get *editor, top-of-screen:offset break +done-adding-insert-operation:label } # if not, create a new operation - insert-from:address:duplex-list <- next-duplex cursor-before - insert-to:address:duplex-list <- next-duplex insert-from + insert-from:address:duplex-list:character <- next-duplex cursor-before + insert-to:address:duplex-list:character <- next-duplex insert-from op:address:operation <- new operation:type *op <- merge 0/insert-operation, save-row/before, save-column/before, top-before, *cursor-row/after, *cursor-column/after, top-after, insert-from, insert-to, 1/coalesce editor <- add-operation editor, op @@ -207,14 +207,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } after <insert-enter-begin> [ cursor-row-before:number <- copy *cursor-row cursor-column-before:number <- copy *cursor-column - top-before:address:duplex-list <- get *editor, top-of-screen:offset - cursor-before:address:duplex-list <- copy *before-cursor + top-before:address:duplex-list:character <- get *editor, top-of-screen:offset + cursor-before:address:duplex-list:character <- copy *before-cursor ] before <insert-enter-end> [ - top-after:address:duplex-list <- get *editor, top-of-screen:offset + top-after:address:duplex-list:character <- get *editor, top-of-screen:offset # never coalesce - insert-from:address:duplex-list <- next-duplex cursor-before - insert-to:address:duplex-list <- next-duplex *before-cursor + insert-from:address:duplex-list:character <- next-duplex cursor-before + insert-to:address:duplex-list:character <- next-duplex *before-cursor op:address:operation <- new operation:type *op <- merge 0/insert-operation, cursor-row-before, cursor-column-before, top-before, *cursor-row/after, *cursor-column/after, top-after, insert-from, insert-to, 0/never-coalesce editor <- add-operation editor, op @@ -224,10 +224,9 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # redo stack, because it's now obsolete. # Beware: since we're counting cursor moves as operations, this means just # moving the cursor can lose work on the undo stack. -recipe add-operation [ +recipe add-operation editor:address:editor-data, op:address:operation -> editor:address:editor-data [ local-scope - editor:address:editor-data <- next-ingredient - op:address:operation <- next-ingredient + load-ingredients undo:address:address:list:address:operation <- get-address *editor, undo:offset *undo <- push op *undo redo:address:address:list:address:operation <- get-address *editor, redo:offset @@ -239,14 +238,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } { typing:address:insert-operation <- maybe-convert *op, typing:variant break-unless typing - start:address:duplex-list <- get *typing, insert-from:offset - end:address:duplex-list <- get *typing, insert-until:offset + start:address:duplex-list:character <- get *typing, insert-from:offset + end:address:duplex-list:character <- get *typing, insert-until:offset # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen *before-cursor <- prev-duplex start remove-duplex-between *before-cursor, end *cursor-row <- get *typing, before-row:offset *cursor-column <- get *typing, before-column:offset - top:address:address:duplex-list <- get *editor, top-of-screen:offset + top:address:address:duplex-list:character <- get-address *editor, top-of-screen:offset *top <- get *typing, before-top-of-screen:offset } ] @@ -255,18 +254,18 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # create an editor and type multiple characters assume-screen 10/width, 5/height 1:address:array:character <- new [] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data assume-console [ type [012] ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data # undo assume-console [ press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # all characters must be gone screen-should-contain [ @@ -281,13 +280,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # create an editor with some text assume-screen 10/width, 5/height 1:address:array:character <- new [a] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # type some characters assume-console [ type [012] ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data screen-should-contain [ . . .012a . @@ -299,7 +298,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # back to original text screen-should-contain [ @@ -313,7 +312,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [3] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -327,14 +326,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # create an editor with some text assume-screen 10/width, 5/height 1:address:array:character <- new [ abc] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # new line assume-console [ left-click 1, 8 press enter ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data screen-should-contain [ . . . abc . @@ -354,7 +353,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset @@ -374,7 +373,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -390,13 +389,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # create an editor, type something, undo assume-screen 10/width, 5/height 1:address:array:character <- new [a] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data assume-console [ type [012] press ctrl-z ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data screen-should-contain [ . . .a . @@ -408,7 +407,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # all characters must be back screen-should-contain [ @@ -422,7 +421,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [3] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -436,13 +435,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } { typing:address:insert-operation <- maybe-convert *op, typing:variant break-unless typing - insert-from:address:duplex-list <- get *typing, insert-from:offset # ignore insert-to because it's already been spliced away + insert-from:address:duplex-list:character <- get *typing, insert-from:offset # ignore insert-to because it's already been spliced away # assert insert-to matches next-duplex(*before-cursor) insert-duplex-range *before-cursor, insert-from # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen *cursor-row <- get *typing, after-row:offset *cursor-column <- get *typing, after-column:offset - top:address:address:duplex-list <- get *editor, top-of-screen:offset + top:address:address:duplex-list:character <- get-address *editor, top-of-screen:offset *top <- get *typing, after-top-of-screen:offset } ] @@ -451,13 +450,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # create an editor, type something, undo assume-screen 10/width, 5/height 1:address:array:character <- new [] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data assume-console [ type [012] press ctrl-z ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data screen-should-contain [ . . . . @@ -469,7 +468,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # all characters must be back screen-should-contain [ @@ -483,7 +482,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [3] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -499,18 +498,18 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [abc def ghi] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data assume-console [ type [1] press ctrl-z ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data # do some more work assume-console [ type [0] ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data screen-should-contain [ . . .0abc . @@ -523,7 +522,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # nothing should happen screen-should-contain [ @@ -539,7 +538,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # create an editor assume-screen 10/width, 5/height 1:address:array:character <- new [] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # insert some text and tabs, hit enter, some more text and tabs assume-console [ @@ -551,7 +550,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press tab type [efg] ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data screen-should-contain [ . . . ab cd . @@ -570,7 +569,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # typing in second line deleted, but not indent 3:number <- get *2:address:editor-data, cursor-row:offset @@ -591,7 +590,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # indent and newline deleted 3:number <- get *2:address:editor-data, cursor-row:offset @@ -611,7 +610,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # empty screen 3:number <- get *2:address:editor-data, cursor-row:offset @@ -631,7 +630,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # first line inserted 3:number <- get *2:address:editor-data, cursor-row:offset @@ -651,7 +650,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # newline and indent inserted 3:number <- get *2:address:editor-data, cursor-row:offset @@ -672,7 +671,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # indent and newline deleted 3:number <- get *2:address:editor-data, cursor-row:offset @@ -698,19 +697,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [abc def ghi] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # move the cursor assume-console [ left-click 3, 1 ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data # undo assume-console [ press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -724,7 +723,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -738,17 +737,17 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } after <move-cursor-begin> [ before-cursor-row:number <- get *editor, cursor-row:offset before-cursor-column:number <- get *editor, cursor-column:offset - before-top-of-screen:address:duplex-list <- get *editor, top-of-screen:offset + before-top-of-screen:address:duplex-list:character <- get *editor, top-of-screen:offset ] before <move-cursor-end> [ after-cursor-row:number <- get *editor, cursor-row:offset after-cursor-column:number <- get *editor, cursor-column:offset - after-top-of-screen:address:duplex-list <- get *editor, top-of-screen:offset + after-top-of-screen:address:duplex-list:character <- get *editor, top-of-screen:offset { break-unless undo-coalesce-tag # if previous operation was also a move, and also had the same coalesce # tag, coalesce with it - undo:address:address:list <- get-address *editor, undo:offset + undo:address:address:list:address:operation <- get-address *editor, undo:offset break-unless *undo op:address:operation <- first *undo move:address:move-operation <- maybe-convert *op, move:variant @@ -760,7 +759,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } *after-row <- copy after-cursor-row after-column:address:number <- get-address *move, after-column:offset *after-column <- copy after-cursor-column - after-top:address:number <- get-address *move, after-top-of-screen:offset + after-top:address:address:duplex-list:character <- get-address *move, after-top-of-screen:offset *after-top <- get *editor, top-of-screen:offset break +done-adding-move-operation:label } @@ -775,7 +774,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } move:address:move-operation <- maybe-convert *op, move:variant break-unless move # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen - top:address:address:duplex-list <- get-address *editor, top-of-screen:offset + top:address:address:duplex-list:character <- get-address *editor, top-of-screen:offset *cursor-row <- get *move, before-row:offset *cursor-column <- get *move, before-column:offset *top <- get *move, before-top-of-screen:offset @@ -789,13 +788,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [a b cdefgh] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 5/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 5/right # position cursor at end of screen and try to move right assume-console [ left-click 3, 3 press right-arrow ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset # screen scrolls @@ -814,7 +813,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -835,7 +834,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -851,20 +850,20 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [abc def ghi] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # move the cursor assume-console [ left-click 3, 1 press left-arrow ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data # undo assume-console [ press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -878,7 +877,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -895,14 +894,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [abc def ghi] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # move the cursor assume-console [ left-click 3, 1 press up-arrow ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset memory-should-contain [ @@ -914,7 +913,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -928,7 +927,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -945,20 +944,20 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [abc def ghi] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # move the cursor assume-console [ left-click 2, 1 press down-arrow ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data # undo assume-console [ press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -972,7 +971,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -992,19 +991,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } d e f] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # scroll the page assume-console [ press ctrl-f ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data # undo assume-console [ press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1027,19 +1026,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } d e f] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # scroll the page assume-console [ press page-down ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data # undo assume-console [ press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1062,20 +1061,20 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } d e f] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # scroll the page down and up assume-console [ press page-down press ctrl-b ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data # undo assume-console [ press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1098,20 +1097,20 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } d e f] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # scroll the page down and up assume-console [ press page-down press page-up ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data # undo assume-console [ press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1131,20 +1130,20 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [abc def ghi] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # move the cursor, then to start of line assume-console [ left-click 2, 1 press ctrl-a ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data # undo assume-console [ press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1158,7 +1157,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -1175,20 +1174,20 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [abc def ghi] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # move the cursor, then to start of line assume-console [ left-click 2, 1 press home ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data # undo assume-console [ press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1202,7 +1201,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -1219,20 +1218,20 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [abc def ghi] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # move the cursor, then to start of line assume-console [ left-click 2, 1 press ctrl-e ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data # undo assume-console [ press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1246,7 +1245,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -1263,20 +1262,20 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [abc def ghi] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # move the cursor, then to start of line assume-console [ left-click 2, 1 press end ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data # undo assume-console [ press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1290,7 +1289,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -1305,14 +1304,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # create an editor, type some text, move the cursor, type some more text assume-screen 10/width, 5/height 1:address:array:character <- new [] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data assume-console [ type [abc] left-click 1, 1 type [d] ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset screen-should-contain [ @@ -1330,7 +1329,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1350,7 +1349,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1370,7 +1369,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1390,7 +1389,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1410,7 +1409,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1430,7 +1429,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1453,7 +1452,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [abc def ghi] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # move the cursor assume-console [ @@ -1462,7 +1461,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press right-arrow press up-arrow ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset memory-should-contain [ @@ -1474,7 +1473,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1488,7 +1487,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1507,19 +1506,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } 1:address:array:character <- new [abc def ghi] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data assume-console [ left-click 3, 1 press ctrl-z ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data # redo assume-console [ press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset ] @@ -1533,7 +1532,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -1551,7 +1550,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen *cursor-row <- get *move, after-row:offset *cursor-column <- get *move, after-column:offset - top:address:address:duplex-list <- get *editor, top-of-screen:offset + top:address:address:duplex-list:character <- get-address *editor, top-of-screen:offset *top <- get *move, after-top-of-screen:offset } ] @@ -1562,7 +1561,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # create an editor assume-screen 10/width, 5/height 1:address:array:character <- new [] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # insert some text and hit backspace assume-console [ @@ -1570,7 +1569,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press backspace press backspace ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data screen-should-contain [ . . .a . @@ -1588,7 +1587,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset @@ -1607,7 +1606,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset @@ -1625,13 +1624,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # save operation to undo after <backspace-character-begin> [ - top-before:address:duplex-list <- get *editor, top-of-screen:offset + top-before:address:duplex-list:character <- get *editor, top-of-screen:offset ] before <backspace-character-end> [ { break-unless backspaced-cell # backspace failed; don't add an undo operation - top-after:address:duplex-list <- get *editor, top-of-screen:offset - undo:address:address:list <- get-address *editor, undo:offset + top-after:address:duplex-list:character <- get *editor, top-of-screen:offset + undo:address:address:list:address:operation <- get-address *editor, undo:offset { # if previous operation was an insert, coalesce this operation with it break-unless *undo @@ -1641,22 +1640,22 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } previous-coalesce-tag:number <- get *deletion, tag:offset coalesce?:boolean <- equal previous-coalesce-tag, 1/coalesce-backspace break-unless coalesce? - delete-from:address:address:duplex-list <- get-address *deletion, delete-from:offset + delete-from:address:address:duplex-list:character <- get-address *deletion, delete-from:offset *delete-from <- copy *before-cursor - backspaced-so-far:address:address:duplex-list <- get-address *deletion, deleted-text:offset + backspaced-so-far:address:address:duplex-list:character <- get-address *deletion, deleted-text:offset insert-duplex-range backspaced-cell, *backspaced-so-far *backspaced-so-far <- copy backspaced-cell after-row:address:number <- get-address *deletion, after-row:offset *after-row <- copy *cursor-row after-column:address:number <- get-address *deletion, after-column:offset *after-column <- copy *cursor-column - after-top:address:number <- get-address *deletion, after-top-of-screen:offset + after-top:address:address:duplex-list:character <- get-address *deletion, after-top-of-screen:offset *after-top <- get *editor, top-of-screen:offset break +done-adding-backspace-operation:label } # if not, create a new operation op:address:operation <- new operation:type - deleted-until:address:duplex-list <- next-duplex *before-cursor + deleted-until:address:duplex-list:character <- next-duplex *before-cursor *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, *cursor-row/after, *cursor-column/after, top-after, backspaced-cell/deleted, *before-cursor/delete-from, deleted-until, 1/coalesce-backspace editor <- add-operation editor, op +done-adding-backspace-operation @@ -1667,17 +1666,17 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } { deletion:address:delete-operation <- maybe-convert *op, delete:variant break-unless deletion - start2:address:address:duplex-list <- get-address *editor, data:offset - anchor:address:duplex-list <- get *deletion, delete-from:offset + start2:address:address:duplex-list:character <- get-address *editor, data:offset + anchor:address:duplex-list:character <- get *deletion, delete-from:offset break-unless anchor - deleted:address:duplex-list <- get *deletion, deleted-text:offset - old-cursor:address:duplex-list <- last-duplex deleted + deleted:address:duplex-list:character <- get *deletion, deleted-text:offset + old-cursor:address:duplex-list:character <- last-duplex deleted insert-duplex-range anchor, deleted # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen *before-cursor <- copy old-cursor *cursor-row <- get *deletion, before-row:offset *cursor-column <- get *deletion, before-column:offset - top:address:address:duplex-list <- get *editor, top-of-screen:offset + top:address:address:duplex-list:character <- get-address *editor, top-of-screen:offset *top <- get *deletion, before-top-of-screen:offset } ] @@ -1686,13 +1685,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } { deletion:address:delete-operation <- maybe-convert *op, delete:variant break-unless deletion - start:address:duplex-list <- get *deletion, delete-from:offset - end:address:duplex-list <- get *deletion, delete-until:offset + start:address:duplex-list:character <- get *deletion, delete-from:offset + end:address:duplex-list:character <- get *deletion, delete-until:offset remove-duplex-between start, end # assert cursor-row/cursor-column/top-of-screen match after-row/after-column/after-top-of-screen *cursor-row <- get *deletion, after-row:offset *cursor-column <- get *deletion, after-column:offset - top:address:address:duplex-list <- get *editor, top-of-screen:offset + top:address:address:duplex-list:character <- get-address *editor, top-of-screen:offset *top <- get *deletion, after-top-of-screen:offset } ] @@ -1703,7 +1702,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } # create an editor assume-screen 10/width, 5/height 1:address:array:character <- new [] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # insert some text and hit delete and backspace a few times assume-console [ @@ -1714,7 +1713,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press delete press delete ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data screen-should-contain [ . . .af . @@ -1732,7 +1731,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset @@ -1751,7 +1750,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset @@ -1770,7 +1769,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] 3:number <- get *2:address:editor-data, cursor-row:offset 4:number <- get *2:address:editor-data, cursor-column:offset @@ -1789,7 +1788,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # first line inserted 3:number <- get *2:address:editor-data, cursor-row:offset @@ -1809,7 +1808,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # first line inserted 3:number <- get *2:address:editor-data, cursor-row:offset @@ -1829,7 +1828,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # first line inserted 3:number <- get *2:address:editor-data, cursor-row:offset @@ -1847,13 +1846,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] after <delete-character-begin> [ - top-before:address:duplex-list <- get *editor, top-of-screen:offset + top-before:address:duplex-list:character <- get *editor, top-of-screen:offset ] before <delete-character-end> [ { break-unless deleted-cell # delete failed; don't add an undo operation - top-after:address:duplex-list <- get *editor, top-of-screen:offset - undo:address:address:list <- get-address *editor, undo:offset + top-after:address:duplex-list:character <- get *editor, top-of-screen:offset + undo:address:address:list:address:operation <- get-address *editor, undo:offset { # if previous operation was an insert, coalesce this operation with it break-unless *undo @@ -1863,21 +1862,21 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } previous-coalesce-tag:number <- get *deletion, tag:offset coalesce?:boolean <- equal previous-coalesce-tag, 2/coalesce-delete break-unless coalesce? - delete-until:address:address:duplex-list <- get-address *deletion, delete-until:offset + delete-until:address:address:duplex-list:character <- get-address *deletion, delete-until:offset *delete-until <- next-duplex *before-cursor - deleted-so-far:address:address:duplex-list <- get-address *deletion, deleted-text:offset + deleted-so-far:address:address:duplex-list:character <- get-address *deletion, deleted-text:offset *deleted-so-far <- append-duplex *deleted-so-far, deleted-cell after-row:address:number <- get-address *deletion, after-row:offset *after-row <- copy *cursor-row after-column:address:number <- get-address *deletion, after-column:offset *after-column <- copy *cursor-column - after-top:address:number <- get-address *deletion, after-top-of-screen:offset + after-top:address:address:duplex-list:character <- get-address *deletion, after-top-of-screen:offset *after-top <- get *editor, top-of-screen:offset break +done-adding-delete-operation:label } # if not, create a new operation op:address:operation <- new operation:type - deleted-until:address:duplex-list <- next-duplex *before-cursor + deleted-until:address:duplex-list:character <- next-duplex *before-cursor *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, *cursor-row/after, *cursor-column/after, top-after, deleted-cell/deleted, *before-cursor/delete-from, deleted-until, 2/coalesce-delete editor <- add-operation editor, op +done-adding-delete-operation @@ -1891,14 +1890,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 10/width, 5/height 1:address:array:character <- new [abc def] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # insert some text and hit delete and backspace a few times assume-console [ left-click 1, 1 press ctrl-k ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data screen-should-contain [ . . .a . @@ -1917,7 +1916,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -1937,7 +1936,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # first line inserted screen-should-contain [ @@ -1958,7 +1957,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -1970,15 +1969,15 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] after <delete-to-end-of-line-begin> [ - top-before:address:duplex-list <- get *editor, top-of-screen:offset + top-before:address:duplex-list:character <- get *editor, top-of-screen:offset ] before <delete-to-end-of-line-end> [ { break-unless deleted-cells # delete failed; don't add an undo operation - top-after:address:duplex-list <- get *editor, top-of-screen:offset - undo:address:address:list <- get-address *editor, undo:offset + top-after:address:duplex-list:character <- get *editor, top-of-screen:offset + undo:address:address:list:address:operation <- get-address *editor, undo:offset op:address:operation <- new operation:type - deleted-until:address:duplex-list <- next-duplex *before-cursor + deleted-until:address:duplex-list:character <- next-duplex *before-cursor *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, *cursor-row/after, *cursor-column/after, top-after, deleted-cells/deleted, *before-cursor/delete-from, deleted-until, 0/never-coalesce editor <- add-operation editor, op +done-adding-delete-operation @@ -1992,14 +1991,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } assume-screen 10/width, 5/height 1:address:array:character <- new [abc def] - 2:address:editor-data <- new-editor 1:address:array:character, screen:address, 0/left, 10/right + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right editor-render screen, 2:address:editor-data # insert some text and hit delete and backspace a few times assume-console [ left-click 1, 2 press ctrl-u ] - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data screen-should-contain [ . . .c . @@ -2018,7 +2017,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-z ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -2038,7 +2037,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } press ctrl-y ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] # first line inserted screen-should-contain [ @@ -2059,7 +2058,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } type [1] ] run [ - editor-event-loop screen:address, console:address, 2:address:editor-data + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data ] screen-should-contain [ . . @@ -2071,21 +2070,42 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } ] after <delete-to-start-of-line-begin> [ - top-before:address:duplex-list <- get *editor, top-of-screen:offset + top-before:address:duplex-list:character <- get *editor, top-of-screen:offset ] before <delete-to-start-of-line-end> [ { break-unless deleted-cells # delete failed; don't add an undo operation - top-after:address:duplex-list <- get *editor, top-of-screen:offset - undo:address:address:list <- get-address *editor, undo:offset + top-after:address:duplex-list:character <- get *editor, top-of-screen:offset + undo:address:address:list:address:operation <- get-address *editor, undo:offset op:address:operation <- new operation:type - deleted-until:address:duplex-list <- next-duplex *before-cursor + deleted-until:address:duplex-list:character <- next-duplex *before-cursor *op <- merge 2/delete-operation, save-row/before, save-column/before, top-before, *cursor-row/after, *cursor-column/after, top-after, deleted-cells/deleted, *before-cursor/delete-from, deleted-until, 0/never-coalesce editor <- add-operation editor, op +done-adding-delete-operation } ] +scenario editor-can-undo-and-redo-ctrl-u-2 [ + # create an editor + assume-screen 10/width, 5/height + 1:address:array:character <- new [] + 2:address:editor-data <- new-editor 1:address:array:character, screen:address:screen, 0/left, 10/right + editor-render screen, 2:address:editor-data + # insert some text and hit delete and backspace a few times + assume-console [ + type [abc] + press ctrl-u + press ctrl-z + ] + editor-event-loop screen:address:screen, console:address:console, 2:address:editor-data + screen-should-contain [ + . . + .abc . + .┈┈┈┈┈┈┈┈┈┈. + . . + ] +] + # todo: # operations for recipe side and each sandbox-data # undo delete sandbox as a separate primitive on the status bar diff --git a/html/factorial.mu.html b/html/factorial.mu.html index d3837c22..31ac9c26 100644 --- a/html/factorial.mu.html +++ b/html/factorial.mu.html @@ -13,13 +13,13 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } .muScenario { color: #00af00; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .Special { color: #ff6060; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> diff --git a/html/fork.mu.html b/html/fork.mu.html index 09d02860..69dc4e30 100644 --- a/html/fork.mu.html +++ b/html/fork.mu.html @@ -13,11 +13,11 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> diff --git a/html/static_dispatch.mu.html b/html/static_dispatch.mu.html new file mode 100644 index 00000000..c3ed60ef --- /dev/null +++ b/html/static_dispatch.mu.html @@ -0,0 +1,55 @@ +<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> +<html> +<head> +<meta http-equiv="content-type" content="text/html; charset=UTF-8"> +<title>Mu - static_dispatch.mu</title> +<meta name="Generator" content="Vim/7.4"> +<meta name="plugin-version" content="vim7.4_v1"> +<meta name="syntax" content="none"> +<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> +<meta name="colorscheme" content="minimal"> +<style type="text/css"> + +</style> + +<script type='text/javascript'> + +</script> +</head> +<body> +<pre id='vimCodeElement'> +recipe test a:number -> b:number [ + local-scope + load-ingredients + b <- add a, 1 +] + +recipe test a:number, b:number -> c:number [ + local-scope + load-ingredients + c <- add a, b +] + +recipe main [ + local-scope + a:number <- test 3 # selects single-ingredient version + $print a, 10/newline + b:number <- test 3, 4 # selects double-ingredient version + $print b, 10/newline + c:number <- test 3, 4, 5 # prefers double- to single-ingredient version + $print c, 10/newline +] +</pre> +</body> +</html> + diff --git a/html/tangle.mu.html b/html/tangle.mu.html index e3dba023..118b2386 100644 --- a/html/tangle.mu.html +++ b/html/tangle.mu.html @@ -13,12 +13,12 @@ pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } +.muControl { color: #c0a020; } .muRecipe { color: #ff8700; } .Comment { color: #9090ff; } .Constant { color: #00a0a0; } .Special { color: #ff6060; } .Delimiter { color: #a04060; } -.muControl { color: #c0a020; } --> </style> @@ -42,19 +42,19 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; } local-scope n:number <- next-ingredient { - +base-case + <base-case> } - +recursive-case + <recursive-case> ] -after +base-case [ +after <base-case> [ # if n=0 return 1 zero?:boolean <- equal n, 0 break-unless zero? reply 1 ] -after +recursive-case [ +after <recursive-case> [ # return n * factorial(n - 1) x:number <- subtract n, 1 subresult:number <- factorial x


context:
space:
mode: