brainfucktt 0.1.0

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Ryan Scott Lewis <ryan@rynet.us>.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,97 @@
+# Brainfucktt
+
+A [Brainfuck][brainfuck] interpreter built in [Ruby][ruby] using [Treetop][treetop].
+
+Brainfuck is an eight-instruction turing-clomplete programming language created in 1993
+by Urban Müller, based on the more formal programming language [P′′][p''] created by Corrado
+Böhm in 1964.
+
+It is designed to challenge and amuse programmers, and is not made to be suitable for 
+practical use.
+
+## Install
+
+### Bundler: `gem 'brainfucktt'`
+
+### RubyGems: `gem install brainfucktt`
+
+## Brainfuck Instructions
+
+`>` Increment the data pointer (to point to the next cell to the right).
+
+`<` Decrement the data pointer (to point to the next cell to the left).
+
+`+` Increment (increase by one) the byte at the data pointer.
+
+`-` Decrement (decrease by one) the byte at the data pointer.
+
+`.` Output the byte at the data pointer as an ASCII encoded character.
+
+`,` Accept one byte of input, storing its value in the byte at the data pointer.
+
+`[` If the byte at the data pointer is zero, then instead of moving the instruction pointer forward to the next command, jump it forward to the command after the matching `]` command.
+
+`]` If the byte at the data pointer is nonzero, then instead of moving the instruction pointer forward to the next command, jump it back to the command after the matching `[` command.
+
+### Comments
+
+Any character besides one of the 8 instructions above is not parsed and will be regarded as a comment.
+
+## Usage
+
+### Running
+
+```ruby
+require 'brainfucktt'
+
+# "Hello World!" written in Brainfuck
+code = '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.'
+
+Brainfucktt.run(code)
+```
+
+### Parsing
+
+```ruby
+require 'brainfucktt'
+
+# "Hello World!" written in Brainfuck
+code = '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.'
+parser = Brainfucktt.parse(code)
+
+# Print out the AST of the code
+p parser.tree
+
+# Run the code within Ruby
+parser.run
+```
+
+### StringIO
+
+Sometimes you do now want to use STDIN or STDOUT for the I/O of the Brainfuck program.
+
+To do that, you must use the stdlib `stringio`:
+
+```ruby
+require 'brainfucktt'
+require 'stringio'
+
+# "Hello World!" written in Brainfuck
+code = '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.'
+
+output = StringIO.new
+Brainfucktt.run(code, output: output)
+
+p output.string # => "Hello World!\n"
+```
+
+## Copyright
+
+Copyright © 2012 Ryan Scott Lewis <ryan@rynet.us>.
+
+The MIT License (MIT) - See LICENSE for further details.
+
+[brainfuck]: http://www.muppetlabs.com/~breadbox/bf/
+[ruby]: http://ruby-lang.org
+[treetop]: http://treetop.rubyforge.org
+[p'']: http://en.wikipedia.org/wiki/P%E2%80%B2%E2%80%B2

data/Rakefile

