rbf 0.0.3 → 0.0.4

data/bin/rbf

@@ -1,5 +1,23 @@
 #! /usr/bin/env ruby
 require 'rubygems'
+require 'optparse'
 require 'rbf'
 
-RBF.execute(ARGV.first)
+options = {}
+
+OptionParser.new do |opts|
+  opts.on '-h', '--help', 'Display this screen' do
+    puts opts
+    exit
+  end
+
+  opts.on '-s', '--syntax [NAME]', ['default', 'nintendo'], 'Choose a brainfuck syntax' do |value|
+    options[:syntax] = value
+  end
+end.parse!
+
+if ARGV.first
+  RBF.execute(ARGV.first, options[:syntax])
+else
+  RBF.repl(options)
+end

data/lib/rbf/interpreter.rb

@@ -33,63 +33,98 @@ end
 module RBF
 
 class Interpreter
-  class Storage < Array
-    def initialize (*args)
-      super
+  class Storage < Hash
+    attr_reader :position
 
-      @pointer = 0
+    def initialize (data)
+      if data.is_a?(Array)
+        parent = {}
 
-      check!
+        data.each_with_index {|value, index|
+          parent[index] = value
+        }
+
+        super(parent)
+      else
+        super
+      end
+
+      @position = 0
     end
 
     def check!
-      if self[@pointer].nil?
-        self[@pointer] = 0
+      unless self[@position].is_a?(Integer)
+        self[@position] = 0
       end
     end
 
     def forward!
-      @pointer += 1
-
-      check!
+      @position += 1
     end
 
     def backward!
-      @pointer -= 1
-
-      check!
+      @position -= 1
     end 
 
     def increase!
-      self[@pointer] += 1
+      check!
+
+      self[@position] += 1
     end
 
     def decrease!
-      self[@pointer] -= 1
+      check!
+
+      self[@position] -= 1
     end
 
-    def set (value)
-      self[@pointer] = value.to_i
+    def set (value, position=nil)
+      self[position || @position] = value.ord
     end
 
-    def get
-      self[@pointer].to_i
+    def get (position=nil)
+      self[position || @position].to_i rescue 0
+    end
+
+    def inspect
+      "#<Storage(#{position}): #{super}>"
     end
   end
 
-  def initialize
-    @storage = Storage.new
+  attr_reader :options, :storage
+
+  def initialize (options={})
+    @options = options
+
+    @storage = Storage.new(options[:env] || [])
     @input   = STDIN
+    @output  = STDOUT
+
+    @parser    = RBF::Parser.syntax(RBF.syntax(options[:syntax])).new
+    @transform = RBF::Transform.new
+    @optimizer = RBF::Optimizer.new(options)
+  end
+  
+  def parse (text)
+    return text if text.is_a?(Array)
+
+    parsed = @parser.parse_with_debug(text)
+
+    raise SyntaxError, 'There is a syntax error' unless parsed
+
+    @optimizer.optimize(@transform.apply(parsed))
   end
 
-  def evaluate (tree, options={})
+  def evaluate (tree, options=nil)
+    options ||= {}
+
     if options[:catch]
       @output = StringIO.new
     else
       @output = STDOUT
     end
 
-    cycle(tree)
+    cycle(parse(tree))
 
     if options[:catch]
       @output.rewind
@@ -97,6 +132,10 @@ class Interpreter
     end
   end
 
