AmberVM 0.0.19

data/lib/amber/languages/brainfuck.rb

@@ -0,0 +1,153 @@
+require 'strscan'
+require 'amber/functions/math/add'
+require 'amber/functions/math/sub'
+require 'amber/functions/io/print'
+
+module AmberVM
+  module Languages
+    # This is a brainfuck compiler for the VM.
+    # It covers the compleat BF syntax and allows you to write files that are executed.
+    # 
+    # Mostly a gimick I admit but it's a nice demonstration of how rVM works. 
+    class Brainfuck < AmberVM::Languages::Language
+      
+      def Brainfuck.bfpp str
+        str.gsub!(/\/\/.*?\n/,'')
+        str.gsub!(/[^<>+\[\].,\dv-]/,'')
+        str.gsub!('v','[-]')
+        str.gsub!(/(.)(\d+)/) do |s|
+          s[0].chr * s.gsub(/^./,'').to_i
+        end
+        str
+      end
+      
+      # This function compiles a string of BF code and returns the equivalent for the
+      # rVM.
+      def compile code
+        make_vmcode(make_tree(code))
+      end
+      
+      private
+      def make_tree str
+        str.gsub!(/\/\/.*?\n/,'') #delete comments
+        str.gsub!(/[^<>+\[\].,\d-]/,'')
+        s = StringScanner.new(str)
+        tree = []
+        cur = tree
+        stack = []
+        while (!s.eos?)
+          c = s.scan(/./)
+          case (c)
+            when '+'
+            if cur.last and cur.last[0] == :inc
+              cur.last[1] += 1
+            else
+              cur << [:inc, 1]
+            end
+            when '-'
+            if cur.last and cur.last[0] == :dec
+              cur.last[1] += 1
+            else
+              cur << [:dec, 1]
+            end
+            when '<'
+            if cur.last and cur.last[0] == :left
+              cur.last[1] += 1
+            else
+              cur << [:left, 1]
+            end
+            when '>'
+            if cur.last and cur.last[0] == :right
+              cur.last[1] += 1
+            else
+              cur << [:right, 1]
+            end
+            when '['
+            tmp = []
+            cur << [:loop, tmp]
+            stack << cur
+            cur = tmp
+            when '.'
+            cur << [:print]
+            when ','
+            cur << [:read]
+            when ']'
+            cur = stack.pop
+          end
+        end
+        tree
+      end
+      
+      def make_vmcode tree
+        root = AmberVM::Interpreter::Sequence.new();
+        ptr = Interpreter::Variable.new(Interpreter.const(:string,'ptr'))
+        val = Interpreter::Variable.new(ptr)
+        tree.each do |item|
+          case item[0]
+            when :inc
+            root << Interpreter::Assignment.new(
+              ptr,
+              Interpreter::CoreCall.new(
+                :add,
+                [
+                  Interpreter::Condition.new(
+                    val,
+                    val,
+                    Interpreter.const(:number,0)
+                  ),
+                  Interpreter.const(:number,item[1])
+                ]
+              )
+            )
+            when :dec
+            root << Interpreter::Assignment.new(
+              ptr,
+              Interpreter::CoreCall.new(
+                :sub,
+                [
+                  Interpreter::Condition.new(
+                    val,
+                    val,
+                    Interpreter.const(:number,0)
+                  ),
+                  Interpreter.const(:number,item[1])
+                ]
+              )
+            )
+            when :left
+            root << Interpreter::Assignment.new(
+              Interpreter.const(:string,'ptr'),
+              Interpreter::CoreCall.new(
+                :sub,
+                [
+                  ptr,
+                  Interpreter.const(:number,item[1])
+                ]
+              )
+            )
+            when :right
+            root << Interpreter::Assignment.new(
+              Interpreter.const(:string,'ptr'),
+              Interpreter::CoreCall.new(
+                :add,
+                [
+                  ptr,
+                  Interpreter.const(:number,item[1])
+                ]
+              )
+            )
+            when :print
+            root << Interpreter::CoreCall.new(:print, [Interpreter::CoreCall.new(:chr,[val])])
+            when :read
+            when :loop
+            body = make_vmcode(item[1])
+            root << Interpreter::Loop.new(val,	body)
+          end
+        end
+        root
+      end
+      
+      register_for :brainfuck
+    end
+  end
+end