7842 - new directory organization

Baremetal is now the default build target and therefore has its sources
at the top-level. Baremetal programs build using the phase-2 Mu toolchain
that requires a Linux kernel. This phase-2 codebase which used to be at
the top-level is now under the linux/ directory. Finally, the phase-2 toolchain,
while self-hosting, has a way to bootstrap from a C implementation, which
is now stored in linux/bootstrap. The bootstrap C implementation uses some
literate programming tools that are now in linux/bootstrap/tools.

So the whole thing has gotten inverted. Each directory should build one
artifact and include the main sources (along with standard library). Tools
used for building it are relegated to sub-directories, even though those
tools are often useful in their own right, and have had lots of interesting
programs written using them.

A couple of things have gotten dropped in this process:
  - I had old ways to run on just a Linux kernel, or with a Soso kernel.
    No more.
  - I had some old tooling for running a single test at the cursor. I haven't
    used that lately. Maybe I'll bring it back one day.

The reorg isn't done yet. Still to do:
  - redo documentation everywhere. All the README files, all other markdown,
    particularly vocabulary.md.
  - clean up how-to-run comments at the start of programs everywhere
  - rethink what to do with the html/ directory. Do we even want to keep
    supporting it?

In spite of these shortcomings, all the scripts at the top-level, linux/
and linux/bootstrap are working. The names of the scripts also feel reasonable.
This is a good milestone to take stock at.

1 files changed, 165 insertions, 0 deletions

