contrib/nitcc/examples/minilang.nit

   1 import minilang_test_parser
   2
   3 # An naive recursive stack-based interpreter of the minilang language.
   4 class Interpretor
   5         super Visitor
   6
   7         # A stack of numeric values
   8         var stack = new Array[Int]
   9
  10         # A stack of boolean values
  11         var bstack = new Array[Bool]
  12
  13         # The current values assigned to each variable
  14         var vars = new HashMap[String, Int]
  15
  16         redef fun visit(n) do n.accept_calculator(self)
  17 end
  18
  19 redef class Node
  20         # Execution of the node by the interpreter `v`
  21         fun accept_calculator(v: Interpretor) do visit_children(v)
  22 end
  23
  24 redef class Nint
  25         redef fun accept_calculator(v) do v.stack.push(text.to_i)
  26 end
  27
  28 redef class Ns_assign
  29         redef fun accept_calculator(v) do
  30                 super
  31                 v.vars[n_id.text] = v.stack.pop
  32         end
  33 end
  34
  35 redef class Ns_print
  36         redef fun accept_calculator(v) do
  37                 super
  38                 printn v.stack.pop
  39         end
  40 end
  41 redef class Ns_print_str
  42         redef fun accept_calculator(v) do
  43                 var text = n_str.text
  44                 text = text.substring(1, text.length-2)
  45                 printn text
  46         end
  47 end
  48 redef class Ns_println
  49         redef fun accept_calculator(v) do
  50                 print ""
  51         end
  52 end
  53 redef class Ns_if
  54         redef fun accept_calculator(v) do
  55                 v.enter_visit(n_c)
  56                 if v.bstack.pop then
  57                         v.enter_visit(n_then)
  58                 else
  59                         var nelse = n_else
  60                         if nelse != null then v.enter_visit(nelse)
  61                 end
  62         end
  63 end
  64 redef class Ns_while
  65         redef fun accept_calculator(v) do
  66                 loop
  67                         v.enter_visit(n_c)
  68                         if not v.bstack.pop then break
  69                         v.enter_visit(n_stmts)
  70                 end
  71         end
  72 end
  73
  74
  75 redef class Nc_and
  76         redef fun accept_calculator(v) do
  77                 super
  78                 var b1 = v.bstack.pop
  79                 var b2 = v.bstack.pop
  80                 v.bstack.push(b1 and b2)
  81         end
  82 end
  83
  84 redef class Nc_or
  85         redef fun accept_calculator(v) do
  86                 super
  87                 var b1 = v.bstack.pop
  88                 var b2 = v.bstack.pop
  89                 v.bstack.push(b1 or b2)
  90         end
  91 end
  92
  93 redef class Nc_not
  94         redef fun accept_calculator(v) do
  95                 super
  96                 v.bstack.push(not v.bstack.pop)
  97         end
  98 end
  99
 100 redef class Nc_eq
 101         redef fun accept_calculator(v) do
 102                 super
 103                 v.bstack.push(v.stack.pop == v.stack.pop)
 104         end
 105 end
 106
 107 redef class Nc_ne
 108         redef fun accept_calculator(v) do
 109                 super
 110                 v.bstack.push(v.stack.pop != v.stack.pop)
 111         end
 112 end
 113
 114 redef class Nc_lt
 115         redef fun accept_calculator(v) do
 116                 super
 117                 v.bstack.push(v.stack.pop > v.stack.pop)
 118         end
 119 end
 120
 121 redef class Nc_le
 122         redef fun accept_calculator(v) do
 123                 super
 124                 v.bstack.push(v.stack.pop >= v.stack.pop)
 125         end
 126 end
 127
 128 redef class Nc_gt
 129         redef fun accept_calculator(v) do
 130                 super
 131                 v.bstack.push(v.stack.pop < v.stack.pop)
 132         end
 133 end
 134
 135 redef class Nc_ge
 136         redef fun accept_calculator(v) do
 137                 super
 138                 v.bstack.push(v.stack.pop <= v.stack.pop)
 139         end
 140 end
 141
 142 redef class Ne_add
 143         redef fun accept_calculator(v) do
 144                 super
 145                 v.stack.push(v.stack.pop+v.stack.pop)
 146         end
 147 end
 148 redef class Ne_sub
 149         redef fun accept_calculator(v) do
 150                 super
 151                 var n1 = v.stack.pop
 152                 v.stack.push(v.stack.pop-n1)
 153         end
 154 end
 155 redef class Ne_neg
 156         redef fun accept_calculator(v) do
 157                 super
 158                 v.stack.push(-v.stack.pop)
 159         end
 160 end
 161 redef class Ne_mul
 162         redef fun accept_calculator(v) do
 163                 super
 164                 v.stack.push(v.stack.pop*v.stack.pop)
 165         end
 166 end
 167 redef class Ne_div
 168         redef fun accept_calculator(v) do
 169                 super
 170                 var n1 = v.stack.pop
 171                 v.stack.push(v.stack.pop/n1)
 172         end
 173 end
 174 redef class Ne_var
 175         redef fun accept_calculator(v) do
 176                 v.stack.push v.vars[n_id.text]
 177         end
 178 end
 179 redef class Ne_read
 180         redef fun accept_calculator(v) do
 181                 var t = gets
 182                 v.stack.push(t.to_i)
 183         end
 184 end
 185
 186 var t = new TestParser_minilang
 187 var n = t.main
 188
 189 var v = new Interpretor
 190 v.enter_visit(n)