mirror of
https://github.com/golang/go
synced 2024-10-05 00:21:21 -06:00
a627d61d5d
that pad() still counts bytes, but it's currently only used for 1 byte runes. Fixes #612. R=r CC=golang-dev https://golang.org/cl/217064
996 lines
24 KiB
Go
996 lines
24 KiB
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 implements formatted I/O with functions analogous
|
|
to C's printf. The format 'verbs' are derived from C's but
|
|
are simpler.
|
|
|
|
The verbs:
|
|
|
|
General:
|
|
%v the value in a default format.
|
|
when printing structs, the plus flag (%+v) adds field names
|
|
%#v a Go-syntax representation of the value
|
|
%T a Go-syntax representation of the type of the value
|
|
|
|
Boolean:
|
|
%t the word true or false
|
|
Integer:
|
|
%b base 2
|
|
%c the character represented by the corresponding Unicode code point
|
|
%d base 10
|
|
%o base 8
|
|
%x base 16, with lower-case letters for a-f
|
|
%X base 16, with upper-case letters for A-F
|
|
Floating-point:
|
|
%e scientific notation, e.g. -1234.456e+78
|
|
%E scientific notation, e.g. -1234.456E+78
|
|
%f decimal point but no exponent, e.g. 123.456
|
|
%g whichever of %e or %f produces more compact output
|
|
%G whichever of %E or %f produces more compact output
|
|
String and slice of bytes:
|
|
%s the uninterpreted bytes of the string or slice
|
|
%q a double-quoted string safely escaped with Go syntax
|
|
%x base 16 notation with two characters per byte
|
|
Pointer:
|
|
%p base 16 notation, with leading 0x
|
|
|
|
There is no 'u' flag. Integers are printed unsigned if they have unsigned type.
|
|
Similarly, there is no need to specify the size of the operand (int8, int64).
|
|
|
|
For numeric values, the width and precision flags control
|
|
formatting; width sets the width of the field, precision the
|
|
number of places after the decimal, if appropriate. The
|
|
format %6.2f prints 123.45. The width of a field is the number
|
|
of Unicode code points in the string. This differs from C's printf where
|
|
the field width is the number of bytes.
|
|
|
|
Other flags:
|
|
+ always print a sign for numeric values
|
|
- pad with spaces on the right rather than the left (left-justify the field)
|
|
# alternate format: add leading 0 for octal (%#o), 0x for hex (%#x);
|
|
suppress 0x for %p (%#p);
|
|
print a raw (backquoted) string if possible for %q (%#q)
|
|
' ' (space) leave a space for elided sign in numbers (% d);
|
|
put spaces between bytes printing strings or slices in hex (% x)
|
|
0 pad with leading zeros rather than spaces
|
|
|
|
For each Printf-like function, there is also a Print function
|
|
that takes no format and is equivalent to saying %v for every
|
|
operand. Another variant Println inserts blanks between
|
|
operands and appends a newline.
|
|
|
|
Regardless of the verb, if an operand is an interface value,
|
|
the internal concrete value is used, not the interface itself.
|
|
Thus:
|
|
var i interface{} = 23;
|
|
fmt.Printf("%v\n", i);
|
|
will print 23.
|
|
|
|
If an operand implements interface Formatter, that interface
|
|
can be used for fine control of formatting.
|
|
|
|
If an operand implements method String() string that method
|
|
will be used for %v, %s, or Print etc.
|
|
*/
|
|
package fmt
|
|
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"os"
|
|
"reflect"
|
|
"utf8"
|
|
)
|
|
|
|
// Some constants in the form of bytes, to avoid string overhead.
|
|
// Needlessly fastidious, I suppose.
|
|
var (
|
|
trueBytes = []byte("true")
|
|
falseBytes = []byte("false")
|
|
commaSpaceBytes = []byte(", ")
|
|
nilAngleBytes = []byte("<nil>")
|
|
nilParenBytes = []byte("(nil)")
|
|
nilBytes = []byte("nil")
|
|
mapBytes = []byte("map[")
|
|
missingBytes = []byte("missing")
|
|
extraBytes = []byte("?(extra ")
|
|
)
|
|
|
|
// State represents the printer state passed to custom formatters.
|
|
// It provides access to the io.Writer interface plus information about
|
|
// the flags and options for the operand's format specifier.
|
|
type State interface {
|
|
// Write is the function to call to emit formatted output to be printed.
|
|
Write(b []byte) (ret int, err os.Error)
|
|
// Width returns the value of the width option and whether it has been set.
|
|
Width() (wid int, ok bool)
|
|
// Precision returns the value of the precision option and whether it has been set.
|
|
Precision() (prec int, ok bool)
|
|
|
|
// Flag returns whether the flag c, a character, has been set.
|
|
Flag(int) bool
|
|
}
|
|
|
|
// Formatter is the interface implemented by values with a custom formatter.
|
|
// The implementation of Format may call Sprintf or Fprintf(f) etc.
|
|
// to generate its output.
|
|
type Formatter interface {
|
|
Format(f State, c int)
|
|
}
|
|
|
|
// Stringer is implemented by any value that has a String method(),
|
|
// which defines the ``native'' format for that value.
|
|
// The String method is used to print values passed as an operand
|
|
// to a %s or %v format or to an unformatted printer such as Print.
|
|
type Stringer interface {
|
|
String() string
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// getter is implemented by any value that has a Get() method,
|
|
// which means the object contains a pointer. Used by %p.
|
|
type getter interface {
|
|
Get() uintptr
|
|
}
|
|
|
|
const allocSize = 32
|
|
|
|
type pp struct {
|
|
n int
|
|
buf bytes.Buffer
|
|
runeBuf [utf8.UTFMax]byte
|
|
fmt fmt
|
|
}
|
|
|
|
// A leaky bucket of reusable pp structures.
|
|
var ppFree = make(chan *pp, 100)
|
|
|
|
// Allocate a new pp struct. Probably can grab the previous one from ppFree.
|
|
func newPrinter() *pp {
|
|
p, ok := <-ppFree
|
|
if !ok {
|
|
p = new(pp)
|
|
}
|
|
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
|
|
}
|
|
p.buf.Reset()
|
|
_ = ppFree <- p
|
|
}
|
|
|
|
func (p *pp) Width() (wid int, ok bool) { return p.fmt.wid, p.fmt.widPresent }
|
|
|
|
func (p *pp) Precision() (prec int, ok bool) { return p.fmt.prec, p.fmt.precPresent }
|
|
|
|
func (p *pp) Flag(b int) bool {
|
|
switch b {
|
|
case '-':
|
|
return p.fmt.minus
|
|
case '+':
|
|
return p.fmt.plus
|
|
case '#':
|
|
return p.fmt.sharp
|
|
case ' ':
|
|
return p.fmt.space
|
|
case '0':
|
|
return p.fmt.zero
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (p *pp) add(c int) {
|
|
if c < utf8.RuneSelf {
|
|
p.buf.WriteByte(byte(c))
|
|
} else {
|
|
w := utf8.EncodeRune(c, &p.runeBuf)
|
|
p.buf.Write(p.runeBuf[0:w])
|
|
}
|
|
}
|
|
|
|
// Implement Write so we can call Fprintf on a pp (through State), for
|
|
// recursive use in custom verbs.
|
|
func (p *pp) Write(b []byte) (ret int, err os.Error) {
|
|
return p.buf.Write(b)
|
|
}
|
|
|
|
// These routines end in 'f' and take a format string.
|
|
|
|
// Fprintf formats according to a format specifier and writes to w.
|
|
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, error os.Error) {
|
|
p := newPrinter()
|
|
p.doprintf(format, a)
|
|
n64, error := p.buf.WriteTo(w)
|
|
p.free()
|
|
return int(n64), error
|
|
}
|
|
|
|
// Printf formats according to a format specifier and writes to standard output.
|
|
func Printf(format string, a ...interface{}) (n int, errno os.Error) {
|
|
n, errno = Fprintf(os.Stdout, format, a)
|
|
return n, errno
|
|
}
|
|
|
|
// Sprintf formats according to a format specifier and returns the resulting string.
|
|
func Sprintf(format string, a ...interface{}) string {
|
|
p := newPrinter()
|
|
p.doprintf(format, a)
|
|
s := p.buf.String()
|
|
p.free()
|
|
return s
|
|
}
|
|
|
|
// These routines do not take a format string
|
|
|
|
// Fprint formats using the default formats for its operands and writes to w.
|
|
// Spaces are added between operands when neither is a string.
|
|
func Fprint(w io.Writer, a ...interface{}) (n int, error os.Error) {
|
|
p := newPrinter()
|
|
p.doprint(a, false, false)
|
|
n64, error := p.buf.WriteTo(w)
|
|
p.free()
|
|
return int(n64), error
|
|
}
|
|
|
|
// Print formats using the default formats for its operands and writes to standard output.
|
|
// Spaces are added between operands when neither is a string.
|
|
func Print(a ...interface{}) (n int, errno os.Error) {
|
|
n, errno = Fprint(os.Stdout, a)
|
|
return n, errno
|
|
}
|
|
|
|
// Sprint formats using the default formats for its operands and returns the resulting string.
|
|
// Spaces are added between operands when neither is a string.
|
|
func Sprint(a ...interface{}) string {
|
|
p := newPrinter()
|
|
p.doprint(a, false, false)
|
|
s := p.buf.String()
|
|
p.free()
|
|
return s
|
|
}
|
|
|
|
// These routines end in 'ln', do not take a format string,
|
|
// always add spaces between operands, and add a newline
|
|
// after the last operand.
|
|
|
|
// Fprintln formats using the default formats for its operands and writes to w.
|
|
// Spaces are always added between operands and a newline is appended.
|
|
func Fprintln(w io.Writer, a ...interface{}) (n int, error os.Error) {
|
|
p := newPrinter()
|
|
p.doprint(a, true, true)
|
|
n64, error := p.buf.WriteTo(w)
|
|
p.free()
|
|
return int(n64), error
|
|
}
|
|
|
|
// Println formats using the default formats for its operands and writes to standard output.
|
|
// Spaces are always added between operands and a newline is appended.
|
|
func Println(a ...interface{}) (n int, errno os.Error) {
|
|
n, errno = Fprintln(os.Stdout, a)
|
|
return n, errno
|
|
}
|
|
|
|
// Sprintln formats using the default formats for its operands and returns the resulting string.
|
|
// Spaces are always added between operands and a newline is appended.
|
|
func Sprintln(a ...interface{}) string {
|
|
p := newPrinter()
|
|
p.doprint(a, true, true)
|
|
s := p.buf.String()
|
|
p.free()
|
|
return s
|
|
}
|
|
|
|
|
|
// Get the i'th arg of the struct value.
|
|
// If the arg itself is an interface, return a value for
|
|
// the thing inside the interface, not the interface itself.
|
|
func getField(v *reflect.StructValue, i int) reflect.Value {
|
|
val := v.Field(i)
|
|
if i, ok := val.(*reflect.InterfaceValue); ok {
|
|
if inter := i.Interface(); inter != nil {
|
|
return reflect.NewValue(inter)
|
|
}
|
|
}
|
|
return val
|
|
}
|
|
|
|
// Getters for the fields of the argument structure.
|
|
|
|
func getBool(a interface{}) (val bool, ok bool) {
|
|
// Is it a regular bool type?
|
|
if b, ok := a.(bool); ok {
|
|
return b, true
|
|
}
|
|
// Must be a renamed bool type.
|
|
if b, ok := reflect.NewValue(a).(*reflect.BoolValue); ok {
|
|
return b.Get(), true
|
|
}
|
|
return
|
|
}
|
|
|
|
func getInt(a interface{}) (val int64, signed, ok bool) {
|
|
// Is it a predeclared integer type?
|
|
switch i := a.(type) {
|
|
case int:
|
|
return int64(i), true, true
|
|
case int8:
|
|
return int64(i), true, true
|
|
case int16:
|
|
return int64(i), true, true
|
|
case int32:
|
|
return int64(i), true, true
|
|
case int64:
|
|
return i, true, true
|
|
case uint:
|
|
return int64(i), false, true
|
|
case uint8:
|
|
return int64(i), false, true
|
|
case uint16:
|
|
return int64(i), false, true
|
|
case uint32:
|
|
return int64(i), false, true
|
|
case uint64:
|
|
return int64(i), false, true
|
|
case uintptr:
|
|
return int64(i), false, true
|
|
}
|
|
// Must be a renamed integer type.
|
|
switch i := reflect.NewValue(a).(type) {
|
|
case *reflect.IntValue:
|
|
return int64(i.Get()), true, true
|
|
case *reflect.Int8Value:
|
|
return int64(i.Get()), true, true
|
|
case *reflect.Int16Value:
|
|
return int64(i.Get()), true, true
|
|
case *reflect.Int32Value:
|
|
return int64(i.Get()), true, true
|
|
case *reflect.Int64Value:
|
|
return i.Get(), true, true
|
|
case *reflect.UintValue:
|
|
return int64(i.Get()), false, true
|
|
case *reflect.Uint8Value:
|
|
return int64(i.Get()), false, true
|
|
case *reflect.Uint16Value:
|
|
return int64(i.Get()), false, true
|
|
case *reflect.Uint32Value:
|
|
return int64(i.Get()), false, true
|
|
case *reflect.Uint64Value:
|
|
return int64(i.Get()), false, true
|
|
case *reflect.UintptrValue:
|
|
return int64(i.Get()), false, true
|
|
}
|
|
return
|
|
}
|
|
|
|
func getString(a interface{}) (val string, ok bool) {
|
|
if a == nil {
|
|
return "<nil>", ok
|
|
}
|
|
// Is it a regular string or []byte type?
|
|
switch s := a.(type) {
|
|
case string:
|
|
return s, true
|
|
case []byte:
|
|
return string(s), true
|
|
}
|
|
// Must be a renamed string or []byte type.
|
|
v := reflect.NewValue(a)
|
|
if s, ok := v.(*reflect.StringValue); ok {
|
|
return s.Get(), true
|
|
}
|
|
if bytes, ok := v.Interface().([]byte); ok {
|
|
return string(bytes), true
|
|
}
|
|
return
|
|
}
|
|
|
|
var floatBits = reflect.Typeof(float(0)).Size() * 8
|
|
|
|
func getFloat32(a interface{}) (val float32, ok bool) {
|
|
// Is it a regular floating-point type?
|
|
switch f := a.(type) {
|
|
case float32:
|
|
return f, true
|
|
case float:
|
|
if floatBits == 32 {
|
|
return float32(f), true
|
|
}
|
|
}
|
|
// Must be a renamed floating-point type.
|
|
switch f := reflect.NewValue(a).(type) {
|
|
case *reflect.Float32Value:
|
|
return float32(f.Get()), true
|
|
case *reflect.FloatValue:
|
|
if floatBits == 32 {
|
|
return float32(f.Get()), true
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func getFloat64(a interface{}) (val float64, ok bool) {
|
|
// Is it a regular floating-point type?
|
|
switch f := a.(type) {
|
|
case float64:
|
|
return f, true
|
|
case float:
|
|
if floatBits == 64 {
|
|
return float64(f), true
|
|
}
|
|
}
|
|
// Must be a renamed floating-point type.
|
|
switch f := reflect.NewValue(a).(type) {
|
|
case *reflect.Float64Value:
|
|
return float64(f.Get()), true
|
|
case *reflect.FloatValue:
|
|
if floatBits == 64 {
|
|
return float64(f.Get()), true
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// Convert ASCII to integer. n is 0 (and got is false) if no number present.
|
|
|
|
func parsenum(s string, start, end int) (n int, got bool, newi int) {
|
|
if start >= end {
|
|
return 0, false, end
|
|
}
|
|
isnum := false
|
|
num := 0
|
|
for '0' <= s[start] && s[start] <= '9' {
|
|
num = num*10 + int(s[start]-'0')
|
|
start++
|
|
isnum = true
|
|
}
|
|
return num, isnum, start
|
|
}
|
|
|
|
type uintptrGetter interface {
|
|
Get() uintptr
|
|
}
|
|
|
|
func (p *pp) unknownType(v interface{}) {
|
|
if v == nil {
|
|
p.buf.Write(nilAngleBytes)
|
|
return
|
|
}
|
|
p.buf.WriteByte('?')
|
|
p.buf.WriteString(reflect.Typeof(v).String())
|
|
p.buf.WriteByte('?')
|
|
}
|
|
|
|
func (p *pp) printField(field interface{}, plus, sharp bool, depth int) (was_string bool) {
|
|
if field != nil && depth >= 0 {
|
|
switch {
|
|
default:
|
|
if stringer, ok := field.(Stringer); ok {
|
|
p.buf.WriteString(stringer.String())
|
|
return false // this value is not a string
|
|
}
|
|
case sharp:
|
|
if stringer, ok := field.(GoStringer); ok {
|
|
p.buf.WriteString(stringer.GoString())
|
|
return false // this value is not a string
|
|
}
|
|
}
|
|
}
|
|
|
|
// Some types can be done without reflection.
|
|
switch f := field.(type) {
|
|
case bool:
|
|
p.fmt.fmt_boolean(f)
|
|
return false
|
|
case float32:
|
|
p.fmt.fmt_g32(f)
|
|
return false
|
|
case float64:
|
|
p.fmt.fmt_g64(f)
|
|
return false
|
|
case float:
|
|
if floatBits == 32 {
|
|
p.fmt.fmt_g32(float32(f))
|
|
} else {
|
|
p.fmt.fmt_g64(float64(f))
|
|
}
|
|
return false
|
|
case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr:
|
|
v, signed, ok := getInt(field)
|
|
if !ok {
|
|
// cannot happen, but print something to be sure
|
|
p.unknownType(f)
|
|
} else {
|
|
if signed {
|
|
p.fmt.fmt_d64(v)
|
|
} else {
|
|
if sharp {
|
|
p.fmt.sharp = true // turn on 0x
|
|
p.fmt.fmt_ux64(uint64(v))
|
|
} else {
|
|
p.fmt.fmt_ud64(uint64(v))
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
case string:
|
|
if sharp {
|
|
p.fmt.fmt_q(f)
|
|
} else {
|
|
p.fmt.fmt_s(f)
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Need to use reflection
|
|
BigSwitch:
|
|
switch f := reflect.NewValue(field).(type) {
|
|
case *reflect.BoolValue:
|
|
p.fmt.fmt_boolean(f.Get())
|
|
case *reflect.Float32Value:
|
|
p.fmt.fmt_g32(f.Get())
|
|
case *reflect.Float64Value:
|
|
p.fmt.fmt_g64(f.Get())
|
|
case *reflect.FloatValue:
|
|
if floatBits == 32 {
|
|
p.fmt.fmt_g32(float32(f.Get()))
|
|
} else {
|
|
p.fmt.fmt_g64(float64(f.Get()))
|
|
}
|
|
case *reflect.StringValue:
|
|
if sharp {
|
|
p.fmt.fmt_q(f.Get())
|
|
} else {
|
|
p.fmt.fmt_s(f.Get())
|
|
was_string = true
|
|
}
|
|
case *reflect.MapValue:
|
|
if sharp {
|
|
p.buf.WriteString(f.Type().String())
|
|
p.buf.WriteByte('{')
|
|
} else {
|
|
p.buf.Write(mapBytes)
|
|
}
|
|
keys := f.Keys()
|
|
for i, key := range keys {
|
|
if i > 0 {
|
|
if sharp {
|
|
p.buf.Write(commaSpaceBytes)
|
|
} else {
|
|
p.buf.WriteByte(' ')
|
|
}
|
|
}
|
|
p.printField(key.Interface(), plus, sharp, depth+1)
|
|
p.buf.WriteByte(':')
|
|
p.printField(f.Elem(key).Interface(), plus, sharp, depth+1)
|
|
}
|
|
if sharp {
|
|
p.buf.WriteByte('}')
|
|
} else {
|
|
p.buf.WriteByte(']')
|
|
}
|
|
case *reflect.StructValue:
|
|
if sharp {
|
|
p.buf.WriteString(reflect.Typeof(field).String())
|
|
}
|
|
p.add('{')
|
|
v := f
|
|
t := v.Type().(*reflect.StructType)
|
|
p.fmt.clearflags() // clear flags for p.printField
|
|
for i := 0; i < v.NumField(); i++ {
|
|
if i > 0 {
|
|
if sharp {
|
|
p.buf.Write(commaSpaceBytes)
|
|
} else {
|
|
p.buf.WriteByte(' ')
|
|
}
|
|
}
|
|
if plus || sharp {
|
|
if f := t.Field(i); f.Name != "" {
|
|
p.buf.WriteString(f.Name)
|
|
p.buf.WriteByte(':')
|
|
}
|
|
}
|
|
p.printField(getField(v, i).Interface(), plus, sharp, depth+1)
|
|
}
|
|
p.buf.WriteByte('}')
|
|
case *reflect.InterfaceValue:
|
|
value := f.Elem()
|
|
if value == nil {
|
|
if sharp {
|
|
p.buf.WriteString(reflect.Typeof(field).String())
|
|
p.buf.Write(nilParenBytes)
|
|
} else {
|
|
p.buf.Write(nilAngleBytes)
|
|
}
|
|
} else {
|
|
return p.printField(value.Interface(), plus, sharp, depth+1)
|
|
}
|
|
case reflect.ArrayOrSliceValue:
|
|
if sharp {
|
|
p.buf.WriteString(reflect.Typeof(field).String())
|
|
p.buf.WriteByte('{')
|
|
} else {
|
|
p.buf.WriteByte('[')
|
|
}
|
|
for i := 0; i < f.Len(); i++ {
|
|
if i > 0 {
|
|
if sharp {
|
|
p.buf.Write(commaSpaceBytes)
|
|
} else {
|
|
p.buf.WriteByte(' ')
|
|
}
|
|
}
|
|
p.printField(f.Elem(i).Interface(), plus, sharp, depth+1)
|
|
}
|
|
if sharp {
|
|
p.buf.WriteByte('}')
|
|
} else {
|
|
p.buf.WriteByte(']')
|
|
}
|
|
case *reflect.PtrValue:
|
|
v := f.Get()
|
|
// pointer to array or slice or struct? ok at top level
|
|
// but not embedded (avoid loops)
|
|
if v != 0 && depth == 0 {
|
|
switch a := f.Elem().(type) {
|
|
case reflect.ArrayOrSliceValue:
|
|
p.buf.WriteByte('&')
|
|
p.printField(a.Interface(), plus, sharp, depth+1)
|
|
break BigSwitch
|
|
case *reflect.StructValue:
|
|
p.buf.WriteByte('&')
|
|
p.printField(a.Interface(), plus, sharp, depth+1)
|
|
break BigSwitch
|
|
}
|
|
}
|
|
if sharp {
|
|
p.buf.WriteByte('(')
|
|
p.buf.WriteString(reflect.Typeof(field).String())
|
|
p.buf.WriteByte(')')
|
|
p.buf.WriteByte('(')
|
|
if v == 0 {
|
|
p.buf.Write(nilBytes)
|
|
} else {
|
|
p.fmt.sharp = true
|
|
p.fmt.fmt_ux64(uint64(v))
|
|
}
|
|
p.buf.WriteByte(')')
|
|
break
|
|
}
|
|
if v == 0 {
|
|
p.buf.Write(nilAngleBytes)
|
|
break
|
|
}
|
|
p.fmt.sharp = true // turn 0x on
|
|
p.fmt.fmt_ux64(uint64(v))
|
|
case uintptrGetter:
|
|
v := f.Get()
|
|
if sharp {
|
|
p.buf.WriteByte('(')
|
|
p.buf.WriteString(reflect.Typeof(field).String())
|
|
p.buf.WriteByte(')')
|
|
p.buf.WriteByte('(')
|
|
if v == 0 {
|
|
p.buf.Write(nilBytes)
|
|
} else {
|
|
p.fmt.sharp = true
|
|
p.fmt.fmt_ux64(uint64(v))
|
|
}
|
|
p.buf.WriteByte(')')
|
|
} else {
|
|
p.fmt.sharp = true // turn 0x on
|
|
p.fmt.fmt_ux64(uint64(f.Get()))
|
|
}
|
|
default:
|
|
v, signed, ok := getInt(field)
|
|
if ok {
|
|
if signed {
|
|
p.fmt.fmt_d64(v)
|
|
} else {
|
|
if sharp {
|
|
p.fmt.sharp = true // turn on 0x
|
|
p.fmt.fmt_ux64(uint64(v))
|
|
} else {
|
|
p.fmt.fmt_ud64(uint64(v))
|
|
}
|
|
}
|
|
break
|
|
}
|
|
p.unknownType(f)
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (p *pp) doprintf(format string, a []interface{}) {
|
|
end := len(format) - 1
|
|
fieldnum := 0 // we process one field per non-trivial format
|
|
for i := 0; i <= end; {
|
|
c, w := utf8.DecodeRuneInString(format[i:])
|
|
if c != '%' || i == end {
|
|
if w == 1 {
|
|
p.buf.WriteByte(byte(c))
|
|
} else {
|
|
p.buf.WriteString(format[i : i+w])
|
|
}
|
|
i += w
|
|
continue
|
|
}
|
|
i++
|
|
// flags and widths
|
|
p.fmt.clearflags()
|
|
F: for ; i < end; i++ {
|
|
switch format[i] {
|
|
case '#':
|
|
p.fmt.sharp = true
|
|
case '0':
|
|
p.fmt.zero = true
|
|
case '+':
|
|
p.fmt.plus = true
|
|
case '-':
|
|
p.fmt.minus = true
|
|
case ' ':
|
|
p.fmt.space = true
|
|
default:
|
|
break F
|
|
}
|
|
}
|
|
// do we have 20 (width)?
|
|
p.fmt.wid, p.fmt.widPresent, i = parsenum(format, i, end)
|
|
// do we have .20 (precision)?
|
|
if i < end && format[i] == '.' {
|
|
p.fmt.prec, p.fmt.precPresent, i = parsenum(format, i+1, end)
|
|
}
|
|
c, w = utf8.DecodeRuneInString(format[i:])
|
|
i += w
|
|
// percent is special - absorbs no operand
|
|
if c == '%' {
|
|
p.buf.WriteByte('%') // TODO: should we bother with width & prec?
|
|
continue
|
|
}
|
|
if fieldnum >= len(a) { // out of operands
|
|
p.buf.WriteByte('%')
|
|
p.add(c)
|
|
p.buf.Write(missingBytes)
|
|
continue
|
|
}
|
|
field := a[fieldnum]
|
|
fieldnum++
|
|
|
|
// Try formatter except for %T,
|
|
// which is special and handled internally.
|
|
if field != nil && c != 'T' {
|
|
if formatter, ok := field.(Formatter); ok {
|
|
formatter.Format(p, c)
|
|
continue
|
|
}
|
|
}
|
|
|
|
switch c {
|
|
// bool
|
|
case 't':
|
|
if v, ok := getBool(field); ok {
|
|
if v {
|
|
p.buf.Write(trueBytes)
|
|
} else {
|
|
p.buf.Write(falseBytes)
|
|
}
|
|
} else {
|
|
goto badtype
|
|
}
|
|
|
|
// int
|
|
case 'b':
|
|
if v, _, ok := getInt(field); ok {
|
|
p.fmt.fmt_b64(uint64(v)) // always unsigned
|
|
} else if v, ok := getFloat32(field); ok {
|
|
p.fmt.fmt_fb32(v)
|
|
} else if v, ok := getFloat64(field); ok {
|
|
p.fmt.fmt_fb64(v)
|
|
} else {
|
|
goto badtype
|
|
}
|
|
case 'c':
|
|
if v, _, ok := getInt(field); ok {
|
|
p.fmt.fmt_c(int(v))
|
|
} else {
|
|
goto badtype
|
|
}
|
|
case 'd':
|
|
if v, signed, ok := getInt(field); ok {
|
|
if signed {
|
|
p.fmt.fmt_d64(v)
|
|
} else {
|
|
p.fmt.fmt_ud64(uint64(v))
|
|
}
|
|
} else {
|
|
goto badtype
|
|
}
|
|
case 'o':
|
|
if v, signed, ok := getInt(field); ok {
|
|
if signed {
|
|
p.fmt.fmt_o64(v)
|
|
} else {
|
|
p.fmt.fmt_uo64(uint64(v))
|
|
}
|
|
} else {
|
|
goto badtype
|
|
}
|
|
case 'x':
|
|
if v, signed, ok := getInt(field); ok {
|
|
if signed {
|
|
p.fmt.fmt_x64(v)
|
|
} else {
|
|
p.fmt.fmt_ux64(uint64(v))
|
|
}
|
|
} else if v, ok := getString(field); ok {
|
|
p.fmt.fmt_sx(v)
|
|
} else {
|
|
goto badtype
|
|
}
|
|
case 'X':
|
|
if v, signed, ok := getInt(field); ok {
|
|
if signed {
|
|
p.fmt.fmt_X64(v)
|
|
} else {
|
|
p.fmt.fmt_uX64(uint64(v))
|
|
}
|
|
} else if v, ok := getString(field); ok {
|
|
p.fmt.fmt_sX(v)
|
|
} else {
|
|
goto badtype
|
|
}
|
|
|
|
// float
|
|
case 'e':
|
|
if v, ok := getFloat32(field); ok {
|
|
p.fmt.fmt_e32(v)
|
|
} else if v, ok := getFloat64(field); ok {
|
|
p.fmt.fmt_e64(v)
|
|
} else {
|
|
goto badtype
|
|
}
|
|
case 'E':
|
|
if v, ok := getFloat32(field); ok {
|
|
p.fmt.fmt_E32(v)
|
|
} else if v, ok := getFloat64(field); ok {
|
|
p.fmt.fmt_E64(v)
|
|
} else {
|
|
goto badtype
|
|
}
|
|
case 'f':
|
|
if v, ok := getFloat32(field); ok {
|
|
p.fmt.fmt_f32(v)
|
|
} else if v, ok := getFloat64(field); ok {
|
|
p.fmt.fmt_f64(v)
|
|
} else {
|
|
goto badtype
|
|
}
|
|
case 'g':
|
|
if v, ok := getFloat32(field); ok {
|
|
p.fmt.fmt_g32(v)
|
|
} else if v, ok := getFloat64(field); ok {
|
|
p.fmt.fmt_g64(v)
|
|
} else {
|
|
goto badtype
|
|
}
|
|
case 'G':
|
|
if v, ok := getFloat32(field); ok {
|
|
p.fmt.fmt_G32(v)
|
|
} else if v, ok := getFloat64(field); ok {
|
|
p.fmt.fmt_G64(v)
|
|
} else {
|
|
goto badtype
|
|
}
|
|
|
|
// string
|
|
case 's':
|
|
if field != nil {
|
|
// if object implements String, use the result.
|
|
if stringer, ok := field.(Stringer); ok {
|
|
p.fmt.fmt_s(stringer.String())
|
|
break
|
|
}
|
|
}
|
|
if v, ok := getString(field); ok {
|
|
p.fmt.fmt_s(v)
|
|
} else {
|
|
goto badtype
|
|
}
|
|
case 'q':
|
|
if field != nil {
|
|
// if object implements String, use the result.
|
|
if stringer, ok := field.(Stringer); ok {
|
|
p.fmt.fmt_q(stringer.String())
|
|
break
|
|
}
|
|
}
|
|
if v, ok := getString(field); ok {
|
|
p.fmt.fmt_q(v)
|
|
} else {
|
|
goto badtype
|
|
}
|
|
|
|
// pointer, including addresses of reference types.
|
|
case 'p':
|
|
switch v := reflect.NewValue(field).(type) {
|
|
case getter:
|
|
p.fmt.fmt_s("0x")
|
|
p.fmt.fmt_uX64(uint64(v.Get()))
|
|
default:
|
|
goto badtype
|
|
}
|
|
|
|
// arbitrary value; do your best
|
|
case 'v':
|
|
plus, sharp := p.fmt.plus, p.fmt.sharp
|
|
p.fmt.plus = false
|
|
p.fmt.sharp = false
|
|
p.printField(field, plus, sharp, 0)
|
|
|
|
// the value's type
|
|
case 'T':
|
|
p.buf.WriteString(reflect.Typeof(field).String())
|
|
|
|
default:
|
|
badtype:
|
|
p.buf.WriteByte('%')
|
|
p.add(c)
|
|
p.buf.WriteByte('(')
|
|
if field != nil {
|
|
p.buf.WriteString(reflect.Typeof(field).String())
|
|
p.buf.WriteByte('=')
|
|
}
|
|
p.printField(field, false, false, -1)
|
|
p.buf.WriteByte(')')
|
|
}
|
|
}
|
|
if fieldnum < len(a) {
|
|
p.buf.Write(extraBytes)
|
|
for ; fieldnum < len(a); fieldnum++ {
|
|
field := a[fieldnum]
|
|
p.buf.WriteString(reflect.Typeof(field).String())
|
|
p.buf.WriteByte('=')
|
|
p.printField(field, false, false, 0)
|
|
if fieldnum+1 < len(a) {
|
|
p.buf.Write(commaSpaceBytes)
|
|
}
|
|
}
|
|
p.buf.WriteByte(')')
|
|
}
|
|
}
|
|
|
|
func (p *pp) doprint(a []interface{}, addspace, addnewline bool) {
|
|
prev_string := false
|
|
for fieldnum := 0; fieldnum < len(a); fieldnum++ {
|
|
// always add spaces if we're doing println
|
|
field := a[fieldnum]
|
|
if fieldnum > 0 {
|
|
_, is_string := field.(*reflect.StringValue)
|
|
if addspace || !is_string && !prev_string {
|
|
p.buf.WriteByte(' ')
|
|
}
|
|
}
|
|
prev_string = p.printField(field, false, false, 0)
|
|
}
|
|
if addnewline {
|
|
p.buf.WriteByte('\n')
|
|
}
|
|
}
|