nil 1.0.9 → 2.0.0

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# 2.0.0
+
+- Total rewrite of the interpreter
+  * No more code generation, it actually interprets the code
+  * No more interpreter at all. Compiled code is run directly (NilCommands
+    class)
+
+- Rewrite of MacroParser
+  * No more separate methods, everything is done right in the parse method
+  * Also called MacroCompiler now
+
+- Add updated MacroCompiler stuff to executable
+
 # 1.0.9
 - Bug fixes
 

data/Gemfile

@@ -4,5 +4,6 @@ gem 'trollop'
 
 group :development do
   gem 'pry'
+  gem 'pry-doc'
   gem 'riot'
 end

data/README.md

@@ -56,27 +56,7 @@ default mode is `ascii`.
 
 ## Interpreter
 
-nil is also a brain**** interpreter. It does the interpreting in its own special
-way, though:
-
-1. It uses the MacroCompiler to compile the code
-2. It translates the brain**** to Ruby code
-3. It then runs the Ruby code it generated.
-
-The interpreter tries to be smart about the way it translates the code, for
-instance:
-
-`+++++` will be translated to:
-
-    sp += 5
-
-instead of
-
-    sp += 1
-    sp += 1
-    sp += 1
-    sp += 1
-    sp += 1
+nil also interprets brain**** code.
 
 ## Installing
 
@@ -99,13 +79,10 @@ require 'nil'
 
 code = "+4."
 
-mp = Nil::MacroParser.new
-code = mp.parse code
-
-interpreter = Nil::Interpreter.new
-interpreter.compile code
+mc = Nil::MacroCompiler.new
+commands = mp.compile code
 
