befunge98 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 01e0f95f403d53d6741cd5490d880b94e64a5f92
+  data.tar.gz: 43de87a5d275630c9f1616ce66e0ac336866660a
+SHA512:
+  metadata.gz: 2f889c5f8c5e79f34effd2b81ffe1a2ce6b25e8c6b7b520dbae380a08e7e5c01fdce6cff813fa1033d2263cfe390c9f717b0cb6ce000b370021d81813f97646b
+  data.tar.gz: 0d5ddb8725d2203f18fafe2cc4f0fcfac044e681b0f69abc4871e8adb4b3f9332193620f03b037983681ab3281e3f84048008bb991d77ad82127d65dd529c496

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Victor Maslov
+
+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/befunge98.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |spec|
+  spec.name         = "befunge98"
+  spec.version      = "0.0.1"
+  spec.summary      = "[WIP] Probably the first Befunge-98 interpreter in Ruby"
+
+  spec.author       = "Victor Maslov aka Nakilon"
+  spec.email        = "nakilon@gmail.com"
+  spec.license      = "MIT"
+  spec.metadata     = {"source_code_uri" => "https://github.com/nakilon/befunge98"}
+
+  spec.require_path = "lib"
+  spec.add_development_dependency "minitest"
+
+  # spec.bindir       = "bin"
+  # spec.executable   = "befunge98"
+  spec.test_file    = "test.rb"
+  spec.files        = %w{ LICENSE befunge98.gemspec lib/befunge98.rb bin/befunge98 }
+end

data/bin/befunge98

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+Signal.trap :INT do
+  abort "\n(interrupted by SIGINT)"
+end
+
+  require_relative "../lib/befunge98"
+
+  exit Befunge98(File.read(ARGV.first), STDOUT).exitcode

data/lib/befunge98.rb

