braingasm 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f89bf346bd58ba90e981f96d4382b4483b142e26
-  data.tar.gz: 11aa5d5055cd19509f50a0e8d7187dac5adc3d75
+  metadata.gz: dd80d14547d49b0c815eed05dccd712772b3bb58
+  data.tar.gz: 1664bf7fc54b68e9e830d497eccae10522663fce
 SHA512:
-  metadata.gz: 9fc5b538410197b6fb03d05227ee7224860de4b2b6d235c61b1d5006765f48c81c13c4b4c6250376fe945ae4c38b9fc63038010f7952fa1c9ca9c654591ead49
-  data.tar.gz: 6232090d60b2a027bceffdb4547025f214653180d4a4e7f6cecaa76b79a962f6b447fc022f5112de4865d97441db66c22c4894d4479b90c218c2abd6a89c8a9a
+  metadata.gz: d74db6070885068e3c7c844189e2fd72ba309018357495851cac96f53729350259e93b3017acf84cfd0020ff4c32aabb0aca543d6eb6aa90282e154f7aedcc93
+  data.tar.gz: 0228237b8fa8682463eb3ad40f83c9d31b544a1eb71da0b07f6ac7d88359df2d0ddfea83c9acc8c06b0d02482849cc637a48bdbb10d393418ed94cfdd675635f

data/braingasm.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "trollop", "~> 2.1.2"
 
-  spec.add_development_dependency "bundler", "~> 1.12.5"
+  spec.add_development_dependency "bundler", "~> 1.13"
   spec.add_development_dependency "rake", "~> 11.2.2"
   spec.add_development_dependency "rspec", "~> 3.5"
 end

data/examples/number_prefixes.bg

