about summary refs log tree commit diff stats
path: root/archive/1.vm/053recipe_header.cc
blob: 73fde5106a435908a93d3165af74bab4ddfbfd36 (plain) (blame) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
14
# read up to 'len' graphemes after skipping the first 'start' ones
fn substring in: (addr array byte), start: int, len: int, out-ah: (addr handle array byte) {
  var in-stream: (stream byte 0x100)
  var in-stream-addr/esi: (addr stream byte) <- address in-stream
  write in-stream-addr, in
  var out-stream: (stream byte 0x100)
  var out-stream-addr/edi: (addr stream byte) <- address out-stream
  $substring:core: {
    # skip 'start' graphemes
    var i/eax: int <- copy 0
    {
      compare i, start
      break-if->=
      {
        var dummy/eax: grapheme <- read-grapheme in-stream-addr
        compare dummy, 0xffffffff/end-of-file
        break-if-= $substring:core
      }
      i <- increment
      loop
    }
    # copy 'len' graphemes
    i <- copy 0
    {
      compare i, len
      break-if->=
      {
        var g/eax: grapheme <- read-grapheme in-stream-addr
        compare g, 0xffffffff/end-of-file
        break-if-= $substring:core
        write-grapheme out-stream-addr, g
      }
      i <- increment
      loop
    }
  }
  stream-to-array out-stream-addr, out-ah
}

