From 6d8ef6b12d37336a92c7a6b20b4b66f3ab424464 Mon Sep 17 00:00:00 2001
From: "Kartik K. Agaram" <vc@akkartik.com>
Date: Fri, 24 Apr 2015 22:49:29 -0700
Subject: 1189 - add extensions to all layers

I'm sick of fighting vim's filetype detection. No modeline and files
highlight in random colors. I add a modeline and it stops highlighting
tangle comments. Even though it read my #$%# vimrc! Fuck this shite.
---
 cpp/034exclusive_container.cc | 108 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 108 insertions(+)
 create mode 100644 cpp/034exclusive_container.cc

(limited to 'cpp/034exclusive_container.cc')

diff --git a/cpp/034exclusive_container.cc b/cpp/034exclusive_container.cc
new file mode 100644
index 00000000..89a4f921
--- /dev/null
+++ b/cpp/034exclusive_container.cc
@@ -0,0 +1,108 @@
+//: Exclusive containers contain exactly one of a fixed number of 'variants'
+//: of different types.
+//:
+//: They also implicitly contain a tag describing precisely which variant is
+//: currently stored in them.
+
+:(before "End Mu Types Initialization")
+//: We'll use this container as a running example, with two integer elements.
+{
+int tmp = Type_number["integer-or-point"] = Next_type_number++;
+Type[tmp].size = 2;
+Type[tmp].kind = exclusive_container;
+Type[tmp].name = "integer-or-point";
+//? cout << tmp << ": " << Type[tmp].elements.size() << '\n'; //? 1
+vector<type_number> t1;
+t1.push_back(integer);
+Type[tmp].elements.push_back(t1);
+//? cout << Type[tmp].elements.size() << '\n'; //? 1
+vector<type_number> t2;
+t2.push_back(point);
+Type[tmp].elements.push_back(t2);
+//? cout << Type[tmp].elements.size() << '\n'; //? 1
+//? cout << "point: " << point << '\n'; //? 1
+Type[tmp].element_names.push_back("i");
+Type[tmp].element_names.push_back("p");
+}
+
+:(scenario copy_exclusive_container)
+# Copying exclusive containers copies all their contents and an extra location for the tag.
+recipe main [
+  1:integer <- copy 1:literal  # 'point' variant
+  2:integer <- copy 34:literal
+  3:integer <- copy 35:literal
+  4:integer-or-point <- copy 1:integer-or-point
+]
++mem: storing 1 in location 4
++mem: storing 34 in location 5
++mem: storing 35 in location 6
+
+:(before "End size_of(types) Cases")
+if (t.kind == exclusive_container) {
+  // size of an exclusive container is the size of its largest variant
+  // (So like containers, it can't contain arrays.)
+//?   cout << "--- " << types[0] << ' ' << t.size << '\n'; //? 1
+//?   cout << "point: " << Type_number["point"] << " " << Type[Type_number["point"]].name << " " << Type[Type_number["point"]].size << '\n'; //? 1
+//?   cout << t.name << ' ' << t.size << ' ' << t.elements.size() << '\n'; //? 1
+  size_t result = 0;
+  for (size_t i = 0; i < t.size; ++i) {
+    size_t tmp = size_of(t.elements[i]);
+//?     cout << i << ": " << t.elements[i][0] << ' ' << tmp << ' ' << result << '\n'; //? 1
+    if (tmp > result) result = tmp;
+  }
+  // ...+1 for its tag.
+  return result+1;
+}
+
+//:: To access variants of an exclusive container, use 'maybe-convert'.
+//: It always returns an address (so that you can modify it) or null (to
+//: signal that the conversion failed (because the container contains a
+//: different variant).
+
+//: 'maybe-convert' requires a literal in ingredient 1. We'll use a synonym
+//: called 'variant'.
+:(before "End Mu Types Initialization")
+Type_number["variant"] = 0;
+
+:(scenario maybe_convert)
+recipe main [
+  12:integer <- copy 1:literal
+  13:integer <- copy 35:literal
+  14:integer <- copy 36:literal
+  20:address:point <- maybe-convert 12:integer-or-point, 1:variant
+]
++mem: storing 13 in location 20
+
+:(scenario maybe_convert_fail)
+recipe main [
+  12:integer <- copy 1:literal
+  13:integer <- copy 35:literal
+  14:integer <- copy 36:literal
+  20:address:point <- maybe-convert 12:integer-or-point, 0:variant
+]
++mem: storing 0 in location 20
+
+:(before "End Primitive Recipe Declarations")
+MAYBE_CONVERT,
+:(before "End Primitive Recipe Numbers")
+Recipe_number["maybe-convert"] = MAYBE_CONVERT;
+:(before "End Primitive Recipe Implementations")
+case MAYBE_CONVERT: {
+  trace("run") << "ingredient 0 is " << current_instruction().ingredients[0].name;
+  reagent base = canonize(current_instruction().ingredients[0]);
+  int base_address = base.value;
+  int base_type = base.types[0];
+  assert(Type[base_type].kind == exclusive_container);
+  trace("run") << "ingredient 1 is " << current_instruction().ingredients[1].name;
+  assert(isa_literal(current_instruction().ingredients[1]));
+  size_t tag = current_instruction().ingredients[1].value;
+  vector<int> result;
+  if (tag == static_cast<size_t>(Memory[base_address])) {
+    result.push_back(base_address+1);
+  }
+  else {
+    result.push_back(0);
+  }
+  write_memory(current_instruction().products[0], result);
+  break;
+}
-- 
cgit 1.4.1-2-gfad0