rprb 0.1

data/LICENSE

@@ -0,0 +1,5 @@
+Public Domain
+
+No warranties
+
+You know the drill

data/README

@@ -0,0 +1,53 @@
+##
+## Intro/sample script for rprb (aka Reverse Polish RuBy)
+##
+
+{ Kernel swap puts drop } :say sto
+{ "Enter to continue..." say gets drop } :pause sto
+
+# basic RPN stuff
+1 1 + p
+2 * p
+pause
+
+# basic Ruby stuff
+zero? p
+0 zero? p
+Array.new 1 push p
+clr
+pause
+
+# obviously, lines starting with # are ignored, but also..
+<<proc { puts "hi!" }
+call
+pause
+
+# like Lisp, we have a "read" function
+"1 1 +" read p
+# which is equivalent to
+{ 1 1 + } p
+pause
+
+# and an "eval" function to evaluate the results
+eval p clr
+pause
+
+# and an "evaln" function to evaluate n times
+{ 1 1 + } 5 dupn 5 evaln p clr
+
+# we have registers..
+1 :a sto p
+:a rcl p
+
+# registers store our functions
+:drop rcl p
+{ dup2 + } :fib sto
+0 1 fib p
+
+# exen executes multiple times
+:fib 5 exen
+
+# which is equivalent to
+:fib rcl 5 evaln
+
+# and a bunch of other stuff

data/bin/rprb

@@ -0,0 +1,13 @@
+begin
+   require 'rprb'
+rescue LoadError
+   require 'rubygems'
+   require_gem 'rprb'
+end
+
+dc = RpRb::DC.new
+while gets
+   dc.eval dc.read($_.chomp)
+end
+
+# vim:ft=ruby

data/lib/expr.rb

@@ -0,0 +1,64 @@
+# This code is release by the authors into the Public Domain
+
+# stream: expr+
+# expr: block | atom | comment
+# string_literal: duh
+# block: { stream }
+# atom: \S+ | string_literal
+# comment: # anything endl
+# endl: \n
+#
+
+require 'rubygems'
+require 'packrat/grammar'
+
+module RpRb
+   Grammar = Packrat::Grammar.new do
+      start_symbol :Stream
+
+      S = hidden(/\s*/)
+      FS = hidden(/\s\s*/)
+
+      prod :Stream, [mult(:Expression), ast(:Stream)]
+
+      prod :StringLiteral, [/"(?:[^"]|\\")*"/, lift(0)]
+
+      prod :Block, [hidden('{'), S, :Stream, S, hidden('}'), ast(:Block)]
+
+      prod :Atom, [any(:StringLiteral, /[^{} \t]+/), lift(0)]
+
+      rule :Expression, [S, any(:Block, :Atom), S, ast(:Expression)]
+   end
+
+   Parser = Grammar.interpreting_parser
+
+   class Reader 
+      def read(string)
+         to_stream(Parser.parse_string(string))
+      end
+
+      include RpRb::Grammar::ASTs
+
+      def to_stream(ast)
+         case ast
+         when Stream
+            ast.children[0].collect { |child| to_stream(child) }
+         when Expression, Block
+            to_stream ast.children[0]
+         else
+            ast
+         end
+      end
+   end
+end
+
+if __FILE__ == $0
+   require 'pp'
+
+   while gets
+      puts "Parser output:"
+      pp RpRb::Parser.parse_string($_.chomp)
+      puts "Reader output:"
+      pp RpRb::Reader.new.read($_.chomp)
+   end
+end

data/lib/rprb.rb

