brainfuck 0.1.2 → 0.2.0

data/.gitignore

@@ -2,3 +2,5 @@ pkg/*
 *.gem
 .bundle
 coverage
+*.rbc
+*.bfc

data/Gemfile.lock

@@ -1,29 +1,17 @@
 PATH
   remote: .
   specs:
-    brainfuck (0.1.0)
-      highline
+    brainfuck (0.2.0)
       parslet
 
 GEM
   remote: http://rubygems.org/
   specs:
-    blankslate (2.1.2.3)
-    diff-lcs (1.1.2)
-    highline (1.6.1)
-    parslet (1.0.0)
-      blankslate (~> 2.1.2.3)
-    rspec (2.2.0)
-      rspec-core (~> 2.2)
-      rspec-expectations (~> 2.2)
-      rspec-mocks (~> 2.2)
-    rspec-core (2.2.1)
-    rspec-expectations (2.2.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.2.0)
-    simplecov (0.3.7)
-      simplecov-html (>= 0.3.7)
-    simplecov-html (0.3.9)
+    blankslate (2.1.2.4)
+    minitest (2.0.2)
+    mocha (0.9.12)
+    parslet (1.2.0)
+      blankslate (~> 2.0)
 
 PLATFORMS
   java
@@ -31,8 +19,5 @@ PLATFORMS
 
 DEPENDENCIES
   brainfuck!
-  bundler
-  highline
-  parslet
-  rspec
-  simplecov
+  minitest
+  mocha

data/Rakefile

@@ -1,17 +1,19 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
-require 'simplecov'
-SimpleCov.start do
-  add_group "Lib", 'lib'
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb'] - FileList['test/acceptance/**/*_test.rb']
+  t.verbose = true
 end
 
-require 'rspec/core'
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = FileList['spec/**/*_spec.rb']
+require 'rake/testtask'
+desc 'Run acceptance tests'
+Rake::TestTask.new :acceptance do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/acceptance/**/*_test.rb']
+  t.verbose = true
 end
-task
 
-task :default => :spec
-task :test => [:spec]
+task :default => [:test, :acceptance]

data/Readme.md

@@ -1,31 +1,37 @@
 # brainfuck
 
