<!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 - 031address.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">
<!--
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; }
.traceAbsent { color: #c00000; }
.cSpecial { color: #008000; }
.Comment { color: #9090ff; }
.Delimiter { color: #a04060; }
.Special { color: #ff6060; }
.Identifier { color: #804000; }
.Constant { color: #00a0a0; }
.traceContains { color: #008000; }
-->
</style>
<script type='text/javascript'>
<!--
-->
</script>
</head>
<body>
<pre id='vimCodeElement'>
<span class="Comment">//: Instructions can read from addresses pointing at other locations using the</span>
<span class="Comment">//: 'lookup' property.</span>
<span class="Delimiter">:(scenario copy_indirect)</span>
recipe main [
<span class="Constant">1</span>:address:number<span class="Special"> <- </span>copy <span class="Constant">2</span>
<span class="Constant">2</span>:number<span class="Special"> <- </span>copy <span class="Constant">34</span>
<span class="Comment"># This loads location 1 as an address and looks up *that* location.</span>
<span class="Constant">3</span>:number<span class="Special"> <- </span>copy <span class="Constant">1</span>:address:number/lookup
]
<span class="traceContains">+mem: storing 34 in location 3</span>
<span class="Delimiter">:(before "long long int base = x.value" following "vector<double> read_memory(reagent x)")</span>
x = canonize<span class="Delimiter">(</span>x<span class="Delimiter">);</span>
<span class="Comment">//: similarly, write to addresses pointing at other locations using the</span>
<span class="Comment">//: 'lookup' property</span>
<span class="Delimiter">:(scenario store_indirect)</span>
recipe main [
<span class="Constant">1</span>:address:number<span class="Special"> <- </span>copy <span class="Constant">2</span>
<span class="Constant">1</span>:address:number/lookup<span class="Special"> <- </span>copy <span class="Constant">34</span>
]
<span class="traceContains">+mem: storing 34 in location 2</span>
<span class="Delimiter">:(before "long long int base = x.value" following "void write_memory(reagent x, vector<double> data)")</span>
x = canonize<span class="Delimiter">(</span>x<span class="Delimiter">);</span>
if <span class="Delimiter">(</span>x<span class="Delimiter">.</span>value == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
raise << <span class="Constant">"can't write to location 0 in '"</span> << current_instruction<span class="Delimiter">().</span>to_string<span class="Delimiter">()</span> << <span class="Constant">"'</span><span class="cSpecial">\n</span><span class="Constant">"</span> << end<span class="Delimiter">();</span>
<span class="Identifier">return</span><span class="Delimiter">;</span>
<span class="Delimiter">}</span>
<span class="Delimiter">:(after "bool is_mu_array(reagent r)")</span>
r = canonize<span class="Delimiter">(</span>r<span class="Delimiter">);</span>
<span class="Comment">//: writes to address 0 always loudly fail</span>
<span class="Delimiter">:(scenario store_to_0_warns)</span>
<span class="Special">% Hide_warnings = true;</span>
recipe main [
<span class="Constant">1</span>:address:number<span class="Special"> <- </span>copy <span class="Constant">0</span>
<span class="Constant">1</span>:address:number/lookup<span class="Special"> <- </span>copy <span class="Constant">34</span>
]
<span class="traceAbsent">-mem: storing 34 in location 0</span>
<span class="traceContains">+warn: can't write to location 0 in '1:address:number/lookup <- copy 34'</span>
<span class="Delimiter">:(code)</span>
reagent canonize<span class="Delimiter">(</span>reagent x<span class="Delimiter">)</span> <span class="Delimiter">{</span>
if <span class="Delimiter">(</span>is_literal<span class="Delimiter">(</span>x<span class="Delimiter">))</span> <span class="Identifier">return</span> x<span class="Delimiter">;</span>
reagent r = x<span class="Delimiter">;</span>
while <span class="Delimiter">(</span>has_property<span class="Delimiter">(</span>r<span class="Delimiter">,</span> <span class="Constant">"lookup"</span><span class="Delimiter">))</span>
r = lookup_memory<span class="Delimiter">(</span>r<span class="Delimiter">);</span>
<span class="Identifier">return</span> r<span class="Delimiter">;</span>
<span class="Delimiter">}</span>
reagent lookup_memory<span class="Delimiter">(</span>reagent x<span class="Delimiter">)</span> <span class="Delimiter">{</span>
static const type_ordinal ADDRESS = Type_ordinal[<span class="Constant">"address"</span>]<span class="Delimiter">;</span>
reagent result<span class="Delimiter">;</span>
if <span class="Delimiter">(</span>x<span class="Delimiter">.</span>types<span class="Delimiter">.</span>empty<span class="Delimiter">()</span> || x<span class="Delimiter">.</span>types<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)</span> != ADDRESS<span class="Delimiter">)</span> <span class="Delimiter">{</span>
raise << current_recipe_name<span class="Delimiter">()</span> << <span class="Constant">": tried to /lookup "</span> << x<span class="Delimiter">.</span>original_string << <span class="Constant">" but it isn't an address</span><span class="cSpecial">\n</span><span class="Constant">"</span> << end<span class="Delimiter">();</span>
<span class="Identifier">return</span> result<span class="Delimiter">;</span>
<span class="Delimiter">}</span>
<span class="Comment">// compute value</span>
if <span class="Delimiter">(</span>x<span class="Delimiter">.</span>value == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
raise << current_recipe_name<span class="Delimiter">()</span> << <span class="Constant">": tried to /lookup 0</span><span class="cSpecial">\n</span><span class="Constant">"</span> << end<span class="Delimiter">();</span>
<span class="Identifier">return</span> result<span class="Delimiter">;</span>
<span class="Delimiter">}</span>
result<span class="Delimiter">.</span>set_value<span class="Delimiter">(</span>Memory[x<span class="Delimiter">.</span>value]<span class="Delimiter">);</span>
trace<span class="Delimiter">(</span>Primitive_recipe_depth<span class="Delimiter">,</span> <span class="Constant">"mem"</span><span class="Delimiter">)</span> << <span class="Constant">"location "</span> << x<span class="Delimiter">.</span>value << <span class="Constant">" is "</span> << result<span class="Delimiter">.</span>value << end<span class="Delimiter">();</span>
<span class="Comment">// populate types</span>
copy<span class="Delimiter">(</span>++x<span class="Delimiter">.</span>types<span class="Delimiter">.</span>begin<span class="Delimiter">(),</span> x<span class="Delimiter">.</span>types<span class="Delimiter">.</span>end<span class="Delimiter">(),</span> inserter<span class="Delimiter">(</span>result<span class="Delimiter">.</span>types<span class="Delimiter">,</span> result<span class="Delimiter">.</span>types<span class="Delimiter">.</span>begin<span class="Delimiter">()));</span>
<span class="Comment">// drop-one 'lookup'</span>
long long int i = <span class="Constant">0</span><span class="Delimiter">;</span>
long long int len = SIZE<span class="Delimiter">(</span>x<span class="Delimiter">.</span>properties<span class="Delimiter">);</span>
for <span class="Delimiter">(</span>i = <span class="Constant">0</span><span class="Delimiter">;</span> i < len<span class="Delimiter">;</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
if <span class="Delimiter">(</span>x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>first == <span class="Constant">"lookup"</span><span class="Delimiter">)</span> <span class="Identifier">break</span><span class="Delimiter">;</span>
result<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">));</span>
<span class="Delimiter">}</span>
++i<span class="Delimiter">;</span> <span class="Comment">// skip first lookup</span>
for <span class="Delimiter">(;</span> i < len<span class="Delimiter">;</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
result<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">));</span>
<span class="Delimiter">}</span>
<span class="Identifier">return</span> result<span class="Delimiter">;</span>
<span class="Delimiter">}</span>
<span class="SalientComment">//:: 'get' can read from container address</span>
<span class="Delimiter">:(scenario get_indirect)</span>
recipe main [
<span class="Constant">1</span>:number<span class="Special"> <- </span>copy <span class="Constant">2</span>
<span class="Constant">2</span>:number<span class="Special"> <- </span>copy <span class="Constant">34</span>
<span class="Constant">3</span>:number<span class="Special"> <- </span>copy <span class="Constant">35</span>
<span class="Constant">4</span>:number<span class="Special"> <- </span>get <span class="Constant">1</span>:address:point/lookup<span class="Delimiter">,</span> <span class="Constant">0</span>:offset
]
<span class="traceContains">+mem: storing 34 in location 4</span>
<span class="Delimiter">:(scenario include_nonlookup_properties)</span>
recipe main [
<span class="Constant">1</span>:number<span class="Special"> <- </span>copy <span class="Constant">2</span>
<span class="Constant">2</span>:number<span class="Special"> <- </span>copy <span class="Constant">34</span>
<span class="Constant">3</span>:number<span class="Special"> <- </span>copy <span class="Constant">35</span>
<span class="Constant">4</span>:number<span class="Special"> <- </span>get <span class="Constant">1</span>:address:point/lookup/foo<span class="Delimiter">,</span> <span class="Constant">0</span>:offset
]
<span class="traceContains">+mem: storing 34 in location 4</span>
<span class="Delimiter">:(after "reagent base = " following "case GET:")</span>
base = canonize<span class="Delimiter">(</span>base<span class="Delimiter">);</span>
<span class="Delimiter">:(scenario get_address_indirect)</span>
<span class="Comment"># 'get' can read from container address</span>
recipe main [
<span class="Constant">1</span>:number<span class="Special"> <- </span>copy <span class="Constant">2</span>
<span class="Constant">2</span>:number<span class="Special"> <- </span>copy <span class="Constant">34</span>
<span class="Constant">3</span>:number<span class="Special"> <- </span>copy <span class="Constant">35</span>
<span class="Constant">4</span>:number<span class="Special"> <- </span>get-address <span class="Constant">1</span>:address:point/lookup<span class="Delimiter">,</span> <span class="Constant">0</span>:offset
]
<span class="traceContains">+mem: storing 2 in location 4</span>
<span class="Delimiter">:(after "reagent base = " following "case GET_ADDRESS:")</span>
base = canonize<span class="Delimiter">(</span>base<span class="Delimiter">);</span>
<span class="SalientComment">//:: abbreviation for '/lookup': a prefix '*'</span>
<span class="Delimiter">:(scenario lookup_abbreviation)</span>
recipe main [
<span class="Constant">1</span>:address:number<span class="Special"> <- </span>copy <span class="Constant">2</span>
<span class="Constant">2</span>:number<span class="Special"> <- </span>copy <span class="Constant">34</span>
<span class="Constant">3</span>:number<span class="Special"> <- </span>copy *<span class="Constant">1</span>:address:number
]
<span class="traceContains">+mem: storing 34 in location 3</span>
<span class="Delimiter">:(before "End Parsing reagent")</span>
<span class="Delimiter">{</span>
while <span class="Delimiter">(</span>!name<span class="Delimiter">.</span>empty<span class="Delimiter">()</span> && name<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)</span> == <span class="Constant">'*'</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
name<span class="Delimiter">.</span>erase<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">1</span><span class="Delimiter">);</span>
properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair<string<span class="Delimiter">,</span> vector<string> ><span class="Delimiter">(</span><span class="Constant">"lookup"</span><span class="Delimiter">,</span> vector<string><span class="Delimiter">()));</span>
<span class="Delimiter">}</span>
if <span class="Delimiter">(</span>name<span class="Delimiter">.</span>empty<span class="Delimiter">())</span>
raise << <span class="Constant">"illegal name "</span> << original_string << <span class="cSpecial">'\n'</span> << end<span class="Delimiter">();</span>
<span class="Delimiter">}</span>
<span class="SalientComment">//:: helpers for debugging</span>
<span class="Delimiter">:(before "End Primitive Recipe Declarations")</span>
_DUMP<span class="Delimiter">,</span>
<span class="Delimiter">:(before "End Primitive Recipe Numbers")</span>
Recipe_ordinal[<span class="Constant">"$dump"</span>] = _DUMP<span class="Delimiter">;</span>
<span class="Delimiter">:(before "End Primitive Recipe Implementations")</span>
case _DUMP: <span class="Delimiter">{</span>
reagent after_canonize = canonize<span class="Delimiter">(</span>current_instruction<span class="Delimiter">().</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
cerr << current_recipe_name<span class="Delimiter">()</span> << <span class="Constant">": "</span> << current_instruction<span class="Delimiter">().</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><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 *///: Phase 3: Start running a loaded and transformed recipe.
//:
//: So far we've seen recipes as lists of instructions, and instructions point
//: at other recipes. To kick things off mu needs to know how to run certain
//: 'primitive' recipes. That will then give the ability to run recipes
//: containing these primitives.
//:
//: This layer defines a skeleton with just two primitive recipes: IDLE which
//: does nothing, and COPY, which can copy numbers from one memory location to
//: another. Later layers will add more primitives.
:(scenario copy_literal)
def main [
1:number <- copy 23
]
+run: {1: "number"} <- copy {23: "literal"}
+mem: storing 23 in location 1
:(scenario copy)
def main [
1:number <- copy 23
2:number <- copy 1:number
]
+run: {2: "number"} <- copy {1: "number"}
+mem: location 1 is 23
+mem: storing 23 in location 2
:(scenario copy_multiple)
def main [
1:number, 2:number <- copy 23, 24
]
+mem: storing 23 in location 1
+mem: storing 24 in location 2
:(before "End Types")
// Book-keeping while running a recipe.
//: Later layers will replace this to support running multiple routines at once.
struct routine {
recipe_ordinal running_recipe;
int running_step_index;
routine(recipe_ordinal r) :running_recipe(r), running_step_index(0) {}
bool completed() const;
const vector<instruction>& steps() const;
};
:(before "End Globals")
routine* Current_routine = NULL;
map<string, int> Instructions_running;
map<string, int> Locations_read;
map<string, int> Locations_read_by_instruction;
:(code)
void run(recipe_ordinal r) {
routine rr(r);
Current_routine = &rr;
run_current_routine();
}
void run_current_routine()
{ // curly on a separate line, because later layers will modify function header
while (!Current_routine->completed()) // later layers will modify condition
{
// Running One Instruction
if (current_instruction().is_label) { ++current_step_index(); continue; }
trace(Initial_callstack_depth + Trace_stream->callstack_depth, "run") << to_string(current_instruction()) << end();
if (get_or_insert(Memory, 0) != 0) {
raise << "something wrote to location 0; this should never happen\n" << end();
put(Memory, 0, 0);
}
// read all ingredients from memory, each potentially spanning multiple locations
vector<vector<double> > ingredients;
if (should_copy_ingredients()) {
for (int i = 0; i < SIZE(current_instruction().ingredients); ++i)
ingredients.push_back(read_memory(current_instruction().ingredients.at(i)));
}
// instructions below will write to 'products'
vector<vector<double> > products;
switch (current_instruction().operation) {
// Primitive Recipe Implementations
case COPY: {
copy(ingredients.begin(), ingredients.end(), inserter(products, products.begin()));
break;
}
// End Primitive Recipe Implementations
default: {
cout << "not a primitive op: " << current_instruction().operation << '\n';
}
}
// Write Products of Instruction
if (SIZE(products) < SIZE(current_instruction().products)) {
raise << SIZE(products) << " vs " << SIZE(current_instruction().products) << ": failed to write to all products! " << to_original_string(current_instruction()) << '\n' << end();
}
else {
for (int i = 0; i < SIZE(current_instruction().products); ++i)
write_memory(current_instruction().products.at(i), products.at(i));
}
// End Write Products of Instruction
// End Running One Instruction
finish_instruction:;
++current_step_index();
}
stop_running_current_routine:;
}
bool should_copy_ingredients() {
// End should_copy_ingredients Special-cases
return true;
}
//: Some helpers.
//: We'll need to override these later as we change the definition of routine.
//: Important that they return referrences into the routine.
int& current_step_index() {
return Current_routine->running_step_index;
}
const string& current_recipe_name() {
return get(Recipe, Current_routine->running_recipe).name;
}
const instruction& current_instruction() {
return get(Recipe, Current_routine->running_recipe).steps.at(Current_routine->running_step_index);
}
bool routine::completed() const {
return running_step_index >= SIZE(get(Recipe, running_recipe).steps);
}
const vector<instruction>& routine::steps() const {
return get(Recipe, running_recipe).steps;
}
//:: Startup flow
//: Step 1: load all .mu files with numeric prefixes (in order)
:(before "End Load Recipes")
// Load .mu Core
//? Save_trace = true;
//? START_TRACING_UNTIL_END_OF_SCOPE;
load_file_or_directory("core.mu");
//? DUMP("");
//? exit(0);
//: Step 2: load any .mu files provided at the commandline
:(before "End Commandline Parsing")
// Check For .mu Files
//? START_TRACING_UNTIL_END_OF_SCOPE
if (argc > 1) {
// skip argv[0]
++argv;
--argc;
// ignore argv past '--'; that's commandline args for 'main'
while (argc > 0) {
if (string(*argv) == "--") break;
load_file_or_directory(*argv);
--argc;
++argv;
}
if (Run_tests) Recipe.erase(get(Recipe_ordinal, "main"));
}
transform_all();
//? DUMP("");
//? exit(0);
if (Trace_errors) return 1;
save_snapshots();
//: Step 3: if we aren't running tests, locate a recipe called 'main' and
//: start running it.
:(before "End Main")
if (!Run_tests && contains_key(Recipe_ordinal, "main") && contains_key(Recipe, get(Recipe_ordinal, "main"))) {
// Running Main
setup();
//? Save_trace = true;
if (Trace_main) Trace_stream = new trace_stream;
trace(9990, "run") << "=== Starting to run" << end();
assert(Num_calls_to_transform_all == 1);
run_main(argc, argv);
teardown();
}
:(code)
void run_main(int argc, char* argv[]) {
recipe_ordinal r = get(Recipe_ordinal, "main");
if (r) run(r);
}
//: By default we don't maintain the trace while running main because its
//: overheads can grow rapidly. However, it's useful when debugging.
:(before "End Globals")
bool Trace_main = false;
:(before "End Commandline Options(*arg)")
else if (is_equal(*arg, "--trace")) {
Trace_main = true;
}
:(code)
void dump_profile() {
for (map<string, int>::iterator p = Instructions_running.begin(); p != Instructions_running.end(); ++p) {
cerr << p->first << ": " << p->second << '\n';
}
cerr << "== locations read\n";
for (map<string, int>::iterator p = Locations_read.begin(); p != Locations_read.end(); ++p) {
cerr << p->first << ": " << p->second << '\n';
}
cerr << "== locations read by instruction\n";
for (map<string, int>::iterator p = Locations_read_by_instruction.begin(); p != Locations_read_by_instruction.end(); ++p) {
cerr << p->first << ": " << p->second << '\n';
}
}
:(before "End One-time Setup")
//? atexit(dump_profile);
:(code)
void cleanup_main() {
if (Save_trace && Trace_stream) {
ofstream fout("interactive");
fout << Trace_stream->readable_contents("");
fout.close();
}
if (Trace_stream) delete Trace_stream, Trace_stream = NULL;
}
:(before "End One-time Setup")
atexit(cleanup_main);
:(code)
void load_file_or_directory(string filename) {
if (is_directory(filename)) {
load_all(filename);
return;
}
ifstream fin(filename.c_str());
if (!fin) {
cerr << "no such file '" << filename << "'\n" << end(); // don't raise, just warn. just in case it's just a name for a scenario to run.
return;
}
trace(9990, "load") << "=== " << filename << end();
load(fin);
fin.close();
}
bool is_directory(string path) {
struct stat info;
if (stat(path.c_str(), &info)) return false; // error
return info.st_mode & S_IFDIR;
}
void load_all(string dir) {
dirent** files;
int num_files = scandir(dir.c_str(), &files, NULL, alphasort);
for (int i = 0; i < num_files; ++i) {
string curr_file = files[i]->d_name;
if (isdigit(curr_file.at(0)))
load_file_or_directory(dir+'/'+curr_file);
free(files[i]);
files[i] = NULL;
}
free(files);
}
:(before "End Includes")
#include <dirent.h>
#include <sys/stat.h>
//:: Reading from memory, writing to memory.
:(code)
vector<double> read_memory(reagent/*copy*/ x) {
// Begin Preprocess read_memory(x)
vector<double> result;
if (is_literal(x)) {
result.push_back(x.value);
return result;
}
// End Preprocess read_memory(x)
int size = size_of(x);
for (int offset = 0; offset < size; ++offset) {
double val = get_or_insert(Memory, x.value+offset);
trace(9999, "mem") << "location " << x.value+offset << " is " << no_scientific(val) << end();
result.push_back(val);
}
return result;
}
void write_memory(reagent/*copy*/ x, const vector<double>& data) {
assert(Current_routine); // run-time only
// Begin Preprocess write_memory(x, data)
if (!x.type) {
raise << "can't write to '" << to_string(x) << "'; no type\n" << end();
return;
}
if (is_dummy(x)) return;
if (is_literal(x)) return;
// End Preprocess write_memory(x, data)
if (x.value == 0) {
raise << "can't write to location 0 in '" << to_original_string(current_instruction()) << "'\n" << end();
return;
}
if (size_mismatch(x, data)) {
raise << maybe(current_recipe_name()) << "size mismatch in storing to '" << x.original_string << "' (" << size_of(x) << " vs " << SIZE(data) << ") at '" << to_original_string(current_instruction()) << "'\n" << end();
return;
}
// End write_memory(x) Special-cases
for (int offset = 0; offset < SIZE(data); ++offset) {
assert(x.value+offset > 0);
trace(9999, "mem") << "storing " << no_scientific(data.at(offset)) << " in location " << x.value+offset << end();
put(Memory, x.value+offset, data.at(offset));
}
}
:(code)
int size_of(const reagent& r) {
if (!r.type) return 0;
// End size_of(reagent r) Cases
return size_of(r.type);
}
int size_of(const type_tree* type) {
if (!type) return 0;
// End size_of(type) Cases
return 1;
}
bool size_mismatch(const reagent& x, const vector<double>& data) {
if (!x.type) 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_literal(const reagent& r) {
return is_literal(r.type);
}
bool is_literal(const type_tree* type) {
if (!type) return false;
if (!type->atom) return false;
return type->value == 0;
}
bool scalar(const vector<int>& x) {
return SIZE(x) == 1;
}
bool scalar(const vector<double>& x) {
return SIZE(x) == 1;
}
// helper for tests
void run(const string& form) {
vector<recipe_ordinal> tmp = load(form);
transform_all();
if (tmp.empty()) return;
if (trace_count("error") > 0) return;
// if a test defines main, it probably wants to start there regardless of
// definition order
if (contains_key(Recipe, get(Recipe_ordinal, "main")))
run(get(Recipe_ordinal, "main"));
else
run(tmp.front());
}
:(scenario run_label)
def main [
+foo
1:number <- copy 23
2:number <- copy 1:number
]
+run: {1: "number"} <- copy {23: "literal"}
+run: {2: "number"} <- copy {1: "number"}
-run: +foo
:(scenario run_dummy)
def main [
_ <- copy 0
]
+run: _ <- copy {0: "literal"}
:(scenario write_to_0_disallowed)
% Hide_errors = true;
def main [
0:number <- copy 34
]
-mem: storing 34 in location 0
//: mu is robust to various combinations of commas and spaces. You just have
//: to put spaces around the '<-'.
:(scenario comma_without_space)
def main [
1:number, 2:number <- copy 2,2
]
+mem: storing 2 in location 1
:(scenario space_without_comma)
def main [
1:number, 2:number <- copy 2 2
]
+mem: storing 2 in location 1
:(scenario comma_before_space)
def main [
1:number, 2:number <- copy 2, 2
]
+mem: storing 2 in location 1
:(scenario comma_after_space)
def main [
1:number, 2:number <- copy 2 ,2
]
+mem: storing 2 in location 1