@@ -0,0 +1,189 @@
+# This code is release by the authors into the Public Domain
+
+module Enumerable
+    def collect_with_index
+        result = []
+        each_with_index { |elem, i|
+            result << yield(elem, i)
+        }
+        result
+    end
+end
+
+#class Rational
+#    def inspect
+#        to_s
+#    end
+#end
+
+def trythese(*procs)
+    if procs.length == 0
+        raise "Ahhg!"
+    else
+        begin
+            procs[0].call
+        rescue Exception => error
+            #puts "ERROR: " + error
+            trythese(*procs[1..-1])
+        end
+    end
+end
+
+require 'expr'
+
+module RpRb
+class DC
+    def initialize
+        @reader = Reader.new
+
+        @stack = []
+
+        @registers = {
+            :eval => proc { |x| eval x },
+            :read => proc { |x| read x },
+
+            :p => proc { ||
+                puts "___"
+                puts @stack.collect_with_index { |entry, i| "%3d: %s" % [i, entry.inspect] }.reverse.join("\n")
+                puts "---"
+                :noval
+            },
+
+            :pick => proc { |n| @stack[n] },
+            :del => proc { |n| @stack.slice!(n); :noval },
+            :sto => proc { |val, sym| @registers[sym] = val; :noval },
+            :rcl => proc { |sym| @registers[sym] },
+            :if => proc { |den, elz, test| if test; den; else; elz; end },
+            :len => proc { || @stack.length },
+
+			:push => proc { |array, elem| array.push elem; array },
+
+            :while => proc { |expr, cond| loop { eval(cond); break unless @stack.shift; eval(expr) }; :noval },
+            :evaln => proc { |expr, n| n.times { eval(expr) }; :noval },
+            :loop => proc { |expr, times| times.times { |i| @stack.unshift(i); eval(expr) }; :noval },
+            :each => proc { |enumerable, expr| enumerable.each { |elem| @stack.unshift(elem); eval(expr) }; :noval },
+
+            :array => proc { |length| @stack.slice!(0, length).reverse },
+
+			:regs => proc { || @registers.keys },
+        }
+
+
+        [
+            read('{ Array.new } :"[]" sto'),
+            read('0 array :control sto'),
+            read('{ false true 2 pick if 1 del } :not sto'),
+            read('{ :control rcl swap unshift :control sto } :save sto'),
+            read('{ :control rcl 0 slice! } :restore sto'),
+            read('{ 1 pick 2 del } :swap sto'),
+            read('{ 0 del } :drop sto'),
+            read('{ 0 pick } :dup sto'),
+            read('{ {drop} swap evaln } :dropn sto'),
+            read('{ 2 dropn } :drop2 sto'),
+            read('{ 2 dupn } :dup2 sto'),
+            read('{ len dropn } :clr sto'),
+            read('{ rcl eval } :exe sto'),
+            read('{ swap rcl swap evaln } :exen sto'),
+            read('{ 1 - } :dec sto'),
+            read('{ 1 + } :inc sto'),
+            read('{ -1 * } :neg sto'),
+            read('{ 1.0 swap / } :inv sto'),
+            read('{ restore dup save } :peek sto'),
+            read('{ restore drop save } :poke sto'),
+            read('{ save {peek 1 - pick} peek evaln restore drop } :dupn sto'),
+            read('0 array :nop sto'),
+            read('{ swap dup length save swap each restore array } :map sto'),
+            read('{ File swap open save peek readlines restore close drop } :slurp sto'),
+            read('{ slurp {chomp} map {read} map {eval} each } :load sto'),
+            read('{ inc dup pick swap del } :take sto'),
+            read('{ len {+} swap dec evaln } :sum sto'),
+        ].each { |stream| eval(stream) }
+    end
+
+    def stack
+        @stack.dup
+    end
+
+    def read(val)
+        @reader.read val
+    end
+
+    def eval(tokens)
+        #puts "Eval-ing #{tokens.inspect}"
+        tokens.each { |token|
+            #puts "processing token #{token.inspect}..."
+            result = trythese(
+             *[
+                proc { execute(token.intern)                     },
+                proc { parse_code(token)                         },
+                proc { Kernel.eval(token)                        },
+                proc { puts("Error, nothing left to do"); :noval },
+              ]
+            )
+
+            unless result == :noval
+                @stack.unshift result
+            end
+        }
+
+        :noval
+    end
+
+    def parse_code(stream)
+        if stream.is_a? Array
+            stream
+        else
+            raise "#{stream.inspect} isn't code!"
+        end
+    end
+
+    def execute(fn)
+        # check if /fn/ names a register
+        if @registers.include? fn
+            case @registers[fn]
+            when Proc, Method
+                values = @stack.slice!(0, @registers[fn].arity).reverse
+                return @registers[fn].call(*values)
+            else
+                return eval(@registers[fn])
+            end
+        end
+
+        # check if /fn/ is a valid function call for an item on the stack
+        @stack.each_with_index { |src, arity|
+            begin
+                if fn == :call and (src.is_a?(Proc) or src.is_a?(Method)) and (src.arity == arity or src.arity == -1)
+                    values = @stack.slice!(0, arity + 1).reverse
+                    return values[0].call(*values[1..-1])
+                elsif src.respond_to?(fn) and (src.method(fn).arity == arity or src.method(fn).arity == -1)
+                    values = @stack.slice!(0, arity + 1).reverse
+                    return values[0].send(fn, *values[1..-1])
+                end
+            rescue ArgumentsError
+            end
+        }
+
+        # check if /fn/ is a valid method of Kernel or Math
+        [Kernel, Math].each { |src|
+            begin
+                if src.respond_to? fn
+                    values = @stack.slice!(0, src.method(fn).arity).reverse
+                    return src.send(fn, *values)
+                end
+            rescue
+            end
+        }
+
+        raise "Couldn't execute function on stack item, DC, Kernel, or Math"
+    end
+end
+end
+
+if __FILE__ == $0
+    dc = RpRb::DC.new
+    while gets
+        dc.eval dc.read($_.chomp)
+    end
+end
+
+# vim:ts=4:sw=4