+  def execute (path, options=nil)
+    evaluate(File.read(path), options)
+  end
+
   def cycle (tree)
     tree.each {|token|
       if token.is_a?(Array)
@@ -130,7 +169,7 @@ class Interpreter
   end
 
   define_method ?. do
-    @output.print @storage.get.chr
+    @output.print @storage.get.chr rescue nil
     @output.flush
   end
 

data/lib/rbf/optimizer.rb

@@ -0,0 +1,74 @@
+#--
+#           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                   Version 2, December 2004
+#
+#  Copyleft meh. [http://meh.paranoid.pk | meh@paranoici.org]
+#
+#           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module RBF
+
+class Optimizer
+  class Algorithm
+    attr_reader :optimizer
+
+    def initialize (optimizer)
+      @optimizer = optimizer
+    end
+
+    def optimize (tree)
+      nil
+    end
+  end
+
+  attr_reader :options
+
+  def initialize (options={})
+    @options = options
+  end
+
+  def optimize (tree)
+    result = tree.clone
+
+    algorithms.each {|alg|
+      alg.new(self).optimize(result)
+    }
+
+    result
+  end
+
+  def algorithms
+    Optimizer.constants.map {|const|
+      Optimizer.const_get(const) unless options[const.to_s.downcase.to_sym] == false
+    }.compact
+  end
+
+  class UselessOperations < Algorithm
+    def optimize (tree)
+      i = 0
+
+      until i >= tree.length
+        if tree[i].is_a?(Array) && tree[i + 1].is_a?(Array)
+          optimize(tree[i])
+          optimize(tree[i + 1])
+
+          i += 2
+        elsif tree[i].is_a?(Array)
+          optimize(tree[i])
+
+          i += 1
+        elsif [[?+, ?-], [?-, ?+], [?>, ?<], [?<, ?>]].member?(tree[i ... i + 2])
+          tree.slice!(i ... i + 2)
+        else
+          i += 1
+        end
+      end 
+    end
+  end
+end
+
+end

data/lib/rbf/parser.rb

@@ -15,7 +15,7 @@ require 'parslet'
 module RBF
 
 class Parser < Parslet::Parser
-  def self.apply (keys)
+  def self.syntax (keys)
     klass = self.clone
     
     klass.class_eval {
@@ -69,4 +69,17 @@ class Parser < Parslet::Parser
   root :code
 end
 
+class Transform < Parslet::Transform
+  rule(?> => simple(:x)) { ?> }
+  rule(?< => simple(:x)) { ?< }
+
+  rule(?+ => simple(:x)) { ?+ }
+  rule(?- => simple(:x)) { ?- }
+
+  rule(?. => simple(:x)) { ?. }
+  rule(?, => simple(:x)) { ?, }
+
+  rule(:loop => subtree(:x)) { x }
+end
+
 end

data/lib/rbf.rb

@@ -12,28 +12,89 @@
 
 require 'rbf/syntax'
 require 'rbf/parser'
-require 'rbf/transform'
+require 'rbf/optimizer'
 require 'rbf/interpreter'
 
 require 'parslet/convenience'
 
 module RBF
-  def self.parse (text, syntax=nil)
-    Transform.new.apply(Parser.apply(syntax || Syntax::Default).new.parse_with_debug(text)) or
+  def self.syntax (name)
+    name.is_a?(Hash) ? name :
+      (RBF::Syntax.const_get(name.to_s.capitalize) rescue nil) || Syntax::Default
+  end
+
+  def self.parse (text, syn=nil)
+    Transform.new.apply(Parser.syntax(syntax(syn)).new.parse_with_debug(text)) or
       raise SyntaxError, 'There is a syntax error'
   end
 
-  def self.evaluate (text, options={})
-    tree = text.is_a?(Array) ? text : parse(text.to_s, options[:syntax])
+  def self.optimize (text, options=nil)
+    options ||= {}
+
+    Optimizer.new(options).optimize(text.is_a?(Array) ? text : parse(text.to_s, options[:syntax]))
+  end
+
+  def self.evaluate (text, options=nil)
+    options ||= {}
 
-    Interpreter.new.evaluate(tree, options)
+    Interpreter.new(options).evaluate(text)
   end
 
   def self.execute (file, options={})
     evaluate(File.read(file), options)
   end
 
-  def self.[] (text, syntax=nil)
-    evaluate(text, :catch => true, :syntax => syntax)
+  def self.[] (text, syn=nil)
+    evaluate(text, :catch => true, :syntax => syn)
+  end
+
+  def self.repl (options=nil)
+    require 'colorb'
+
+    interpreter = Interpreter.new(options || {})
+
+    loop do
+      STDOUT.print '>> '.bold
+      STDOUT.flush
+
+      begin
+        line = STDIN.gets.chomp rescue nil or raise SystemExit
+      rescue Interrupt, SystemExit
+        puts "\nExiting REPL."
+
+        return false
+      end
+
+      begin
+        if line.start_with?('!')
+          case line[1 .. -1]
+            when 'exit', 'quit'
+              return true
+
+            when 'storage'
+              STDOUT.puts interpreter.storage.inspect
+
+            when 'position'
+              STDOUT.puts interpreter.storage.position.to_s.bold
+
+            when /^get(?:\s*(\d+))?$/
+              STDOUT.puts "#{($1 || interpreter.storage.position).to_s.bold}: #{interpreter.storage.get($1.to_i)}"
+
+            when /^set(?:\s+(\d+)\s+(\d+))/
+              interpreter.storage.set($2.to_i, $1.to_i)
+
+            else
+              STDOUT.puts 'Command not found'.red
+          end
+        else
+          output = interpreter.evaluate(line, interpreter.options.merge(:catch => true))
+
+          print output
+          print "\n" unless output.empty? || output.end_with?("\n")
+        end
+      rescue
+        STDOUT.puts $!.inspect.red, $@.join("\n")
+      end
+    end
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: rbf
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - meh.
@@ -23,6 +23,17 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: colorb
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
 description: 
 email: meh@paranoici.org
 executables: 
@@ -32,10 +43,10 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/rbf/transform.rb
 - lib/rbf/interpreter.rb
 - lib/rbf/syntax.rb
 - lib/rbf/parser.rb
+- lib/rbf/optimizer.rb
 - lib/rbf.rb
 - bin/rbf
 homepage: http://github.com/meh/rbf

data/lib/rbf/transform.rb

@@ -1,30 +0,0 @@
-#--
-#           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-#                   Version 2, December 2004
-#
-#  Copyleft meh. [http://meh.paranoid.pk | meh@paranoici.org]
-#
-#           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-#  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-#
-#  0. You just DO WHAT THE FUCK YOU WANT TO.
-#++
-
-require 'parslet'
-
-module RBF
-
-class Transform < Parslet::Transform
-  rule(?> => simple(:x)) { ?> }
-  rule(?< => simple(:x)) { ?< }
-
-  rule(?+ => simple(:x)) { ?+ }
-  rule(?- => simple(:x)) { ?- }
-
-  rule(?. => simple(:x)) { ?. }
-  rule(?, => simple(:x)) { ?, }
-
-  rule(:loop => subtree(:x)) { x }
-end
-
-end