fn test-substring {
  var out-h: (handle array byte)
  var out-ah/edi: (addr handle array byte) <- address out-h
  # prefix substrings
  substring 0, 0, 3, out-ah
  var out/eax: (addr array byte) <- lookup *out-ah
  check-strings-equal out, "", "F - test-substring/null"
  substring "", 0, 3, out-ah
  var out/eax: (addr array byte) <- lookup *out-ah
#?   print-string-to-real-screen out
#?   print-string-to-real-screen "\n"
  check-strings-equal out, "", "F - test-substring/empty"
  #
  substring "abcde", 0, 3, out-ah
  var out/eax: (addr array byte) <- lookup *out-ah
#?   print-string-to-real-pre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
//: Advanced notation for the common/easy case where a recipe takes some fixed
//: number of ingredients and yields some fixed number of products.

void test_recipe_with_header() {
  run(
      "def main [\n"
      "  1:num/raw <- add2 3, 5\n"
      "]\n"
      "def add2 x:num, y:num -> z:num [\n"
      "  local-scope\n"
      "  load-ingredients\n"
      "  z:num <- add x, y\n"
      "  return z\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "mem: storing 8 in location 1\n"
  );
}

//: 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")
if (in.peek() != '[') {
  trace(101, "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 (has_data(in) && in.peek() != '[' && in.peek() != '\n') {
    string s = next_word(in);
    if (s.empty()) {
      assert(!has_data(in));
      raise << "incomplete recipe header at end of file (0)\n" << end();
      return;
    }
    if (s == "<-")
      raise << "recipe " << result.name << " should say '->' and not '<-'\n" << end();
    if (s == "->") break;
    result.ingredients.push_back(reagent(s));
    trace(101, "parse") << "header ingredient: " << result.ingredients.back().original_string << end();
    skip_whitespace_but_not_newline(in);
  }
  while (has_data(in) && in.peek() != '[' && in.peek() != '\n') {
    string s = next_word(in);
    if (s.empty()) {
      assert(!has_data(in));
      raise << "incomplete recipe header at end of file (1)\n" << end();
      return;
    }
    result.products.push_back(reagent(s));
    trace(101, "parse") << "header product: " << result.products.back().original_string << end();
    skip_whitespace_but_not_newline(in);
  }
  // End Load Recipe Header(result)
}

void test_recipe_handles_stray_comma() {
  run(
      "def main [\n"
      "  1:num/raw <- add2 3, 5\n"
      "]\n"
      "def add2 x:num, y:num -> z:num, [\n"
      "  local-scope\n"
      "  load-ingredients\n"
      "  z:num <- add x, y\n"
      "  return z\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "mem: storing 8 in location 1\n"
  );
}

void test_recipe_handles_stray_comma_2() {
  run(
      "def main [\n"
      "  foo\n"
      "]\n"
      "def foo, [\n"
      "  1:num/raw <- add 2, 2\n"
      "]\n"
      "def bar [\n"
      "  1:num/raw <- add 2, 3\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "mem: storing 4 in location 1\n"
  );
}

void test_recipe_handles_wrong_arrow() {
  Hide_errors = true;
  run(
      "def foo a:num <- b:num [\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "error: recipe foo should say '->' and not '<-'\n"
  );
}

void test_recipe_handles_missing_bracket() {
  Hide_errors = true;
  run(
      "def main\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "error: main: recipe body must begin with '['\n"
  );
}

void test_recipe_handles_missing_bracket_2
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-23 02:00:00 +0000
lass="p">( "def main\n" " local-scope\n" " {\n" " }\n" "]\n" ); // doesn't overflow line when reading header CHECK_TRACE_DOESNT_CONTAIN("parse: header ingredient: local-scope"); CHECK_TRACE_CONTENTS( "error: main: recipe body must begin with '['\n" ); } void test_recipe_handles_missing_bracket_3() { Hide_errors = true; run( "def main # comment\n" " local-scope\n" " {\n" " }\n" "]\n" ); // doesn't overflow line when reading header CHECK_TRACE_DOESNT_CONTAIN("parse: header ingredient: local-scope"); CHECK_TRACE_CONTENTS( "error: main: recipe body must begin with '['\n" ); } :(after "Begin debug_string(recipe x)") out << "ingredients:\n"; for (int i = 0; i < SIZE(x.ingredients); ++i) out << " " << debug_string(x.ingredients.at(i)) << '\n'; out << "products:\n"; for (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. :(code) void test_recipe_without_ingredients_or_products_has_header() { run( "def test [\n" " 1:num <- copy 34\n" "]\n" ); CHECK_TRACE_CONTENTS( "parse: recipe test has a header\n" ); } :(before "End Recipe Body(result)") if (!result.has_header) { result.has_header = true; for (int i = 0; i < SIZE(result.steps); ++i) { const instruction& inst = result.steps.at(i); if ((inst.name == "reply" && !inst.ingredients.empty()) || (inst.name == "return" && !inst.ingredients.empty()) || inst.name == "next-ingredient" || inst.name == "ingredient" || inst.name == "rewind-ingredients") { result.has_header = false; break; } } } if (result.has_header) { trace(101, "parse") << "recipe " << result.name << " has a header" << end(); } //: Support type abbreviations in headers. :(code) void test_type_abbreviations_in_recipe_headers() { run( "def main [\n" " local-scope\n" " a:text <- foo\n" " 1:char/raw <- index *a, 0\n" "]\n" "def foo -> a:text [ # 'text' is an abbreviation\n" " local-scope\n" " load-ingredients\n" " a <- new [abc]\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 97 in location 1\n" ); } :(before "End Expand Type Abbreviations(caller)") for (long int i = 0; i < SIZE(caller.ingredients); ++i) expand_type_abbreviations(caller.ingredients.at(i).type); for (long int i = 0; i < SIZE(caller.products); ++i) expand_type_abbreviations(caller.products.at(i).type); //: 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.name == "load-inputs") { curr.clear(); recipe_ordinal op = get(Recipe_ordinal, "next-ingredient-without-typechecking"); for (int i = 0; i < SIZE(result.ingredients); ++i) { curr.operation = op; curr.name = "next-ingredient-without-typechecking"; curr.products.push_back(result.ingredients.at(i)); result.steps.push_back(curr); curr.clear(); } } if (curr.name == "next-ingredient-without-typechecking") { raise << maybe(result.name) << "never call 'next-ingredient-without-typechecking' directly\n" << end(); curr.clear(); } //: internal version of next-ingredient; don't call this directly :(before "End Primitive Recipe Declarations") NEXT_INGREDIENT_WITHOUT_TYPECHECKING, :(before "End Primitive Recipe Numbers") put(Recipe_ordinal, "next-ingredient-without-typechecking", NEXT_INGREDIENT_WITHOUT_TYPECHECKING); :(before "End Primitive Recipe Checks") case NEXT_INGREDIENT_WITHOUT_TYPECHECKING: { break; } :(before "End Primitive Recipe Implementations") case NEXT_INGREDIENT_WITHOUT_TYPECHECKING: { assert(!Current_routine->calls.empty()); if (current_call().next_ingredient_to_process < SIZE(current_call().ingredient_atoms)) { products.push_back( 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_call().next_ingredient_to_process; } else { products.resize(2); // pad the first product with sufficient zeros to match its type products.at(0).resize(size_of(current_instruction().products.at(0))); products.at(1).push_back(0); } break; } //: more useful error messages if someone forgets 'load-ingredients' :(code) void test_load_ingredients_missing_error() { Hide_errors = true; run( "def foo a:num [\n" " local-scope\n" " b:num <- add a:num, 1\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: foo: tried to read ingredient 'a' in 'b:num <- add a:num, 1' but it hasn't been written to yet\n" "error: did you forget 'load-ingredients'?\n" ); } :(after "use-before-set Error") if (is_present_in_ingredients(caller, ingredient.name)) raise << " did you forget 'load-ingredients'?\n" << end(); :(code) void test_load_ingredients_missing_error_2() { Hide_errors = true; run( "def foo a:num [\n" " local-scope\n" " b:num <- add a, 1\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: foo: missing type for 'a' in 'b:num <- add a, 1'\n" "error: did you forget 'load-ingredients'?\n" ); } :(after "missing-type Error 1") if (is_present_in_ingredients(get(Recipe, get(Recipe_ordinal, recipe_name)), x.name)) raise << " did you forget 'load-ingredients'?\n" << end(); :(code) bool is_present_in_ingredients(const recipe& callee, const string& ingredient_name) { for (int i = 0; i < SIZE(callee.ingredients); ++i) { if (callee.ingredients.at(i).name == ingredient_name) return true; } return false; } //:: Check all calls against headers. void test_show_clear_error_on_bad_call() { Hide_errors = true; run( "def main [\n" " 1:num <- foo 34\n" "]\n" "def foo x:point -> y:num [\n" " local-scope\n" " load-ingredients\n" " return 35\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: main: ingredient 0 has the wrong type at '1:num <- foo 34'\n" ); } void test_show_clear_error_on_bad_call_2() { Hide_errors = true; run( "def main [\n" " 1:point <- foo 34\n" "]\n" "def foo x:num -> y:num [\n" " local-scope\n" " load-ingredients\n" " return x\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: main: product 0 has the wrong type at '1:point <- foo 34'\n" ); } :(after "Transform.push_back(check_instruction)") Transform.push_back(check_calls_against_header); // idempotent :(code) void check_calls_against_header(const recipe_ordinal r) { const recipe& caller = get(Recipe, r); trace(101, "transform") << "--- type-check calls inside recipe " << caller.name << end(); for (int i = 0; i < SIZE(caller.steps); ++i) { const instruction& inst = caller.steps.at(i); if (is_primitive(inst.operation)) continue; const recipe& callee = get(Recipe, inst.operation); if (!callee.has_header) continue; for (long int i = 0; i < min(SIZE(inst.ingredients), SIZE(callee.ingredients)); ++i) { // ingredients coerced from call to callee if (!types_coercible(callee.ingredients.at(i), inst.ingredients.at(i))) { raise << maybe(caller.name) << "ingredient " << i << " has the wrong type at '" << to_original_string(inst) << "'\n" << end(); raise << " ['" << to_string(callee.ingredients.at(i).type) << "' vs '" << to_string(inst.ingredients.at(i).type) << "']\n" << end(); } } for (long int i = 0; i < min(SIZE(inst.products), SIZE(callee.products)); ++i) { if (is_dummy(inst.products.at(i))) continue; // products coerced from callee to call if (!types_coercible(inst.products.at(i), callee.products.at(i))) { raise << maybe(caller.name) << "product " << i << " has the wrong type at '" << to_original_string(inst) << "'\n" << end(); raise << " ['" << to_string(inst.products.at(i).type) << "' vs '" << to_string(callee.products.at(i).type) << "']\n" << end(); } } } } //:: Check types going in and out of all recipes with headers. void test_recipe_headers_are_checked() { Hide_errors = true; transform( "def add2 x:num, y:num -> z:num [\n" " local-scope\n" " load-ingredients\n" " z:&:num <- copy 0/unsafe\n" " return z\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: add2: replied with the wrong type at 'return z'\n" ); } :(before "End Checks") Transform.push_back(check_return_instructions_against_header); // idempotent :(code) void check_return_instructions_against_header(const recipe_ordinal r) { const recipe& caller_recipe = get(Recipe, r); if (!caller_recipe.has_header) return; trace(101, "transform") << "--- checking return instructions against header for " << caller_recipe.name << end(); for (int i = 0; i < SIZE(caller_recipe.steps); ++i) { const instruction& inst = caller_recipe.steps.at(i); if (inst.name != "reply" && inst.name != "return") continue; if (SIZE(caller_recipe.products) != SIZE(inst.ingredients)) { raise << maybe(caller_recipe.name) << "replied with the wrong number of products at '" << to_original_string(inst) << "'\n" << end(); continue; } for (int i = 0; i < SIZE(caller_recipe.products); ++i) { if (!types_match(caller_recipe.products.at(i), inst.ingredients.at(i))) raise << maybe(caller_recipe.name) << "replied with the wrong type at '" << to_original_string(inst) << "'\n" << end(); } } } void test_recipe_headers_are_checked_2() { Hide_errors = true; transform( "def add2 x:num, y:num [\n" " local-scope\n" " load-ingredients\n" " z:&:num <- copy 0/unsafe\n" " return z\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: add2: replied with the wrong number of products at 'return z'\n" ); } void test_recipe_headers_are_checked_against_pre_transformed_instructions() { Hide_errors = true; transform( "def foo -> x:num [\n" " local-scope\n" " x:num <- copy 0\n" " z:bool <- copy false\n" " return-if z, z\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: foo: replied with the wrong type at 'return-if z, z'\n" ); } void test_recipe_headers_check_for_duplicate_names() { Hide_errors = true; transform( "def foo x:num, x:num -> z:num [\n" " local-scope\n" " load-ingredients\n" " return z\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: foo: 'x' can't repeat in the ingredients\n" ); } void test_recipe_headers_check_for_duplicate_names_2() { Hide_errors = true; transform( "def foo x:num, x:num [ # no result\n" " local-scope\n" " load-ingredients\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: foo: 'x' can't repeat in the ingredients\n" ); } void test_recipe_headers_check_for_missing_types() { Hide_errors = true; transform( "def main [\n" " foo 0\n" "]\n" "def foo a [\n" // no type for 'a' "]\n" ); CHECK_TRACE_CONTENTS( "error: foo: ingredient 'a' has no type\n" ); } :(before "End recipe Fields") map<string, int> ingredient_index; :(after "Begin Instruction Modifying Transforms") Transform.push_back(check_header_ingredients); // idempotent :(code) void check_header_ingredients(const recipe_ordinal r) { recipe& caller_recipe = get(Recipe, r); caller_recipe.ingredient_index.clear(); trace(101, "transform") << "--- checking return instructions against header for " << caller_recipe.name << end(); for (int i = 0; i < SIZE(caller_recipe.ingredients); ++i) { if (caller_recipe.ingredients.at(i).type == NULL) raise << maybe(caller_recipe.name) << "ingredient '" << caller_recipe.ingredients.at(i).name << "' has no type\n" << end(); if (contains_key(caller_recipe.ingredient_index, caller_recipe.ingredients.at(i).name)) raise << 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. void test_deduce_instruction_types_from_recipe_header() { run( "def main [\n" " 1:num/raw <- add2 3, 5\n" "]\n" "def add2 x:num, y:num -> z:num [\n" " local-scope\n" " load-ingredients\n" " z <- add x, y # no type for z\n" " return z\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 8 in location 1\n" ); } :(after "Begin Type Modifying Transforms") 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(101, "transform") << "--- deduce types from header for " << caller_recipe.name << end(); map<string, const type_tree*> header_type; for (int i = 0; i < SIZE(caller_recipe.ingredients); ++i) { if (!caller_recipe.ingredients.at(i).type) continue; // error handled elsewhere put(header_type, caller_recipe.ingredients.at(i).name, caller_recipe.ingredients.at(i).type); trace(103, "transform") << "type of " << caller_recipe.ingredients.at(i).name << " is " << names_to_string(caller_recipe.ingredients.at(i).type) << end(); } for (int i = 0; i < SIZE(caller_recipe.products); ++i) { if (!caller_recipe.products.at(i).type) continue; // error handled elsewhere put(header_type, caller_recipe.products.at(i).name, caller_recipe.products.at(i).type); trace(103, "transform") << "type of " << caller_recipe.products.at(i).name << " is " << names_to_string(caller_recipe.products.at(i).type) << end(); } for (int i = 0; i < SIZE(caller_recipe.steps); ++i) { instruction& inst = caller_recipe.steps.at(i); trace(102, "transform") << "instruction: " << to_string(inst) << end(); for (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()) continue; if (!contains_key(header_type, inst.ingredients.at(i).name)) continue; // error handled elsewhere inst.ingredients.at(i).type = new type_tree(*get(header_type, inst.ingredients.at(i).name)); trace(103, "transform") << "type of " << inst.ingredients.at(i).name << " is " << names_to_string(inst.ingredients.at(i).type) << end(); } for (int i = 0; i < SIZE(inst.products); ++i) { trace(103, "transform") << " product: " << to_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()) continue; if (!contains_key(header_type, inst.products.at(i).name)) continue; // error handled elsewhere inst.products.at(i).type = new type_tree(*get(header_type, inst.products.at(i).name)); trace(103, "transform") << "type of " << inst.products.at(i).name << " is " << names_to_string(inst.products.at(i).type) << end(); } } } //: One final convenience: no need to say what to return if the information is //: in the header. void test_return_based_on_header() { run( "def main [\n" " 1:num/raw <- add2 3, 5\n" "]\n" "def add2 x:num, y:num -> z:num [\n" " local-scope\n" " load-ingredients\n" " z <- add x, y\n" " return\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 8 in location 1\n" ); } :(after "Transform.push_back(check_header_ingredients)") Transform.push_back(fill_in_return_ingredients); // idempotent :(code) void fill_in_return_ingredients(const recipe_ordinal r) { recipe& caller_recipe = get(Recipe, r); trace(101, "transform") << "--- fill in return ingredients from header for recipe " << caller_recipe.name << end(); if (!caller_recipe.has_header) return; for (int i = 0; i < SIZE(caller_recipe.steps); ++i) { instruction& inst = caller_recipe.steps.at(i); if (inst.name == "reply" || inst.name == "return") add_header_products(inst, caller_recipe); } // fall through return if (!caller_recipe.steps.empty()) { const instruction& final_instruction = caller_recipe.steps.at(SIZE(caller_recipe.steps)-1); if (final_instruction.name == "reply" || final_instruction.name == "return") return; } instruction inst; inst.name = "return"; 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" || inst.name == "return"); // collect any products with the same names as ingredients for (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()))); } } } void test_explicit_return_ignores_header() { run( "def main [\n" " 1:num/raw, 2:num/raw <- add2 3, 5\n" "]\n" "def add2 a:num, b:num -> y:num, z:num [\n" " local-scope\n" " load-ingredients\n" " y <- add a, b\n" " z <- subtract a, b\n" " return a, z\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 3 in location 1\n" "mem: storing -2 in location 2\n" ); } void test_return_on_fallthrough_based_on_header() { run( "def main [\n" " 1:num/raw <- add2 3, 5\n" "]\n" "def add2 x:num, y:num -> z:num [\n" " local-scope\n" " load-ingredients\n" " z <- add x, y\n" "]\n" ); CHECK_TRACE_CONTENTS( "transform: instruction: return {z: \"number\"}\n" "mem: storing 8 in location 1\n" ); } void test_return_on_fallthrough_already_exists() { run( "def main [\n" " 1:num/raw <- add2 3, 5\n" "]\n" "def add2 x:num, y:num -> z:num [\n" " local-scope\n" " load-ingredients\n" " z <- add x, y # no type for z\n" " return z\n" "]\n" ); CHECK_TRACE_CONTENTS( "transform: instruction: return {z: ()}\n" ); CHECK_TRACE_DOESNT_CONTAIN("transform: instruction: return z:num"); CHECK_TRACE_CONTENTS( "mem: storing 8 in location 1\n" ); } void test_return_causes_error_in_empty_recipe() { Hide_errors = true; run( "def foo -> x:num [\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: foo: tried to read ingredient 'x' in 'return x:num' but it hasn't been written to yet\n" ); } void test_return_after_conditional_return_based_on_header() { run( "def main [\n" " 1:num/raw <- add2 3, 5\n" "]\n" "def add2 x:num, y:num -> z:num [\n" " local-scope\n" " load-ingredients\n" " z <- add x, y\n" // no type for z " return-if false, 34\n" "]\n" ); CHECK_TRACE_CONTENTS( "mem: storing 8 in location 1\n" ); } void test_recipe_headers_perform_same_ingredient_check() { Hide_errors = true; run( "def main [\n" " 1:num <- copy 34\n" " 2:num <- copy 34\n" " 3:num <- add2 1:num, 2:num\n" "]\n" "def add2 x:num, y:num -> x:num [\n" " local-scope\n" " load-ingredients\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: main: '3:num <- add2 1:num, 2:num' should write to '1:num' rather than '3:num'\n" ); } //: One special-case is recipe 'main'. Make sure it's only ever taking in text //: ingredients, and returning a single number. void test_recipe_header_ingredients_constrained_for_main() { Hide_errors = true; run( "def main x:num [\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: ingredients of recipe 'main' must all be text (address:array:character)\n" ); } void test_recipe_header_products_constrained_for_main() { Hide_errors = true; run( "def main -> x:text [\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: recipe 'main' must return at most a single product, a number\n" ); } void test_recipe_header_products_constrained_for_main_2() { Hide_errors = true; run( "def main -> x:num, y:num [\n" "]\n" ); CHECK_TRACE_CONTENTS( "error: recipe 'main' must return at most a single product, a number\n" ); } :(after "Transform.push_back(expand_type_abbreviations)") Transform.push_back(check_recipe_header_constraints); :(code) void check_recipe_header_constraints(const recipe_ordinal r) { const recipe& caller = get(Recipe, r); if (caller.name != "main") return; trace(102, "transform") << "check recipe header constraints for recipe " << caller.name << end(); if (!caller.has_header) return; reagent/*local*/ expected_ingredient("x:address:array:character"); for (int i = 0; i < SIZE(caller.ingredients); ++i) { if (!types_strictly_match(expected_ingredient, caller.ingredients.at(i))) { raise << "ingredients of recipe 'main' must all be text (address:array:character)\n" << end(); break; } } int nprod = SIZE(caller.products); reagent/*local*/ expected_product("x:number"); if (nprod > 1 || (nprod == 1 && !types_strictly_match(expected_product, caller.products.at(0)))) { raise << "recipe 'main' must return at most a single product, a number\n" << end(); } }
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-23 02:00:00 +0000