data/test/tc_evaluator.rb

@@ -0,0 +1,199 @@
+require 'test/unit'
+require 'rprb'
+
+include RpRb
+
+class DCTest < Test::Unit::TestCase
+   def setup
+      @dc = DC.new
+   end
+
+   def e(arg)
+      @dc.eval arg
+   end
+
+   def r(arg)
+      @dc.read arg
+   end
+
+   def re(arg)
+      e r(arg)
+   end
+
+   def s
+      @dc.stack
+   end
+
+   def test_basic_eval
+      re('nil nil')
+      assert_equal [nil, nil], s
+
+      re('clr 1 2 3')
+      assert_equal [3, 2, 1], s
+   end
+
+   def test_basic_method_calling
+      re('1 2 +')
+      assert_equal [3], s
+
+      re 'clr 1 2 3 4 4 array 5 push'
+      assert_equal [[1, 2, 3, 4, 5]], s
+   end
+
+   def test_basic_Math_method_calling
+      re('0 sin 0 cos')
+      assert_equal [1.0, 0.0], s
+   end
+
+   def test_proc_calling
+      re '"proc{|arg|1+arg}" eval 1 call'
+      assert_equal [2], s
+
+      re 'clr Math.method(:sin) 0 call'
+      assert_equal [0.0], s
+   end
+
+   def test_basic_dc_methods
+      re('0 dup')
+      assert_equal [0, 0], s
+
+      re('nil dup')
+      assert_equal [nil, nil, 0, 0], s
+
+      re('drop2 drop')
+      assert_equal [0], s
+
+      re('1 2')
+      assert_equal [2, 1, 0], s
+
+      re('drop dup2')
+      assert_equal [1, 0, 1, 0], s
+
+      re('drop2')
+      assert_equal [1, 0], s
+
+      re 'swap'
+      assert_equal [0, 1], s
+
+      re '1 pick'
+      assert_equal [1, 0, 1], s
+
+      re 'neg'
+      assert_equal [-1, 0, 1], s
+
+      re 'inc'
+      assert_equal [0, 0, 1], s
+
+      re 'dec'
+      assert_equal [-1, 0, 1], s
+
+      re 'len'
+      assert_equal [3, -1, 0, 1], s
+
+      re '[]'
+      assert_equal [[], 3, -1, 0, 1], s
+   end
+
+   def test_variables
+      re('0 1 :a sto')
+      assert_equal [0], s
+
+      re(':a rcl')
+      assert_equal [1, 0], s
+   end
+
+   def test_if
+      re('1 2 true if')
+      assert_equal [1], s
+
+      re('clr 1 2 false if')
+      assert_equal [2], s
+   end
+
+   def test_not
+      re 'false not'
+      assert_equal [true], s
+
+      re 'clr true not'
+      assert_equal [false], s
+
+      re 'clr nil not'
+      assert_equal [true], s
+
+      re 'clr 0 not'
+      assert_equal [false], s
+   end
+
+   def test_while
+      re '{ 1 } { len 5 == not } while'
+      assert_equal [1, 1, 1, 1, 1], s
+   end
+
+   def test_array
+      re '1 2 3 4 4 array'
+      assert_equal [[1, 2, 3, 4]], s
+   end
+
+   def test_evaln
+      re '{ 1 } 5 evaln'
+      assert_equal [1, 1, 1, 1, 1], s
+      
+      re '3 dropn { dup2 + } 3 evaln'
+      assert_equal [5, 3, 2, 1, 1], s
+   end
+
+   def test_stored_procedures
+      re('{ dup2 + } :fib sto 1 1')
+      assert_equal [1, 1], s
+      re('fib fib')
+      assert_equal [3, 2, 1, 1], s
+      re(':fib rcl eval')
+      assert_equal [5, 3, 2, 1, 1], s
+      re(':fib rcl 2 evaln')
+      assert_equal [13, 8, 5, 3, 2, 1, 1], s
+   end
+
+   def test_save_restore
+      re '1 save 2 save restore save :control rcl'
+      assert_equal [[2, 1]], s
+
+      re('clr Array.new :control sto 1 save :control rcl')
+      assert_equal [[1]], s
+
+      re 'clr restore'
+      assert_equal [1], s
+
+      re 'clr :control rcl'
+      assert_equal [[]], s
+   end
+
+   def test_each
+      re '1 2 3 4 5 5 array { 2 * } each'
+      assert_equal [10, 8, 6, 4, 2], s
+   end
+
+   def test_map
+      re('1 2 3 4 5 5 array { 2 * } map')
+      assert_equal [[2, 4, 6, 8, 10]], s
+
+      re 'clr 1 2 3 4 5 5 array { neg } map'
+      assert_equal [[-1, -2, -3, -4, -5]], s
+   end
+
+   def test_load
+      require 'tempfile'
+      thefile = nil
+      Tempfile.open("tc_evaluator") { |file|
+         thefile = file
+         file.write <<-END
+{ dup2 + } :fib sto
+{ 1 1 } :blah sto
+         END
+      }
+
+      re %Q{"#{thefile.path}" load}
+      re 'blah :fib 3 exen'
+      assert_equal [5, 3, 2, 1, 1], s
+      thefile.delete
+   end
+end

