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

about summary refs log tree commit diff stats

diff options

Diffstat (limited to 'apps/ex5')

0 files changed, 0 insertions, 0 deletions

literals everywhere' href='/akkartik/mu/commit/020run.cc?h=main&id=bc6436927640603675e2e700007f53c5ab213869'>bc643692 ^

9fc64bbc ^

bc643692 ^

57699011 ^

9fc64bbc ^

a26cc359 ^

bc643692 ^

5497090a ^

a26cc359 ^

d7494165 ^

a26cc359 ^

57699011 ^

a26cc359 ^

0487a30e ^

bc643692 ^

0487a30e ^

0487a30e ^

6f5d7864 ^

ec926027 ^

3c435756 ^

1228ec73 ^

363be37f ^

ac0e9db5 ^

363be37f ^

69e14325 ^

1228ec73 ^

7da71d03 ^

0edf822f ^

e0551d78 ^

c062021a ^

7da71d03 ^

9fc64bbc ^

363be37f ^

b75e94b3 ^

9fc64bbc ^

b75e94b3 ^

68329610 ^

69e14325 ^

c475ccc3 ^

a7d70735 ^

6c1376f8 ^

a767dbd3 ^

77cdc6d0 ^

795f5244 ^

5f98a10c ^

795f5244 ^

35064671 ^

dc269891 ^

fca0ebbe ^

e74a2940 ^

6c1376f8 ^

e74a2940 ^

0487a30e ^

dc269891 ^

fca0ebbe ^

dcfca05e ^

f1a6f323 ^

d241c9c4 ^

827898fc ^

d241c9c4 ^

f1a6f323 ^

d241c9c4 ^

dcfca05e ^

d241c9c4 ^

9cf71627 ^

cfb142b9 ^

5f98a10c ^

cfb142b9 ^

0487a30e ^

2dab0edb ^

1066660e ^

9fc64bbc ^

9d670bb5 ^

9fc64bbc ^

e74a2940 ^

3c435756 ^

2199940a ^

ac0e9db5 ^

8eff7919 ^

ec926027 ^

7c8493b3 ^

795f5244 ^

ec926027 ^

dcfca05e ^

795f5244 ^

dcfca05e ^

69e14325 ^

795f5244 ^

ec926027 ^

e5e9f7db ^

785a60fa ^

e5e9f7db ^

b39ceb27 ^

2186422c ^

e7f76736 ^

cea49fde ^

e7f76736 ^

a3481777 ^

926e1b04 ^

ae5f0b6f ^

d71d3b4a ^

b39ceb27 ^

e7f76736 ^

e5e9f7db ^

b39ceb27 ^

ae5f0b6f ^

b39ceb27 ^

6c1376f8 ^

4f10b93a ^

cea49fde ^

ae5f0b6f ^

e7f76736 ^

e7f76736 ^

267ebb59 ^

e0551d78 ^

c062021a ^

e0551d78 ^

e5e9f7db ^

e0551d78 ^

f78f92c5 ^

11312cec ^

24047016 ^

f78f92c5 ^

6ace0363 ^

9f78ec2d ^

267ebb59 ^

bb8a644b ^

f5f4b698 ^

5f98a10c ^

f5f4b698 ^

ad8e984f ^

b2ec0969 ^

8c9e97ae ^

267ebb59 ^

ccd792da ^

71974f15 ^

b98d3876 ^

267ebb59 ^

9f78ec2d ^

9c362f85 ^

9f78ec2d ^

7284d503 ^

e5e9f7db ^

fca0ebbe ^

fca0ebbe ^

ab6ed192 ^

a4ef18b1 ^

a26cc359 ^

ac0e9db5 ^

795f5244 ^

cdd6fd09 ^

b291f85b ^

cae5461b ^

fca0ebbe ^

0c0bc3ae ^

6b6dfb0c ^

18429d40 ^

ac0e9db5 ^

9b8d3917 ^

70179d1f ^

c6034af3 ^

35064671 ^

70179d1f ^

9b8d3917 ^

ac0e9db5 ^

9b8d3917 ^

cdd6fd09 ^

795f5244 ^

b291f85b ^

cae5461b ^

c1a50c82 ^

ac0e9db5 ^

c6034af3 ^

93b7d983 ^

c6034af3 ^

3076bab4 ^

c6034af3 ^

f48f6c14 ^

eaa75c87 ^

decaddb4 ^

70179d1f ^

c6034af3 ^

c91caafd ^

6c1376f8 ^

70179d1f ^

78164bab ^

6b6dfb0c ^

78164bab ^

c6034af3 ^

a0fc38c9 ^

78164bab ^

e5e9f7db ^

7ac8feef ^

e5e9f7db ^

decaddb4 ^

bc643692 ^

5497090a ^

decaddb4 ^

bc643692 ^

d7494165 ^

fc55fea0 ^

bc643692 ^

fc55fea0 ^

bc643692 ^

18429d40 ^

bc643692 ^

5f98a10c ^

18429d40 ^

a0fc38c9 ^

18429d40 ^

bc643692 ^

6d2b1168 ^

677fa104 ^

578327f1 ^

677fa104 ^

578327f1 ^

677fa104 ^

578327f1 ^

677fa104 ^

578327f1 ^

677fa104 ^

578327f1 ^

677fa104 ^

578327f1 ^

677fa104 ^

578327f1 ^

677fa104 ^

578327f1 ^

12
13

19
20

28
29

32
33
34

43
44

48
49

53
54
55

56
57

72
73
74

75
76

85
86

104
105

111
112
113

117
118

121
122

125
126

129
130

135
136

160
161

165
166

176
177

192
193

194
195

216
217

225
226

249
250

256
257

258
259
260

263
264

265
266
267

287
288

295
296
297

305
306
307

309
310
311

317
318

332
333
334

335
336
337

342
343

344
345
346

366
367
368

372
373
374

378
379
380

//: 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")
// Check For .mu Files
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 (base == 0) return;
  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;
  }
  // End write_memory(reagent x, long long int base) Special-cases
  for (long long int offset = 0; offset < SIZE(data); ++offset) {
    assert(base+offset > 0);
    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;
  if (trace_count("error") > 0) 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


context:
space:
mode: