# Wrappers around file system primitives that take a 'resources' object and
# are thus easier to test.
#
# - start-reading - asynchronously open a file, returning a channel source for
# receiving the results
# - start-writing - asynchronously open a file, returning a channel sink for
# the data to write
# - slurp - synchronously read from a file
# - dump - synchronously write to a file
container resources [
lock:bool
data:&:@:resource
]
container resource [
name: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 *///: Comparison primitives
:(before "End Primitive Recipe Declarations")
EQUAL,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "equal", EQUAL);
:(before "End Primitive Recipe Checks")
case EQUAL: {
if (SIZE(inst.ingredients) <= 1) {
raise << maybe(get(Recipe, r).name) << "'equal' needs at least two ingredients to compare in '" << to_original_string(inst) << "'\n" << end();
break;
}
const reagent& exemplar = inst.ingredients.at(0);
for (int i = /*skip exemplar*/1; i < SIZE(inst.ingredients); ++i) {
if (!types_match(inst.ingredients.at(i), exemplar) && !types_match(exemplar, inst.ingredients.at(i))) {
raise << maybe(get(Recipe, r).name) << "'equal' expects ingredients to be all of the same type, but got '" << to_original_string(inst) << "'\n" << end();
goto finish_checking_instruction;
}
}
if (SIZE(inst.products) > 1) {
raise << maybe(get(Recipe, r).name) << "'equal' yields exactly one product in '" << to_original_string(inst) << "'\n" << end();
break;
}
if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_boolean(inst.products.at(0))) {
raise << maybe(get(Recipe, r).name) << "'equal' should yield a boolean, but got '" << inst.products.at(0).original_string << "'\n" << end();
break;
}
break;
}
:(before "End Primitive Recipe Implementations")
case EQUAL: {
vector<double>& exemplar = ingredients.at(0);
bool result = true;
for (int i = /*skip exemplar*/1; i < SIZE(ingredients); ++i) {
if (SIZE(ingredients.at(i)) != SIZE(exemplar)) {
result = false;
break;
}
if (!equal(ingredients.at(i).begin(), ingredients.at(i).end(), exemplar.begin())) {
result = false;
break;
}
}
products.resize(1);
products.at(0).push_back(result);
break;
}
:(scenario equal)
def main [
1:num <- copy 34
2:num <- copy 33
3:bool <- equal 1:num, 2:num
]
+mem: location 1 is 34
+mem: location 2 is 33
+mem: storing 0 in location 3
:(scenario equal_2)
def main [
1:num <- copy 34
2:num <- copy 34
3:bool <- equal 1:num, 2:num
]
+mem: location 1 is 34
+mem: location 2 is 34
+mem: storing 1 in location 3
:(scenario equal_multiple)
def main [
1:bool <- equal 34, 34, 34
]
+mem: storing 1 in location 1
:(scenario equal_multiple_2)
def main [
1:bool <- equal 34, 34, 35
]
+mem: storing 0 in location 1
:(before "End Primitive Recipe Declarations")
NOT_EQUAL,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "not-equal", NOT_EQUAL);
:(before "End Primitive Recipe Checks")
case NOT_EQUAL: {
if (SIZE(inst.ingredients) != 2) {
raise << maybe(get(Recipe, r).name) << "'equal' needs two ingredients to compare in '" << to_original_string(inst) << "'\n" << end();
break;
}
const reagent& exemplar = inst.ingredients.at(0);
if (!types_match(inst.ingredients.at(1), exemplar) && !types_match(exemplar, inst.ingredients.at(1))) {
raise << maybe(get(Recipe, r).name) << "'equal' expects ingredients to be all of the same type, but got '" << to_original_string(inst) << "'\n" << end();
goto finish_checking_instruction;
}
if (SIZE(inst.products) > 1) {
raise << maybe(get(Recipe, r).name) << "'equal' yields exactly one product in '" << to_original_string(inst) << "'\n" << end();
break;
}
if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_boolean(inst.products.at(0))) {
raise << maybe(get(Recipe, r).name) << "'equal' should yield a boolean, but got '" << inst.products.at(0).original_string << "'\n" << end();
break;
}
break;
}
:(before "End Primitive Recipe Implementations")
case NOT_EQUAL: {
vector<double>& exemplar = ingredients.at(0);
products.resize(1);
if (SIZE(ingredients.at(1)) != SIZE(exemplar)) {
products.at(0).push_back(true);
break;
}
bool equal_ingredients = equal(ingredients.at(1).begin(), ingredients.at(1).end(), exemplar.begin());
products.at(0).push_back(!equal_ingredients);
break;
}
:(scenario not_equal)
def main [
1:num <- copy 34
2:num <- copy 33
3:bool <- not-equal 1:num, 2:num
]
+mem: location 1 is 34
+mem: location 2 is 33
+mem: storing 1 in location 3
:(scenario not_equal_2)
def main [
1:num <- copy 34
2:num <- copy 34
3:bool <- not-equal 1:num, 2:num
]
+mem: location 1 is 34
+mem: location 2 is 34
+mem: storing 0 in location 3
:(before "End Primitive Recipe Declarations")
GREATER_THAN,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "greater-than", GREATER_THAN);
:(before "End Primitive Recipe Checks")
case GREATER_THAN: {
if (SIZE(inst.ingredients) <= 1) {
raise << maybe(get(Recipe, r).name) << "'greater-than' needs at least two ingredients to compare in '" << to_original_string(inst) << "'\n" << end();
break;
}
for (int i = 0; i < SIZE(inst.ingredients); ++i) {
if (!is_mu_number(inst.ingredients.at(i))) {
raise << maybe(get(Recipe, r).name) << "'greater-than' can only compare numbers; got '" << inst.ingredients.at(i).original_string << "'\n" << end();
goto finish_checking_instruction;
}
}
if (SIZE(inst.products) > 1) {
raise << maybe(get(Recipe, r).name) << "'greater-than' yields exactly one product in '" << to_original_string(inst) << "'\n" << end();
break;
}
if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_boolean(inst.products.at(0))) {
raise << maybe(get(Recipe, r).name) << "'greater-than' should yield a boolean, but got '" << inst.products.at(0).original_string << "'\n" << end();
break;
}
break;
}
:(before "End Primitive Recipe Implementations")
case GREATER_THAN: {
bool result = true;
for (int i = /**/1; i < SIZE(ingredients); ++i) {
if (ingredients.at(i-1).at(0) <= ingredients.at(i).at(0)) {
result = false;
}
}
products.resize(1);
products.at(0).push_back(result);
break;
}
:(scenario greater_than)
def main [
1:num <- copy 34
2:num <- copy 33
3:bool <- greater-than 1:num, 2:num
]
+mem: storing 1 in location 3
:(scenario greater_than_2)
def main [
1:num <- copy 34
2:num <- copy 34
3:bool <- greater-than 1:num, 2:num
]
+mem: storing 0 in location 3
:(scenario greater_than_multiple)
def main [
1:bool <- greater-than 36, 35, 34
]
+mem: storing 1 in location 1
:(scenario greater_than_multiple_2)
def main [
1:bool <- greater-than 36, 35, 35
]
+mem: storing 0 in location 1
:(before "End Primitive Recipe Declarations")
LESSER_THAN,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "lesser-than", LESSER_THAN);
:(before "End Primitive Recipe Checks")
case LESSER_THAN: {
if (SIZE(inst.ingredients) <= 1) {
raise << maybe(get(Recipe, r).name) << "'lesser-than' needs at least two ingredients to compare in '" << to_original_string(inst) << "'\n" << end();
break;
}
for (int i = 0; i < SIZE(inst.ingredients); ++i) {
if (!is_mu_number(inst.ingredients.at(i))) {
raise << maybe(get(Recipe, r).name) << "'lesser-than' can only compare numbers; got '" << inst.ingredients.at(i).original_string << "'\n" << end();
goto finish_checking_instruction;
}
}
if (SIZE(inst.products) > 1) {
raise << maybe(get(Recipe, r).name) << "'lesser-than' yields exactly one product in '" << to_original_string(inst) << "'\n" << end();
break;
}
if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_boolean(inst.products.at(0))) {
raise << maybe(get(Recipe, r).name) << "'lesser-than' should yield a boolean, but got '" << inst.products.at(0).original_string << "'\n" << end();
break;
}
break;
}
:(before "End Primitive Recipe Implementations")
case LESSER_THAN: {
bool result = true;
for (int i = /**/1; i < SIZE(ingredients); ++i) {
if (ingredients.at(i-1).at(0) >= ingredients.at(i).at(0)) {
result = false;
}
}
products.resize(1);
products.at(0).push_back(result);
break;
}
:(scenario lesser_than)
def main [
1:num <- copy 32
2:num <- copy 33
3:bool <- lesser-than 1:num, 2:num
]
+mem: storing 1 in location 3
:(scenario lesser_than_2)
def main [
1:num <- copy 34
2:num <- copy 33
3:bool <- lesser-than 1:num, 2:num
]
+mem: storing 0 in location 3
:(scenario lesser_than_multiple)
def main [
1:bool <- lesser-than 34, 35, 36
]
+mem: storing 1 in location 1
:(scenario lesser_than_multiple_2)
def main [
1:bool <- lesser-than 34, 35, 35
]
+mem: storing 0 in location 1
:(before "End Primitive Recipe Declarations")
GREATER_OR_EQUAL,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "greater-or-equal", GREATER_OR_EQUAL);
:(before "End Primitive Recipe Checks")
case GREATER_OR_EQUAL: {
if (SIZE(inst.ingredients) <= 1) {
raise << maybe(get(Recipe, r).name) << "'greater-or-equal' needs at least two ingredients to compare in '" << to_original_string(inst) << "'\n" << end();
break;
}
for (int i = 0; i < SIZE(inst.ingredients); ++i) {
if (!is_mu_number(inst.ingredients.at(i))) {
raise << 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;
}
}
if (SIZE(inst.products) > 1) {
raise << maybe(get(Recipe, r).name) << "'greater-or-equal' yields exactly one product in '" << to_original_string(inst) << "'\n" << end();
break;
}
if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_boolean(inst.products.at(0))) {
raise << maybe(get(Recipe, r).name) << "'greater-or-equal' should yield a boolean, but got '" << inst.products.at(0).original_string << "'\n" << end();
break;
}
break;
}
:(before "End Primitive Recipe Implementations")
case GREATER_OR_EQUAL: {
bool result = true;
for (int i = /**/1; i < SIZE(ingredients); ++i) {
if (ingredients.at(i-1).at(0) < ingredients.at(i).at(0)) {
result = false;
}
}
products.resize(1);
products.at(0).push_back(result);
break;
}
:(scenario greater_or_equal)
def main [
1:num <- copy 34
2:num <- copy 33
3:bool <- greater-or-equal 1:num, 2:num
]
+mem: storing 1 in location 3
:(scenario greater_or_equal_2)
def main [
1:num <- copy 34
2:num <- copy 34
3:bool <- greater-or-equal 1:num, 2:num
]
+mem: storing 1 in location 3
:(scenario greater_or_equal_3)
def main [
1:num <- copy 34
2:num <- copy 35
3:bool <- greater-or-equal 1:num, 2:num
]
+mem: storing 0 in location 3
:(scenario greater_or_equal_multiple)
def main [
1:bool <- greater-or-equal 36, 35, 35
]
+mem: storing 1 in location 1
:(scenario greater_or_equal_multiple_2)
def main [
1:bool <- greater-or-equal 36, 35, 36
]
+mem: storing 0 in location 1
:(before "End Primitive Recipe Declarations")
LESSER_OR_EQUAL,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "lesser-or-equal", LESSER_OR_EQUAL);
:(before "End Primitive Recipe Checks")
case LESSER_OR_EQUAL: {
if (SIZE(inst.ingredients) <= 1) {
raise << maybe(get(Recipe, r).name) << "'lesser-or-equal' needs at least two ingredients to compare in '" << to_original_string(inst) << "'\n" << end();
break;
}
for (int i = 0; i < SIZE(inst.ingredients); ++i) {
if (!is_mu_number(inst.ingredients.at(i))) {
raise << 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;
}
}
if (SIZE(inst.products) > 1) {
raise << maybe(get(Recipe, r).name) << "'greater-or-equal' yields exactly one product in '" << to_original_string(inst) << "'\n" << end();
break;
}
if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_boolean(inst.products.at(0))) {
raise << maybe(get(Recipe, r).name) << "'greater-or-equal' should yield a boolean, but got '" << inst.products.at(0).original_string << "'\n" << end();
break;
}
break;
}
:(before "End Primitive Recipe Implementations")
case LESSER_OR_EQUAL: {
bool result = true;
for (int i = /**/1; i < SIZE(ingredients); ++i) {
if (ingredients.at(i-1).at(0) > ingredients.at(i).at(0)) {
result = false;
}
}
products.resize(1);
products.at(0).push_back(result);
break;
}
:(scenario lesser_or_equal)
def main [
1:num <- copy 32
2:num <- copy 33
3:bool <- lesser-or-equal 1:num, 2:num
]
+mem: storing 1 in location 3
:(scenario lesser_or_equal_2)
def main [
1:num <- copy 33
2:num <- copy 33
3:bool <- lesser-or-equal 1:num, 2:num
]
+mem: storing 1 in location 3
:(scenario lesser_or_equal_3)
def main [
1:num <- copy 34
2:num <- copy 33
3:bool <- lesser-or-equal 1:num, 2:num
]
+mem: storing 0 in location 3
:(scenario lesser_or_equal_multiple)
def main [
1:bool <- lesser-or-equal 34, 35, 35
]
+mem: storing 1 in location 1
:(scenario lesser_or_equal_multiple_2)
def main [
1:bool <- lesser-or-equal 34, 35, 34
]
+mem: storing 0 in location 1
:(before "End Primitive Recipe Declarations")
MAX,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "max", MAX);
:(before "End Primitive Recipe Checks")
case MAX: {
if (SIZE(inst.ingredients) <= 1) {
raise << maybe(get(Recipe, r).name) << "'max' needs at least two ingredients to compare in '" << to_original_string(inst) << "'\n" << end();
break;
}
for (int i = 0; i < SIZE(inst.ingredients); ++i) {
if (!is_mu_number(inst.ingredients.at(i))) {
raise << maybe(get(Recipe, r).name) << "'max' can only compare numbers; got '" << inst.ingredients.at(i).original_string << "'\n" << end();
goto finish_checking_instruction;
}
}
if (SIZE(inst.products) > 1) {
raise << maybe(get(Recipe, r).name) << "'max' yields exactly one product in '" << to_original_string(inst) << "'\n" << end();
break;
}
if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
raise << maybe(get(Recipe, r).name) << "'max' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end();
break;
}
break;
}
:(before "End Primitive Recipe Implementations")
case MAX: {
int result = ingredients.at(0).at(0);
for (int i = /**/1; i < SIZE(ingredients); ++i) {
if (ingredients.at(i).at(0) > result) {
result = ingredients.at(i).at(0);
}
}
products.resize(1);
products.at(0).push_back(result);
break;
}
:(before "End Primitive Recipe Declarations")
MIN,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "min", MIN);
:(before "End Primitive Recipe Checks")
case MIN: {
if (SIZE(inst.ingredients) <= 1) {
raise << maybe(get(Recipe, r).name) << "'min' needs at least two ingredients to compare in '" << to_original_string(inst) << "'\n" << end();
break;
}
for (int i = 0; i < SIZE(inst.ingredients); ++i) {
if (!is_mu_number(inst.ingredients.at(i))) {
raise << maybe(get(Recipe, r).name) << "'min' can only compare numbers; got '" << inst.ingredients.at(i).original_string << "'\n" << end();
goto finish_checking_instruction;
}
}
if (SIZE(inst.products) > 1) {
raise << maybe(get(Recipe, r).name) << "'min' yields exactly one product in '" << to_original_string(inst) << "'\n" << end();
break;
}
if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) {
raise << maybe(get(Recipe, r).name) << "'min' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end();
break;
}
break;
}
:(before "End Primitive Recipe Implementations")
case MIN: {
int result = ingredients.at(0).at(0);
for (int i = /**/1; i < SIZE(ingredients); ++i) {
if (ingredients.at(i).at(0) < result) {
result = ingredients.at(i).at(0);
}
}
products.resize(1);
products.at(0).push_back(result);
break;
}