brainfuck 0.1.2 → 0.2.0

data/lib/brainfuck/lexer.rb

@@ -0,0 +1,32 @@
+module Brainfuck
+  class Lexer < Parslet::Parser
+    INSTRUCTIONS = %w{> < + - [ ] . ,}
+
+    alias_method :tokenize, :parse
+    class << self
+      def clean code
+        code.chars.select {|c| INSTRUCTIONS.include? c }.join
+      end
+    end
+
+    rule(:lparen)     { str('[') >> space? }
+    rule(:rparen)     { str(']') >> space? }
+
+    rule(:space)      { match('\s').repeat(1) }
+    rule(:space?)     { space.maybe }
+
+    rule(:fwd)        { str('>') >> space? }
+    rule(:bwd)        { str('<') >> space? }
+
+    rule(:inc)        { str('+') >> space? }
+    rule(:dec)        { str('-') >> space? }
+
+    rule(:puts)       { str('.') >> space? }
+    rule(:gets)       { str(',') >> space? }
+
+    rule(:iteration)  { lparen >> expression >> rparen }
+
+    rule(:expression) { (iteration.as(:iteration) | fwd.as(:fwd) | bwd.as(:bwd) | inc.as(:inc) | dec.as(:dec) | puts.as(:puts) | gets.as(:gets)).repeat.as(:exp) }
+    root :expression
+  end
+end

data/lib/brainfuck/main.rb

@@ -0,0 +1,99 @@
+require 'brainfuck/version'
+
+module Brainfuck
+
+  # Command line interface to Brainfuck.
+  #
+  # Currently we only take a brainfuck source name to compile and
+  # run.
+  #
+  class Main
+
+    def initialize
+      @print = Compiler::Print.new
+      @compile_only = false
+      @evals = []
+      @rest = []
+    end
+
+    def main(argv=ARGV)
+      options(argv)
+      evals unless @evals.empty?
+      script unless @rest.empty?
+      compile if @compile_only
+    end
+
+    # Batch compile all brainfuck files given as arguments.
+    def compile
+      @rest.each do |bf|
+        begin
+          Compiler.compile_file bf, nil, @print
+        rescue Compiler::Error => e
+          e.show
+        end
+      end
+    end
+
+    # Evaluate code given on command line
+    def evals
+      bnd = Object.new
+      def bnd.get; binding; end
+      bnd = bnd.get
+      mod = nil
+      @evals.each do |code|
+        CodeLoader.execute_code code, bnd, mod, @print
+      end
+    end
+
+    # Run the given script if any
+    def script
+      CodeLoader.execute_file @rest.first, nil, @print
+    end
+
+    # Parse command line options
+    def options(argv)
+      options = Rubinius::Options.new "Usage: brainfuck [options] [program]", 20
+      options.doc "Brainfuck is a Brainfuck implementation for the Rubinius VM."
+      options.doc ""
+      options.doc "OPTIONS:"
+
+      # options.on "-", "Read and evalute code from STDIN" do
+      #   @evals << STDIN.read
+      # end
+
+      # options.on "--print-ast", "Print the Brainfuck AST" do
+      #   @print.ast = true
+      # end
+
+      # options.on "--print-asm", "Print the Rubinius ASM" do
+      #   @print.asm = true
+      # end
+
+      # options.on "--print-sexp", "Print the Brainfuck Sexp" do
+      #   @print.sexp = true
+      # end
+
+      # options.on "--print-all", "Print Sexp, AST and Rubinius ASM" do
+      #   @print.ast = @print.asm = @print.sexp = true
+      # end
+
+      options.on "-C", "--compile", "Just batch compile dont execute." do
+        @compile_only = true
+      end
+# 
+#       options.on "-e", "CODE", "Execute CODE" do |e|
+#         @evals << e
+#       end
+
+      options.on "-h", "--help", "Display this help" do
+        puts options
+        exit 0
+      end
+
+      options.doc ""
+
+      @rest = options.parse(argv)
+    end
+
+  end
+end

data/lib/brainfuck/parser.rb

@@ -1,31 +1,16 @@
 module Brainfuck
-  class Parser < Parslet::Parser
-    INSTRUCTIONS = %w{> < + - [ ] . ,}
+  class Parser < Parslet::Transform
+    rule(:fwd => simple(:fwd))            { AST::FwdNode.new }
+    rule(:bwd => simple(:bwd))            { AST::BwdNode.new }
 