-Just another Brainfuck interpreter in Ruby!
+An implementation of Brainfuck on the [Rubinius](http://rubini.us) VM.
+
 (If you don't know what Brainfuck is, you definitely
 [should](http://en.wikipedia.org/wiki/Brainfuck)).
 
-This interpreter works with MRI 1.8.7, 1.9.2 and JRuby 1.5.5.
-
-## UPDATE: Known caveats solved since 0.1.0!
-
-Thanks to a complete rewrite using Kaspar Schiess' `parslet` (which you should
-definitely [check it out](http://github.com/kschiess/parslet)) nested loops
-work flawlessly. So yes, you can now run that high-security online payment
-system you wrote in Brainfuck :)
+Obviously... needs Rubinius!
 
 ## Installation and usage
 
 You just `gem install brainfuck` (or `gem 'brainfuck'` in your Gemfile)!
 
-And then: `brainfuck my_file.bf`
+And then: 
+
+    $ brainfuck my_file.bf
+
+Or if you just want to generate the compiled bytecode in `my_file.bfc`:
+
+    $ brainfuck -C my_file.bf
 
 You can also require the gem and use inline brainfuck in your ruby scripts like this:
 
     require 'brainfuck'
 
-    Brainfuck.run "+++>+++<---"
+    # Brainfuck needs an object binding to do its stuff.
+    bnd = Object.new
+    def bnd.get; binding; end
+    bnd = bnd.get
+
+    Brainfuck::CodeLoader.execute_code "+++>+++<---", bnd, nil
     # => [0, 3]
 
+
 ## Note on Patches/Pull Requests
  
 * Fork the project.

data/bin/brainfuck

@@ -1,3 +1,3 @@
 #!/usr/bin/env ruby
 require 'brainfuck'
-Brainfuck.run File.read(ARGV.first)
+Brainfuck::Main.new.main ARGV.first

data/brainfuck.gemspec

@@ -9,16 +9,15 @@ Gem::Specification.new do |s|
   s.authors     = ["Josep M. Bach"]
   s.email       = ["josep.m.bach@gmail.com"]
   s.homepage    = "http://github.com/txus/brainfuck"
-  s.summary     = %q{Another Brainfuck interpreter in Ruby}
-  s.description     = %q{Another Brainfuck interpreter in Ruby}
+  s.summary     = %q{An implementation of Brainfuck on the Rubinius VM.}
+  s.description = %q{An implementation of Brainfuck on the Rubinius VM.}
 
   s.rubyforge_project = "brainfuck"
 
-  s.add_runtime_dependency "highline"
   s.add_runtime_dependency "parslet"
-  s.add_development_dependency "rspec"
-  s.add_development_dependency "bundler"
-  s.add_development_dependency "simplecov"
+
+  s.add_development_dependency "minitest"
+  s.add_development_dependency "mocha"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/brainfuck.rb

@@ -1,22 +1,9 @@
 require 'parslet'
-require 'highline/system_extensions'
 
-require 'brainfuck/stack'
 require 'brainfuck/ast'
-
+require 'brainfuck/lexer'
 require 'brainfuck/parser'
-require 'brainfuck/interpreter'
-
-module Brainfuck
-  class << self
-    def run code
-      Interpreter.stack.clear
-
-      code = Parser.clean code
-      parsed = Parser.new.parse code
-      ast = Interpreter.new.apply parsed
-      ast.each(&:eval)
-      Interpreter.stack.to_a
-    end
-  end
-end
+require 'brainfuck/stages'
+require 'brainfuck/compiler'
+require 'brainfuck/main'
+require 'brainfuck/code_loader'

data/lib/brainfuck/ast.rb

@@ -1,30 +1,138 @@
 module Brainfuck
   module AST
-    class FwdNode < Struct.new(:stack)
-      def eval; stack.fwd ; end
+    class FwdNode
+      def bytecode(g)
+        g.push_local 1
+        g.meta_push_1
+        g.meta_send_op_plus 0
+        g.set_local 1
+
+        # Check the contents of the new cell
+        g.push_local 0   
+        g.swap_stack
+        g.send :[], 1, false
+
+        fin = g.new_label
+        g.git fin
+        g.pop
+
+        # If the cell is nil set it to 0
+        g.push_local 0
+        g.push_local 1
+        g.meta_push_0
+        g.send :[]=, 2, false
+
+        # Otherwise, do nothing
+        fin.set!
+      end
     end
-    class BwdNode < Struct.new(:stack)
-      def eval; stack.bwd ; end
+    class BwdNode
+      def bytecode(g)
+        g.push_local 1
+        g.meta_push_1
+        g.meta_send_op_minus 0
+        g.set_local 1
+
+        # Check the contents of the new cell
+        g.push_local 0   
+        g.swap_stack
+        g.send :[], 1, false
+
+        fin = g.new_label
+        g.git fin
+        g.pop
+
+        # If the cell is nil set it to 0
+        g.push_local 0
+        g.push_local 1
+        g.meta_push_0
+        g.send :[]=, 2, false
+
+        # Otherwise, do nothing
+        fin.set!
+      end
     end
 
-    class IncNode < Struct.new(:stack)
-      def eval; stack.inc ; end
+    class IncNode
+      def bytecode(g)
+        g.push_local 0
+        g.push_local 1
+
+        g.dup_many(2)
+        g.send :[], 1, false
+        g.meta_push_1
+        g.meta_send_op_plus 0
+
+        g.send :[]=, 2, false
+        g.pop
+      end
     end
-    class DecNode < Struct.new(:stack)
-      def eval; stack.dec ; end
+    class DecNode
+      def bytecode(g)
+        g.push_local 0
+        g.push_local 1
+
+        g.dup_many(2)
+        g.send :[], 1, false
+        g.meta_push_1
+        g.meta_send_op_minus 0
+
+        g.send :[]=, 2, false
+        g.pop
+      end
     end
-    class PutsNode < Struct.new(:stack)
-      def eval; stack.puts ; end
+    class PutsNode
+      def bytecode(g)
+        g.push_const :STDOUT
+
+        g.push_local 0
+        g.push_local 1
+        g.send :[], 1, false
+
+        g.send :putc, 1, true
+      end
+    end
+    class GetsNode
+      def bytecode(g)
+        g.push :self
+        g.push_literal "stty raw -echo"
+        g.send :system, 1, true
+        g.pop
+
+        g.push_local 0
+        g.push_local 1
+
+        g.push_const :STDIN
+        g.send :getc, 0, false
+
+        g.send :[]=, 2, false
+
+        g.push :self
+        g.push_literal "stty -raw echo"
+        g.send :system, 1, true
+        g.pop
+      end
     end
-    class GetsNode < Struct.new(:stack)
-      def eval; stack.gets ; end
+    class IterationNode < Struct.new(:exp)
+      def bytecode(g)
+        repeat = g.new_label
+        repeat.set!
+
+        exp.bytecode(g)
+
+        g.push_local 0
+        g.push_local 1
+        g.send :[], 1, true
+        g.meta_push_0
+        g.meta_send_op_equal 0
+
+        g.gif repeat
+      end
     end
-    class IterationNode < Struct.new(:stack, :exp)
-      def eval
-        until stack.current == 0
-          exp.each do |node|
-            node.eval
-          end
+    class Script < Struct.new(:exp)
+      def bytecode(g)
+        exp.each do |e|
+          e.bytecode(g)
         end
       end
     end

data/lib/brainfuck/code_loader.rb

@@ -0,0 +1,31 @@
+module Brainfuck
+  class CodeLoader < Rubinius::CodeLoader
+
+    def self.execute_code(code, binding, from_module, print = Compiler::Print.new)
+      cm = Compiler.compile_for_eval(code, binding.variables,
+                                     "(eval)", 1, print)
+      cm.scope = binding.static_scope.dup
+      cm.name = :__eval__
+
+      script = Rubinius::CompiledMethod::Script.new(cm, "(eval)", true)
+      script.eval_binding = binding
+      script.eval_source = code
+
+      cm.scope.script = script
+
+      be = Rubinius::BlockEnvironment.new
+      be.under_context(binding.variables, cm)
+      be.from_eval!
+      be.call
+    end
+
+    # Takes a .bf file name, compiles it if needed and executes it.
+    def self.execute_file(name, compile_to = nil, print = Compiler::Print.new)
+      cm = Compiler.compile_if_needed(name, compile_to, print)
+      ss = ::Rubinius::StaticScope.new Object
+      code = Object.new
+      ::Rubinius.attach_method(:__run__, cm, ss, code)
+      code.__run__
+    end
+  end
+end

data/lib/brainfuck/compiler.rb

@@ -0,0 +1,81 @@
+module Brainfuck
+  class Compiler < Rubinius::Compiler
+
+    def self.compiled_filename(filename)
+      if filename =~ /.bf$/
+        filename + "c"
+      else
+        filename + ".compiled.bfc"
+      end
+    end
+
+    def self.always_recompile=(flag)
+      @always_recompile = flag
+    end
+
+    def self.compile_if_needed(file, output = nil, print = Print.new)
+      compiled = output || compiled_filename(file)
+      needed = @always_recompile || !File.exists?(compiled) ||
+        File.stat(compiled).mtime < File.stat(file).mtime
+      if needed
+        compile_file(file, compiled, print)
+      else
+        Brainfuck::CodeLoader.new(compiled).load_compiled_file(compiled, 0)
+      end
+    end
+
+
+    def self.compile_file(file, output = nil, print = Print.new)
+      compiler = new :brainfuck_file, :compiled_file
+      parser = compiler.parser
+
+      parser.input file
+
+      compiler.generator = Rubinius::Generator.new
+      compiler.writer.name = output || compiled_filename(file)
+
+      parser.print = print
+      compiler.packager.print.bytecode = true if print.asm?
+
+      begin
+        compiler.run
+
+      rescue Exception => e
+        compiler_error "Error trying to compile brainfuck: #{file}", e
+      end
+    end
+
+    def self.compile_for_eval(code, variable_scope, file = "(eval)", line = 0, print = Print.new)
+      compiler = new :brainfuck_code, :compiled_method
+      parser = compiler.parser
+
+      parser.input code, file, line
+      compiler.generator.root = Rubinius::AST::EvalExpression
+      compiler.generator.variable_scope = variable_scope
+
+      parser.print = print
+      compiler.packager.print.bytecode = true if print.asm?
+
+      begin
+        compiler.run
+      rescue Exception => e
+        compiler_error "Error trying to compile brainfuck: #{file}", e
+      end
+    end
+
+    class Print < Struct.new(:sexp, :ast, :asm)
+      def sexp?
+        @sexp
+      end
+
+      def ast?
+        @ast
+      end
+
+      def asm?
+        @asm
+      end
+    end
+
+  end
+end