vendor/github.com/davecgh/go-spew/spew/common.go

   1 /*
   2  * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 package spew
  18
  19 import (
  20         "bytes"
  21         "fmt"
  22         "io"
  23         "reflect"
  24         "sort"
  25         "strconv"
  26 )
  27
  28 // Some constants in the form of bytes to avoid string overhead.  This mirrors
  29 // the technique used in the fmt package.
  30 var (
  31         panicBytes            = []byte("(PANIC=")
  32         plusBytes             = []byte("+")
  33         iBytes                = []byte("i")
  34         trueBytes             = []byte("true")
  35         falseBytes            = []byte("false")
  36         interfaceBytes        = []byte("(interface {})")
  37         commaNewlineBytes     = []byte(",\n")
  38         newlineBytes          = []byte("\n")
  39         openBraceBytes        = []byte("{")
  40         openBraceNewlineBytes = []byte("{\n")
  41         closeBraceBytes       = []byte("}")
  42         asteriskBytes         = []byte("*")
  43         colonBytes            = []byte(":")
  44         colonSpaceBytes       = []byte(": ")
  45         openParenBytes        = []byte("(")
  46         closeParenBytes       = []byte(")")
  47         spaceBytes            = []byte(" ")
  48         pointerChainBytes     = []byte("->")
  49         nilAngleBytes         = []byte("<nil>")
  50         maxNewlineBytes       = []byte("<max depth reached>\n")
  51         maxShortBytes         = []byte("<max>")
  52         circularBytes         = []byte("<already shown>")
  53         circularShortBytes    = []byte("<shown>")
  54         invalidAngleBytes     = []byte("<invalid>")
  55         openBracketBytes      = []byte("[")
  56         closeBracketBytes     = []byte("]")
  57         percentBytes          = []byte("%")
  58         precisionBytes        = []byte(".")
  59         openAngleBytes        = []byte("<")
  60         closeAngleBytes       = []byte(">")
  61         openMapBytes          = []byte("map[")
  62         closeMapBytes         = []byte("]")
  63         lenEqualsBytes        = []byte("len=")
  64         capEqualsBytes        = []byte("cap=")
  65 )
  66
  67 // hexDigits is used to map a decimal value to a hex digit.
  68 var hexDigits = "0123456789abcdef"
  69
  70 // catchPanic handles any panics that might occur during the handleMethods
  71 // calls.
  72 func catchPanic(w io.Writer, v reflect.Value) {
  73         if err := recover(); err != nil {
  74                 w.Write(panicBytes)
  75                 fmt.Fprintf(w, "%v", err)
  76                 w.Write(closeParenBytes)
  77         }
  78 }
  79
  80 // handleMethods attempts to call the Error and String methods on the underlying
  81 // type the passed reflect.Value represents and outputes the result to Writer w.
  82 //
  83 // It handles panics in any called methods by catching and displaying the error
  84 // as the formatted value.
  85 func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {
  86         // We need an interface to check if the type implements the error or
  87         // Stringer interface.  However, the reflect package won't give us an
  88         // interface on certain things like unexported struct fields in order
  89         // to enforce visibility rules.  We use unsafe, when it's available,
  90         // to bypass these restrictions since this package does not mutate the
  91         // values.
  92         if !v.CanInterface() {
  93                 if UnsafeDisabled {
  94                         return false
  95                 }
  96
  97                 v = unsafeReflectValue(v)
  98         }
  99
 100         // Choose whether or not to do error and Stringer interface lookups against
 101         // the base type or a pointer to the base type depending on settings.
 102         // Technically calling one of these methods with a pointer receiver can
 103         // mutate the value, however, types which choose to satisify an error or
 104         // Stringer interface with a pointer receiver should not be mutating their
 105         // state inside these interface methods.
 106         if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
 107                 v = unsafeReflectValue(v)
 108         }
 109         if v.CanAddr() {
 110                 v = v.Addr()
 111         }
 112
 113         // Is it an error or Stringer?
 114         switch iface := v.Interface().(type) {
 115         case error:
 116                 defer catchPanic(w, v)
 117                 if cs.ContinueOnMethod {
 118                         w.Write(openParenBytes)
 119                         w.Write([]byte(iface.Error()))
 120                         w.Write(closeParenBytes)
 121                         w.Write(spaceBytes)
 122                         return false
 123                 }
 124
 125                 w.Write([]byte(iface.Error()))
 126                 return true
 127
 128         case fmt.Stringer:
 129                 defer catchPanic(w, v)
 130                 if cs.ContinueOnMethod {
 131                         w.Write(openParenBytes)
 132                         w.Write([]byte(iface.String()))
 133                         w.Write(closeParenBytes)
 134                         w.Write(spaceBytes)
 135                         return false
 136                 }
 137                 w.Write([]byte(iface.String()))
 138                 return true
 139         }
 140         return false
 141 }
 142
 143 // printBool outputs a boolean value as true or false to Writer w.
 144 func printBool(w io.Writer, val bool) {
 145         if val {
 146                 w.Write(trueBytes)
 147         } else {
 148                 w.Write(falseBytes)
 149         }
 150 }
 151
 152 // printInt outputs a signed integer value to Writer w.
 153 func printInt(w io.Writer, val int64, base int) {
 154         w.Write([]byte(strconv.FormatInt(val, base)))
 155 }
 156
 157 // printUint outputs an unsigned integer value to Writer w.
 158 func printUint(w io.Writer, val uint64, base int) {
 159         w.Write([]byte(strconv.FormatUint(val, base)))
 160 }
 161
 162 // printFloat outputs a floating point value using the specified precision,
 163 // which is expected to be 32 or 64bit, to Writer w.
 164 func printFloat(w io.Writer, val float64, precision int) {
 165         w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
 166 }
 167
 168 // printComplex outputs a complex value using the specified float precision
 169 // for the real and imaginary parts to Writer w.
 170 func printComplex(w io.Writer, c complex128, floatPrecision int) {
 171         r := real(c)
 172         w.Write(openParenBytes)
 173         w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
 174         i := imag(c)
 175         if i >= 0 {
 176                 w.Write(plusBytes)
 177         }
 178         w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
 179         w.Write(iBytes)
 180         w.Write(closeParenBytes)
 181 }
 182
 183 // printHexPtr outputs a uintptr formatted as hexidecimal with a leading '0x'
 184 // prefix to Writer w.
 185 func printHexPtr(w io.Writer, p uintptr) {
 186         // Null pointer.
 187         num := uint64(p)
 188         if num == 0 {
 189                 w.Write(nilAngleBytes)
 190                 return
 191         }
 192
 193         // Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
 194         buf := make([]byte, 18)
 195
 196         // It's simpler to construct the hex string right to left.
 197         base := uint64(16)
 198         i := len(buf) - 1
 199         for num >= base {
 200                 buf[i] = hexDigits[num%base]
 201                 num /= base
 202                 i--
 203         }
 204         buf[i] = hexDigits[num]
 205
 206         // Add '0x' prefix.
 207         i--
 208         buf[i] = 'x'
 209         i--
 210         buf[i] = '0'
 211
 212         // Strip unused leading bytes.
 213         buf = buf[i:]
 214         w.Write(buf)
 215 }
 216
 217 // valuesSorter implements sort.Interface to allow a slice of reflect.Value
 218 // elements to be sorted.
 219 type valuesSorter struct {
 220         values  []reflect.Value
 221         strings []string // either nil or same len and values
 222         cs      *ConfigState
 223 }
 224
 225 // newValuesSorter initializes a valuesSorter instance, which holds a set of
 226 // surrogate keys on which the data should be sorted.  It uses flags in
 227 // ConfigState to decide if and how to populate those surrogate keys.
 228 func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {
 229         vs := &valuesSorter{values: values, cs: cs}
 230         if canSortSimply(vs.values[0].Kind()) {
 231                 return vs
 232         }
 233         if !cs.DisableMethods {
 234                 vs.strings = make([]string, len(values))
 235                 for i := range vs.values {
 236                         b := bytes.Buffer{}
 237                         if !handleMethods(cs, &b, vs.values[i]) {
 238                                 vs.strings = nil
 239                                 break
 240                         }
 241                         vs.strings[i] = b.String()
 242                 }
 243         }
 244         if vs.strings == nil && cs.SpewKeys {
 245                 vs.strings = make([]string, len(values))
 246                 for i := range vs.values {
 247                         vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())
 248                 }
 249         }
 250         return vs
 251 }
 252
 253 // canSortSimply tests whether a reflect.Kind is a primitive that can be sorted
 254 // directly, or whether it should be considered for sorting by surrogate keys
 255 // (if the ConfigState allows it).
 256 func canSortSimply(kind reflect.Kind) bool {
 257         // This switch parallels valueSortLess, except for the default case.
 258         switch kind {
 259         case reflect.Bool:
 260                 return true
 261         case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
 262                 return true
 263         case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
 264                 return true
 265         case reflect.Float32, reflect.Float64:
 266                 return true
 267         case reflect.String:
 268                 return true
 269         case reflect.Uintptr:
 270                 return true
 271         case reflect.Array:
 272                 return true
 273         }
 274         return false
 275 }
 276
 277 // Len returns the number of values in the slice.  It is part of the
 278 // sort.Interface implementation.
 279 func (s *valuesSorter) Len() int {
 280         return len(s.values)
 281 }
 282
 283 // Swap swaps the values at the passed indices.  It is part of the
 284 // sort.Interface implementation.
 285 func (s *valuesSorter) Swap(i, j int) {
 286         s.values[i], s.values[j] = s.values[j], s.values[i]
 287         if s.strings != nil {
 288                 s.strings[i], s.strings[j] = s.strings[j], s.strings[i]
 289         }
 290 }
 291
 292 // valueSortLess returns whether the first value should sort before the second
 293 // value.  It is used by valueSorter.Less as part of the sort.Interface
 294 // implementation.
 295 func valueSortLess(a, b reflect.Value) bool {
 296         switch a.Kind() {
 297         case reflect.Bool:
 298                 return !a.Bool() && b.Bool()
 299         case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
 300                 return a.Int() < b.Int()
 301         case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
 302                 return a.Uint() < b.Uint()
 303         case reflect.Float32, reflect.Float64:
 304                 return a.Float() < b.Float()
 305         case reflect.String:
 306                 return a.String() < b.String()
 307         case reflect.Uintptr:
 308                 return a.Uint() < b.Uint()
 309         case reflect.Array:
 310                 // Compare the contents of both arrays.
 311                 l := a.Len()
 312                 for i := 0; i < l; i++ {
 313                         av := a.Index(i)
 314                         bv := b.Index(i)
 315                         if av.Interface() == bv.Interface() {
 316                                 continue
 317                         }
 318                         return valueSortLess(av, bv)
 319                 }
 320         }
 321         return a.String() < b.String()
 322 }
 323
 324 // Less returns whether the value at index i should sort before the
 325 // value at index j.  It is part of the sort.Interface implementation.
 326 func (s *valuesSorter) Less(i, j int) bool {
 327         if s.strings == nil {
 328                 return valueSortLess(s.values[i], s.values[j])
 329         }
 330         return s.strings[i] < s.strings[j]
 331 }
 332
 333 // sortValues is a sort function that handles both native types and any type that
 334 // can be converted to error or Stringer.  Other inputs are sorted according to
 335 // their Value.String() value to ensure display stability.
 336 func sortValues(values []reflect.Value, cs *ConfigState) {
 337         if len(values) == 0 {
 338                 return
 339         }
 340         sort.Sort(newValuesSorter(values, cs))
 341 }