befunge 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 755f4a89eb72d0411019a7893e06ac36af17adbe
+  data.tar.gz: bcd23559bd918099356cbff55b3420074aae86c7
+SHA512:
+  metadata.gz: 8e303c70c8d2c4a49043bf310fbb121ae1a85a61d199afbb8c694f53c1f4cc666da5a6bf0bf047863268d122e1ee835819a71fdc063f2e48b072e3c285c1a05b
+  data.tar.gz: ee1c81455fcadaa5bf06628fdc944d65d816b69c5fafd58666be07dc2258d3d2964ad5f98afa3657f4505874d195bdde130726df368557ec022c42dc14e46dd9

data/bin/befunge

@@ -0,0 +1,25 @@
+#!/usr/bin/ruby
+
+require './lib/operations.rb'
+require './lib/code_map.rb'
+require './lib/pointer.rb'
+require './lib/stack.rb'
+require './lib/befunge_interpreter.rb'
+require 'colorize'
+
+AVAILABLE_FLAGS = %w(-d -a)
+
+filename = ARGV[0]
+flags = ARGV[1..-1]
+flags ||= []
+flags.each { |flag| raise 'Fuck you' unless AVAILABLE_FLAGS.include?(flag) }
+
+if flags.include?('-a')
+  klass = BefungeInterpreterAnimation
+elsif flags.include?('-d')
+  klass = BefungeInterpreterDebugger
+else
+  klass = BefungeInterpreter
+end
+
+klass.new(filename, flags).interpret

data/lib/befunge_interpreter.rb

@@ -0,0 +1,90 @@
+# This is the top-level class containing everything needed to interpret
+# befunge code. Intialize with a string location of a filename and an array
+# of flags and then call BefungeInterpreter#interpret. This will run the
+# befunge code.
+# TODO: Implement flags - debugging mode, animation mode.
+class BefungeInterpreter
+  include Operations
+
+  def initialize(file, flags)
+    @code_map = CodeMap.new(file)
+    @flags = flags
+    @stack = Stack.new
+    @string_mode = false
+    @computing = true
+    @return_string = ''
+  end
+
+  def interpret
+    operate_and_step while @computing
+  end
+
+  private
+
+  def operate_and_step
+    operate!(@code_map.get_operation)
+    @code_map.pointer.step
+  end
+
+  def print_status
+    system 'clear'
+    @code_map.print_map
+    print_stack
+    print_return_string
+  end
+
+  def print_stack
+    print_whole_stack if @stack.length <= 10
+    print_top_ten_stack if @stack.length > 10
+  end
+
+  def print_whole_stack
+    p @stack
+  end
+
+  def print_top_ten_stack
+    puts "Showing top ten items on stack..."
+    @stack[-11..-1].each { |stack_item| print ", #{stack_item}" }
+    print "]\n"
+  end
+
+  def print_return_string
+    p @return_string
+  end
+end
+
+# Use this class for debugger mode
+class BefungeInterpreterDebugger < BefungeInterpreter
+  def interpret
+    print_status
+    while @computing
+      puts "\nDebugger Mode!~"
+      puts 'Commands: n = next([, step_amt]), p = put_operation(x, y, op)'
+      user_input = $stdin.gets.chomp
+      case user_input
+      when /\An\z/ then operate_and_step
+      when /\An \d+\z/ then operate_and_step(Integer(user_input[2..-1]))
+      when /\A(\d+)n/ then operate_and_step(Integer(user_input.match(/(\d+)/)[1]))
+      when /\Aquit\z/ then @computing = false
+      end
+      print_status
+    end
+  end
+
+  def operate_and_step(n = 1)
+    n.times { super() }
+  end
+end
+
+# Use this class for animation mode
+class BefungeInterpreterAnimation < BefungeInterpreter
+  def interpret
+    print_status
+    while @computing
+      sleep 0.1
+      operate_and_step
+      print_status
+    end
+  end
+end
+

