apps/rpn.mu

   1 # Integer arithmetic using postfix notation
   2 #
   3 # Limitations:
   4 #   Division not implemented yet.
   5 #
   6 # To build:
   7 #   $ ./translate apps/rpn.mu
   8 #
   9 # Example session:
  10 #   $ qemu-system-i386 code.img
  11 #   > 4
  12 #   4
  13 #   > 5 3 -
  14 #   2
  15 #
  16 # Error handling is non-existent. This is just a prototype.
  17
  18 fn main screen: (addr screen), keyboard: (addr keyboard), data-disk: (addr disk) {
  19   var in-storage: (stream byte 0x80)
  20   var in/esi: (addr stream byte) <- address in-storage
  21   var y/ecx: int <- copy 0
  22   # read-eval-print loop
  23   {
  24     var x/eax: int <- draw-text-rightward screen, "> ", 0/x, 0x80/xmax, y, 3/fg/cyan, 0/bg
  25     read-line-from-keyboard keyboard, in, screen, 0xf/fg 0/bg
  26     # parse and eval
  27     var out/eax: int <- simplify in
  28     # print
  29     y <- increment
  30     out, y <- draw-int32-decimal-wrapping-right-then-down screen, out, 0/xmin, y, 0x80/xmax, 0x30/ymax, 0/x, y, 7/fg, 0/bg
  31     # newline
  32     y <- increment
  33     #
  34     loop
  35   }
  36 }
  37
  38 type int-stack {
  39   data: (handle array int)
  40   top: int
  41 }
  42
  43 fn simplify in: (addr stream byte) -> _/eax: int {
  44   var word-storage: slice
  45   var word/ecx: (addr slice) <- address word-storage
  46   var stack-storage: int-stack
  47   var stack/esi: (addr int-stack) <- address stack-storage
  48   initialize-int-stack stack, 0x10
  49   $simplify:word-loop: {
  50     next-word in, word
  51     var done?/eax: boolean <- slice-empty? word
  52     compare done?, 0
  53     break-if-!=
  54     # if word is an operator, perform it
  55     {
  56       var is-add?/eax: boolean <- slice-equal? word, "+"
  57       compare is-add?, 0
  58       break-if-=
  59       var _b/eax: int <- pop-int-stack stack
  60       var b/edx: int <- copy _b
  61       var a/eax: int <- pop-int-stack stack
  62       a <- add b
  63       push-int-stack stack, a
  64       loop $simplify:word-loop
  65     }
  66     {
  67       var is-sub?/eax: boolean <- slice-equal? word, "-"
  68       compare is-sub?, 0
  69       break-if-=
  70       var _b/eax: int <- pop-int-stack stack
  71       var b/edx: int <- copy _b
  72       var a/eax: int <- pop-int-stack stack
  73       a <- subtract b
  74       push-int-stack stack, a
  75       loop $simplify:word-loop
  76     }
  77     {
  78       var is-mul?/eax: boolean <- slice-equal? word, "*"
  79       compare is-mul?, 0
  80       break-if-=
  81       var _b/eax: int <- pop-int-stack stack
  82       var b/edx: int <- copy _b
  83       var a/eax: int <- pop-int-stack stack
  84       a <- multiply b
  85       push-int-stack stack, a
  86       loop $simplify:word-loop
  87     }
  88     # otherwise it's an int
  89     var n/eax: int <- parse-decimal-int-from-slice word
  90     push-int-stack stack, n
  91     loop
  92   }
  93   var result/eax: int <- pop-int-stack stack
  94   return result
  95 }
  96
  97 fn initialize-int-stack _self: (addr int-stack), n: int {
  98   var self/esi: (addr int-stack) <- copy _self
  99   var d/edi: (addr handle array int) <- get self, data
 100   populate d, n
 101   var top/eax: (addr int) <- get self, top
 102   copy-to *top, 0
 103 }
 104
 105 fn push-int-stack _self: (addr int-stack), _val: int {
 106   var self/esi: (addr int-stack) <- copy _self
 107   var top-addr/ecx: (addr int) <- get self, top
 108   var data-ah/edx: (addr handle array int) <- get self, data
 109   var data/eax: (addr array int) <- lookup *data-ah
 110   var top/edx: int <- copy *top-addr
 111   var dest-addr/edx: (addr int) <- index data, top
 112   var val/eax: int <- copy _val
 113   copy-to *dest-addr, val
 114   add-to *top-addr, 1
 115 }
 116
 117 fn pop-int-stack _self: (addr int-stack) -> _/eax: int {
 118   var self/esi: (addr int-stack) <- copy _self
 119   var top-addr/ecx: (addr int) <- get self, top
 120   {
 121     compare *top-addr, 0
 122     break-if->
 123     return 0
 124   }
 125   subtract-from *top-addr, 1
 126   var data-ah/edx: (addr handle array int) <- get self, data
 127   var data/eax: (addr array int) <- lookup *data-ah
 128   var top/edx: int <- copy *top-addr
 129   var result-addr/eax: (addr int) <- index data, top
 130   var val/eax: int <- copy *result-addr
 131   return val
 132 }