-    class << self
-      def clean code
-        code.chars.select {|c| INSTRUCTIONS.include? c }.join
-      end
-    end
+    rule(:inc => simple(:inc))            { AST::IncNode.new }
+    rule(:dec => simple(:dec))            { AST::DecNode.new }
 
-    rule(:lparen)     { str('[') >> space? }
-    rule(:rparen)     { str(']') >> space? }
+    rule(:puts => simple(:puts))          { AST::PutsNode.new }
+    rule(:gets => simple(:gets))          { AST::GetsNode.new }
 
-    rule(:space)      { match('\s').repeat(1) }
-    rule(:space?)     { space.maybe }
+    rule(:iteration => subtree(:iteration)) { AST::IterationNode.new(iteration) }
 
-    rule(:fwd)        { str('>') >> space? }
-    rule(:bwd)        { str('<') >> space? }
-
-    rule(:inc)        { str('+') >> space? }
-    rule(:dec)        { str('-') >> space? }
-
-    rule(:puts)       { str('.') >> space? }
-    rule(:gets)       { str(',') >> space? }
-
-    rule(:iteration)  { lparen >> expression >> rparen }
-
-    rule(:expression) { (iteration.as(:iteration) | fwd.as(:fwd) | bwd.as(:bwd) | inc.as(:inc) | dec.as(:dec) | puts.as(:puts) | gets.as(:gets)).repeat.as(:exp) }
-    root :expression
+    rule(:exp => subtree(:exp)) { AST::Script.new(exp) }
   end
 end

data/lib/brainfuck/stages.rb

@@ -0,0 +1,170 @@
+require 'pp'
+module Brainfuck
+  class Stage
+
+    
+    # This stage takes a tree of Brainfuck::AST nodes and
+    # simply calls the bytecode method on them.
+    class Generator < Rubinius::Compiler::Stage
+      next_stage Rubinius::Compiler::Encoder
+      attr_accessor :variable_scope, :root
+
+      def initialize(compiler, last)
+        super
+        @compiler = compiler
+        @variable_scope = nil
+        compiler.generator = self
+      end
+
+      def run
+        @output = Rubinius::Generator.new
+
+        @output.set_line Integer(1)
+
+        # ENVIRONMENT INITIALIZATION
+        # --------------------------
+        
+        # Initialize the heap as a one-cell array containing zero,
+        # and the pointer as a zero integer.
+        @output.meta_push_0
+        @output.set_local 1
+        @output.cast_array
+        @output.set_local 0
+
+        @input.bytecode @output
+
+        bottom = @output.new_label
+
+        @output.push_const :ENV
+        @output.push_literal "DEBUG"
+        @output.send :[], 1, false
+
+        @output.gif bottom
+
+        # Print the heap and the pointer if ENV['DEBUG']
+        @output.push_literal "Heap: "
+
+        @output.push_local 0
+        @output.send :inspect, 0
+
+        @output.push_literal "\nPointer: "
+        @output.push_local 1
+        @output.push_literal "\n"
+        @output.send :print, 5, true
+        # end Print
+
+        bottom.set!
+      
+        @output.use_detected
+        # Return the heap
+        @output.push_local 0
+        @output.ret
+        @output.close
+
+        run_next
+      end
+
+    end
+
+    # AST trasnformation for evaling source string.
+    #
+    # This stage removes the ModuleNode from root of AST tree if
+    # the code being compiled is going to be used for eval. We remove
+    # the module, because in eval we must not return the module object
+    # Also if the last statement is a DiscardNode, we replace it with
+    # its inner expression, in order to return a value.
+    #
+    # If the source is not being compiled for eval, then output is
+    # the same AST given as input.
+    class EvalExpr < Rubinius::Compiler::Stage
+      next_stage Generator
+
+      def initialize(compiler, last)
+        @compiler = compiler
+        super
+      end
+
+      def run
+        @output = @input
+        run_next
+      end
+    end
+
+    # This stage takes a ruby array as produced by the lexer
+    # and produces a tree of Brainfuck::AST nodes.
+    class BfAST < Rubinius::Compiler::Stage
+      next_stage EvalExpr
+
+      def initialize(compiler, last)
+        @compiler = compiler
+        super
+      end
+
+      def run
+        @output = Brainfuck::Parser.new.apply @input
+        pp(@output) if @compiler.parser.print.ast?
+        run_next
+      end
+    end
+
+    # This stage takes python code and produces a ruby array
+    # containing representation of the python source.
+    # We are currently using python's own parser, so we just
+    # read the sexp as its printed by bin/astpretty.py
+    class BfCode < Rubinius::Compiler::Stage
+
+      stage :brainfuck_code
+      next_stage BfAST
+      attr_reader :filename, :line
+      attr_accessor :print
+
+      def initialize(compiler, last)
+        super
+        @print = Compiler::Print.new
+        compiler.parser = self
+      end
+
+      def input(code, filename = "eval", line = 1)
+        @code = code
+        @filename = filename
+        @line = line
+      end
+
+      def run
+        code = Lexer.clean(@code)
+        @output = Lexer.new.tokenize(code)
+        pp(@output) if @print.sexp?
+        run_next
+      end
+    end
+
+    # This stage takes a brainfuck filename and produces a ruby array
+    # containing representation of the brainfuck source.
+    class BfFile < Rubinius::Compiler::Stage
+
+      stage :brainfuck_file
+      next_stage BfAST
+      attr_reader :filename, :line
+      attr_accessor :print
+
+      def initialize(compiler, last)
+        super
+        @print = Compiler::Print.new
+        compiler.parser = self
+      end
+
+      def input(filename, line = 1)
+        @filename = filename
+        @line = line
+      end
+
+      def run
+        code = Lexer.clean(File.read(@filename))
+        @output = Lexer.new.tokenize(code)
+        pp(@output) if @print.sexp?
+        run_next
+      end
+    end
+
+  end
+end