diff --git a/linux/tile/table.mu b/linux/tile/table.mu
new file mode 100644
index 00000000..9c03117b
--- /dev/null
+++ b/linux/tile/table.mu
@@ -0,0 +1,165 @@
+fn initialize-table _self: (addr table), n: int {
+  var self/esi: (addr table) <- copy _self
+  var data-ah/eax: (addr handle array bind) <- get self, data
+  populate data-ah, n
+}
+
+fn deep-copy-table _src: (addr table), _dest: (addr table) {
+#?   print-string 0, "deep-copy-table\n"
+  var src/eax: (addr table) <- copy _src
+  var src-data-ah/eax: (addr handle array bind) <- get src, data
+  var _src-data/eax: (addr array bind) <- lookup *src-data-ah
+  var src-data/esi: (addr array bind) <- copy _src-data
+  var n/ecx: int <- length src-data
+  var dest/eax: (addr table) <- copy _dest
+  initialize-table dest, n
+  var dest-data-ah/eax: (addr handle array bind) <- get dest, data
+  var _dest-data/eax: (addr array bind) <- lookup *dest-data-ah
+  var dest-data/edi: (addr array bind) <- copy _dest-data
+  var i/eax: int <- copy 0
+  {
+    compare i, n
+    break-if->=
+#?     print-string 0, "iter\n"
+    $deep-copy:element: {
+      var offset/edx: (offset bind) <- compute-offset src-data, i
+      var src-bind/ecx: (addr bind) <- index src-data, offset
+      var dest-bind/edx: (addr bind) <- index dest-data, offset
+      var src-key-ah/ebx: (addr handle array byte) <- get src-bind, key
+      var src-key/eax: (addr array byte) <- lookup *src-key-ah
+      compare src-key, 0
+      break-if-=
+      # copy key
+      var dest-key-ah/eax: (addr handle array byte) <- get dest-bind, key
+      copy-object src-key-ah, dest-key-ah
+      # deep copy value
+      var src-val-ah/eax: (addr handle value) <- get src-bind, value
+      var _src-val/eax: (addr value) <- lookup *src-val-ah
+      var src-val/ecx: (addr value) <- copy _src-val
+      var dest-val-ah/eax: (addr handle value) <- get dest-bind, value
+      allocate dest-val-ah
+      var dest-val/eax: (addr value) <- lookup *dest-val-ah
+#?       print-string 0, "deep copy value {\n"
+      deep-copy-value src-val, dest-val
+#?       print-string 0, "}\n"
+    }
+    i <- increment
+    loop
+  }
+#?   print-string 0, "end deep-copy-table\n"
+}
+
+fn bind-in-table _self: (addr table), key: (addr handle array byte), val: (addr value) {
+  var self/esi: (addr table) <- copy _self
+  var data-ah/esi: (addr handle array bind) <- get self, data
+  var _data/eax: (addr array bind) <- lookup *data-ah
+  var data/esi: (addr array bind) <- copy _data
+  var next-empty-slot-index/eax: (offset bind) <- next-empty-slot data, key
+  var dest/eax: (addr bind) <- index data, next-empty-slot-index
+  make-binding dest, key, val
+}
+
+# manual test: full array of binds
+fn next-empty-slot _data: (addr array bind), key: (addr handle array byte) -> _/eax: (offset bind) {
+  var data/esi: (addr array bind) <- copy _data
+  var len/ecx: int <- length data
+  var i/edx: int <- copy 0
+  var result/eax: (offset bind) <- copy 0
+  $next-empty-slot:loop: {
+    result <- compute-offset data, i
+    compare i, len
+    break-if->=
+    {
+      var target/esi: (addr bind) <- index data, result
+      var target2/esi: (addr handle array byte) <- get target, key
+      var target3/eax: (addr array byte) <- lookup *target2
+      compare target3, 0
+      break-if-= $next-empty-slot:loop
+      # TODO: how to indicate that key already exists? we don't want to permit rebinding
+    }
+    i <- increment
+    loop
+  }
+  return result
+}
+
+fn make-number-binding _self: (addr bind), key: (addr handle array byte), _val: float {
+  var self/esi: (addr bind) <- copy _self
+  var dest/eax: (addr handle array byte) <- get self, key
+  copy-object key, dest
+  var dest2/eax: (addr handle value) <- get self, value
+  allocate dest2
+  var dest3/eax: (addr value) <- lookup *dest2
+  var dest4/eax: (addr float) <- get dest3, number-data
+  var val/xmm0: float <- copy _val
+  copy-to *dest4, val
+}
+
+fn make-binding _self: (addr bind), key: (addr handle array byte), val: (addr value) {
+  var self/esi: (addr bind) <- copy _self
+  var dest/eax: (addr handle array byte) <- get self, key
+  copy-object key, dest
+  var dest2/eax: (addr handle value) <- get self, value
+  allocate dest2
+  var dest3/eax: (addr value) <- lookup *dest2
+  copy-object val, dest3
+}
+
+fn lookup-binding _self: (addr table), key: (addr array byte), out: (addr handle value) {
+  var self/esi: (addr table) <- copy _self
+  var data-ah/esi: (addr handle array bind) <- get self, data
+  var _data/eax: (addr array bind) <- lookup *data-ah
+  var data/esi: (addr array bind) <- copy _data
+  var len/edx: int <- length data
+  var i/ebx: int <- copy 0
+  $lookup-binding:loop: {
+    compare i, len
+    break-if->=
+    {
+      var offset/edx: (offset bind) <- compute-offset data, i
+      var target-bind/esi: (addr bind) <- index data, offset
+      var target2/edx: (addr handle array byte) <- get target-bind, key
+      var target3/eax: (addr array byte) <- lookup *target2
+      compare target3, 0
+      break-if-= $lookup-binding:loop
+      var is-match?/eax: boolean <- string-equal? target3, key
+      compare is-match?, 0/false
+      break-if-=
+      # found
+      var target/eax: (addr handle value) <- get target-bind, value
+      copy-object target, out
+      break $lookup-binding:loop
+    }
+    i <- increment
+    loop
+  }
+}
+
+fn dump-table _self: (addr table) {
+  var self/esi: (addr table) <- copy _self
+  var data-ah/esi: (addr handle array bind) <- get self, data
+  var _data/eax: (addr array bind) <- lookup *data-ah
+  var data/esi: (addr array bind) <- copy _data
+  var len/edx: int <- length data
+  var i/ebx: int <- copy 0
+  {
+    compare i, len
+    break-if->=
+    var offset/edx: (offset bind) <- compute-offset data, i
+    var target-bind/esi: (addr bind) <- index data, offset
+    var key-ah/edx: (addr handle array byte) <- get target-bind, key
+    var key/eax: (addr array byte) <- lookup *key-ah
+    compare key, 0
+    break-if-=
+    print-string 0, key
+    print-string 0, ": "
+    var val-ah/eax: (addr handle value) <- get target-bind, value
+    var val/eax: (addr value) <- lookup *val-ah
+    var type/eax: (addr int) <- get val, type
+    print-int32-hex 0, *type
+    print-string 0, "\n"
+    i <- increment
+    loop
+  }
+  print-string 0, "\n"
+}