1 files changed, 79 insertions, 0 deletions
diff --git a/cpp/032new b/cpp/032new
new file mode 100644
index 00000000..e75d4148
--- /dev/null
+++ b/cpp/032new
@@ -0,0 +1,79 @@
+//: A simple memory allocator to create space for new variables at runtime.
+
+:(scenarios run)
+:(scenario "new")
+# call new two times with identical arguments; you should get back different results
+recipe main [
+  1:address:integer/raw <- new integer:type
+  2:address:integer/raw <- new integer:type
+  3:boolean/raw <- equal 1:address:integer/raw, 2:address:integer/raw
+]
++mem: storing 0 in location 3
+
+:(before "End Globals")
+const size_t Alloc_init = 1000;
+:(before "End routine Fields")
+size_t alloc;
+:(replace{} "routine::routine(recipe_number r)")
+  routine::routine(recipe_number r) :alloc(Alloc_init) {
+    calls.push(call(r));
+  }
+
+//: first handle 'type' operands
+:(before "End Mu Types Initialization")
+Type_number["type"] = 0;
+:(after "Per-recipe Transforms")
+// replace type names with type_numbers
+if (inst.operation == Recipe_number["new"]) {
+  // first arg must be of type 'type'
+  assert(inst.ingredients.size() >= 1);
+//?   cout << inst.ingredients[0].to_string() << '\n'; //? 1
+  assert(isa_literal(inst.ingredients[0]));
+  if (inst.ingredients[0].properties[0].second[0] == "type") {
+    inst.ingredients[0].set_value(Type_number[inst.ingredients[0].name]);
+  }
+  trace("new") << inst.ingredients[0].name << " -> " << inst.ingredients[0].value;
+}
+
+:(before "End Globals")
+// Operator to look at elements of arrays.
+const int NEW = 30;
+:(before "End Primitive Recipe Numbers")
+Recipe_number["new"] = NEW;
+assert(Next_recipe_number == NEW);
+Next_recipe_number++;
+:(before "End Primitive Recipe Implementations")
+case NEW: {
+  vector<int> result;
+  trace("mem") << "new alloc: " << Current_routine->alloc;
+  result.push_back(Current_routine->alloc);
+  write_memory(instructions[pc].products[0], result);
+  vector<int> types;
+  types.push_back(instructions[pc].ingredients[0].value);
+  if (instructions[pc].ingredients.size() > 1) {
+    // array
+    vector<int> capacity = read_memory(instructions[pc].ingredients[1]);
+    trace("mem") << "array size is " << capacity[0];
+    Memory[Current_routine->alloc] = capacity[0];
+    Current_routine->alloc += capacity[0]*size_of(types);
+  }
+  else {
+    // scalar
+    Current_routine->alloc += size_of(types);
+  }
+  break;
+}
+
+:(scenario "new_array")
+recipe main [
+  1:address:array:integer/raw <- new integer:type, 5:literal
+  2:address:integer/raw <- new integer:type
+  3:integer/raw <- subtract 2:address:integer/raw, 1:address:array:integer/raw
+]
++run: instruction main/0
++mem: array size is 5
++run: instruction main/1
++run: instruction main/2
++mem: storing 5 in location 3
+
+//: vim: ft=cpp