motherfucking debugger

bin/tvm.c

@@ -1,12 +1,18 @@
 #include <stdio.h>
 #include <terror/dbg.h>
 #include <terror/bstrlib.h>
+#include <terror/debugger.h>
 #include <terror/vm.h>
 
+int Debug;
+
 int
 main(int argc, char *argv[])
 {
   bstring filename = bfromcstr(argv[1]);
+  if(argc > 2 && strcmp(argv[2], "-d") == 0) {
+    Debug = 1;
+  }
   VM_start(filename);
   return 0;
 }

compiler/kernel/beta.rb

@@ -1,13 +1,12 @@
-# Vector#map
-VM.types[:vector].map = -> fn {
+Vector.map = -> fn {
   new = []
   each(-> element {
     new.push fn.apply(element)
   })
   new
 }
 
-VM.types[:vector].length = -> fn {
+Vector.length = -> fn {
   len = 0
   each(-> element { len += 1 })
   len

compiler/lib/terror.rb

@@ -1,6 +1,7 @@
 require "terror/version"
 require "terror/core_ext/node"
 require "terror/visitor"
+require 'pathname'
 
 module Terror
   def self.parse_file(file, verbose=false)
@@ -10,6 +11,7 @@ def self.parse_file(file, verbose=false)
     puts visitor.generator.disassemble if verbose
     # Always return nil at the end of a script
     visitor.generator.pushnil
-    puts visitor.finalize(:main)
+    puts Pathname.new(file).expand_path
+    puts visitor.finalize('0_main')
   end
 end

compiler/lib/terror/generator.rb

@@ -10,6 +10,7 @@ class Generator
     attr_accessor :children
 
     def initialize(parent=nil)
+      @current_line = -1
       @children = []
       @parent    = parent
 
@@ -40,6 +41,14 @@ def encode(name)
       output
     end
 
+    def setline(line)
+      if @current_line != line
+        @ip += 2
+        _setline line
+        @current_line = line
+      end
+    end
+
     def push(value)
       @ip += 2
       _push literal(value)
@@ -152,12 +161,15 @@ def local name
     end
 
     def literal value
+      inspect = value.is_a?(Symbol) ? value.to_s.inspect : value.inspect
       val = value.is_a?(Numeric) ? value : "\"#{value}"
 
-      @literals.index(val) or begin
+      idx = @literals.index(val) || begin
         @literals.push val
         @literals.index(val)
       end
+
+      "#{idx} #{inspect}"
     end
   end
 end

compiler/lib/terror/instructions.rb

@@ -109,6 +109,7 @@ def emit(instruction)
 
     # op :opcode, value, arity
     op :noop,      0x00, 0
+    op :setline,   0x01, 1
 
     op :pushself,  0x10, 0
     op :push,      0x11, 1

compiler/lib/terror/visitor.rb

@@ -5,57 +5,70 @@ module Terror
   class Visitor
     attr_reader :generator
 
+    attr_accessor :linenum
+
     def initialize(parent=nil)
       @generator = Generator.new(parent)
+      @linenum = 0
       @slots = {}
       @fns = []
     end
     alias_method :g, :generator
 
     def name
-      @name ||= "block_#{SecureRandom.hex}"
+      @name ||= "#{linenum}_block_#{SecureRandom.hex}"
     end
 
     def fixnum_literal(node, parent)
+      setline(node)
       g.push node.value
     end
 
     def float_literal(node, parent)
+      setline(node)
       g.push node.value
     end
 
     def local_variable_assignment(node, parent)
+      setline(node)
       node.value.lazy_visit self, node
       g.setlocal node.name
     end
 
     def local_variable_access(node, parent)
+      setline(node)
       g.pushlocal node.name
     end
 
     def block(node, parent)
+      setline(node)
       node.array.each do |expression|
         expression.lazy_visit self, node
       end
     end
 
     def nil_literal(node, parent)
+      setline(node)
       g.pushnil
     end
 
     def true_literal(node, parent)
+      setline(node)
       g.pushtrue
     end
 
     def false_literal(node, parent)
+      setline(node)
       g.pushfalse
     end
 
     def string_literal(node, parent)
+      setline(node)
       g.push node.string
     end
 
     def send(node, parent)
+      setline(node)
       if node.receiver.respond_to?(:name) && @slots[node.receiver.name] && @slots[node.receiver.name].include?(node.name)
         return slot_retrieval(node, parent)
       end
@@ -69,7 +82,9 @@ def send(node, parent)
     end
 
     def defn(block)
+      setline(block)
       visitor = Visitor.new(g)
+      visitor.linenum = block.line
       block.arguments.names.each do |arg|
         # vivify arguments as locals
         visitor.g.scope.new_local(arg)
@@ -80,6 +95,7 @@ def defn(block)
     end
 
     def send_with_arguments(node, parent)
+      setline(node)
       node.receiver.lazy_visit self, node
       argc = node.arguments.array.count
       node.arguments.lazy_visit self
@@ -88,16 +104,19 @@ def send_with_arguments(node, parent)
     end
 
     def actual_arguments(node, parent)
+      setline(node)
       node.array.each do |argument|
         argument.lazy_visit(self, parent)
       end
     end
 
     def self(node, parent)
+      setline(node)
       g.pushself
     end
 
     def if(node, parent)
+      setline(node)
       node.condition.lazy_visit(self, parent)
 
       body_val = else_val = nil
@@ -118,11 +137,13 @@ def if(node, parent)
     end
 
     def slot_retrieval(node, parent)
+      setline(node)
       node.receiver.lazy_visit self
       g.getslot node.name
     end
 
     def attribute_assignment(node, parent)
+      setline(node)
       receiver_name = if node.receiver.is_a?(Rubinius::AST::Self)
                         :self
                       else
@@ -138,6 +159,7 @@ def attribute_assignment(node, parent)
     end
 
     def constant_assignment(node, parent)
+      setline(node)
       receiver_name = :lobby
       attribute_name = node.constant.name.to_sym
       @slots[receiver_name] ||= []
@@ -149,6 +171,7 @@ def constant_assignment(node, parent)
     end
 
     def element_assignment(node, parent)
+      setline(node)
       receiver_name = if node.receiver.is_a?(Rubinius::AST::Self)
                         :self
                       else
@@ -164,17 +187,20 @@ def element_assignment(node, parent)
     end
 
     def array_literal(node, parent)
+      setline(node)
       node.body.reverse.each do |element|
         element.lazy_visit self
       end
       g.makevec node.body.count
     end
 
     def empty_array(node, parent)
+      setline(node)
       g.makevec 0
     end
 
     def hash_literal(node, parent)
+      setline(node)
       node.array.reverse.each do |element|
         element.lazy_visit self
       end
@@ -184,15 +210,18 @@ def hash_literal(node, parent)
     end
 
     def symbol_literal(node, parent)
+      setline(node)
       g.push node.value
     end
 
     def constant_access(node, parent)
+      setline(node)
       g.pushlobby
       g.getslot node.name
     end
 
     def or(node, parent)
+      setline(node)
       node.left.lazy_visit self
       node.right.lazy_visit self
       g.send_message :or, 1
@@ -203,6 +232,12 @@ def finalize(name)
       fns = @fns.map { |fn| fn.finalize(fn.name) }
       [out, fns].flatten.join("\n")
     end
+
+    private
+
+    def setline(node)
+      g.setline(node.line)
+    end
   end
 end
 

compiler/test/terror/generator_test.rb

@@ -22,6 +22,12 @@ module Terror
       end
     end
 
+    describe '#setline' do
+      it 'sets the current file line' do
+        @g.setline(3)
+      end
+    end
+
     describe '#push' do
       it 'pushes an integer literal to the stack' do
         @g.push(3)

compiler/test/terror/instructions_test.rb

@@ -23,7 +23,7 @@ module Terror
     end
 
     describe 'instructions with 1 operand' do
-      %w(push pushlocal setlocal jmp jif jit getslot setslot makevec).each do |instruction|
+      %w(setline push pushlocal setlocal jmp jif jit getslot setslot makevec).each do |instruction|
         describe instruction do
           it "#{instruction} is encoded correctly" do
             inst = @g.__send__ "_#{instruction}", 2

compiler/test/terror/visitor_test.rb

@@ -15,12 +15,14 @@ def visit(code)
 
     def compiles(code, &block)
       g = Generator.new
+      g.setline 1
       g.instance_eval(&block)
       visit(code).instructions.must_equal g.instructions
     end
 
     def compiles_block(code, &block)
       g = Generator.new
+      g.setline 1
       g.instance_eval(&block)
       visit(code).children.first.instructions.must_equal g.instructions
     end