Merge pull request #2 from romanyx/feature/improve

Use uintptr instead of runtime.Frame

Author: romanyx

error.go

@@ -5,13 +5,6 @@ import (
 	"runtime"
 )
 
-const defaultStackCap = 20
-
-type withStack struct {
-	origin error
-	stack  []runtime.Frame
-}
-
 func (e *withStack) Error() string {
 	return e.origin.Error()
 }
@@ -21,48 +14,88 @@ func (e *withStack) Unwrap() error {
 }
 
 func (e *withStack) StackTrace() []runtime.Frame {
-	return e.stack
+	return e.stack.StackTrace()
 }
 
-func trace(err error, offset int) *withStack {
-	e := withStack{
-		origin: err,
-		stack:  make([]runtime.Frame, 0, defaultStackCap),
-	}
+type withStack struct {
+	origin error
+	*stack
+}
 
-	for {
-		if f, ok := getFrame(offset); ok {
-			e.stack = append(e.stack, f)
-			offset++
-			continue
-		}
+// frame represents a program counter inside a stack frame.
+// For historical reasons if Frame is interpreted as a uintptr
+// its value represents the program counter + 1.
+type frame uintptr
 
-		break
+// pc returns the program counter for this frame;
+// multiple frames may have the same PC value.
+func (f frame) pc() uintptr { return uintptr(f) - 1 }
+
+// file returns the full path to the file that contains the
+// function for this Frame's pc.
+func (f frame) file() string {
+	fn := runtime.FuncForPC(f.pc())
+	if fn == nil {
+		return "unknown"
 	}
+	file, _ := fn.FileLine(f.pc())
+	return file
+}
 
-	return &e
+// line returns the line number of source code of the
+// function for this Frame's pc.
+func (f frame) line() int {
+	fn := runtime.FuncForPC(f.pc())
+	if fn == nil {
+		return 0
+	}
+	_, line := fn.FileLine(f.pc())
+	return line
 }
 
-func getFrame(caller int) (runtime.Frame, bool) {
-	pc, file, line, ok := runtime.Caller(caller)
-	if !ok {
-		return runtime.Frame{}, false
+// name returns the name of this function, if known.
+func (f frame) name() string {
+	fn := runtime.FuncForPC(f.pc())
+	if fn == nil {
+		return "unknown"
 	}
+	return fn.Name()
+}
 
-	f := runtime.Frame{
-		PC:   pc,
-		File: file,
-		Line: line,
+func (f frame) runtime() runtime.Frame {
+	rf := runtime.Frame{
+		PC:   f.pc(),
+		File: f.file(),
+		Line: f.line(),
 	}
 
-	fn := runtime.FuncForPC(pc)
+	fn := runtime.FuncForPC(f.pc())
 	if fn == nil {
-		return f, true
+		return rf
 	}
 
-	f.Func = fn
-	f.Function = fn.Name()
-	f.Entry = fn.Entry()
+	rf.Func = fn
+	rf.Function = fn.Name()
+	rf.Entry = fn.Entry()
+
+	return rf
+}
+
+// stack represents a stack of program counters.
+type stack []uintptr
+
+func (s *stack) StackTrace() []runtime.Frame {
+	f := make([]runtime.Frame, len(*s))
+	for i := 0; i < len(f); i++ {
+		f[i] = frame((*s)[i]).runtime()
+	}
+	return f
+}
 
-	return f, true
+func callers() *stack {
+	const depth = 32
+	var pcs [depth]uintptr
+	n := runtime.Callers(3, pcs[:])
+	var st stack = pcs[0:n]
+	return &st
 }

stack.go

@@ -7,12 +7,13 @@ import (
 	"strconv"
 )
 
-const offset = 3
-
 // Errorf saves stack trace and pass arguments to
 // fmt.Errorf.
 func Errorf(format string, a ...interface{}) error {
-	return trace(fmt.Errorf(format, a...), offset)
+	return &withStack{
+		fmt.Errorf(format, a...),
+		callers(),
+	}
 }
 
 // Origin returns unwrapped origin of the error.
@@ -32,7 +33,7 @@ func Origin(err error) error {
 
 // Trace returns stack trace for error.
 func Trace(err error) []runtime.Frame {
-	stack := make([]runtime.Frame, 0, defaultStackCap)
+	stack := make([]runtime.Frame, 0, 30)
 
 	for {
 		if err == nil {