data/lib/code_map.rb

@@ -0,0 +1,61 @@
+# This class is reponsible for keeping the befunge code. It will output
+# the current operation the pointer is at, and also set and get operations
+# based on coordinates. CodeMap#print_map will be used for animation
+# and debuggin modes.
+class CodeMap
+  attr_reader :width, :height, :pointer, :map
+  def initialize(file)
+    @pointer = Pointer.new
+    @map = File.open(file, 'r').readlines.map { |line| line.chomp.split '' }
+    format_code_map
+  end
+
+  def get_operation
+    @map[@pointer.y][@pointer.x]
+  end
+
+  def set_operation_at(x, y, op)
+    @map[y][x] = op
+  end
+
+  def get_operation_at(x, y)
+    @map[y][x]
+  end
+
+  def print_map
+    system 'clear'
+    @map.each_with_index do |line, i|
+      line.each_with_index do |char, j|
+        if @pointer.x == j && @pointer.y == i
+          print char.colorize(background: :red)
+        else
+          print char
+        end
+      end
+
+      print "\n"
+    end
+  end
+
+  private
+
+  def format_code_map
+    check_if_valid
+    until @map.length == 20
+      @map << []
+      80.times { @map.last << ' ' }
+    end
+    @map.each do |line|
+      until line.length == 80
+        line << ' '
+      end
+    end
+  end
+
+  def check_if_valid
+    raise 'Invalid map' unless @map.length <= 80
+    @map.each do |line|
+      raise 'Invalid map' unless line.length <= 80
+    end
+  end
+end

data/lib/operations.rb