@@ -0,0 +1,62 @@
+require 'pathname'
+
+def require_task(path)
+  begin
+    require path
+    
+    yield
+  rescue LoadError
+    puts '', "Could not load '#{path}'.", 'Try to `rake gem:spec` and `bundle install` and try again.', ''
+  end
+end
+
+spec = Gem::Specification.new do |s|
+  
+  # Variables
+  s.name = 'brainfucktt'
+  s.author = 'Ryan Scott Lewis'
+  s.email = 'ryan@rynet.us'
+  s.summary = 'A Brainfuck interpreter built in Ruby using Treetop.'
+  
+  # Dependencies
+  s.add_dependency 'treetop', '~> 1.4'
+  s.add_dependency 'polyglot', '~> 0.3'
+  s.add_dependency 'version', '~> 1.0'
+  s.add_development_dependency 'at', '~> 0.1'
+  s.add_development_dependency 'rake', '~> 10.0'
+  s.add_development_dependency 'guard-rspec', '~> 2.1'
+  s.add_development_dependency 'guard-yard', '~> 2.0'
+  s.add_development_dependency 'rb-fsevent', '~> 0.9'
+  s.add_development_dependency 'fuubar', '~> 1.1'
+  s.add_development_dependency 'redcarpet', '~> 2.2.2'
+  s.add_development_dependency 'github-markup', '~> 0.7'
+  
+  # Pragmatically set variables
+  s.homepage = "http://github.com/RyanScottLewis/#{s.name}"
+  s.version = Pathname.glob('VERSION*').first.read
+  s.description = Pathname.glob('README*').first.read
+  s.require_paths = ['lib']
+  s.files        = `git ls-files`.lines.to_a.collect { |s| s.strip }
+  s.executables  = `git ls-files -- bin/*`.lines.to_a.collect { |s| File.basename(s.strip) }
+  
+end
+
+desc 'Generate the gemspec defined in this Rakefile'
+task :gemspec do
+  Pathname.new("#{spec.name}.gemspec").open('w') { |f| f.write(spec.to_ruby) }
+end
+
+require_task 'rake/version_task' do
+  Rake::VersionTask.new do |t|
+    t.with_git_tag = true
+    t.with_gemspec = spec
+  end
+end
+
+require 'rubygems/package_task'
+Gem::PackageTask.new(spec) do |t|
+  t.need_zip = false
+  t.need_tar = false
+end
+
+task :default => :gemspec

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/brainfucktt.gemspec

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "brainfucktt"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ryan Scott Lewis"]
+  s.date = "2012-12-06"
+  s.description = "# Brainfucktt\n\nA [Brainfuck][brainfuck] interpreter built in [Ruby][ruby] using [Treetop][treetop].\n\nBrainfuck is an eight-instruction turing-clomplete programming language created in 1993\nby Urban M\u{fc}ller, based on the more formal programming language [P\u{2032}\u{2032}][p''] created by Corrado\nB\u{f6}hm in 1964.\n\nIt is designed to challenge and amuse programmers, and is not made to be suitable for \npractical use.\n\n## Install\n\n### Bundler: `gem 'brainfucktt'`\n\n### RubyGems: `gem install brainfucktt`\n\n## Brainfuck Instructions\n\n`>` Increment the data pointer (to point to the next cell to the right).\n\n`<` Decrement the data pointer (to point to the next cell to the left).\n\n`+` Increment (increase by one) the byte at the data pointer.\n\n`-` Decrement (decrease by one) the byte at the data pointer.\n\n`.` Output the byte at the data pointer as an ASCII encoded character.\n\n`,` Accept one byte of input, storing its value in the byte at the data pointer.\n\n`[` If the byte at the data pointer is zero, then instead of moving the instruction pointer forward to the next command, jump it forward to the command after the matching `]` command.\n\n`]` If the byte at the data pointer is nonzero, then instead of moving the instruction pointer forward to the next command, jump it back to the command after the matching `[` command.\n\n### Comments\n\nAny character besides one of the 8 instructions above is not parsed and will be regarded as a comment.\n\n## Usage\n\n### Running\n\n```ruby\nrequire 'brainfucktt'\n\n# \"Hello World!\" written in Brainfuck\ncode = '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.'\n\nBrainfucktt.run(code)\n```\n\n### Parsing\n\n```ruby\nrequire 'brainfucktt'\n\n# \"Hello World!\" written in Brainfuck\ncode = '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.'\nparser = Brainfucktt.parse(code)\n\n# Print out the AST of the code\np parser.tree\n\n# Run the code within Ruby\nparser.run\n```\n\n### StringIO\n\nSometimes you do now want to use STDIN or STDOUT for the I/O of the Brainfuck program.\n\nTo do that, you must use the stdlib `stringio`:\n\n```ruby\nrequire 'brainfucktt'\nrequire 'stringio'\n\n# \"Hello World!\" written in Brainfuck\ncode = '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.'\n\noutput = StringIO.new\nBrainfucktt.run(code, output: output)\n\np output.string # => \"Hello World!\\n\"\n```\n\n## Copyright\n\nCopyright \u{a9} 2012 Ryan Scott Lewis <ryan@rynet.us>.\n\nThe MIT License (MIT) - See LICENSE for further details.\n\n[brainfuck]: http://www.muppetlabs.com/~breadbox/bf/\n[ruby]: http://ruby-lang.org\n[treetop]: http://treetop.rubyforge.org\n[p'']: http://en.wikipedia.org/wiki/P%E2%80%B2%E2%80%B2"
+  s.email = "ryan@rynet.us"
+  s.files = ["Gemfile", "LICENSE", "README.md", "Rakefile", "VERSION", "brainfucktt.gemspec", "examples/hello_world.rb", "examples/hello_world_with_comments.rb", "examples/stringio.rb", "lib/brainfucktt.rb", "lib/brainfucktt/byte.rb", "lib/brainfucktt/conversion_helpers.rb", "lib/brainfucktt/data.rb", "lib/brainfucktt/errors.rb", "lib/brainfucktt/language.rb", "lib/brainfucktt/language/decrement_byte.rb", "lib/brainfucktt/language/decrement_pointer.rb", "lib/brainfucktt/language/increment_byte.rb", "lib/brainfucktt/language/increment_pointer.rb", "lib/brainfucktt/language/input_byte.rb", "lib/brainfucktt/language/loop.rb", "lib/brainfucktt/language/output_byte.rb", "lib/brainfucktt/language/tree.rb", "lib/brainfucktt/language_parser.treetop", "lib/brainfucktt/node.rb", "lib/brainfucktt/parser.rb"]
+  s.homepage = "http://github.com/RyanScottLewis/brainfucktt"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "A Brainfuck interpreter built in Ruby using Treetop."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<treetop>, ["~> 1.4"])
+      s.add_runtime_dependency(%q<polyglot>, ["~> 0.3"])
+      s.add_runtime_dependency(%q<version>, ["~> 1.0"])
+      s.add_development_dependency(%q<at>, ["~> 0.1"])
+      s.add_development_dependency(%q<rake>, ["~> 10.0"])
+      s.add_development_dependency(%q<guard-rspec>, ["~> 2.1"])
+      s.add_development_dependency(%q<guard-yard>, ["~> 2.0"])
+      s.add_development_dependency(%q<rb-fsevent>, ["~> 0.9"])
+      s.add_development_dependency(%q<fuubar>, ["~> 1.1"])
+      s.add_development_dependency(%q<redcarpet>, ["~> 2.2.2"])
+      s.add_development_dependency(%q<github-markup>, ["~> 0.7"])
+    else
+      s.add_dependency(%q<treetop>, ["~> 1.4"])
+      s.add_dependency(%q<polyglot>, ["~> 0.3"])
+      s.add_dependency(%q<version>, ["~> 1.0"])
+      s.add_dependency(%q<at>, ["~> 0.1"])
+      s.add_dependency(%q<rake>, ["~> 10.0"])
+      s.add_dependency(%q<guard-rspec>, ["~> 2.1"])
+      s.add_dependency(%q<guard-yard>, ["~> 2.0"])
+      s.add_dependency(%q<rb-fsevent>, ["~> 0.9"])
+      s.add_dependency(%q<fuubar>, ["~> 1.1"])
+      s.add_dependency(%q<redcarpet>, ["~> 2.2.2"])
+      s.add_dependency(%q<github-markup>, ["~> 0.7"])
+    end
+  else
+    s.add_dependency(%q<treetop>, ["~> 1.4"])
+    s.add_dependency(%q<polyglot>, ["~> 0.3"])
+    s.add_dependency(%q<version>, ["~> 1.0"])
+    s.add_dependency(%q<at>, ["~> 0.1"])
+    s.add_dependency(%q<rake>, ["~> 10.0"])
+    s.add_dependency(%q<guard-rspec>, ["~> 2.1"])
+    s.add_dependency(%q<guard-yard>, ["~> 2.0"])
+    s.add_dependency(%q<rb-fsevent>, ["~> 0.9"])
+    s.add_dependency(%q<fuubar>, ["~> 1.1"])
+    s.add_dependency(%q<redcarpet>, ["~> 2.2.2"])
+    s.add_dependency(%q<github-markup>, ["~> 0.7"])
+  end
+end

