Make tracebacks work and show something useful

Author: ncw

main.go

@@ -65,6 +65,7 @@ func main() {
 	module := py.NewModule("__main__", "", nil, nil)
 	res, err := vm.Run(module.Globals, module.Globals, code, nil)
 	if err != nil {
+		py.TracebackDump(err)
 		log.Fatal(err)
 	}
 	fmt.Printf("Return = %v\n", res)

marshal/marshal.go

@@ -377,6 +377,7 @@ func LoadFrozenModule(name string, data []byte) *py.Module {
 	module := py.NewModule(name, "", nil, nil)
 	_, err = vm.Run(module.Globals, module.Globals, code, nil)
 	if err != nil {
+		py.TracebackDump(err)
 		panic(err)
 	}
 	return module

py/code.go

@@ -204,3 +204,19 @@ func NewCode(argcount int32, kwonlyargcount int32,
 		Weakreflist:    nil,
 	}
 }
+
+// Use co_lnotab to compute the line number from a bytecode index,
+// addrq.  See lnotab_notes.txt for the details of the lnotab
+// representation.
+func (co *Code) Addr2Line(addrq int32) int32 {
+	line := co.Firstlineno
+	addr := int32(0)
+	for i := 0; i < len(co.Lnotab); i += 2 {
+		addr += int32(co.Lnotab[i])
+		if addr > addrq {
+			break
+		}
+		line += int32(co.Lnotab[i+1])
+	}
+	return line
+}

py/exception.go

@@ -4,6 +4,7 @@ package py
 
 import (
 	"fmt"
+	"io"
 )
 
 // A python Exception object
@@ -19,9 +20,9 @@ type Exception struct {
 
 // A python exception info block
 type ExceptionInfo struct {
-	Type      Object
+	Type      *Type
 	Value     Object
-	Traceback Object
+	Traceback *Traceback
 }
 
 // Make Exception info statisfy the error interface
@@ -111,6 +112,13 @@ func (e ExceptionInfo) Error() string {
 	return e.Value.Type().Name
 }
 
+// Dump a traceback for exc to w
+func (exc *ExceptionInfo) TracebackDump(w io.Writer) {
+	fmt.Fprintf(w, "Traceback (most recent call last):\n")
+	exc.Traceback.TracebackDump(w)
+	fmt.Fprintf(w, "%v: %v\n", exc.Type.Name, exc.Value)
+}
+
 // ExceptionNew
 func ExceptionNew(metatype *Type, args Tuple, kwargs StringDict) Object {
 	if len(kwargs) != 0 {

py/traceback.go

@@ -0,0 +1,100 @@
+// Traceback objects
+
+package py
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+// A python Traceback object
+type Traceback struct {
+	Next   *Traceback
+	Frame  *Frame
+	Lasti  int32
+	Lineno int32
+}
+
+var TracebackType = NewType("traceback", "A python traceback")
+
+// Type of this object
+func (o *Traceback) Type() *Type {
+	return TracebackType
+}
+
+// Make a new traceback
+func NewTraceback(next *Traceback, frame *Frame, lasti, lineno int32) *Traceback {
+	return &Traceback{
+		Next:   next,
+		Frame:  frame,
+		Lasti:  lasti,
+		Lineno: lineno,
+	}
+}
+
+/*
+Traceback (most recent call last):
+  File "throws.py", line 8, in <module>
+    main()
+  File "throws.py", line 5, in main
+    throws()
+  File "throws.py", line 2, in throws
+    raise RuntimeError('this is the error message')
+RuntimeError: this is the error message
+*/
+
+// Dump a traceback for tb to w
+func (tb *Traceback) TracebackDump(w io.Writer) {
+	for ; tb != nil; tb = tb.Next {
+		fmt.Fprintf(w, "  File %q, line %d, in %s\n", tb.Frame.Code.Filename, tb.Lineno, tb.Frame.Code.Name)
+		fmt.Fprintf(w, "    %s\n", "FIXME line of source goes here")
+	}
+}
+
+// Dumps a traceback to stderr
+func TracebackDump(err interface{}) {
+	switch e := err.(type) {
+	case ExceptionInfo:
+		e.TracebackDump(os.Stderr)
+	case *ExceptionInfo:
+		e.TracebackDump(os.Stderr)
+	case *Exception:
+		fmt.Fprintf(os.Stderr, "Exception %#v\n", e)
+		fmt.Fprintf(os.Stderr, "-- No traceback available --\n")
+	default:
+		fmt.Fprintf(os.Stderr, "Error %#v\n", err)
+		fmt.Fprintf(os.Stderr, "-- No traceback available --\n")
+	}
+}
+
+// Properties
+func init() {
+	TracebackType.Dict["__tb_next__"] = &Property{
+		Fget: func(self Object) Object {
+			next := self.(*Traceback).Next
+			if next == nil {
+				return None
+			}
+			return next
+		},
+	}
+	TracebackType.Dict["__tb_frame__"] = &Property{
+		Fget: func(self Object) Object {
+			return self.(*Traceback).Frame
+		},
+	}
+	TracebackType.Dict["__tb_lasti__"] = &Property{
+		Fget: func(self Object) Object {
+			return Int(self.(*Traceback).Lasti)
+		},
+	}
+	TracebackType.Dict["__tb_lineno__"] = &Property{
+		Fget: func(self Object) Object {
+			return Int(self.(*Traceback).Lineno)
+		},
+	}
+}
+
+// Make sure it satisfies the interface
+var _ Object = (*Traceback)(nil)

vm/eval.go

@@ -71,6 +71,16 @@ func (vm *Vm) PUSH(obj py.Object) {
 	vm.frame.Stack = append(vm.frame.Stack, obj)
 }
 
+// Adds a traceback to the exc passed in for the current vm state
+func (vm *Vm) AddTraceback(exc *py.ExceptionInfo) {
+	exc.Traceback = &py.Traceback{
+		Next:   exc.Traceback,
+		Frame:  vm.frame,
+		Lasti:  vm.frame.Lasti,
+		Lineno: vm.frame.Code.Addr2Line(vm.frame.Lasti),
+	}
+}
+
 // Set an exception in the VM
 //
 // The exception must be a valid exception instance (eg as returned by
@@ -81,7 +91,8 @@ func (vm *Vm) SetException(exception py.Object) {
 	vm.old_exc = vm.exc
 	vm.exc.Value = exception
 	vm.exc.Type = exception.Type()
-	vm.exc.Traceback = py.None // FIXME start the traceback
+	vm.exc.Traceback = nil
+	vm.AddTraceback(&vm.exc)
 	vm.exit = exitException
 }
 
@@ -93,6 +104,7 @@ func (vm *Vm) CheckExceptionRecover(r interface{}) {
 	if exc, ok := r.(py.ExceptionInfo); ok {
 		vm.old_exc = vm.exc
 		vm.exc = exc
+		vm.AddTraceback(&vm.exc)
 		vm.exit = exitException
 		fmt.Printf("*** Propagating exception: %s\n", exc.Error())
 	} else {
@@ -636,9 +648,9 @@ func do_END_FINALLY(vm *Vm, arg int32) {
 		w := vm.POP()
 		u := vm.POP()
 		// FIXME PyErr_Restore(v, w, u)
-		vm.exc.Type = v
+		vm.exc.Type = v.(*py.Type)
 		vm.exc.Value = w
-		vm.exc.Traceback = u
+		vm.exc.Traceback = u.(*py.Traceback)
 		vm.exit = exitReraise
 	} else if v != py.None {
 		vm.SetException(py.ExceptionNewf(py.SystemError, "'finally' pops bad exception %#v", v))
@@ -1315,9 +1327,9 @@ func (vm *Vm) UnwindExceptHandler(frame *py.Frame, block *py.TryBlock) {
 	} else {
 		frame.Stack = frame.Stack[:block.Level+3]
 	}
-	vm.exc.Type = vm.POP()
+	vm.exc.Type = vm.POP().(*py.Type)
 	vm.exc.Value = vm.POP()
-	vm.exc.Traceback = vm.POP()
+	vm.exc.Traceback = vm.POP().(*py.Traceback)
 }
 
 // Run the virtual machine on a Frame object
@@ -1405,21 +1417,16 @@ func RunFrame(frame *py.Frame) (res py.Object, err error) {
 			}
 			if vm.exit&(exitException|exitReraise) != 0 && (b.Type == SETUP_EXCEPT || b.Type == SETUP_FINALLY) {
 				fmt.Printf("*** Exception\n")
-				var exc, val, tb py.Object
 				handler := b.Handler
 				// This invalidates b
 				frame.PushBlock(EXCEPT_HANDLER, -1, vm.STACK_LEVEL())
 				vm.PUSH(vm.old_exc.Traceback)
 				vm.PUSH(vm.old_exc.Value)
-				if vm.old_exc.Type != nil {
-					vm.PUSH(vm.exc.Type)
-				} else {
-					vm.PUSH(py.None)
-				}
+				vm.PUSH(vm.exc.Type) // can be nil
 				// FIXME PyErr_Fetch(&exc, &val, &tb)
-				exc = vm.exc.Type
-				val = vm.exc.Value
-				tb = vm.exc.Traceback
+				exc := vm.exc.Type
+				val := vm.exc.Value
+				tb := vm.exc.Traceback
 				// Make the raw exception data
 				// available to the handler,
 				// so a program can emulate the
@@ -1429,9 +1436,6 @@ func RunFrame(frame *py.Frame) (res py.Object, err error) {
 				vm.exc.Type = exc
 				vm.exc.Value = val
 				vm.exc.Traceback = tb
-				if tb == nil {
-					tb = py.None
-				}
 				vm.PUSH(tb)
 				vm.PUSH(val)
 				vm.PUSH(exc)