@@ -0,0 +1,3 @@
+10,
+[5> #+5+ 2<#[1[<]] 2-] 5[>] 15+
+26[.+] 10.

data/exe/braingasm

@@ -19,7 +19,7 @@ opts = Trollop::options do
   opt :as_is,         "EOF leaves cell unchanged"
   conflicts :zero, :negative, :as_is
 
-  opt :unbound,       "Allow aritrarily large cells"
+  opt :unbound,       "Allow arbitrarily large cells"
   opt :cell_size,     "Cell size in bits",
                       :short => '-s',
                       :default => 8
@@ -33,9 +33,8 @@ err "Error: No filname given" unless filename
 err "Error: No such file: #{filename}" unless File.exists?(filename)
 
 begin
-  input = IO.read(filename)
-  machine = Braingasm.initialize_machine(input)
-  machine.run
+  code = IO.read(filename)
+  Braingasm.run(code)
 rescue Braingasm::BraingasmError => e
   err "#{e.type}: #{e.message}"
 end

data/lib/braingasm.rb

@@ -1,12 +1,25 @@
 require "braingasm/tokenizer"
 require "braingasm/parser"
+require "braingasm/compiler"
 require "braingasm/machine"
+require "braingasm/io"
 
 module Braingasm
+
+  def self.run(code)
+    machine = self.initialize_machine(code)
+    machine.run()
+  end
+
   def self.initialize_machine(code)
-    machine = Machine.new
     tokenizer = Tokenizer.new(code)
-    machine.program = Parser.new(tokenizer).parse_program
+    compiler = Compiler.new
+    program = Parser.new(tokenizer, compiler).parse_program
+    machine = Machine.new
+
+    machine.input = InputBuffer.new($<)
+    machine.output = $>
+    machine.program = program
     machine
   end
 end

data/lib/braingasm/compiler.rb

@@ -0,0 +1,122 @@
+require "braingasm/prefixes"
+
+module Braingasm
+  class Compiler
+    attr_accessor :prefixes, :loop_stack
+
+    def initialize
+      @prefixes = PrefixStack.new
+      @loop_stack = []
+    end
+
+    def push_prefix(prefix)
+      @prefixes << prefix
+      prefix
+    end
+
+    def pos
+      push_prefix ->(m) { m.pos }
+    end
+
+    def random
+      random = proc { |n, _| rand n }
+      return_max_value = proc { |_, _| Options[:cell_limit] }
+      push_prefix @prefixes.fix_params(random, return_max_value)
+    end
+
+    def zero
+      push_prefix ->(m) { m.last_write == 0 ? 1 : 0 }
+    end
+
+    def parity
+      push_prefix ->(m) { (m.last_write &.% 2) || 0 }
+    end
+
+    def right()
+      @prefixes.fix_params ->(n, m) { m.inst_right(n) }
+    end
+
+    def left()
+      @prefixes.fix_params ->(n, m) { m.inst_left(n) }
+    end
+
+    def inc()
+      @prefixes.fix_params ->(n, m) { m.inst_inc(n) }
+    end
+
+    def dec()
+      @prefixes.fix_params ->(n, m) { m.inst_dec(n) }
+    end
+
+    def print()
+      if @prefixes.empty?
+        ->(m) { m.inst_print_cell }
+      else
+        @prefixes.fix_params ->(n, m) { m.inst_print(n) }
+      end
+    end
+
+    def print_int()
+      if @prefixes.empty?
+        ->(m) { m.inst_print_cell_int }
+      else
+        @prefixes.fix_params ->(n, m) { m.inst_print_int(n) }
+      end
+    end
+
+    def read()
+      if @prefixes.empty?
+        ->(m) { m.inst_read_byte }
+      else
+        @prefixes.fix_params ->(n, m) { m.cell = n }
+      end
+    end
+
+    def read_int()
+      @prefixes.fix_params ->(n, m) { m.inst_read_int(n) }, 10
+    end
+
+    def jump(to)
+      ->(m) { m.inst_jump(to) }
+    end
+
+    def loop_start(start_index)
+      return prefixed_loop(start_index) unless @prefixes.empty?
+
+      new_loop = Loop.new
+      @loop_stack.push(new_loop)
+      new_loop.start_index = start_index
+      new_loop
+    end
+
+    def prefixed_loop(start_index)
+      new_loop = FixedLoop.new
+      @loop_stack.push(new_loop)
+      new_loop.start_index = start_index + 1
+      push_ctrl = @prefixes.fix_params ->(n, m) { m.inst_push_ctrl(n) }
+      [push_ctrl, new_loop]
+    end
+
+    def loop_end(index)
+      current_loop = @loop_stack.pop
+      raise BraingasmError, "Unmatched `]`" unless current_loop
+      current_loop.stop_index = index
+      jump(current_loop.start_index)
+    end
+
+    class Loop
+      attr_accessor :start_index, :stop_index
+
+      def call(machine)
+        machine.inst_jump_if_data_zero(stop_index + 1)
+      end
+    end
+
+    class FixedLoop < Loop
+      def call(machine)
+        machine.inst_jump_if_ctrl_zero(stop_index + 1)
+      end
+    end
+
+  end
+end

data/lib/braingasm/io.rb

@@ -0,0 +1,41 @@
+module Braingasm
+  class InputBuffer
+
+    def initialize(source)
+      @source = source
+      @buffer = StringIO.new
+    end
+
+    def ungetc(s)
+      case s
+      when String
+        @buffer.ungetc(s) if s.chomp.size > 0
+      when Integer
+        @buffer.ungetc(s) unless s == 10
+      end
+    end
+
+    def getbyte
+      @buffer.getbyte unless eof?
+    end
+
+    def gets
+      @buffer.gets unless eof?
+    end
+
+    def eof?
+      return true if @buffer.closed?
+      return false unless @buffer.eof?
+
+      s = @source.gets
+      if s
+        @buffer.string = s
+        false
+      else
+        @buffer.close
+        true
+      end
+    end
+
+  end
+end

data/lib/braingasm/machine.rb

@@ -6,20 +6,24 @@ module Braingasm
   # A Machine keeps the state of a running program, and exposes various
   # operations to modify this state
   class Machine
-    attr_accessor :tape, :dp, :program, :ip
+    attr_accessor :tape, :dp, :program, :ip, :ctrl_stack, :last_write, :input, :output
 
     def initialize
       @tape = Array.new(10) { 0 }
       @dp = 0           # data pointer
+      @data_offset = 0
       @ip = 0           # instruction pointer
+
+      @ctrl_stack = []
+      @last_write = 0
     end
 
     def run
       return if @program.empty?
 
       loop do
-        continue = step
-        break unless continue && @ip < @program.size
+        step()
+        break unless @ip < @program.size
       end
     end
 
@@ -30,6 +34,19 @@ module Braingasm
       @ip = jump.to
     end
 
+    def cell
+      @tape[@dp]
+    end
+
+    def cell=(new_value)
+      @tape[@dp] = new_value
+      trigger_cell_updated
+    end
+
+    def pos
+      @dp - @data_offset
+    end
+
     def inst_right(n=1)
       new_dp = @dp + n
       no_cells = @tape.length
@@ -46,9 +63,10 @@ module Braingasm
       new_dp = @dp - n
 
       if new_dp < 0
-        n.times do
-          @tape.unshift 0
-        end
+        new_cells = -new_dp
+        new_cells.times { @tape.unshift 0 }
+        @data_offset += new_cells
+
         new_dp = 0
       end
 
@@ -61,33 +79,65 @@ module Braingasm
 
     def inst_inc(n=1)
       @tape[@dp] += n
-      wrap_cell
+      trigger_cell_updated
     end
 
     def inst_dec(n=1)
       @tape[@dp] -= n
-      wrap_cell
+      trigger_cell_updated
     end
 
     def inst_jump(to)
       raise JumpSignal.new(to)
     end
 
-    def inst_jump_if_zero(to)
-      raise JumpSignal.new(to) if @tape[@dp] == 0
+    def inst_jump_if_data_zero(to)
+      raise JumpSignal.new(to) if cell == 0
+    end
+
+    def inst_jump_if_ctrl_zero(to)
+      ctrl = ctrl_stack.pop
+      raise JumpSignal.new(to) if ctrl == 0
+      ctrl_stack << ctrl - 1
+    end
+
+    def inst_push_ctrl(x)
+      ctrl_stack << x
+    end
+
+    def inst_print(chr)
+      @output.putc chr
     end
 
     def inst_print_cell
-      putc @tape[@dp]
+      @output.putc cell
+    end
+
+    def inst_print_int(n)
+      @output.print n
+    end
+
+    def inst_print_cell_int
+      @output.print cell
     end
 
     def inst_read_byte
-      @tape[@dp] = ARGF.getbyte || Options[:eof] || @tape[@dp]
+      @tape[@dp] = @input.getbyte || Options[:eof] || @tape[@dp]
+      trigger_cell_updated
+    end
+
+    def inst_read_int(radix=10)
+      return unless @input.gets =~ /\d+/
+
+      @input.ungetc($')
+      @tape[@dp] = $&.to_i(radix)
+      trigger_cell_updated
     end
 
     private
-    def wrap_cell
+    def trigger_cell_updated
       @tape[@dp] %= Options[:cell_limit] if Options[:wrap_cells]
+      @last_write = @tape[@dp]
     end
   end
 end

data/lib/braingasm/options.rb

@@ -18,6 +18,10 @@ module Braingasm
       @options[option] = value
     end
 
+    def self.reset
+      @options = @defaults.dup
+    end
+
     private
     def self.check_defaults(option)
       raise ArgumentError, "Unknown option '#{option}'" unless @defaults.has_key?(option)

data/lib/braingasm/parser.rb

@@ -1,15 +1,16 @@
 require "braingasm/errors"
+require "braingasm/compiler"
 
 module Braingasm
 
   # Takes some input code and generates the program
   class Parser
-    attr_accessor :program, :loop_stack
+    attr_accessor :input, :program
 
-    def initialize(input)
+    def initialize(input, compiler)
       @input = input
+      @compiler = compiler
       @program = []
-      @loop_stack = []
     end
 
     def parse_program
@@ -17,88 +18,60 @@ module Braingasm
         push_instruction parse_next(@input)
       end
 
-      raise_parsing_error("Unmatched `[`") unless @loop_stack.empty?
+      raise_parsing_error("Unmatched `[`") unless @compiler.loop_stack.empty?
       @program
     end
 
     def parse_next(tokens)
-      case tokens.next
+      token = tokens.next
+
+      case token
+      when Integer
+        @compiler.push_prefix token
+        false
+      when :hash
+        @compiler.pos()
+        false
+      when :r
+        @compiler.random()
+        false
+      when :z
+        @compiler.zero()
+        false
+      when :p
+        @compiler.parity()
+        false
       when :right
-        right()
+        @compiler.right()
       when :left
-        left()
+        @compiler.left()
       when :plus
-        inc()
+        @compiler.inc()
       when :minus
-        dec()
+        @compiler.dec()
       when :period
-        print()
+        @compiler.print()
+      when :colon
+        @compiler.print_int()
       when :comma
-        read()
+        @compiler.read()
+      when :semicolon
+        @compiler.read_int()
       when :loop_start
-        loop_start()
+        @compiler.loop_start(@program.size)
       when :loop_end
-        loop_end()
+        @compiler.loop_end(@program.size)
       end
+    rescue BraingasmError => e
+      raise_parsing_error(e.message)
     end
 
     def push_instruction(instruction)
       return unless instruction
-      @program.push instruction
+      @program.push(*instruction)
       @program.size - 1
     end
 
-    def right(n=1)
-      -> m { m.inst_right(n) }
-    end
-
-    def left(n=1)
-      -> m { m.inst_left(n) }
-    end
-
-    def inc(n=1)
-      -> m { m.inst_inc(n) }
-    end
-
-    def dec(n=1)
-      -> m { m.inst_dec(n) }
-    end
-
-    def print()
-      -> m { m.inst_print_cell }
-    end
-
-    def read()
-      -> m { m.inst_read_byte }
-    end
-
-    def jump(to)
-      -> m { m.inst_jump(to) }
-    end
-
-    def loop_start()
-        new_loop = Loop.new
-        @loop_stack.push(new_loop)
-        new_loop.start_index = @program.size
-        new_loop
-    end
-
-    def loop_end
-        current_loop = @loop_stack.pop
-        raise_parsing_error("Unmatched `]`") unless current_loop
-        index = @program.size
-        current_loop.stop_index = index
-        jump(current_loop.start_index)
-    end
-
-    class Loop
-      attr_accessor :start_index, :stop_index
-
-      def call(machine)
-        machine.inst_jump_if_zero(stop_index + 1)
-      end
-    end
-
     def raise_parsing_error(message)
       raise ParsingError.new(@input.line_numer, @input.column_number), message
     end

data/lib/braingasm/prefixes.rb

@@ -0,0 +1,30 @@
+require "forwardable"
+
+module Braingasm
+
+  class PrefixStack
+    extend Forwardable
+    attr_accessor :stack
+    def_delegators :@stack, :empty?, :<<, :pop, :==
+
+    def initialize
+      @stack = []
+    end
+
+    def fix_params(function, default_param=1)
+      prefix = @stack.pop || default_param
+
+      case prefix
+      when Integer
+        function.curry.call(prefix)
+      when Proc
+        proc do |m|
+          n = prefix.call(m)
+          function.call(n, m)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/braingasm/tokenizer.rb

@@ -35,17 +35,25 @@ module Braingasm
 
     private
     def read_token(scanner)
-        tokens = { '+' => :plus,
-                   '-' => :minus,
-                   '<' => :left,
-                   '>' => :right,
-                   '.' => :period,
-                   ',' => :comma,
-                   '[' => :loop_start,
-                   ']' => :loop_end }
-        tokens[scanner.scan(/\S/)] || :unknown
+      return scanner.matched.to_i if scanner.scan(/\d+/)
+      @@simple_tokens[scanner.scan(/\S/)] || :unknown
     end
 
+    @@simple_tokens = { '+' => :plus,
+                        '-' => :minus,
+                        '<' => :left,
+                        '>' => :right,
+                        '.' => :period,
+                        ':' => :colon,
+                        ',' => :comma,
+                        ';' => :semicolon,
+                        '#' => :hash,
+                        'r' => :r,
+                        'p' => :p,
+                        'z' => :z,
+                        '[' => :loop_start,
+                        ']' => :loop_end }
+
   end
 end
 

data/lib/braingasm/version.rb

@@ -1,3 +1,3 @@
 module Braingasm
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: braingasm
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Daniel Rødskog
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-29 00:00:00.000000000 Z
+date: 2016-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trollop
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.12.5
+        version: '1.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.12.5
+        version: '1.13'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -85,12 +85,16 @@ files:
 - bin/setup
 - braingasm.gemspec
 - examples/io.b
+- examples/number_prefixes.bg
 - exe/braingasm
 - lib/braingasm.rb
+- lib/braingasm/compiler.rb
 - lib/braingasm/errors.rb
+- lib/braingasm/io.rb
 - lib/braingasm/machine.rb
 - lib/braingasm/options.rb
 - lib/braingasm/parser.rb
+- lib/braingasm/prefixes.rb
 - lib/braingasm/tokenizer.rb
 - lib/braingasm/version.rb
 homepage: https://github.com/daniero/braingasm