data/examples/hello_world.rb

@@ -0,0 +1,6 @@
+require_relative '../lib/brainfucktt'
+
+# "Hello World!" written in Brainfuck
+code = '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.'
+
+Brainfucktt.run(code)

data/examples/hello_world_with_comments.rb

@@ -0,0 +1,28 @@
+require_relative '../lib/brainfucktt'
+
+code = DATA.read
+
+Brainfucktt.run(code)
+
+__END__
++++++ +++++             initialize counter (cell #0) to 10
+[                       use loop to set the next four cells to 70/100/30/10
+    > +++++ ++              add  7 to cell #1
+    > +++++ +++++           add 10 to cell #2 
+    > +++                   add  3 to cell #3
+    > +                     add  1 to cell #4
+    <<<< -                  decrement counter (cell #0)
+]                       end loop
+> ++ .                  print 'H'
+> + .                   print 'e'
++++++ ++ .              print 'l'
+.                       print 'l'
++++ .                   print 'o'
+> ++ .                  print ' '
+<< +++++ +++++ +++++ .  print 'W'
+> .                     print 'o'
++++ .                   print 'r'
+----- - .               print 'l'
+----- --- .             print 'd'
+> + .                   print '!'
+> .                     print '\n'

data/examples/stringio.rb

@@ -0,0 +1,11 @@
+require_relative '../lib/brainfucktt'
+
+require 'stringio'
+
+# "Hello World!" written in Brainfuck
+code = '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.'
+
+output = StringIO.new
+Brainfucktt.run(code, output: output)
+
+p output.string # => "Hello World!\n"

data/lib/brainfucktt.rb

@@ -0,0 +1,17 @@
+require 'pathname'
+require 'forwardable'
+
+__LIB__ ||= Pathname.new(__FILE__).join('..').expand_path
+$:.unshift(__LIB__.to_s) unless $:.include?(__LIB__)
+
+require 'brainfucktt/parser'
+
+# A Brainfuck interpreter built in Ruby using Treetop.
+module Brainfucktt
+  class << self
+    extend Forwardable
+    
+    delegate [:parse, :run] => Parser
+    
+  end
+end

data/lib/brainfucktt/byte.rb

@@ -0,0 +1,104 @@
+require 'brainfucktt/conversion_helpers'
+
+module Brainfucktt
+  
+  # A Byte.
+  class Byte
+    include ConversionHelpers
+    include Comparable
+    
+    # Set the value of the Byte instance at the given offset.
+    # 
+    # @param [Byte, Integer, #to_i] value
+    # @raise [Brainfucktt::InvalidByteError] When the given value cannot be converted into an Integer or is not between 0 and 255.
+    def initialize(value=0)
+      @value = convert_to_integer(value)
+    end
+    
+    # Add to this Byte instance's value.
+    # 
+    # @param [Byte, Integer, #to_i] value
+    # @raise [Brainfucktt::InvalidByteError] When the given value cannot be converted into an Integer or is not between 0 and 255.
+    # @return [Integer] The new value.
+    def +(value)
+      @value += convert_to_integer(value)
+    end
+    
+    # Subtract from this Byte instance's value.
+    # 
+    # @param [Byte, Integer, #to_i] value
+    # @raise [Brainfucktt::InvalidByteError] When the given value cannot be converted into an Integer or is not between 0 and 255.
+    # @return [Integer] The new value.
+    def -(value)
+      @value -= convert_to_integer(value)
+    end
+    
+    # Compare with another Byte, Integer, String, etc..
+    # 
+    # @return [nil, Integer]
+    def <=>(other)
+      @value <=> convert_to_integer(other)
+    end
+    
+    # Check to see if the given object instance is the same instance as self.
+    # 
+    # @return [true, false]
+    def ==(other)
+      self == other
+    end
+    
+    # Check to see if the given object instance as an Integer is the same as the value of
+    # this Byte instance.
+    # 
+    # @return [true, false]
+    def eql?(other)
+      @value == convert_to_integer(other)
+    end
+    alias_method :equal?, :eql?
+    
+    # Check this Byte instance is empty.
+    # 
+    # @return [true, false]
+    def empty?
+      @value == 0
+    end
+    
+    # Return the Byte as an Integer
+    # 
+    # @return [Integer]
+    def to_i
+      @value
+    end
+    
+    # Return the Byte as a binary string.
+    # 
+    # @return [String]
+    def to_binary
+      @value.to_s(2)
+    end
+    
+    # Return the Byte as an ASCII character.
+    # 
+    # @return [String]
+    def to_ascii
+      @value.chr
+    end
+    alias_method :to_s, :to_ascii
+    
+    # Return the Byte as a hexadecimal string.
+    # 
+    # @return [String]
+    def to_hex
+      @value.to_s(16)
+    end
+    
+    # Return the Byte as a binary string.
+    # 
+    # @return [String]
+    def inspect
+      "#<#{self.class}:#{object_id.to_s(16)} integer=#{to_i.inspect} hex=#{to_hex.inspect} ascii=#{to_ascii.inspect} binary=#{to_binary.inspect} >"
+    end
+    
+  end
+  
+end

data/lib/brainfucktt/conversion_helpers.rb

@@ -0,0 +1,37 @@
+require 'brainfucktt/errors'
+
+module Brainfucktt
+  
+  # Helpers for Classes which have methods that accepts a value that need
+  # to be converted into a specific type.
+  module ConversionHelpers
+    
+    protected
+    
+    def convert_to_integer(value)
+      raise InvalidByteError unless value.is_a?(Integer) || value.respond_to?(:to_i)
+      value = value.to_i unless value.is_a?(Integer)
+      
+      value
+    end
+    
+    def convert_to_byte(value)
+      raise InvalidByteError unless value.is_a?(Byte) || value.is_a?(Integer) || value.respond_to?(:to_i)
+      value = value.to_i unless value.is_a?(Byte) || value.is_a?(Integer)
+      value = Byte.new(value) unless value.is_a?(Byte)
+      
+      # TODO: Complain about 0 to 255 compliance
+      
+      value
+    end
+    
+    def convert_to_options(value)
+      raise InvalidOptionsError unless value.is_a?(Hash) || value.respond_to?(:to_hash) || value.respond_to?(:to_h)
+      value = value.to_hash rescue value.to_h unless value.is_a?(Hash)
+      
+      value
+    end
+    
+  end
+  
+end

data/lib/brainfucktt/data.rb

@@ -0,0 +1,56 @@
+require 'brainfucktt/conversion_helpers'
+require 'brainfucktt/byte'
+
+module Brainfucktt
+  
+  # An Array of Byte instances.
+  class Data
+    include ConversionHelpers
+    
+    attr_reader :bytes
+    
+    def initialize
+      @bytes = []
+    end
+    
+    # Retrieve the Byte instance at the given offset.
+    # 
+    # @param [Integer, #to_i] offset
+    # @raise [Brainfucktt::InvalidOffsetError] When the given offset cannot be converted into an Integer.
+    # @return [Byte] The Byte instance at the given offset.
+    def [](offset)
+      offset = convert_to_integer(offset)
+      self[offset] = 0 if @bytes[offset].nil?
+      
+      @bytes[offset]
+    end
+    
+    # Set the value of the Byte instance at the given offset.
+    # 
+    # @param [Integer, #to_i] offset
+    # @param [Byte, Integer, #to_i] value
+    # @raise [Brainfucktt::InvalidByteError] When the given value cannot be converted into an Integer or is not between 0 and 255.
+    # @raise [Brainfucktt::InvalidOffsetError] When the given offset cannot be converted into an Integer.
+    # @return [Byte] The Byte instance at the given offset.
+    def []=(offset, value)
+      expand_to(offset)
+      
+      @bytes[offset] = convert_to_byte(value)
+    end
+    
+    # Fill from the end of the Data collection to the given offset with empty
+    # Byte instances, if Data collection is less than the given offset.
+    # 
+    # @param [Integer, #to_i] offset
+    # @raise [Brainfucktt::InvalidOffsetError] When the given offset cannot be converted into an Integer.
+    # @return [Byte] The Byte instance at the given offset.
+    def expand_to(offset)
+      offset = convert_to_integer(offset)
+      (@bytes.length..offset).each { @bytes << Byte.new } if @bytes.at(offset).nil?
+      
+      @bytes[offset]
+    end
+    
+  end
+  
+end

data/lib/brainfucktt/errors.rb

@@ -0,0 +1,62 @@
+require 'brainfucktt/language_parser'
+
+module Brainfucktt
+  
+  # Base class for all errors within this library.
+  class Error < StandardError
+    
+  end
+  
+  # Raised when the value set within a Data instance is greater than a byte or less than zero.
+  class InvalidByteError < Error
+    
+    # @return [String] The error message.
+    def to_s
+      'The value of a Byte must be an Integer or respond to to_i and be between 0 and 255'
+    end
+    
+  end
+  
+  # Raised when the offset given is notDatanteger.
+  class InvalidOffsetError < Error
+    
+    # @return [String] The error message.
+    def to_s
+      'The offset of a Byte must be an Integer or respond to to_i'
+    end
+    
+  end
+  
+  # Raised when the offset given is notDatash.
+  class InvalidOptionsError < Error
+    
+    # @return [String] The error message.
+    def to_s
+      'The options must be a Hash or respond to to_hash or to_h'
+    end
+    
+  end
+  
+  # Raised when the code being parsed has a syntax error.
+  class ParserError < Error
+    extend Forwardable
+    
+    def_delegator :@language_parser, :failure_reason, :reason
+    def_delegator :@language_parser, :failure_line,   :line
+    def_delegator :@language_parser, :failure_column, :column
+    
+    # @param [Brainfucktt::LanguageParser] language_parser
+    def initialize(language_parser)
+      raise TypeError unless language_parser.instance_of?(Brainfucktt::LanguageParser)
+        
+      @language_parser = language_parser
+    end
+    
+    # @return [String]
+    def to_s
+      "Error at column #{column}, line #{line} - '#{reason}'"
+    end
+    
+  end
+  
+end

data/lib/brainfucktt/language.rb

@@ -0,0 +1,14 @@
+require 'pathname'
+
+Dir[ Pathname.new(__FILE__).join('..', 'language').expand_path.join('**', '*.rb') ].each do |path|
+  require path
+end
+
+module Brainfucktt
+  
+  # The container for syntax nodes.
+  module Language
+    
+  end
+  
+end

data/lib/brainfucktt/language/decrement_byte.rb

@@ -0,0 +1,17 @@
+require 'brainfucktt/node'
+
+module Brainfucktt
+  module Language
+    
+    # -
+    class DecrementByte < Node
+      
+      # Decrement the byte at the pointer.
+      def run(parser)
+        parser.byte -= 1
+      end
+      
+    end
+    
+  end
+end

data/lib/brainfucktt/language/decrement_pointer.rb

@@ -0,0 +1,17 @@
+require 'brainfucktt/node'
+
+module Brainfucktt
+  module Language
+    
+    # <
+    class DecrementPointer < Node
+      
+      # Decrement the pointer.
+      def run(parser)
+        parser.pointer -= 1
+      end
+      
+    end
+    
+  end
+end

data/lib/brainfucktt/language/increment_byte.rb

@@ -0,0 +1,17 @@
+require 'brainfucktt/node'
+
+module Brainfucktt
+  module Language
+    
+    # +
+    class IncrementByte < Node
+      
+      # Increment the byte at the pointer.
+      def run(parser)
+        parser.byte += 1
+      end
+      
+    end
+    
+  end
+end

data/lib/brainfucktt/language/increment_pointer.rb

@@ -0,0 +1,17 @@
+require 'brainfucktt/node'
+
+module Brainfucktt
+  module Language
+    
+    # >
+    class IncrementPointer < Node
+      
+      # Increment the pointer.
+      def run(parser)
+        parser.pointer += 1
+      end
+      
+    end
+    
+  end
+end

data/lib/brainfucktt/language/input_byte.rb

@@ -0,0 +1,28 @@
+require 'brainfucktt/node'
+
+module Brainfucktt
+  module Language
+    
+    # ,
+    class InputByte < Node
+      
+      # Input an ASCII character and store it in the byte at the pointer.
+      def run(parser)
+        parser.byte = get_character(parser.stdin)
+      end
+      
+      protected
+      
+      def get_character(io)
+        begin
+          system("stty raw -echo")
+          str = io.getc
+        ensure
+          system("stty -raw echo")
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/brainfucktt/language/loop.rb

@@ -0,0 +1,17 @@
+require 'brainfucktt/node'
+
+module Brainfucktt
+  module Language
+    
+    # [ ]
+    class Loop < Node
+      
+      # Run the loop
+      def run(parser)
+        elements.first.run(parser) until parser.byte.empty?
+      end
+      
+    end
+    
+  end
+end

data/lib/brainfucktt/language/output_byte.rb

@@ -0,0 +1,17 @@
+require 'brainfucktt/node'
+
+module Brainfucktt
+  module Language
+    
+    # .
+    class OutputByte < Node
+      
+      # Output the byte at the pointer as an ASCII character.
+      def run(parser)
+        parser.output.print parser.byte.to_s
+      end
+      
+    end
+    
+  end
+end

data/lib/brainfucktt/language/tree.rb

@@ -0,0 +1,17 @@
+require 'brainfucktt/node'
+
+module Brainfucktt
+  module Language
+    
+    # The syntax tree of the source code or loop.
+    class Tree < Node
+      attr_accessor :data
+      
+      # Run the code.
+      def run(parser)
+        elements.each { |element| element.run(parser) }
+      end
+    end
+    
+  end
+end

data/lib/brainfucktt/language_parser.treetop

@@ -0,0 +1,49 @@
+module Brainfucktt
+  grammar Language
+    
+    rule tree
+      (loop / increment_pointer / decrement_pointer / increment_byte / decrement_byte / input_byte / output_byte / ignored_character)* <Tree>
+    end
+    
+    rule ignored_character
+      !(begin_loop / end_loop / increment_pointer / decrement_pointer / increment_byte / decrement_byte / input_byte / output_byte) .
+    end
+    
+    rule loop
+      begin_loop tree end_loop <Loop>
+    end
+    
+    rule begin_loop
+      '['
+    end
+    
+    rule end_loop
+      ']'
+    end
+    
+    rule increment_pointer
+      '>' <IncrementPointer>
+    end
+    
+    rule decrement_pointer
+      '<' <DecrementPointer>
+    end
+    
+    rule increment_byte
+      '+' <IncrementByte>
+    end
+    
+    rule decrement_byte
+      '-' <DecrementByte>
+    end
+    
+    rule input_byte
+      ',' <InputByte>
+    end
+    
+    rule output_byte
+      '.' <OutputByte>
+    end
+    
+  end
+end

data/lib/brainfucktt/node.rb

@@ -0,0 +1,45 @@
+require 'treetop/runtime/syntax_node'
+
+module Brainfucktt
+  
+  # The base class for Brainfucktt syntax nodes in the AST
+  class Node < Treetop::Runtime::SyntaxNode
+    
+    alias_method :elements_with_treetop, :elements
+    
+    # The children of this Node instance.
+    # 
+    # @return [<Brainfucktt::Node>]
+    def elements
+      elements_with_treetop.find_all { |node| node.is_a?(Brainfucktt::Node) } rescue []
+    end
+    
+    # Return the text value of this Node instance.
+    # 
+    # @return [String]
+    def to_s
+      text_value
+    end
+    
+    # Print out the AST of this instance node and it's children with indentation.
+    # 
+    # @return [String]
+    def inspect(indent="")
+      result = ""
+      result << indent
+      result << self.class.to_s.sub(/.*:/,'')
+      result << " #{to_s} " unless self.is_a?(Language::Tree) || self.is_a?(Language::Loop)
+      
+      unless elements.empty?
+        result << ":"
+        elements.each do |e|
+          result << "\n#{e.inspect(indent+"  ")}" rescue "\n#{indent} #{e.inspect}"
+        end
+      end
+      
+      result
+    end
+    
+  end
+  
+end

data/lib/brainfucktt/parser.rb

@@ -0,0 +1,78 @@
+require 'polyglot'
+require 'treetop'
+require 'brainfucktt/errors'
+require 'brainfucktt/language'
+require 'brainfucktt/language_parser'
+require 'brainfucktt/data'
+require 'brainfucktt/conversion_helpers'
+
+module Brainfucktt
+  
+  # The Brainfuck parser.
+  class Parser
+    include ConversionHelpers
+    
+    class << self
+      
+      # Get a new or the cached instance of this class.
+      # 
+      # @return [Brainfucktt::LanguageParser]
+      def instance
+        @instance ||= LanguageParser.new
+      end
+      
+      # Parse the given Brainfuck code.
+      # 
+      # @param [String, #to_s] code
+      # @raise [Brainfucktt::ParserError]
+      # @return [Brainfucktt::Parser]
+      def parse(code)
+        tree = instance.parse(code)
+        raise ParserError, instance unless tree
+        
+        new(tree)
+      end
+      
+      # Parse and run the given Brainfuck code.
+      # 
+      # @param [String, #to_s] code
+      def run(code, options={})
+        parse(code).run(options)
+      end
+    end
+    
+    attr_reader :data, :tree, :input, :output
+    attr_accessor :pointer
+    
+    def initialize(tree)
+      @data, @tree, @pointer = Data.new, tree, 0
+    end
+      
+    # Run the parsed Brainfuck code.
+    # 
+    # @raise [Brainfucktt::InvalidOptionsError] When the given offset cannot be converted into an Integer.
+    # @param [Hash, #to_hash, #to_h] options
+    def run(options={})
+      options = { input: STDIN, output: STDOUT }.merge( convert_to_options(options) )
+      
+      @input, @output = options.values_at(:input, :output)
+      @tree.run(self)
+    end
+    
+    # Returns the Byte instance within the @data collection at pointer.
+    # 
+    # @return [Brainfucktt::Byte]
+    def byte
+      @data[@pointer]
+    end
+    
+    # Set the value of the Byte instance within the @data collection at pointer.
+    # 
+    # @return [Brainfucktt::Byte]
+    def byte=(value)
+      @data[@pointer] = value
+    end
+    
+  end
+  
+end

metadata

@@ -0,0 +1,279 @@
+--- !ruby/object:Gem::Specification
+name: brainfucktt
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Scott Lewis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: polyglot
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: version
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: at
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: guard-yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: fuubar
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.2
+- !ruby/object:Gem::Dependency
+  name: github-markup
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: ! "# Brainfucktt\n\nA [Brainfuck][brainfuck] interpreter built in [Ruby][ruby]
+  using [Treetop][treetop].\n\nBrainfuck is an eight-instruction turing-clomplete
+  programming language created in 1993\nby Urban Müller, based on the more formal
+  programming language [P′′][p''] created by Corrado\nBöhm in 1964.\n\nIt is designed
+  to challenge and amuse programmers, and is not made to be suitable for \npractical
+  use.\n\n## Install\n\n### Bundler: `gem 'brainfucktt'`\n\n### RubyGems: `gem install
+  brainfucktt`\n\n## Brainfuck Instructions\n\n`>` Increment the data pointer (to
+  point to the next cell to the right).\n\n`<` Decrement the data pointer (to point
+  to the next cell to the left).\n\n`+` Increment (increase by one) the byte at the
+  data pointer.\n\n`-` Decrement (decrease by one) the byte at the data pointer.\n\n`.`
+  Output the byte at the data pointer as an ASCII encoded character.\n\n`,` Accept
+  one byte of input, storing its value in the byte at the data pointer.\n\n`[` If
+  the byte at the data pointer is zero, then instead of moving the instruction pointer
+  forward to the next command, jump it forward to the command after the matching `]`
+  command.\n\n`]` If the byte at the data pointer is nonzero, then instead of moving
+  the instruction pointer forward to the next command, jump it back to the command
+  after the matching `[` command.\n\n### Comments\n\nAny character besides one of
+  the 8 instructions above is not parsed and will be regarded as a comment.\n\n##
+  Usage\n\n### Running\n\n```ruby\nrequire 'brainfucktt'\n\n# \"Hello World!\" written
+  in Brainfuck\ncode = '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.'\n\nBrainfucktt.run(code)\n```\n\n###
+  Parsing\n\n```ruby\nrequire 'brainfucktt'\n\n# \"Hello World!\" written in Brainfuck\ncode
+  = '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.'\nparser
+  = Brainfucktt.parse(code)\n\n# Print out the AST of the code\np parser.tree\n\n#
+  Run the code within Ruby\nparser.run\n```\n\n### StringIO\n\nSometimes you do now
+  want to use STDIN or STDOUT for the I/O of the Brainfuck program.\n\nTo do that,
+  you must use the stdlib `stringio`:\n\n```ruby\nrequire 'brainfucktt'\nrequire 'stringio'\n\n#
+  \"Hello World!\" written in Brainfuck\ncode = '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.'\n\noutput
+  = StringIO.new\nBrainfucktt.run(code, output: output)\n\np output.string # => \"Hello
+  World!\\n\"\n```\n\n## Copyright\n\nCopyright © 2012 Ryan Scott Lewis <ryan@rynet.us>.\n\nThe
+  MIT License (MIT) - See LICENSE for further details.\n\n[brainfuck]: http://www.muppetlabs.com/~breadbox/bf/\n[ruby]:
+  http://ruby-lang.org\n[treetop]: http://treetop.rubyforge.org\n[p'']: http://en.wikipedia.org/wiki/P%E2%80%B2%E2%80%B2"
+email: ryan@rynet.us
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- brainfucktt.gemspec
+- examples/hello_world.rb
+- examples/hello_world_with_comments.rb
+- examples/stringio.rb
+- lib/brainfucktt.rb
+- lib/brainfucktt/byte.rb
+- lib/brainfucktt/conversion_helpers.rb
+- lib/brainfucktt/data.rb
+- lib/brainfucktt/errors.rb
+- lib/brainfucktt/language.rb
+- lib/brainfucktt/language/decrement_byte.rb
+- lib/brainfucktt/language/decrement_pointer.rb
+- lib/brainfucktt/language/increment_byte.rb
+- lib/brainfucktt/language/increment_pointer.rb
+- lib/brainfucktt/language/input_byte.rb
+- lib/brainfucktt/language/loop.rb
+- lib/brainfucktt/language/output_byte.rb
+- lib/brainfucktt/language/tree.rb
+- lib/brainfucktt/language_parser.treetop
+- lib/brainfucktt/node.rb
+- lib/brainfucktt/parser.rb
+homepage: http://github.com/RyanScottLewis/brainfucktt
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1616283130574261905
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A Brainfuck interpreter built in Ruby using Treetop.
+test_files: []