7157

6 files changed, 96 insertions, 101 deletions

diff --git a/apps/arith.mu b/apps/arith.mu
index 551753de..6fbd3745 100644
--- a/apps/arith.mu
+++ b/apps/arith.mu
@@ -31,7 +31,7 @@
 #
 # Error handling is non-existent. This is just a prototype.
 
-fn main -> exit-status/ebx: int {
+fn main -> _/ebx: int {
   enable-keyboard-immediate-mode
   var look/esi: grapheme <- copy 0  # lookahead
   var n/eax: int <- copy 0  # result of each expression
@@ -52,19 +52,22 @@ fn main -> exit-status/ebx: int {
     loop
   }
   enable-keyboard-type-mode
-  exit-status <- copy 0
+  return 0
 }
 
-fn simplify -> result/eax: int, look/esi: grapheme {
+fn simplify -> _/eax: int, _2/esi: grapheme {
   # prime the pump
-  look <- get-char
+  var look/esi: grapheme <- get-char
   # do it
+  var result/eax: int <- copy 0
   result, look <- expression look
+  return result, look
 }
 
-fn expression _look: grapheme -> result/eax: int, look/esi: grapheme {
-  look <- copy _look  # should be a no-op
+fn expression _look: grapheme -> _/eax: int, _2/esi: grapheme {
+  var look/esi: grapheme <- copy _look
   # read arg
+  var result/eax: int <- copy 0
   result, look <- term look
   $expression:loop: {
     # while next non-space char in ['+', '-']
@@ -103,12 +106,14 @@ fn expression _look: grapheme -> result/eax: int, look/esi: grapheme {
     loop
   }
   look <- skip-spaces look
+  return result, look
 }
 
-fn term _look: grapheme -> result/eax: int, look/esi: grapheme {
-  look <- copy _look  # should be a no-op
+fn term _look: grapheme -> _/eax: int, _2/esi: grapheme {
+  var look/esi: grapheme <- copy _look
   # read arg
   look <- skip-spaces look
+  var result/eax: int <- copy 0
   result, look <- factor look
   $term:loop: {
     # while next non-space char in ['*', '/']
@@ -146,74 +151,69 @@ fn term _look: grapheme -> result/eax: int, look/esi: grapheme {
     }
     loop
   }
+  return result, look
 }
 
-fn factor _look: grapheme -> result/eax: int, look/esi: grapheme {
-$factor:body: {
-  look <- copy _look  # should be a no-op
+fn factor _look: grapheme -> _/eax: int, _2/esi: grapheme {
+  var look/esi: grapheme <- copy _look  # should be a no-op
   look <- skip-spaces look
   # if next char is not '(', parse a number
   compare look, 0x28  # '('
   {
     break-if-=
+    var result/eax: int <- copy 0
     result, look <- num look
-    break $factor:body
+    return result, look
   }
   # otherwise recurse
   look <- get-char  # '('
+  var result/eax: int <- copy 0
   result, look <- expression look
   look <- skip-spaces look
   look <- get-char  # ')'
-}  # $factor:body
+  return result, look
 }
 
-fn is-mul-or-div? c: grapheme -> result/eax: boolean {
-$is-mul-or-div?:body: {
+fn is-mul-or-div? c: grapheme -> _/eax: boolean {
   compare c, 0x2a  # '*'
   {
     break-if-!=
-    result <- copy 1  # true
-    break $is-mul-or-div?:body
+    return 1  # true
   }
   compare c, 0x2f  # '/'
   {
     break-if-!=
-    result <- copy 1  # true
-    break $is-mul-or-div?:body
+    return 1  # true
   }
-  result <- copy 0  # false
-}  # $is-mul-or-div?:body
+  return 0  # false
 }
 
-fn is-add-or-sub? c: grapheme -> result/eax: boolean {
-$is-add-or-sub?:body: {
+fn is-add-or-sub? c: grapheme -> _/eax: boolean {
   compare c, 0x2b  # '+'
   {
     break-if-!=
-    result <- copy 1  # true
-    break $is-add-or-sub?:body
+    return 1  # true
   }
   compare c, 0x2d  # '-'
   {
     break-if-!=
-    result <- copy 1  # true
-    break $is-add-or-sub?:body
+    return 1  # true
   }
-  result <- copy 0  # false
-}  # $is-add-or-sub?:body
+  return 0  # false
 }
 
-fn operator _look: grapheme -> op/ecx: byte, look/esi: grapheme {
-  op <- copy _look
-  look <- get-char
+fn operator _look: grapheme -> _/ecx: byte, _2/esi: grapheme {
+  var op/ecx: byte <- copy _look
+  var look/esi: grapheme <- get-char
+  return op, look
 }
 
-fn num _look: grapheme -> result/eax: int, look/esi: grapheme {
-  look <- copy _look  # should be a no-op
-  var out/edi: int <- copy 0
+fn num _look: grapheme -> _/eax: int, _2/esi: grapheme {
+  var look/esi: grapheme <- copy _look
+  var result/edi: int <- copy 0
   {
     var first-digit/eax: int <- to-decimal-digit look
-    out <- copy first-digit
+    result <- copy first-digit
   }
   {
     look <- get-char
@@ -221,37 +221,38 @@ fn num _look: grapheme -> result/eax: int, look/esi: grapheme {
     var digit?/eax: boolean <- is-decimal-digit? look
     compare digit?, 0  # false
     break-if-=
-    # out *= 10
+    # result *= 10
     {
       var ten/eax: int <- copy 0xa
-      out <- multiply ten
+      result <- multiply ten
     }
-    # out += digit(look)
+    # result += digit(look)
     var digit/eax: int <- to-decimal-digit look
-    out <- add digit
+    result <- add digit
     loop
   }
-  result <- copy out
+  return result, look
 }
 
-fn skip-spaces _look: grapheme -> look/esi: grapheme {
-  look <- copy _look  # should be a no-op
+fn skip-spaces _look: grapheme -> _/esi: grapheme {
+  var look/esi: grapheme <- copy _look  # should be a no-op
   {
     compare look, 0x20
     break-if-!=
     look <- get-char
     loop
   }
+  return look
 }
 
-fn get-char -> look/esi: grapheme {
-  var tmp/eax: grapheme <- read-key-from-real-keyboard
-  print-grapheme-to-real-screen tmp
-  look <- copy tmp
+fn get-char -> _/esi: grapheme {
+  var look/eax: grapheme <- read-key-from-real-keyboard
+  print-grapheme-to-real-screen look
   compare look, 4
   {
     break-if-!=
     print-string 0, "^D\n"
     syscall_exit
   }
+  return look
 }
diff --git a/apps/parse-int.mu b/apps/parse-int.mu
index 65ee4da1..fb32c106 100644
--- a/apps/parse-int.mu
+++ b/apps/parse-int.mu
@@ -6,8 +6,7 @@
 #   $ echo $?
 #   123
 
-fn main _args: (addr array addr array byte) -> exit-status/ebx: int {
-$main-body: {
+fn main _args: (addr array addr array byte) -> _/ebx: int {
   # if no args, print a message and exit
   var args/esi: (addr array addr array byte) <- copy _args
   var n/ecx: int <- length args
@@ -15,36 +14,34 @@ $main-body: {
   {
     break-if->
     print-string 0, "usage: parse-int <integer>\n"
-    exit-status <- copy 1
-    break $main-body
+    return 1
   }
   # otherwise parse the first arg as an integer
   var in/ecx: (addr addr array byte) <- index args, 1
   var out/eax: int <- parse-int *in
-  exit-status <- copy out
-}
+  return out
 }
 
-fn parse-int _in: (addr array byte) -> result/eax: int {
+fn parse-int _in: (addr array byte) -> _/eax: int {
   var in/esi: (addr array byte) <- copy _in
   var len/edx: int <- length in
   var i/ecx: int <- copy 0
-  var out/edi: int <- copy 0
+  var result/edi: int <- copy 0
   {
     compare i, len
     break-if->=
-    # out *= 10
+    # result *= 10
     var ten/eax: int <- copy 0xa
-    out <- multiply ten
+    result <- multiply ten
     # c = in[i]
     var tmp/ebx: (addr byte) <- index in, i
-    var c/eax: byte <- copy 0
-    c <- copy-byte *tmp
+    var c/eax: byte <- copy-byte *tmp
     #
-    var digit/eax: int <- to-decimal-digit c
-    out <- add digit
+    var g/eax: grapheme <- copy c
+    var digit/eax: int <- to-decimal-digit g
+    result <- add digit
     i <- increment
     loop
   }
-  result <- copy out
+  return result
 }
diff --git a/apps/print-file.mu b/apps/print-file.mu
index 0726164c..f04713c0 100644
--- a/apps/print-file.mu
+++ b/apps/print-file.mu
@@ -7,35 +7,33 @@
 #   $ ./a.elf x
 #   abc
 
-fn main _args: (addr array addr array byte) -> exit-status/ebx: int {
+fn main _args: (addr array addr array byte) -> _/ebx: int {
   var args/eax: (addr array addr array byte) <- copy _args
-$main-body: {
-    var n/ecx: int <- length args
-    compare n, 1
+  var n/ecx: int <- length args
+  compare n, 1
+  {
+    break-if->
+    print-string 0, "usage: cat <filename>\n"
+    return 0
+  }
+  {
+    break-if-<=
+    var filename/edx: (addr addr array byte) <- index args 1
+    var in: (handle buffered-file)
     {
-      break-if->
-      print-string 0, "usage: cat <filename>\n"
-      break $main-body
+      var addr-in/eax: (addr handle buffered-file) <- address in
+      open *filename, 0, addr-in
     }
+    var _in-addr/eax: (addr buffered-file) <- lookup in
+    var in-addr/ecx: (addr buffered-file) <- copy _in-addr
     {
-      break-if-<=
-      var filename/edx: (addr addr array byte) <- index args 1
-      var in: (handle buffered-file)
-      {
-        var addr-in/eax: (addr handle buffered-file) <- address in
-        open *filename, 0, addr-in
-      }
-      var _in-addr/eax: (addr buffered-file) <- lookup in
-      var in-addr/ecx: (addr buffered-file) <- copy _in-addr
-      {
-        var c/eax: byte <- read-byte-buffered in-addr
-        compare c, 0xffffffff  # EOF marker
-        break-if-=
-        var g/eax: grapheme <- copy c
-        print-grapheme 0, g
-        loop
-      }
+      var c/eax: byte <- read-byte-buffered in-addr
+      compare c, 0xffffffff  # EOF marker
+      break-if-=
+      var g/eax: grapheme <- copy c
+      print-grapheme 0, g
+      loop
     }
   }
-  exit-status <- copy 0
+  return 0
 }
diff --git a/apps/rpn.mu b/apps/rpn.mu
index bd0d721f..b1c66021 100644
--- a/apps/rpn.mu
+++ b/apps/rpn.mu
@@ -26,7 +26,7 @@
 #
 # Error handling is non-existent. This is just a prototype.
 
-fn main -> exit-status/ebx: int {
+fn main -> _/ebx: int {
   var in-storage: (stream byte 0x100)
   var in/esi: (addr stream byte) <- address in-storage
   print-string 0, "press ctrl-c or ctrl-d to exit\n"
@@ -48,7 +48,7 @@ fn main -> exit-status/ebx: int {
     #
     loop
   }
-  exit-status <- copy 0
+  return 0
 }
 
 type int-stack {
@@ -56,7 +56,7 @@ type int-stack {
   top: int
 }
 
-fn simplify in: (addr stream byte) -> result/eax: int {
+fn simplify in: (addr stream byte) -> _/eax: int {
   var word-storage: slice
   var word/ecx: (addr slice) <- address word-storage
   var stack-storage: int-stack
@@ -106,7 +106,8 @@ fn simplify in: (addr stream byte) -> result/eax: int {
     push-int-stack stack, n
     loop
   }
-  result <- pop-int-stack stack
+  var result/eax: int <- pop-int-stack stack
+  return result
 }
 
 fn initialize-int-stack _self: (addr int-stack), n: int {
@@ -129,21 +130,19 @@ fn push-int-stack _self: (addr int-stack), _val: int {
   add-to *top-addr, 1
 }
 
-fn pop-int-stack _self: (addr int-stack) -> val/eax: int {
-$pop-int-stack:body: {
+fn pop-int-stack _self: (addr int-stack) -> _/eax: int {
   var self/esi: (addr int-stack) <- copy _self
   var top-addr/ecx: (addr int) <- get self, top
   {
     compare *top-addr, 0
     break-if->
-    val <- copy 0
-    break $pop-int-stack:body
+    return 0
   }
   subtract-from *top-addr, 1
   var data-ah/edx: (addr handle array int) <- get self, data
   var data/eax: (addr array int) <- lookup *data-ah
   var top/edx: int <- copy *top-addr
   var result-addr/eax: (addr int) <- index data, top
-  val <- copy *result-addr
-}
+  var val/eax: int <- copy *result-addr
+  return val
 }
diff --git a/apps/texture.mu b/apps/texture.mu
index edac4126..1eaf892d 100644
--- a/apps/texture.mu
+++ b/apps/texture.mu
@@ -6,7 +6,7 @@
 #   $ ./translate_mu apps/texture.mu
 #   $ ./a.elf > a.ppm
 
-fn main -> exit-status/ebx: int {
+fn main -> _/ebx: int {
 #?   var width/esi: int <- copy 0x190  # 400
 #?   var height/edi: int <- copy 0xe1  # 225; aspect ratio 16:9
   var width/esi: int <- copy 0xff
@@ -54,5 +54,5 @@ fn main -> exit-status/ebx: int {
     row <- increment
     loop
   }
-  exit-status <- copy 0
+  return 0
 }
diff --git a/apps/tui.mu b/apps/tui.mu
index be74e1c4..7dad7d1b 100644
--- a/apps/tui.mu
+++ b/apps/tui.mu
@@ -4,7 +4,7 @@
 #   $ ./translate_mu apps/tui.mu
 #   $ ./a.elf
 
-fn main -> exit-status/ebx: int {
+fn main -> _/ebx: int {
   var nrows/eax: int <- copy 0
   var ncols/ecx: int <- copy 0
   nrows, ncols <- screen-size 0
@@ -30,5 +30,5 @@ fn main -> exit-status/ebx: int {
   var x-int/eax: int <- copy x
   print-int32-hex 0, x-int
   print-string 0, "\n"
-  exit-status <- copy 0
+  return 0
 }