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
98void contact_in_group(void **state);
void contact_not_in_group(void **state);
void contact_name_when_name_exists(void **state);
void contact_jid_when_name_not_exists(void **state);
void contact_string_when_name_exists(void **state);
void contact_string_when_name_not_exists(void **state);
void contact_string_when_default_resource(void **state);
void contact_presence_offline(void **state);
void contact_presence_uses_highest_priority(void **state);
void contact_presence_chat_when_same_prioroty(void **state);
void contact_presence_online_when_same_prioroty(void **state);
void contact_presence_away_when_same_prioroty(void **state);
void contact_presence_xa_when_same_prioroty(void **state);
void contact_presence_dnd(void **state);
void contact_subscribed_when_to(void **state);
void contact_subscribed_when_both(void **state);
voidpre { 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)
recipe main [
1:number <- copy 23
]
+run: 1:number <- copy 23
+mem: storing 23 in location 1
:(scenario copy)
recipe 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)
recipe 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 change this.
struct routine {
recipe_ordinal running_recipe;
long long int running_step_index;
routine(recipe_ordinal r) :running_recipe(r), running_step_index(0) {}
bool completed() const;
};
:(before "End Globals")
routine* Current_routine = NULL;
map<string, long long int> Instructions_running;
map<string, long long int> Locations_read;
map<string, long long 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 header
while (!Current_routine->completed()) // later layers will modify condition
{
// Running One Instruction
//? Instructions_running[current_recipe_name()]++;
if (current_instruction().is_label) { ++current_step_index(); continue; }
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 potentially spanning multiple locations
vector<vector<double> > ingredients;
if (should_copy_ingredients()) {
for (long long int i = 0; i < SIZE(current_instruction().ingredients); ++i) {
ingredients.push_back(read_memory(current_instruction().ingredients.at(i)));
//? Locations_read[current_recipe_name()] += SIZE(ingredients.back());
//? Locations_read_by_instruction[current_instruction().name] += SIZE(ingredients.back());
}
}
// 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';
}
}
if (SIZE(products) < SIZE(current_instruction().products)) {
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) {
write_memory(current_instruction().products.at(i), products.at(i));
}
}
// End of 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.
inline long long int& current_step_index() {
return Current_routine->running_step_index;
}
inline const string& current_recipe_name() {
return get(Recipe, Current_routine->running_recipe).name;
}
inline const instruction& current_instruction() {
return get(Recipe, Current_routine->running_recipe).steps.at(Current_routine->running_step_index);
}
inline bool routine::completed() const {
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();
//: Step 2: load any .mu files provided at the commandline
:(before "End Commandline Parsing")
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_permanently(*argv);
argv++;
argc--;
}
transform_all();
//? dump_recipe("handle-keyboard-event"), exit(0);
if (Run_tests) Recipe.erase(get(Recipe_ordinal, "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 && contains_key(Recipe_ordinal, "main") && contains_key(Recipe, get(Recipe_ordinal, "main"))) {
setup();
//? Trace_file = "interactive";
//? START_TRACING_UNTIL_END_OF_SCOPE;
trace(9990, "run") << "=== Starting to run" << end();
run_main(argc, argv);
teardown();
}
:(code)
void run_main(int argc, char* argv[]) {
recipe_ordinal r = get(Recipe_ordinal, "main");
if (r) run(r);
}
:(code)
void dump_profile() {
for (map<string, long long int>::iterator p = Instructions_running.begin(); p != Instructions_running.end(); ++p) {
cerr << p->first << ": " << p->second << '\n';
}
cerr << "== locations read\n";
for (map<string, long long 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, long long 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 (!Trace_file.empty() && Trace_stream) {
ofstream fout((Trace_dir+Trace_file).c_str());
fout << Trace_stream->readable_contents("");
fout.close();
}
}
:(before "End One-time Setup")
atexit(cleanup_main);
:(code)
void load_permanently(string filename) {
if (is_directory(filename)) {
load_all_permanently(filename);
return;
}
ifstream fin(filename.c_str());
fin.peek();
if (!fin) {
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
Recently_added_recipes.clear();
// End load_permanently.
}
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_permanently(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))) continue;
load_permanently(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 x) {
vector<double> result;
if (is_literal(x)) {
result.push_back(x.value);
return result;
}
long long int base = x.value;
long long int size = size_of(x);
for (long long int offset = 0; offset < size; ++offset) {
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_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) {
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.type == NULL) return 0;
// End size_of(reagent) Cases
return size_of(r.type);
}
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.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);
}
inline bool is_dummy(const reagent& x) {
return x.name == "_";
}
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;
}
inline bool scalar(const vector<long long int>& x) {
return SIZE(x) == 1;
}
inline bool scalar(const vector<double>& x) {
return SIZE(x) == 1;
}
// helper for tests
void run(string form) {
vector<recipe_ordinal> tmp = load(form);
transform_all();
if (tmp.empty()) return;
run(tmp.front());
}
:(scenario run_label)
recipe main [
+foo
1:number <- copy 23
2:number <- copy 1:number
]
+run: 1:number <- copy 23
+run: 2:number <- copy 1:number
-run: +foo
:(scenario run_dummy)
recipe main [
_ <- copy 0
]
+run: _ <- copy 0
:(scenario write_to_0_disallowed)
% Hide_errors = true;
recipe 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)
recipe main [
1:number, 2:number <- copy 2,2
]
+mem: storing 2 in location 1
:(scenario space_without_comma)
recipe main [
1:number, 2:number <- copy 2 2
]
+mem: storing 2 in location 1
:(scenario comma_before_space)
recipe main [
1:number, 2:number <- copy 2, 2
]
+mem: storing 2 in location 1
:(scenario comma_after_space)
recipe main [
1:number, 2:number <- copy 2 ,2
]
+mem: storing 2 in location 1
|