code review 4607052: os.Error API: don't export os.ErrorString, use os.NewEr...

src/pkg/fmt/print.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package fmt
 
 import (
         "bytes"
         "io"
         "os"
         "reflect"
         "unicode"
         "utf8"
 )
 
 // Some constants in the form of bytes, to avoid string overhead.
 // Needlessly fastidious, I suppose.
 var (
         commaSpaceBytes = []byte(", ")
         nilAngleBytes   = []byte("<nil>")
         nilParenBytes   = []byte("(nil)")
         nilBytes        = []byte("nil")
         mapBytes        = []byte("map[")
         missingBytes    = []byte("(MISSING)")
+        panicBytes      = []byte("(PANIC=")
         extraBytes      = []byte("%!(EXTRA ")
         irparenBytes    = []byte("i)")
         bytesBytes      = []byte("[]byte{")
         widthBytes      = []byte("%!(BADWIDTH)")
         precBytes       = []byte("%!(BADPREC)")
         noVerbBytes     = []byte("%!(NOVERB)")
 )
 
 // State represents the printer state passed to custom formatters.
 // It provides access to the io.Writer interface plus information about
@@ skipping 27 matching lines @@
 
 // GoStringer is implemented by any value that has a GoString() method,
 // which defines the Go syntax for that value.
 // The GoString method is used to print values passed as an operand
 // to a %#v format.
 type GoStringer interface {
         GoString() string
 }
 
 type pp struct {
-        n       int
-        buf     bytes.Buffer
-        runeBuf [utf8.UTFMax]byte
-        fmt     fmt
+        n         int
+        panicking bool
+        buf       bytes.Buffer
+        runeBuf   [utf8.UTFMax]byte
+        fmt       fmt
 }
 
 // A cache holds a set of reusable objects.
 // The buffered channel holds the currently available objects.
 // If more are needed, the cache creates them by calling new.
 type cache struct {
         saved chan interface{}
         new   func() interface{}
 }
 
@@ skipping 18 matching lines @@
 
 func newCache(f func() interface{}) *cache {
         return &cache{make(chan interface{}, 100), f}
 }
 
 var ppFree = newCache(func() interface{} { return new(pp) })
 
 // Allocate a new pp struct or grab a cached one.
 func newPrinter() *pp {
         p := ppFree.get().(*pp)
+        p.panicking = false
         p.fmt.init(&p.buf)
         return p
 }
 
 // Save used pp structs in ppFree; avoids an allocation per invocation.
 func (p *pp) free() {
         // Don't hold on to pp structs with large buffers.
         if cap(p.buf.Bytes()) > 1024 {
                 return
         }
@@ skipping 435 matching lines @@
         }
 }
 
 var (
         intBits     = reflect.TypeOf(0).Bits()
         floatBits   = reflect.TypeOf(0.0).Bits()
         complexBits = reflect.TypeOf(1i).Bits()
         uintptrBits = reflect.TypeOf(uintptr(0)).Bits()
 )
 
+func (p *pp) catchPanic(val interface{}, verb int) {
+        if err := recover(); err != nil {
+                // If it's a nil pointer, just say "<nil>". The likeliest causes are a
+                // Stringer that fails to guard against nil or a nil pointer for a
+                // value receiver, and in either case, "<nil>" is a nice result.
+                if v := reflect.ValueOf(val); v.Kind() == reflect.Ptr && v.IsNil() {
+                        p.buf.Write(nilAngleBytes)
+                        return
+                }
+                // Otherwise print a concise panic message. Most of the time the panic
+                // value will print itself nicely.
+                if p.panicking {
+                        // Nested panics; the recursion in printField cannot succeed.
+                        panic(err)
+                }
+                p.buf.WriteByte('%')
+                p.add(verb)
+                p.buf.Write(panicBytes)
+                p.panicking = true
+                p.printField(err, 'v', false, false, 0)
+                p.panicking = false
+                p.buf.WriteByte(')')
+        }
+}
+
 func (p *pp) printField(field interface{}, verb int, plus, goSyntax bool, depth int) (wasString bool) {
         if field == nil {
                 if verb == 'T' || verb == 'v' {
                         p.buf.Write(nilAngleBytes)
                 } else {
                         p.badVerb(verb, field)
                 }
                 return false
         }
 
         // Special processing considerations.
         // %T (the value's type) and %p (its address) are special; we always do them first.
         switch verb {
         case 'T':
                 p.printField(reflect.TypeOf(field).String(), 's', false, false, 0)
                 return false
         case 'p':
                 p.fmtPointer(field, reflect.ValueOf(field), verb, goSyntax)
                 return false
         }
         // Is it a Formatter?
         if formatter, ok := field.(Formatter); ok {
+                defer p.catchPanic(field, verb)
                 formatter.Format(p, verb)
                 return false // this value is not a string
 
         }
         // Must not touch flags before Formatter looks at them.
         if plus {
                 p.fmt.plus = false
         }
         // If we're doing Go syntax and the field knows how to supply it, take care of it now.
         if goSyntax {
                 p.fmt.sharp = false
                 if stringer, ok := field.(GoStringer); ok {
+                        defer p.catchPanic(field, verb)
                         // Print the result of GoString unadorned.
                         p.fmtString(stringer.GoString(), 's', false, field)
                         return false // this value is not a string
                 }
         } else {
                 // Is it a Stringer?
                 if stringer, ok := field.(Stringer); ok {
+                        defer p.catchPanic(field, verb)
                         p.printField(stringer.String(), verb, plus, false, depth)
                         return false // this value is not a string
                 }
         }
 
         // Some types can be done without reflection.
         switch f := field.(type) {
         case bool:
                 p.fmtBool(f, verb, field)
                 return false
@@ skipping 336 matching lines @@
                         if addspace || !isString && !prevString {
                                 p.buf.WriteByte(' ')
                         }
                 }
                 prevString = p.printField(field, 'v', false, false, 0)
         }
         if addnewline {
                 p.buf.WriteByte('\n')
         }
 }