data/test/tc_misc.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+require 'rprb'
+
+class MiscTest < Test::Unit::TestCase
+   def test_collect_with_index
+      assert_equal [0, 1, 2, 3], [1, 2, 3, 4].collect_with_index { |a, i| i }
+   end
+end

data/test/tc_reader.rb

@@ -0,0 +1,27 @@
+require 'test/unit'
+require 'rprb'
+
+include RpRb
+
+class ReaderTest < Test::Unit::TestCase
+   def setup
+      @reader = Reader.new
+   end
+
+   def r(arg)
+      @reader.read arg
+   end
+
+   def test_read
+      assert_equal ['1'], @reader.read("1")
+      assert_equal [['1']], @reader.read("{ 1 }")
+      assert_equal [['1']], @reader.read("{1}")
+
+      assert_equal ['1', ['1']], @reader.read('1 {1}')
+
+      assert_equal [[]], @reader.read('{ }')
+
+      assert_equal ['"1 2 3"'], r('"1 2 3"')
+      assert_equal ['"proc {}"'], r('"proc {}"')
+   end
+end

data/test/ts_all.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH << File.dirname(__FILE__) << File.join(File.dirname(__FILE__), '../lib')
+
+require 'tc_misc'
+require 'tc_reader'
+require 'tc_evaluator'

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: rprb
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Jimmy Thrasher and Justin Dubs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2006-10-11 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rockit
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 7
+        - 2
+        version: 0.7.2
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: 
+executables: 
+- rprb
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/rprb.rb
+- lib/expr.rb
+- bin/rprb
+- test/ts_all.rb
+- test/tc_evaluator.rb
+- test/tc_reader.rb
+- test/tc_misc.rb
+- README
+- LICENSE
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Provides Ruby in RPN style, ostensibly for a dc replacement
+test_files: 
+- test/ts_all.rb
+- test/tc_evaluator.rb
+- test/tc_reader.rb
+- test/tc_misc.rb