data/lib/brainfuck/version.rb

@@ -1,3 +1,3 @@
 module Brainfuck
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/test/acceptance/acceptance_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+class BrainfuckAcceptanceTest < MiniTest::Unit::TestCase
+
+  def test_ok
+    assert_evaluates [2,1], "++++>++++---.<--."
+  end
+
+  def test_without_loops_nor_user_input
+    STDOUT.expects(:putc).times(2)
+    assert_evaluates [2,1], "++++>++++---.<--."
+  end
+
+  def test_with_user_input
+    STDIN.expects(:getc).returns 97
+
+    assert_evaluates [101], ",++++"
+  end
+
+  def test_with_loops
+    assert_evaluates [1], "++++[-]+-+"
+  end
+
+  def test_transfers_from_one_cell_to_another
+    assert_evaluates [0, 10], "++++++++++      [>+<-]"
+  end
+
+  def test_transfers_from_one_cell_to_the_third
+    assert_evaluates [0, 0, 10], "++++++++++      [>+<-]>[>+<-]"
+  end
+
+  def test_transfers_from_one_cell_to_the_third_and_back_to_the_second
+    assert_evaluates [0, 10, 0], "++++++++++      [>+<-]>[>+<-]>[<+>-]"
+  end
+
+  def test_nested_loop_examples
+    assert_evaluates [0], "[++++++++++[-]+-+-]"
+  end
+
+  def test_hello_world
+    assert_evaluates [0, 87, 100, 33, 10], <<-EOS
+      +++++ +++++            
+      [                      
+          > +++++ ++         
+          > +++++ +++++      
+          > +++              
+          > +                
+          <<<< -              
+      ]                   
+      > ++ .                  
+      > + .                   
+      +++++ ++ .              
+      .                       
+      +++ .                   
+      > ++ .                  
+      << +++++ +++++ +++++ .  
+      > .                     
+      +++ .                   
+      ----- - .               
+      ----- --- .             
+      > + .                   
+      > .                     
+  EOS
+  end
+
+  private
+
+  def assert_evaluates(expected, code)
+    bnd = Object.new
+    def bnd.get; binding; end
+    bnd = bnd.get
+    mod = nil
+    assert_equal expected, Brainfuck::CodeLoader.execute_code(code, bnd, mod)
+  end
+end

data/test/brainfuck/ast_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+module Brainfuck
+  class ASTTest < MiniTest::Unit::TestCase
+
+  end
+end

data/test/brainfuck/lexer_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+module Brainfuck
+  class LexerTest < MiniTest::Unit::TestCase
+
+    def test_INSTRUCTIONS_returns_valid_symbols
+      assert_equal %w{> < + - [ ] . ,}, Lexer::INSTRUCTIONS
+    end
+
+    def test_clean_cleans_all_invalid_symbols
+      assert_equal '><+-[-].,', Lexer.clean(">3< 223+fn - ()()[r23-] .bdn*& ,")
+    end
+
+    %w{lparen rparen space space? fwd bwd inc dec puts gets iteration expression}.each do |rule|
+      define_method("test_implements_a_#{rule}_rule") do
+        assert Lexer.new.respond_to?(rule), "Parser should implement a #{rule} rule"
+      end
+    end
+
+  end
+end