@@ -0,0 +1,147 @@
+# This module is responsible for performing operations. It keeps all logic
+# based on opertaions encapsulated. It is meant to be included with the
+# top-level BefungeInterpreter.
+module Operations
+  # Bunch of Constants here.
+  # Important thing: %i() defines array of symbols while %w() defines array
+  # of strings. The Hash[Array#zip(Array)] pattern I've chosen to employ here
+  # simply maps the string/symbol single character representation of the
+  # operation to it's actual method name here. For instance:
+  # OPERATORS_MAP['!'] => :logical_not
+  # We can just #send that symbol in our #operate! method.
+
+  MATH_OPS = %i(+ - * / %)
+  DIRECTION_OPS = %i(^ < > v)
+  DIRECTIONS = %i(n w e s)
+  DIRECTIONS_MAP = Hash[DIRECTION_OPS.zip(DIRECTIONS)]
+  OPERATORS = %w(! ` ? _ | : \\ $ . , # p g & ~ @)
+  OPERATORS_MAP = Hash[OPERATORS.zip([
+    :logical_not, :greater_than, :rand_direction, :left_right,
+    :up_down, :duplicate_stack_top, :swap_stack_top,
+    :pop_and_discard, :pop_and_display_int, :pop_and_display_char,
+    :trampoline, :put_call, :get_call, :get_user_input_int,
+    :get_user_input_char, :end_program
+  ])]
+
+  def operate!(op)
+    string_mode and return if op == '"'
+    push_ascii_value(op) and return if @string_mode
+    return if op == ' '
+    send(op) and return if MATH_OPS.include?(op.to_sym)
+    push_num(op) and return if Integer(op) rescue false
+    change_dir(op.to_sym) and return if DIRECTION_OPS.include?(op.to_sym)
+    send(OPERATORS_MAP[op])
+  end
+
+  # Meta. This defines the + - * / % methods in one loop since they're
+  # really all the same rpn calculation.
+  MATH_OPS.each do |math_op|
+    define_method(math_op) do
+      a = @stack.pop
+      b = @stack.pop
+      @stack.push(b.send(math_op, a))
+    end
+  end
+
+  def push_num(num)
+    @stack.push(num.to_i)
+  end
+
+  # I call this method two different ways - one with directional operational
+  # arguments < > ^ v and one with actual directions :n :e :s :w. This is
+  # the reason for the unless statement here.
+  def change_dir(op)
+    op = DIRECTIONS_MAP[op] unless DIRECTIONS.include?(op)
+    @code_map.pointer.direction = op
+  end
+
+  def logical_not
+    @stack.pop == 0 ? @stack.push(1) : @stack.push(0)
+  end
+
+  def greater_than
+    a = @stack.pop
+    b = @stack.pop
+    b > a ? @stack.push(1) : @stack.push(0)
+  end
+
+  def rand_direction
+    @code_map.pointer.direction = DIRECTIONS.sample
+  end
+
+  def left_right
+    @stack.pop == 0 ? change_dir(:e) : change_dir(:w)
+  end
+
+  def up_down
+    @stack.pop == 0 ? change_dir(:s) : change_dir(:n)
+  end
+
+  def string_mode
+    @string_mode = !@string_mode
+    true
+  end
+
+  def duplicate_stack_top
+    @stack.push(0) and return if @stack.empty?
+    @stack.push(@stack.last)
+  end
+
+  def swap_stack_top
+    return if @stack.length < 2
+    @stack[-1], @stack[-2] = @stack[-2], @stack[-1]
+  end
+
+  def pop_and_discard
+    @stack.pop
+  end
+
+  def pop_and_display_int
+    display_int = @stack.pop
+    @return_string << display_int.to_s
+    print display_int
+  end
+
+  def pop_and_display_char
+    display_char = @stack.pop.chr
+    @return_string << display_char
+    print display_char
+  end
+
+  def trampoline
+    @code_map.pointer.trampoline = true
+  end
+
+  def put_call
+    y = @stack.pop
+    x = @stack.pop
+    v = @stack.pop
+    @code_map.set_operation(y, x, v.chr)
+  end
+
+  def get_call
+    y = @stack.pop
+    x = @stack.pop
+    @stack.push(@code_map.get_operation_at(y, x).ord)
+  end
+
+  def get_user_input_int
+    puts 'Befunge needs your input for int!'
+    @stack.push(Integer($stdin.gets.chomp))
+  end
+
+  def get_user_input_char
+    puts 'Befunge needs your input for char!'
+    input = $stdin.gets.chomp
+    raise 'Must be a single character' unless input.length == 1
+    @stack.push(input.ord)
+  end
+
+  def end_program
+    @computing = false
+  end
+
+  def push_ascii_value(op)
+    @stack.push(op.ord)
+  end
+end

data/lib/pointer.rb

@@ -0,0 +1,26 @@
+# This class is responsible for keeping track of it's location on the
+# code map and moving in a direction every iteration.
+class Pointer
+  attr_accessor :direction, :trampoline, :x, :y
+  DIRECTIONS = [:w, :e, :n, :s]
+  DIRECTIONS_MAP = Hash[DIRECTIONS.zip(
+    [
+      [-1, 0], [1, 0], [0, -1], [0, 1]
+    ])]
+
+  def initialize(direction = :e)
+    @direction = direction
+    @x, @y = 0, 0
+    @trampoline = false
+  end
+
+  def step
+    diff = DIRECTIONS_MAP[@direction]
+    multiplier = @trampoline ? 2 : 1
+    self.x = x + diff.first * multiplier
+    self.y = y + diff.last * multiplier
+    self.x = x % 80
+    self.y = y % 20
+    @trampoline = false
+  end
+end

data/lib/stack.rb

@@ -0,0 +1,6 @@
+class Stack < Array
+  def pop
+    return 0 if empty?
+    super
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: befunge
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Obnoxious_Slime
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Basic Befunge Interpreter
+email: Obnoxious_slime@mail.com
+executables:
+- befunge
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/befunge
+- lib/befunge_interpreter.rb
+- lib/code_map.rb
+- lib/operations.rb
+- lib/pointer.rb
+- lib/stack.rb
+homepage: 
+licenses:
+- WTFPL
+metadata: {}
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Befunge
+test_files: []