-interpreter.run
+commands.run
 ```
 
 Run `nil -h` for command line tool usage.

data/bin/nil

@@ -14,18 +14,15 @@ Usage:
 where [options] are:
 EOS
 
-opt :compile_only, "Output compiled Ruby code to standard output instead of running it."
+opt :compile_only, "Only compile macros in the code, do not run."
 end
 
 code = ARGF.read
-mp = Nil::MacroParser.new
-code = mp.parse code
-i = Nil::Interpreter.new
-i.compile code, mp.mode
+mp = Nil::MacroCompiler.new
+c = mp.compile code
 
 if opts[:compile_only]
-  puts i.compiled_ruby
-  exit
+  puts c.code
+else
+  c.run
 end
-
-i.run

data/lib/nil.rb

@@ -1,6 +1,6 @@
 require 'pp'
 require 'nil/version'
-require 'nil/interpreter'
+require 'nil/nil_commands'
 require 'nil/macro'
 
 module Nil

data/lib/nil/macro.rb

@@ -1,15 +1,40 @@
 module Nil
-  class MacroParser
-    attr_accessor :original_code, :compiled_code, :mode
-
+  class MacroCompiler
     def initialize
-      @mode = 'ascii'
     end
 
     def compile_subroutines(code)
+    end
+
+    def compile(code)
+      # Strip whitespace
+      code.gsub!(/\s/, '')
+
+
+      # Interpret the mdoe definition in the code
+      mode = 'ascii'
+      code.match /\.mode\((ascii|num)\)/i do |m|
+        $1 == 'num' ? mode = 'num' : nil
+      end
+      code.gsub!(/\.mode\((ascii|num)\)/i, '')
+
+      # Expand incldued files
+      included_code = ""
+      files = code.scan(/\.include\(([^\)]+)\)/).flatten
+      files.each do |f|
+        included_code << File.open(f, 'r').read.strip
+      end
+      code.gsub!(/\.include\(([^\)]+)\)/, '')
+      code = included_code + code
+
+      # Strip comments
+      code.gsub!(/;(.+);/, '')
+
+      # Compile subroutines
       subroutines = {}
       sub_def_regex = Regexp.new ':(?<sub-name>[a-zA-Z0-9_]+)\{(?<sub-code>[\[\]><\-\+.,A-Za-z0-9:]+)\}'
       sub_call_regex = Regexp.new '([a-zA-Z0-9_]+):'
+
       code.scan(sub_def_regex).map do |sub|
         subroutines[sub[0]] = sub[1]
       end
@@ -24,54 +49,14 @@ module Nil
         subroutines[$1]
       end
 
-      code.gsub(sub_def_regex, '')
-    end
-
-    def interpret_mode_definition(code)
-      code.match /\.mode\((ascii|num)\)/i do |m|
-        $1 == 'num' ? @mode = 'num' : @mode = 'ascii'
-      end
-      code.gsub(/\.mode\((ascii|num)\)/i, '')
-    end
-
-    def expand_included_files(code)
-      c = code
-      include_regex = Regexp.new '\.include\(([^\)]+)\)'
-      included_code = ""
-      files = c.scan(include_regex).flatten
-      files.each do |f|
-        included_code << File.open(f, 'r').read.strip
-      end
-      c.gsub!(include_regex, '')
-      c = included_code + c
-      c
-    end
-
-    def strip_comments(code)
-      code.gsub(/;(.+);/, '')
-    end
-
-    def parse(code)
-      @original_code = code
-
-      compiled_code = @original_code
-
-      compiled_code.gsub!(/\s/, '')
-
-      compiled_code = interpret_mode_definition(compiled_code)
-
-      Nil::Interpreter.mode = @mode
-
-      compiled_code = expand_included_files(compiled_code)
-
-      compiled_code = strip_comments(compiled_code)
+      code.gsub!(sub_def_regex, '')
 
-      compiled_code.gsub!(/([\+-<>])(\d+)/) do |m| # Parse the numerical commands.
+      # Parse numerical commands
+      code.gsub!(/([\+-<>])(\d+)/) do |m|
         $1 * $2.to_i
       end
 
-      compiled_code = compile_subroutines(compiled_code)
-      compiled_code
+      Nil::NilCommands.new(code, mode)
     end
   end
 end

data/lib/nil/nil_commands.rb

@@ -0,0 +1,55 @@
+module Nil
+  class NilCommands
+    attr_reader :sp, :stack, :code_pointer, :loop_begin_pointer,
+      :loop_end_pointer, :mode, :code
+
+
+    def initialize(code, mode = 'ascii')
+      @sp = 0
+      @stack = [0] * 10_000
+      @code_pointer = 0
+      @loop_begin_pointer = 0
+      @loop_end_pointer = 0
+
+      @code = code
+      @mode = mode
+    end
+
+    def run
+      while @code_pointer <= code.size
+        case code[@code_pointer]
+        when '.'
+          if @mode == 'num'
+            puts @stack[@sp]
+          else
+            print @stack[@sp].chr
+          end
+        when ','
+          if @mode == 'num'
+            @stack[@sp] = gets[0].to_i
+          else
+            @stack[@sp] = gets[0].ord
+          end
+        when '+'
+          @stack[@sp] += 1
+        when '-'
+          @stack[@sp] -= 1 unless @stack[@sp] == 0
+        when '>'
+          @sp += 1
+        when '<'
+          @sp -= 1
+        when '['
+          @loop_begin_pointer = @code_pointer
+
+          if @stack[@sp] <= 0
+            @code_pointer = @loop_end_pointer
+          end
+        when ']'
+          @loop_end_pointer = @code_pointer
+          @code_pointer = (@loop_begin_pointer - 1)
+        end
+        @code_pointer += 1
+      end
+    end
+  end
+end

data/lib/nil/version.rb

@@ -1,3 +1,3 @@
 module Nil
-  VERSION = "1.0.9"
+  VERSION = "2.0.0"
 end

data/test/nil_test.rb

@@ -1,125 +1,129 @@
 require 'nil'
+require 'stringio'
 require 'riot'
 
 Riot.pretty_dots
 
-BOILERPLATE = <<RB
-sp = 0
-stack = [0] * 10_000
-RB
+context "NilCommands" do
+  context "Adding" do
+    setup { Nil::NilCommands.new("+") }
 
-context "Interpreter" do
-  setup { Nil::Interpreter.new }
+    asserts("adds value in stack at stack pointer") do
+      topic.run
+      topic.stack[topic.sp] == 1
+    end
+  end
 
-  context "General code generation" do
-    asserts("invalid characters in code cause failure") { topic.compile "a++", 'num' }.raises SyntaxError
+  context "Subtracting" do
+    setup { Nil::NilCommands.new("+-") }
 
-    asserts("creates boilerplate code") { topic.compiled_ruby == BOILERPLATE }
+    asserts("subtracts value in stack at stack pointer") do
+      topic.run
+      topic.stack[topic.sp] == 0
+    end
   end
 
-  context "Modes" do
-    asserts("handles . in numerical mode") { topic.compile('.', 'num') == (BOILERPLATE + "puts stack[sp]\n") }
-    asserts("handles . in ascii mode") { topic.compile('.', 'ascii') == (BOILERPLATE + "print stack[sp].chr\n") }
-  end
+  context "Stack Pointer" do
+    asserts("stack pointer is incremented") do
+      nc = Nil::NilCommands.new(">")
+      nc.run
+      nc.sp == 1
+    end
 
-  context "General operator handling" do
-    asserts("handles ,") { topic.compile(',', 'num') == (BOILERPLATE + "stack[sp] = gets[0]\n") }
-    asserts("handles >") { topic.compile('>', 'num') == (BOILERPLATE + "sp += 1\n") }
-    asserts("handles <") { topic.compile('<', 'num') == (BOILERPLATE + "sp -= 1\n") }
-    asserts("handles +") { topic.compile('+', 'num') == (BOILERPLATE + "stack[sp] += 1\n") }
-    asserts("handles -") { topic.compile('-', 'num') == (BOILERPLATE + "stack[sp] -= 1\n") }
-    asserts("handles [") { topic.compile('[', 'num') == (BOILERPLATE + "while stack[sp] != 0\n" ) }
-    asserts("handles ]") { topic.compile(']', 'num') == (BOILERPLATE + "end\n" ) }
+    asserts("stack pointer is decremented") do
+      nc = Nil::NilCommands.new("><")
+      nc.run
+      nc.sp == 0
+    end
   end
 
-  context "Advanced operator handling" do
-  asserts("handles multiple operators smartly") do
-    code = topic.compile "++++---->>>><<<<", 'num'
-    code == BOILERPLATE + <<CODE
-stack[sp] += 4
-stack[sp] -= 4
-sp += 4
-sp -= 4
-CODE
-  end
+  context "Loops" do
+    setup { Nil::NilCommands.new("++++[-]") }
 
-  asserts("handles multiple printing statements") do
-    code = "++++.>+++."
-    code = topic.compile(code, 'num')
-    code == BOILERPLATE + <<CODE
-stack[sp] += 4
-puts stack[sp]
-sp += 1
-stack[sp] += 3
-puts stack[sp]
-CODE
+    asserts("while loops work") do
+      topic.run
+      topic.stack[topic.sp] == 0
+    end
   end
-end
 
-  context "Bug testing" do
-    denies("error raised when brackets are inside subroutines") do
-      code = ":sub{+++[-]}sub:"
-      code = (Nil::MacroParser.new).parse code
-      topic.compile(code)
-    end.raises SyntaxError
-  end
+  context "IO" do
+    context "Numerical output" do
+      setup { Nil::NilCommands.new("+++.", 'num') }
+
+      asserts("that numerical mode output works") do
+        out = StringIO.new
+        $stdout = out
+        topic.run
+        out.rewind
+        out.read == "3\n"
+      end
+    end
 
+    context "ASCII output" do
+      setup { Nil::NilCommands.new("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.", 'ascii') }
+
+      asserts("that ASCII output works") do
+        out = StringIO.new
+        old_out = $stdout
+        $stdout = out
+        topic.run
+        out.rewind
+        out.read == "d\n"
+        $stdout = old_out
+      end
+    end
+  end
 end
 
-context "MacroParser" do
-  setup { Nil::MacroParser.new }
+context "MacroCompiler" do
+  setup { Nil::MacroCompiler.new }
 
   context "Basics" do
-    asserts("that the original code equals code passed to parser") do
-      code = "++><>--" # Just some random stuff
-      topic.parse code
-      compiled_original_code = topic.original_code
-      code == compiled_original_code
-    end
+    asserts("that returned value is of NilCommands class") { topic.compile("").class == Nil::NilCommands }
   end
 
   context "Numbered commands" do
     asserts("that numbered commands are expanded") do
       code = "+5-5>5<5"
-      compiled_code = topic.parse code
-      compiled_code == "+++++----->>>>><<<<<"
+      compiled_code = topic.compile code
+      compiled_code.code == "+++++----->>>>><<<<<"
     end
   end
 
   context "Modes" do
     asserts("that numerical mode is correctly set") do
       code = ".mode(num)"
-      compiled = topic.parse code
-      Nil::Interpreter.mode == 'num'
+      compiled = topic.compile code
+      compiled.mode == 'num'
     end
 
     asserts("that ascii mode is correctly set") do
       code = ".mode(ascii)"
-      compiled = topic.parse code
-      Nil::Interpreter.mode == 'ascii'
+      compiled = topic.compile code
+      compiled.mode == 'ascii'
     end
 
     asserts("that ascii mode is set by default") do
       code = "+"
-      compiled = topic.parse code
-      Nil::Interpreter.mode == 'ascii'
+      compiled = topic.compile code
+      compiled.mode == 'ascii'
     end
   end
 
   context "Subroutines" do
     asserts("that subroutines are expanded") do
       code = ":test{++--><}++test:"
-      compiled_code = topic.parse code
-      compiled_code == "++++--><"
+      compiled_code = topic.compile code
+      compiled_code.code == "++++--><"
     end
 
     asserts("that subroutines contaning numbered commands are expanded") do
       code = ":test{+5}test:"
-      compiled_code = topic.parse code
-      compiled_code == "+++++"
+      compiled_code = topic.compile code
+      compiled_code.code == "+++++"
     end
 
-    asserts("that recursive subroutines throw exceptions") { topic.parse ":sub{sub:}sub:" }.raises(SyntaxError)
+    asserts("that recursive subroutines throw exceptions") { topic.compile ":sub{sub:}sub:" }.raises(SyntaxError)
   end
 
   context "Whitespace & Comments" do
@@ -131,28 +135,28 @@ context "MacroParser" do
 }
 add:
 CODE
-compiled_code = topic.parse code
-compiled_code == "++--++++"
-  end
+      compiled_code = topic.compile code
+      compiled_code.code == "++--++++"
+    end
 
     asserts("that comments are stripped") do
       code = ";this is a comment; ++--"
-      compiled_code = topic.parse code
-      compiled_code == "++--"
+      compiled_code = topic.compile code
+      compiled_code.code == "++--"
     end
   end
 
   context "File includes" do
     asserts("that other files are included") do
       code = ".include(test/test.nil)--"
-      compiled_code = topic.parse code
-      compiled_code == "++--"
+      compiled_code = topic.compile code
+      compiled_code.code == "++--"
     end
 
     asserts("that multiple files are included correctly") do
       code = ".include(test/test.nil).include(test/another.nil)--"
-      compiled_code = topic.parse code
-      compiled_code == "++>>--"
+      compiled_code = topic.compile code
+      compiled_code.code == "++>>--"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nil
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-05 00:00:00.000000000 Z
+date: 2012-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trollop
@@ -45,8 +45,8 @@ files:
 - TODO.md
 - bin/nil
 - lib/nil.rb
-- lib/nil/interpreter.rb
 - lib/nil/macro.rb
+- lib/nil/nil_commands.rb
 - lib/nil/version.rb
 - nil.gemspec
 - test/another.nil
@@ -80,3 +80,4 @@ test_files:
 - test/another.nil
 - test/nil_test.rb
 - test/test.nil
+has_rdoc: 

data/lib/nil/interpreter.rb

@@ -1,87 +0,0 @@
-module Nil
-  class Interpreter
-    attr_reader :compiled_ruby
-
-    def self.mode=(x)
-      @@mode = x
-    end
-
-    def self.mode
-      @@mode
-    end
-
-    def run
-      eval(@compiled_ruby)
-    end
-
-    def initialize
-      @@mode = 'ascii'
-    end
-
-    def handle_command(command, count)
-      case command[0]
-      when '+'
-        "stack[sp] += #{count}\n"
-      when '-'
-        "stack[sp] -= #{count}\n"
-      when '>'
-        "sp += #{count}\n"
-      when '<'
-        "sp -= #{count}\n"
-      when '['
-        s = ""
-        count.times do
-          s << "while stack[sp] != 0\n"
-        end
-        s
-      when ']'
-        s = ""
-        count.times do
-          s << "end\n"
-        end
-        s
-      when '.'
-        s = ""
-        count.times do
-          if @@mode == 'num'
-            s << "puts stack[sp]\n"
-          else
-            s << "print stack[sp].chr\n"
-          end
-        end
-        s
-      when ','
-        s = ""
-        count.times do
-          s << "stack[sp] = gets[0]\n"
-        end
-        s
-      end
-    end
-
-    def compile(code, mode)
-      @@mode = mode
-      @compiled_ruby = <<RB
-sp = 0
-stack = [0] * 10_000
-RB
-
-      code.each_char do |c|
-        if !COMMANDS.include? c
-          raise SyntaxError, "Invalid characters in code."
-        end
-      end
-
-      commands = code.scan( /((.)\2*)/ ).collect { |match| match.first }
-
-      commands.each_index do |i|
-        commands[i] = [commands[i], commands[i].length]
-      end
-
-      commands.each do |c|
-        @compiled_ruby << handle_command(c[0], c[1])
-      end
-      @compiled_ruby
-    end
-  end
-end