@@ -0,0 +1,228 @@
+Encoding::default_internal = Encoding::default_external = "ASCII-8BIT"
+
+def Befunge98 source, stdout = StringIO.new, stdin = STDIN
+  code = source.tap{ |_| fail "empty source" if _.empty? }.split(?\n).map(&:bytes)
+
+  stacks = [stack = []]
+  pop = ->{ stack.pop || 0 }
+
+  sx = sy = ox = oy = 0
+  dx, dy = 1, 0
+  x, y = -1, 0
+  ds = [[0,1], [1,0], [0,-1], [-1,0]]
+  go_west = ->{ dx, dy = *ds[3] }
+  go_east = ->{ dx, dy = *ds[1] }
+  go_north = ->{ dx, dy = *ds[2] }
+  go_south = ->{ dx, dy = *ds[0] }
+  reflect = ->{ dy, dx = [-dy, -dx] }
+  move = lambda do
+    y, x = y + dy, x + dx
+    next if sy + oy + y >= 0 && code[sy + oy + y] && sx + ox + x >= 0 && code[sy + oy + y][sx + ox + x]
+    top    = code. index{ |l| !(l - [32, nil]).empty? }
+    bottom = code.rindex{ |l| !(l - [32, nil]).empty? }
+    left  = code.map{ |l| l. index{ |c| c && c != 32 } }.compact.min
+    right = code.map{ |l| l.rindex{ |c| c && c != 32 } }.compact.max
+    STDERR.puts [code, top..bottom, left..right, [y, x], [dy, dx]].inspect if ENV["DEBUG"]
+    ty, tx = y, x
+    next if loop do
+      zy, zx = sy + oy + ty, sx + ox + tx
+      break unless (top..bottom).include?(zy) && (left..right).include?(zx)
+      break true if code[zy] && code[zy][zx] && code[zy][zx] != 32
+      ty, tx = ty + dy, tx + dx
+    end
+    ty, tx = y - dy, x - dx
+    loop do
+      STDERR.puts [ty, tx].inspect if ENV["DEBUG"]
+      zy, zx = sy + oy + ty, sx + ox + tx
+      break unless (top..bottom).include?(zy) && (left..right).include?(zx)
+      y, x = ty, tx if code[zy] && code[zy][zx] && code[zy][zx] != 32
+      ty, tx = ty - dy, tx - dx
+    end
+  end
+
+  stringmode = jump_over = false
+  iterate = 0
+
+  get = ->{ (code[sy + oy + y] || [])[sx + ox + x] || 32 }
+  loop do
+    if iterate.zero?
+      move[]
+      char = get[]
+    else
+      iterate -= 1
+    end
+    STDERR.puts [[y, x], char.chr, stack].inspect if ENV["DEBUG"]
+
+    next stack << char if stringmode && char.chr != ?"
+    next unless (33..126).include? char
+    next if jump_over && char.chr != ?;
+    case char.chr
+      when ?; ; jump_over ^= true
+
+      ### 93
+      when ?" ; stringmode ^= true
+      when ?0..?9 ; stack << char.chr.to_i
+      when ?$ ; pop[]
+      when ?: ; stack.concat [pop[]] * 2
+      when ?\\ ; stack.concat [pop[], pop[]]
+      when ?# ; move[]  # "adds the delta to the position"
+      when ?> ; go_east[]
+      when ?< ; go_west[]
+      when ?^ ; go_north[]
+      when ?v ; go_south[]
+      when ?? ; [go_east, go_west, go_north, go_south].sample[]
+      when ?+ ; stack << (pop[] + pop[])
+      when ?- ; stack << -(pop[] - pop[])
+      when ?* ; stack << (pop[] * pop[])
+      when ?/ ; b, a = pop[], pop[]; stack << (b.zero? ? 0 : a / b)
+      when ?% ; b, a = pop[], pop[]; stack << (b.zero? ? 0 : a % b)
+      when ?| ; pop[].zero? ? go_south[] : go_north[]
+      when ?_ ; pop[].zero? ? go_east[] : go_west[]
+      when ?~ ; if c = stdin.getbyte then stack << c else reflect[] end
+      when ?&
+        getc = ->{ stdin.getc or (reflect[]; throw nil) }
+        catch nil do
+          nil until (?0..?9).include? c = getc[]
+          while (?0..?9).include? cc = getc[] ; c << cc end
+          stack << c.to_i
+        end
+      when ?, ; stdout.print pop[].chr
+      when ?. ; stdout.print "#{pop[]} "
+      when ?! ; stack << (pop[].zero? ? 1 : 0)
+      when ?` ; stack << (pop[]<pop[] ? 1 : 0)
+      ### Funge-98 Final Specification:
+      # A Funge-98 program should also be able to rely on the memory mechanism acting as
+      # if a cell contains blank space (ASCII 32) if it is unallocated, and setting memory
+      # to be full of blank space cells upon actual allocation (program load, or p instruction)
+      when ?g
+        y, x = [y, x].tap{ y, x = pop[], pop[]; stack << get[] }
+      when ?p
+        py, px, v = pop[], pop[], pop[]
+        if 0 > (d = sx + ox + px)
+          sx -= d
+          code.map!{ |l| Array.new(-d, 32) + l }
+        end
+        if 0 > (d = sy + oy + py)
+          sy -= d
+          code = Array.new(-d, []) + code
+        end
+        code[sy + oy + py] ||= []
+        code[sy + oy + py][sx + ox + px] = v
+      when ?@ ; return Struct.new(:stdout, :stack, :exitcode).new(stdout, stack, 0)
+
+      ### 98
+      when ?q ; return Struct.new(:stdout, :stack, :exitcode).new(stdout, stack, pop[])
+      when ?a..?f ; stack << char - ?a.ord + 10
+      when ?n ; stack.clear
+      when ?'
+        move[]
+        stack << get[]
+      when ?s
+        move[]
+        code[sy + oy + y] ||= []
+        code[sy + oy + y][sx + ox + x] = pop[]
+      when ?[ ; dy, dx = ds[(ds.index([dy, dx]) - 1) % 4]
+      when ?] ; dy, dx = ds[(ds.index([dy, dx]) + 1) % 4]
+      when ?w ; dy, dx = ds[(ds.index([dy, dx]) + (pop[] > pop[] ? -1 : 1)) % 4]
+      when ?r ; reflect[]
+      when ?x ; dy, dx = [pop[], pop[]]
+      when ?j
+        if 0 < t = pop[]
+          t.times{ move[] }
+        else
+          reflect[]
+          t.times{ move[] }
+          reflect[]
+        end
+      when ?k
+        iterate = pop[]
+        fail if char != 32 || char.chr != ?;
+        move[]
+        char = get[]
+      when ?{
+        toss = if 0 > n = pop[]
+          stack.concat [0] * -n
+          []
+        else
+          stack.pop n
+        end
+        stack << ox << oy
+        ox += x + dx
+        oy += y + dy
+        stacks << stack = toss
+      when ?{
+        if 1 == stacks.size
+          reflect[]
+        elsif 0 > n = pop[]
+          stacks.pop
+          stack = stacks.last
+          oy, ox = pop[], pop[]
+          stack.pop -n
+        else
+          t = stack.pop n
+          stacks.pop
+          stack = stacks.last
+          oy, ox = pop[], pop[]
+          stack.concat t
+        end
+      when ?u
+        if 1 == stacks.size
+          reflect[]
+        elsif 0 > n = pop[]
+          -n.times{ stack[-2] << pop[] }
+        else
+          n.times{ stack << stack[-2].pop }
+        end
+      when ?i
+        fail "TODO"
+        s = ""
+        s << c.chr until (c = pop[]).zero?
+        f = pop[]
+        va = [pop[], pop[]]
+        # ...
+      when ?o
+        fail "TODO"
+        s = ""
+        s << c.chr until (c = pop[]).zero?
+        f = pop[]
+        # y, x = pop[], pop[]
+        # h, w = pop[], pop[]
+        # ...
+      when ?=
+        s = ""
+        s << c.chr until (c = pop[]).zero?
+        system s, out: File::NULL, err: File::NULL
+        stack << $?.exitstatus
+      when ?(, ?)
+        fail "TODO"
+        # pop[].times.inject(0){ |i,| i * 256 + pop[] }
+        # reflect[]
+      when ?y
+        y = pop[]
+        ss = stack.size
+        stack << 0
+        stack << 255
+        stack << 0
+        stack << Gem.loaded_specs.values.find{ |_| _.lib_dirs_glob == File.absolute_path(__dir__) }.version.segments.join.to_i
+        stacK << 0
+        stack << File::SEPARATOR.ord
+        stack << 2
+        stack << 0
+        stack << 0
+        stack << y << x
+        stack << dy << dx
+        stack << oy << ox
+        stack << [0, 0] # TODO: 1 vector containing the least point which contains a non-space cell, relative to the origin (env)
+        stack << [0, 0] # TODO: 1 vector containing the greatest point which contains a non-space cell, relative to the least point (env)
+        t = Time.now
+        stack << (t.year - 1900) * 256 * 256 + t.month * 256 + t.day
+        stack << t.hour * 256 * 256 + t.min * 256 + t.sec
+        stack << stacks.size
+        stack.concat stacks.map &:size; stack[-1] = ss
+        stack.concat ARGV.map{ |_| _.chars.map(&:ord) + [0] } + [0]
+        stack.concat ENV.map{ |k, v| "#{k}=#{v}".chars.map(&:ord) + [0] } + [0]
+        stack << stack[1-y].tap{ stack = stack.take ss } if y > 0
+
+    end
+  end
+end

data/test.rb

@@ -0,0 +1,164 @@
+require "minitest/autorun"
+require_relative "lib/befunge98"
+
+describe "lib" do
+  it "prints to STDOUT" do skip end
+  it "prints to String" do skip end
+
+  describe "Befunge-93" do
+    describe "(rely on @ and pop from empty stack)" do
+      before do
+        assert_equal 0, Befunge98(?@).exitcode
+      end
+
+      it '"' do
+        assert_equal [?@.ord], Befunge98("\"@").stack
+      end
+
+      describe "(rely on 0..9)" do
+        before do
+          assert_equal (0..9).to_a, Befunge98("0123456789@").stack
+        end
+
+        it "$" do
+          assert_equal [1], Befunge98("$12$@").stack
+        end
+        it ":" do
+          assert_equal [0, 0, 1, 1], Befunge98(":1:@").stack
+        end
+        it "\\" do
+          assert_equal [0, 1, 0], Befunge98("\\1\\@").stack
+        end
+        it "#" do
+          assert_equal [1], Befunge98('#@1#').stack
+        end
+        it "><^v" do
+          assert_equal [1, 2, 3, 4], Befunge98("<@^1\n"\
+                                               "3v>\n"\
+                                               "5425").stack
+        end
+        it "?" do
+          assert_equal [[1], [2], [3], [4]], 100.times.map{
+            Befunge98("?1@2\n"\
+                      "4555\n"\
+                      "@555\n"\
+                      "3555").stack
+          }.uniq.sort
+        end
+        it "+" do
+          assert_equal [90000], Befunge98("++"+"9+"*10000+"@").stack
+        end
+        it "-" do
+          assert_equal [-90000], Befunge98("--"+"9-"*10000+"@").stack
+        end
+        it "*" do
+          assert_equal [0, 2**31], Befunge98("**2*2"+"2*"*30+"@").stack
+        end
+        it "/" do
+          assert_equal [0, 0, 1, 2], Befunge98("//12/22/21/@").stack
+        end
+        it "/ with -" do
+          assert_equal [-1, -2, -1, -2], Befunge98("1-2/02-1/102-/201-/@").stack
+        end
+        it "|_" do
+          assert_equal [1, 3], Befunge98("00|\n"\
+                                         "41_13@\n"\
+                                         "42_23@").stack
+          assert_equal [2, 4], Befunge98("11|\n"\
+                                         "41_13@\n"\
+                                         "42_23@").stack
+          assert_equal [2, 3], Befunge98("01|\n"\
+                                         "41_13@\n"\
+                                         "42_23@").stack
+          assert_equal [1, 4], Befunge98("10|\n"\
+                                         "41_13@\n"\
+                                         "42_23@").stack
+        end
+        it "-|_" do
+          assert_equal [2, 4], Befunge98("1-01-|\n"\
+                                         "   41_13@\n"\
+                                         "   42_23@").stack
+        end
+        it ", with +" do
+          assert_equal "\x00\x0A\xFF\x00".b, Befunge98(",55+,5"+"5+"*50+",,@").stdout.string
+        end
+        it ". with +" do
+          assert_equal "0 10 255 0 ",        Befunge98(".55+.5"+"5+"*50+"..@").stdout.string
+        end
+        it "!" do
+          assert_equal [1, 1, 0, 0], Befunge98("!0!1!2!@").stack
+        end
+        it "! with -" do
+          assert_equal [0, 0], Befunge98("1-!02-!@").stack
+        end
+        it "`" do
+          assert_equal [0, 0, 1], Befunge98("`01`10`@").stack
+        end
+        it "pg with -" do
+          assert_equal [3, 4], Befunge98("302-01-p401-02-p02-01-g01-02-g@").stack
+        end
+      end
+    end
+
+    it "# test by @lifthrasiir" do
+      assert_equal "3 ", Befunge98(
+      <<~HEREDOC
+        #;v           ; 1.@
+          ># ;2.@;3.@
+      HEREDOC
+      ).stdout.string
+    end
+  end
+
+  describe "Befunge98 operations" do
+    it "q" do
+      assert_equal 0, Befunge98(" q").exitcode
+      assert_equal 1, Befunge98("1q").exitcode
+    end
+
+    describe "(rely on @)" do
+      before do
+        assert_equal 0, Befunge98(?@).exitcode
+      end
+
+      it "~" do
+        assert_equal [2], Befunge98("~1@2", StringIO.new, StringIO.new).stack
+        assert_equal [0, 10, 255, 0], Befunge98("~~~~@", StringIO.new,
+          StringIO.new.tap{ |s| [0, 10, 255, 0].reverse_each &s.method(:ungetbyte) }
+        ).stack
+      end
+      it "&" do
+        assert_equal [2], Befunge98("&1@2", StringIO.new, StringIO.new).stack
+        [?\0, ?\xa, ?\xff].each do |c|
+          assert_equal [12, 34], Befunge98("&&@", StringIO.new,
+            StringIO.new.tap{ |s| "#{c}-12#{c}-34#{c}".bytes.reverse_each &s.method(:ungetbyte) }
+          ).stack
+        end
+      end
+
+      describe "(rely on a..f)" do
+        before do
+          assert_equal (10..15).to_a, Befunge98("abcdef@").stack
+        end
+      end
+    end
+  end
+
+end
+
+describe "bin" do
+  it "hello world" do
+    require "open3"
+    require "tempfile"
+    file = Tempfile.new "temp.b98"
+    begin
+      file.write '64+"!dlroW ,olleH">:#,_@'
+      file.flush
+      string, status = Open3.capture2 "bundle exec ruby bin/befunge98 #{file.path}"
+    ensure
+      file.close
+      file.unlink
+    end
+    assert_equal ["Hello, World!\n", 0], [string, status.exitstatus]
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: befunge98
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Victor Maslov aka Nakilon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-09-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: nakilon@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- befunge98.gemspec
+- bin/befunge98
+- lib/befunge98.rb
+- test.rb
+homepage: 
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/nakilon/befunge98
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: "[WIP] Probably the first Befunge-98 interpreter in Ruby"
+test_files:
+- test.rb