contrib/nitcc/examples/minilang.nit

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