6652 - function to divide whole numbers

prototypes/tile/5.mu

@@ -1,3 +1,30 @@
+# ./a.elf test => run tests
+fn main args-on-stack: (addr array (addr array byte)) -> exit-status/ebx: int {
+  var args/eax: (addr array (addr array byte)) <- copy args-on-stack
+  var tmp/ecx: int <- length args
+  $main-body: {
+    # if (len(args) > 1 && args[1] == "test") run-tests()
+    compare tmp, 1
+    {
+      break-if-<=
+      # if (args[1] == "test") run-tests()
+      var tmp2/ecx: (addr addr array byte) <- index args, 1
+      var tmp3/eax: boolean <- string-equal? *tmp2, "test"
+      compare tmp3, 0
+      {
+        break-if-=
+        run-tests
+        exit-status <- copy 0  # TODO: get at Num-test-failures somehow
+      }
+      break $main-body
+    }
+    # otherwise operate interactively
+    exit-status <- interactive
+  }
+}
+
+# == interactive loop
+
 type cell {
   val: int  # single chars only for now
   parent: (handle cell)
@@ -6,7 +33,7 @@ type cell {
   prev-sibling: (handle cell)
 }
 
-fn main -> exit-status/ebx: int {
+fn interactive -> exit-status/ebx: int {
   var root-handle: (handle cell)
   var root/esi: (addr handle cell) <- address root-handle
   allocate root
@@ -99,18 +126,6 @@ fn tree-depth node-on-stack: (addr cell) -> result/eax: int {
   result <- increment
 }
 
-# slow, iterative divide instruction
-fn try-divide _nr: int, _dr: int -> result/eax: int {
-  result <- copy _nr
-  result <- shift-right 2
-#?   var nr/ecx: int <- copy _nr
-#?   var tmp/ecx: int <- copy 2
-#?   # find nearest power of 2
-#?   {
-#?     k
-#?   }
-}
-
 fn draw-box row1: int, col1: int, row2: int, col2: int {
   draw-horizontal-line row1, col1, col2
   draw-vertical-line row1, row2, col1
@@ -141,3 +156,87 @@ fn draw-vertical-line row1: int, row2: int, col: int {
     loop
   }
 }
+
+# slow, iterative divide instruction
+# preconditions: _nr >= 0, _dr > 0
+fn try-divide _nr: int, _dr: int -> result/eax: int {
+  # x = next power-of-2 multiple of _dr after _nr
+  var x/ecx: int <- copy 1
+  {
+#?     print-int32-hex-to-screen x
+#?     print-string-to-screen "\n"
+    var tmp/edx: int <- copy _dr
+    tmp <- multiply x
+    compare tmp, _nr
+    break-if->
+    x <- shift-left 1
+    loop
+  }
+#?   print-string-to-screen "--\n"
+  # min, max = x/2, x
+  var max/ecx: int <- copy x
+  var min/edx: int <- copy max
+  min <- shift-right 1
+  # narrow down result between min and max
+  var i/eax: int <- copy min
+  {
+#?     print-int32-hex-to-screen i
+#?     print-string-to-screen "\n"
+    var foo/ebx: int <- copy _dr
+    foo <- multiply i
+    compare foo, _nr
+    break-if->
+    i <- increment
+    loop
+  }
+  result <- copy i
+  result <- decrement
+#?   print-string-to-screen "=> "
+#?   print-int32-hex-to-screen result
+#?   print-string-to-screen "\n"
+}
+
+fn test-try-divide-1 {
+  var result/eax: int <- try-divide 0, 2
+  check-ints-equal result, 0, "F - try-divide-1\n"
+}
+
+fn test-try-divide-2 {
+  var result/eax: int <- try-divide 1, 2
+  check-ints-equal result, 0, "F - try-divide-2\n"
+}
+
+fn test-try-divide-3 {
+  var result/eax: int <- try-divide 2, 2
+  check-ints-equal result, 1, "F - try-divide-3\n"
+}
+
+fn test-try-divide-4 {
+  var result/eax: int <- try-divide 4, 2
+  check-ints-equal result, 2, "F - try-divide-4\n"
+}
+
+fn test-try-divide-5 {
+  var result/eax: int <- try-divide 6, 2
+  check-ints-equal result, 3, "F - try-divide-5\n"
+}
+
+fn test-try-divide-6 {
+  var result/eax: int <- try-divide 9, 3
+  check-ints-equal result, 3, "F - try-divide-6\n"
+}
+
+fn test-try-divide-7 {
+  var result/eax: int <- try-divide 0xc, 4
+  check-ints-equal result, 3, "F - try-divide-7\n"
+}
+
+fn test-try-divide-8 {
+  var result/eax: int <- try-divide 0x1b, 3  # 27/3
+  check-ints-equal result, 9, "F - try-divide-8\n"
+}
+
+fn test-try-divide-9 {
+  var result/eax: int <- try-divide 0x1c, 3  # 28/3
+  check-ints-equal result, 9, "F - try-divide-9\n"
+}