141 строка
2,9 КиБ
Go
141 строка
2,9 КиБ
Go
package godog
|
|
|
|
import (
|
|
"fmt"
|
|
"go/build"
|
|
"io"
|
|
"path"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
)
|
|
|
|
// Frame represents a program counter inside a stack frame.
|
|
type stackFrame uintptr
|
|
|
|
// pc returns the program counter for this frame;
|
|
// multiple frames may have the same PC value.
|
|
func (f stackFrame) 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 stackFrame) file() string {
|
|
fn := runtime.FuncForPC(f.pc())
|
|
if fn == nil {
|
|
return "unknown"
|
|
}
|
|
file, _ := fn.FileLine(f.pc())
|
|
return file
|
|
}
|
|
|
|
func trimGoPath(file string) string {
|
|
for _, p := range filepath.SplitList(build.Default.GOPATH) {
|
|
file = strings.Replace(file, filepath.Join(p, "src")+string(filepath.Separator), "", 1)
|
|
}
|
|
return file
|
|
}
|
|
|
|
// line returns the line number of source code of the
|
|
// function for this Frame's pc.
|
|
func (f stackFrame) line() int {
|
|
fn := runtime.FuncForPC(f.pc())
|
|
if fn == nil {
|
|
return 0
|
|
}
|
|
_, line := fn.FileLine(f.pc())
|
|
return line
|
|
}
|
|
|
|
// Format formats the frame according to the fmt.Formatter interface.
|
|
//
|
|
// %s source file
|
|
// %d source line
|
|
// %n function name
|
|
// %v equivalent to %s:%d
|
|
//
|
|
// Format accepts flags that alter the printing of some verbs, as follows:
|
|
//
|
|
// %+s path of source file relative to the compile time GOPATH
|
|
// %+v equivalent to %+s:%d
|
|
func (f stackFrame) Format(s fmt.State, verb rune) {
|
|
funcname := func(name string) string {
|
|
i := strings.LastIndex(name, "/")
|
|
name = name[i+1:]
|
|
i = strings.Index(name, ".")
|
|
return name[i+1:]
|
|
}
|
|
|
|
switch verb {
|
|
case 's':
|
|
switch {
|
|
case s.Flag('+'):
|
|
pc := f.pc()
|
|
fn := runtime.FuncForPC(pc)
|
|
if fn == nil {
|
|
io.WriteString(s, "unknown")
|
|
} else {
|
|
file, _ := fn.FileLine(pc)
|
|
fmt.Fprintf(s, "%s\n\t%s", fn.Name(), trimGoPath(file))
|
|
}
|
|
default:
|
|
io.WriteString(s, path.Base(f.file()))
|
|
}
|
|
case 'd':
|
|
fmt.Fprintf(s, "%d", f.line())
|
|
case 'n':
|
|
name := runtime.FuncForPC(f.pc()).Name()
|
|
io.WriteString(s, funcname(name))
|
|
case 'v':
|
|
f.Format(s, 's')
|
|
io.WriteString(s, ":")
|
|
f.Format(s, 'd')
|
|
}
|
|
}
|
|
|
|
// stack represents a stack of program counters.
|
|
type stack []uintptr
|
|
|
|
func (s *stack) Format(st fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
switch {
|
|
case st.Flag('+'):
|
|
for _, pc := range *s {
|
|
f := stackFrame(pc)
|
|
fmt.Fprintf(st, "\n%+v", f)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func callStack() *stack {
|
|
const depth = 32
|
|
var pcs [depth]uintptr
|
|
n := runtime.Callers(3, pcs[:])
|
|
var st stack = pcs[0:n]
|
|
return &st
|
|
}
|
|
|
|
// fundamental is an error that has a message and a stack, but no caller.
|
|
type traceError struct {
|
|
msg string
|
|
*stack
|
|
}
|
|
|
|
func (f *traceError) Error() string { return f.msg }
|
|
|
|
func (f *traceError) Format(s fmt.State, verb rune) {
|
|
switch verb {
|
|
case 'v':
|
|
if s.Flag('+') {
|
|
io.WriteString(s, f.msg)
|
|
f.stack.Format(s, verb)
|
|
return
|
|
}
|
|
fallthrough
|
|
case 's':
|
|
io.WriteString(s, f.msg)
|
|
case 'q':
|
|
fmt.Fprintf(s, "%q", f.msg)
|
|
}
|
|
}
|