...
Run Format

Source file src/fmt/print.go

     1	// Copyright 2009 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package fmt
     6	
     7	import (
     8		"errors"
     9		"io"
    10		"os"
    11		"reflect"
    12		"sync"
    13		"unicode/utf8"
    14	)
    15	
    16	// Some constants in the form of bytes, to avoid string overhead.
    17	// Needlessly fastidious, I suppose.
    18	var (
    19		commaSpaceBytes  = []byte(", ")
    20		nilAngleBytes    = []byte("<nil>")
    21		nilParenBytes    = []byte("(nil)")
    22		nilBytes         = []byte("nil")
    23		mapBytes         = []byte("map[")
    24		percentBangBytes = []byte("%!")
    25		missingBytes     = []byte("(MISSING)")
    26		badIndexBytes    = []byte("(BADINDEX)")
    27		panicBytes       = []byte("(PANIC=")
    28		extraBytes       = []byte("%!(EXTRA ")
    29		irparenBytes     = []byte("i)")
    30		bytesBytes       = []byte("[]byte{")
    31		badWidthBytes    = []byte("%!(BADWIDTH)")
    32		badPrecBytes     = []byte("%!(BADPREC)")
    33		noVerbBytes      = []byte("%!(NOVERB)")
    34	)
    35	
    36	// State represents the printer state passed to custom formatters.
    37	// It provides access to the io.Writer interface plus information about
    38	// the flags and options for the operand's format specifier.
    39	type State interface {
    40		// Write is the function to call to emit formatted output to be printed.
    41		Write(b []byte) (ret int, err error)
    42		// Width returns the value of the width option and whether it has been set.
    43		Width() (wid int, ok bool)
    44		// Precision returns the value of the precision option and whether it has been set.
    45		Precision() (prec int, ok bool)
    46	
    47		// Flag reports whether the flag c, a character, has been set.
    48		Flag(c int) bool
    49	}
    50	
    51	// Formatter is the interface implemented by values with a custom formatter.
    52	// The implementation of Format may call Sprint(f) or Fprint(f) etc.
    53	// to generate its output.
    54	type Formatter interface {
    55		Format(f State, c rune)
    56	}
    57	
    58	// Stringer is implemented by any value that has a String method,
    59	// which defines the ``native'' format for that value.
    60	// The String method is used to print values passed as an operand
    61	// to any format that accepts a string or to an unformatted printer
    62	// such as Print.
    63	type Stringer interface {
    64		String() string
    65	}
    66	
    67	// GoStringer is implemented by any value that has a GoString method,
    68	// which defines the Go syntax for that value.
    69	// The GoString method is used to print values passed as an operand
    70	// to a %#v format.
    71	type GoStringer interface {
    72		GoString() string
    73	}
    74	
    75	// Use simple []byte instead of bytes.Buffer to avoid large dependency.
    76	type buffer []byte
    77	
    78	func (b *buffer) Write(p []byte) (n int, err error) {
    79		*b = append(*b, p...)
    80		return len(p), nil
    81	}
    82	
    83	func (b *buffer) WriteString(s string) (n int, err error) {
    84		*b = append(*b, s...)
    85		return len(s), nil
    86	}
    87	
    88	func (b *buffer) WriteByte(c byte) error {
    89		*b = append(*b, c)
    90		return nil
    91	}
    92	
    93	func (bp *buffer) WriteRune(r rune) error {
    94		if r < utf8.RuneSelf {
    95			*bp = append(*bp, byte(r))
    96			return nil
    97		}
    98	
    99		b := *bp
   100		n := len(b)
   101		for n+utf8.UTFMax > cap(b) {
   102			b = append(b, 0)
   103		}
   104		w := utf8.EncodeRune(b[n:n+utf8.UTFMax], r)
   105		*bp = b[:n+w]
   106		return nil
   107	}
   108	
   109	type pp struct {
   110		n         int
   111		panicking bool
   112		erroring  bool // printing an error condition
   113		buf       buffer
   114		// arg holds the current item, as an interface{}.
   115		arg interface{}
   116		// value holds the current item, as a reflect.Value, and will be
   117		// the zero Value if the item has not been reflected.
   118		value reflect.Value
   119		// reordered records whether the format string used argument reordering.
   120		reordered bool
   121		// goodArgNum records whether the most recent reordering directive was valid.
   122		goodArgNum bool
   123		runeBuf    [utf8.UTFMax]byte
   124		fmt        fmt
   125	}
   126	
   127	var ppFree = sync.Pool{
   128		New: func() interface{} { return new(pp) },
   129	}
   130	
   131	// newPrinter allocates a new pp struct or grabs a cached one.
   132	func newPrinter() *pp {
   133		p := ppFree.Get().(*pp)
   134		p.panicking = false
   135		p.erroring = false
   136		p.fmt.init(&p.buf)
   137		return p
   138	}
   139	
   140	// free saves used pp structs in ppFree; avoids an allocation per invocation.
   141	func (p *pp) free() {
   142		// Don't hold on to pp structs with large buffers.
   143		if cap(p.buf) > 1024 {
   144			return
   145		}
   146		p.buf = p.buf[:0]
   147		p.arg = nil
   148		p.value = reflect.Value{}
   149		ppFree.Put(p)
   150	}
   151	
   152	func (p *pp) Width() (wid int, ok bool) { return p.fmt.wid, p.fmt.widPresent }
   153	
   154	func (p *pp) Precision() (prec int, ok bool) { return p.fmt.prec, p.fmt.precPresent }
   155	
   156	func (p *pp) Flag(b int) bool {
   157		switch b {
   158		case '-':
   159			return p.fmt.minus
   160		case '+':
   161			return p.fmt.plus
   162		case '#':
   163			return p.fmt.sharp
   164		case ' ':
   165			return p.fmt.space
   166		case '0':
   167			return p.fmt.zero
   168		}
   169		return false
   170	}
   171	
   172	func (p *pp) add(c rune) {
   173		p.buf.WriteRune(c)
   174	}
   175	
   176	// Implement Write so we can call Fprintf on a pp (through State), for
   177	// recursive use in custom verbs.
   178	func (p *pp) Write(b []byte) (ret int, err error) {
   179		return p.buf.Write(b)
   180	}
   181	
   182	// These routines end in 'f' and take a format string.
   183	
   184	// Fprintf formats according to a format specifier and writes to w.
   185	// It returns the number of bytes written and any write error encountered.
   186	func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
   187		p := newPrinter()
   188		p.doPrintf(format, a)
   189		n, err = w.Write(p.buf)
   190		p.free()
   191		return
   192	}
   193	
   194	// Printf formats according to a format specifier and writes to standard output.
   195	// It returns the number of bytes written and any write error encountered.
   196	func Printf(format string, a ...interface{}) (n int, err error) {
   197		return Fprintf(os.Stdout, format, a...)
   198	}
   199	
   200	// Sprintf formats according to a format specifier and returns the resulting string.
   201	func Sprintf(format string, a ...interface{}) string {
   202		p := newPrinter()
   203		p.doPrintf(format, a)
   204		s := string(p.buf)
   205		p.free()
   206		return s
   207	}
   208	
   209	// Errorf formats according to a format specifier and returns the string
   210	// as a value that satisfies error.
   211	func Errorf(format string, a ...interface{}) error {
   212		return errors.New(Sprintf(format, a...))
   213	}
   214	
   215	// These routines do not take a format string
   216	
   217	// Fprint formats using the default formats for its operands and writes to w.
   218	// Spaces are added between operands when neither is a string.
   219	// It returns the number of bytes written and any write error encountered.
   220	func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
   221		p := newPrinter()
   222		p.doPrint(a, false, false)
   223		n, err = w.Write(p.buf)
   224		p.free()
   225		return
   226	}
   227	
   228	// Print formats using the default formats for its operands and writes to standard output.
   229	// Spaces are added between operands when neither is a string.
   230	// It returns the number of bytes written and any write error encountered.
   231	func Print(a ...interface{}) (n int, err error) {
   232		return Fprint(os.Stdout, a...)
   233	}
   234	
   235	// Sprint formats using the default formats for its operands and returns the resulting string.
   236	// Spaces are added between operands when neither is a string.
   237	func Sprint(a ...interface{}) string {
   238		p := newPrinter()
   239		p.doPrint(a, false, false)
   240		s := string(p.buf)
   241		p.free()
   242		return s
   243	}
   244	
   245	// These routines end in 'ln', do not take a format string,
   246	// always add spaces between operands, and add a newline
   247	// after the last operand.
   248	
   249	// Fprintln formats using the default formats for its operands and writes to w.
   250	// Spaces are always added between operands and a newline is appended.
   251	// It returns the number of bytes written and any write error encountered.
   252	func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
   253		p := newPrinter()
   254		p.doPrint(a, true, true)
   255		n, err = w.Write(p.buf)
   256		p.free()
   257		return
   258	}
   259	
   260	// Println formats using the default formats for its operands and writes to standard output.
   261	// Spaces are always added between operands and a newline is appended.
   262	// It returns the number of bytes written and any write error encountered.
   263	func Println(a ...interface{}) (n int, err error) {
   264		return Fprintln(os.Stdout, a...)
   265	}
   266	
   267	// Sprintln formats using the default formats for its operands and returns the resulting string.
   268	// Spaces are always added between operands and a newline is appended.
   269	func Sprintln(a ...interface{}) string {
   270		p := newPrinter()
   271		p.doPrint(a, true, true)
   272		s := string(p.buf)
   273		p.free()
   274		return s
   275	}
   276	
   277	// getField gets the i'th field of the struct value.
   278	// If the field is itself is an interface, return a value for
   279	// the thing inside the interface, not the interface itself.
   280	func getField(v reflect.Value, i int) reflect.Value {
   281		val := v.Field(i)
   282		if val.Kind() == reflect.Interface && !val.IsNil() {
   283			val = val.Elem()
   284		}
   285		return val
   286	}
   287	
   288	// parsenum converts ASCII to integer.  num is 0 (and isnum is false) if no number present.
   289	func parsenum(s string, start, end int) (num int, isnum bool, newi int) {
   290		if start >= end {
   291			return 0, false, end
   292		}
   293		for newi = start; newi < end && '0' <= s[newi] && s[newi] <= '9'; newi++ {
   294			num = num*10 + int(s[newi]-'0')
   295			isnum = true
   296		}
   297		return
   298	}
   299	
   300	func (p *pp) unknownType(v reflect.Value) {
   301		if !v.IsValid() {
   302			p.buf.Write(nilAngleBytes)
   303			return
   304		}
   305		p.buf.WriteByte('?')
   306		p.buf.WriteString(v.Type().String())
   307		p.buf.WriteByte('?')
   308	}
   309	
   310	func (p *pp) badVerb(verb rune) {
   311		p.erroring = true
   312		p.add('%')
   313		p.add('!')
   314		p.add(verb)
   315		p.add('(')
   316		switch {
   317		case p.arg != nil:
   318			p.buf.WriteString(reflect.TypeOf(p.arg).String())
   319			p.add('=')
   320			p.printArg(p.arg, 'v', 0)
   321		case p.value.IsValid():
   322			p.buf.WriteString(p.value.Type().String())
   323			p.add('=')
   324			p.printValue(p.value, 'v', 0)
   325		default:
   326			p.buf.Write(nilAngleBytes)
   327		}
   328		p.add(')')
   329		p.erroring = false
   330	}
   331	
   332	func (p *pp) fmtBool(v bool, verb rune) {
   333		switch verb {
   334		case 't', 'v':
   335			p.fmt.fmt_boolean(v)
   336		default:
   337			p.badVerb(verb)
   338		}
   339	}
   340	
   341	// fmtC formats a rune for the 'c' format.
   342	func (p *pp) fmtC(c int64) {
   343		r := rune(c) // Check for overflow.
   344		if int64(r) != c {
   345			r = utf8.RuneError
   346		}
   347		w := utf8.EncodeRune(p.runeBuf[0:utf8.UTFMax], r)
   348		p.fmt.pad(p.runeBuf[0:w])
   349	}
   350	
   351	func (p *pp) fmtInt64(v int64, verb rune) {
   352		switch verb {
   353		case 'b':
   354			p.fmt.integer(v, 2, signed, ldigits)
   355		case 'c':
   356			p.fmtC(v)
   357		case 'd', 'v':
   358			p.fmt.integer(v, 10, signed, ldigits)
   359		case 'o':
   360			p.fmt.integer(v, 8, signed, ldigits)
   361		case 'q':
   362			if 0 <= v && v <= utf8.MaxRune {
   363				p.fmt.fmt_qc(v)
   364			} else {
   365				p.badVerb(verb)
   366			}
   367		case 'x':
   368			p.fmt.integer(v, 16, signed, ldigits)
   369		case 'U':
   370			p.fmtUnicode(v)
   371		case 'X':
   372			p.fmt.integer(v, 16, signed, udigits)
   373		default:
   374			p.badVerb(verb)
   375		}
   376	}
   377	
   378	// fmt0x64 formats a uint64 in hexadecimal and prefixes it with 0x or
   379	// not, as requested, by temporarily setting the sharp flag.
   380	func (p *pp) fmt0x64(v uint64, leading0x bool) {
   381		sharp := p.fmt.sharp
   382		p.fmt.sharp = leading0x
   383		p.fmt.integer(int64(v), 16, unsigned, ldigits)
   384		p.fmt.sharp = sharp
   385	}
   386	
   387	// fmtUnicode formats a uint64 in U+1234 form by
   388	// temporarily turning on the unicode flag and tweaking the precision.
   389	func (p *pp) fmtUnicode(v int64) {
   390		precPresent := p.fmt.precPresent
   391		sharp := p.fmt.sharp
   392		p.fmt.sharp = false
   393		prec := p.fmt.prec
   394		if !precPresent {
   395			// If prec is already set, leave it alone; otherwise 4 is minimum.
   396			p.fmt.prec = 4
   397			p.fmt.precPresent = true
   398		}
   399		p.fmt.unicode = true // turn on U+
   400		p.fmt.uniQuote = sharp
   401		p.fmt.integer(int64(v), 16, unsigned, udigits)
   402		p.fmt.unicode = false
   403		p.fmt.uniQuote = false
   404		p.fmt.prec = prec
   405		p.fmt.precPresent = precPresent
   406		p.fmt.sharp = sharp
   407	}
   408	
   409	func (p *pp) fmtUint64(v uint64, verb rune) {
   410		switch verb {
   411		case 'b':
   412			p.fmt.integer(int64(v), 2, unsigned, ldigits)
   413		case 'c':
   414			p.fmtC(int64(v))
   415		case 'd':
   416			p.fmt.integer(int64(v), 10, unsigned, ldigits)
   417		case 'v':
   418			if p.fmt.sharpV {
   419				p.fmt0x64(v, true)
   420			} else {
   421				p.fmt.integer(int64(v), 10, unsigned, ldigits)
   422			}
   423		case 'o':
   424			p.fmt.integer(int64(v), 8, unsigned, ldigits)
   425		case 'q':
   426			if 0 <= v && v <= utf8.MaxRune {
   427				p.fmt.fmt_qc(int64(v))
   428			} else {
   429				p.badVerb(verb)
   430			}
   431		case 'x':
   432			p.fmt.integer(int64(v), 16, unsigned, ldigits)
   433		case 'X':
   434			p.fmt.integer(int64(v), 16, unsigned, udigits)
   435		case 'U':
   436			p.fmtUnicode(int64(v))
   437		default:
   438			p.badVerb(verb)
   439		}
   440	}
   441	
   442	func (p *pp) fmtFloat32(v float32, verb rune) {
   443		switch verb {
   444		case 'b':
   445			p.fmt.fmt_fb32(v)
   446		case 'e':
   447			p.fmt.fmt_e32(v)
   448		case 'E':
   449			p.fmt.fmt_E32(v)
   450		case 'f', 'F':
   451			p.fmt.fmt_f32(v)
   452		case 'g', 'v':
   453			p.fmt.fmt_g32(v)
   454		case 'G':
   455			p.fmt.fmt_G32(v)
   456		default:
   457			p.badVerb(verb)
   458		}
   459	}
   460	
   461	func (p *pp) fmtFloat64(v float64, verb rune) {
   462		switch verb {
   463		case 'b':
   464			p.fmt.fmt_fb64(v)
   465		case 'e':
   466			p.fmt.fmt_e64(v)
   467		case 'E':
   468			p.fmt.fmt_E64(v)
   469		case 'f', 'F':
   470			p.fmt.fmt_f64(v)
   471		case 'g', 'v':
   472			p.fmt.fmt_g64(v)
   473		case 'G':
   474			p.fmt.fmt_G64(v)
   475		default:
   476			p.badVerb(verb)
   477		}
   478	}
   479	
   480	func (p *pp) fmtComplex64(v complex64, verb rune) {
   481		switch verb {
   482		case 'b', 'e', 'E', 'f', 'F', 'g', 'G':
   483			p.fmt.fmt_c64(v, verb)
   484		case 'v':
   485			p.fmt.fmt_c64(v, 'g')
   486		default:
   487			p.badVerb(verb)
   488		}
   489	}
   490	
   491	func (p *pp) fmtComplex128(v complex128, verb rune) {
   492		switch verb {
   493		case 'b', 'e', 'E', 'f', 'F', 'g', 'G':
   494			p.fmt.fmt_c128(v, verb)
   495		case 'v':
   496			p.fmt.fmt_c128(v, 'g')
   497		default:
   498			p.badVerb(verb)
   499		}
   500	}
   501	
   502	func (p *pp) fmtString(v string, verb rune) {
   503		switch verb {
   504		case 'v':
   505			if p.fmt.sharpV {
   506				p.fmt.fmt_q(v)
   507			} else {
   508				p.fmt.fmt_s(v)
   509			}
   510		case 's':
   511			p.fmt.fmt_s(v)
   512		case 'x':
   513			p.fmt.fmt_sx(v, ldigits)
   514		case 'X':
   515			p.fmt.fmt_sx(v, udigits)
   516		case 'q':
   517			p.fmt.fmt_q(v)
   518		default:
   519			p.badVerb(verb)
   520		}
   521	}
   522	
   523	func (p *pp) fmtBytes(v []byte, verb rune, typ reflect.Type, depth int) {
   524		if verb == 'v' || verb == 'd' {
   525			if p.fmt.sharpV {
   526				if v == nil {
   527					if typ == nil {
   528						p.buf.WriteString("[]byte(nil)")
   529					} else {
   530						p.buf.WriteString(typ.String())
   531						p.buf.Write(nilParenBytes)
   532					}
   533					return
   534				}
   535				if typ == nil {
   536					p.buf.Write(bytesBytes)
   537				} else {
   538					p.buf.WriteString(typ.String())
   539					p.buf.WriteByte('{')
   540				}
   541			} else {
   542				p.buf.WriteByte('[')
   543			}
   544			for i, c := range v {
   545				if i > 0 {
   546					if p.fmt.sharpV {
   547						p.buf.Write(commaSpaceBytes)
   548					} else {
   549						p.buf.WriteByte(' ')
   550					}
   551				}
   552				p.printArg(c, 'v', depth+1)
   553			}
   554			if p.fmt.sharpV {
   555				p.buf.WriteByte('}')
   556			} else {
   557				p.buf.WriteByte(']')
   558			}
   559			return
   560		}
   561		switch verb {
   562		case 's':
   563			p.fmt.fmt_s(string(v))
   564		case 'x':
   565			p.fmt.fmt_bx(v, ldigits)
   566		case 'X':
   567			p.fmt.fmt_bx(v, udigits)
   568		case 'q':
   569			p.fmt.fmt_q(string(v))
   570		default:
   571			p.badVerb(verb)
   572		}
   573	}
   574	
   575	func (p *pp) fmtPointer(value reflect.Value, verb rune) {
   576		use0x64 := true
   577		switch verb {
   578		case 'p', 'v':
   579			// ok
   580		case 'b', 'd', 'o', 'x', 'X':
   581			use0x64 = false
   582			// ok
   583		default:
   584			p.badVerb(verb)
   585			return
   586		}
   587	
   588		var u uintptr
   589		switch value.Kind() {
   590		case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
   591			u = value.Pointer()
   592		default:
   593			p.badVerb(verb)
   594			return
   595		}
   596	
   597		if p.fmt.sharpV {
   598			p.add('(')
   599			p.buf.WriteString(value.Type().String())
   600			p.add(')')
   601			p.add('(')
   602			if u == 0 {
   603				p.buf.Write(nilBytes)
   604			} else {
   605				p.fmt0x64(uint64(u), true)
   606			}
   607			p.add(')')
   608		} else if verb == 'v' && u == 0 {
   609			p.buf.Write(nilAngleBytes)
   610		} else {
   611			if use0x64 {
   612				p.fmt0x64(uint64(u), !p.fmt.sharp)
   613			} else {
   614				p.fmtUint64(uint64(u), verb)
   615			}
   616		}
   617	}
   618	
   619	var (
   620		intBits     = reflect.TypeOf(0).Bits()
   621		uintptrBits = reflect.TypeOf(uintptr(0)).Bits()
   622	)
   623	
   624	func (p *pp) catchPanic(arg interface{}, verb rune) {
   625		if err := recover(); err != nil {
   626			// If it's a nil pointer, just say "<nil>". The likeliest causes are a
   627			// Stringer that fails to guard against nil or a nil pointer for a
   628			// value receiver, and in either case, "<nil>" is a nice result.
   629			if v := reflect.ValueOf(arg); v.Kind() == reflect.Ptr && v.IsNil() {
   630				p.buf.Write(nilAngleBytes)
   631				return
   632			}
   633			// Otherwise print a concise panic message. Most of the time the panic
   634			// value will print itself nicely.
   635			if p.panicking {
   636				// Nested panics; the recursion in printArg cannot succeed.
   637				panic(err)
   638			}
   639			p.fmt.clearflags() // We are done, and for this output we want default behavior.
   640			p.buf.Write(percentBangBytes)
   641			p.add(verb)
   642			p.buf.Write(panicBytes)
   643			p.panicking = true
   644			p.printArg(err, 'v', 0)
   645			p.panicking = false
   646			p.buf.WriteByte(')')
   647		}
   648	}
   649	
   650	// clearSpecialFlags pushes %#v back into the regular flags and returns their old state.
   651	func (p *pp) clearSpecialFlags() (plusV, sharpV bool) {
   652		plusV = p.fmt.plusV
   653		if plusV {
   654			p.fmt.plus = true
   655			p.fmt.plusV = false
   656		}
   657		sharpV = p.fmt.sharpV
   658		if sharpV {
   659			p.fmt.sharp = true
   660			p.fmt.sharpV = false
   661		}
   662		return
   663	}
   664	
   665	// restoreSpecialFlags, whose argument should be a call to clearSpecialFlags,
   666	// restores the setting of the plusV and sharpV flags.
   667	func (p *pp) restoreSpecialFlags(plusV, sharpV bool) {
   668		if plusV {
   669			p.fmt.plus = false
   670			p.fmt.plusV = true
   671		}
   672		if sharpV {
   673			p.fmt.sharp = false
   674			p.fmt.sharpV = true
   675		}
   676	}
   677	
   678	func (p *pp) handleMethods(verb rune, depth int) (handled bool) {
   679		if p.erroring {
   680			return
   681		}
   682		// Is it a Formatter?
   683		if formatter, ok := p.arg.(Formatter); ok {
   684			handled = true
   685			defer p.restoreSpecialFlags(p.clearSpecialFlags())
   686			defer p.catchPanic(p.arg, verb)
   687			formatter.Format(p, verb)
   688			return
   689		}
   690	
   691		// If we're doing Go syntax and the argument knows how to supply it, take care of it now.
   692		if p.fmt.sharpV {
   693			if stringer, ok := p.arg.(GoStringer); ok {
   694				handled = true
   695				defer p.catchPanic(p.arg, verb)
   696				// Print the result of GoString unadorned.
   697				p.fmt.fmt_s(stringer.GoString())
   698				return
   699			}
   700		} else {
   701			// If a string is acceptable according to the format, see if
   702			// the value satisfies one of the string-valued interfaces.
   703			// Println etc. set verb to %v, which is "stringable".
   704			switch verb {
   705			case 'v', 's', 'x', 'X', 'q':
   706				// Is it an error or Stringer?
   707				// The duplication in the bodies is necessary:
   708				// setting handled and deferring catchPanic
   709				// must happen before calling the method.
   710				switch v := p.arg.(type) {
   711				case error:
   712					handled = true
   713					defer p.catchPanic(p.arg, verb)
   714					p.printArg(v.Error(), verb, depth)
   715					return
   716	
   717				case Stringer:
   718					handled = true
   719					defer p.catchPanic(p.arg, verb)
   720					p.printArg(v.String(), verb, depth)
   721					return
   722				}
   723			}
   724		}
   725		return false
   726	}
   727	
   728	func (p *pp) printArg(arg interface{}, verb rune, depth int) (wasString bool) {
   729		p.arg = arg
   730		p.value = reflect.Value{}
   731	
   732		if arg == nil {
   733			if verb == 'T' || verb == 'v' {
   734				p.fmt.pad(nilAngleBytes)
   735			} else {
   736				p.badVerb(verb)
   737			}
   738			return false
   739		}
   740	
   741		// Special processing considerations.
   742		// %T (the value's type) and %p (its address) are special; we always do them first.
   743		switch verb {
   744		case 'T':
   745			p.printArg(reflect.TypeOf(arg).String(), 's', 0)
   746			return false
   747		case 'p':
   748			p.fmtPointer(reflect.ValueOf(arg), verb)
   749			return false
   750		}
   751	
   752		// Some types can be done without reflection.
   753		switch f := arg.(type) {
   754		case bool:
   755			p.fmtBool(f, verb)
   756		case float32:
   757			p.fmtFloat32(f, verb)
   758		case float64:
   759			p.fmtFloat64(f, verb)
   760		case complex64:
   761			p.fmtComplex64(f, verb)
   762		case complex128:
   763			p.fmtComplex128(f, verb)
   764		case int:
   765			p.fmtInt64(int64(f), verb)
   766		case int8:
   767			p.fmtInt64(int64(f), verb)
   768		case int16:
   769			p.fmtInt64(int64(f), verb)
   770		case int32:
   771			p.fmtInt64(int64(f), verb)
   772		case int64:
   773			p.fmtInt64(f, verb)
   774		case uint:
   775			p.fmtUint64(uint64(f), verb)
   776		case uint8:
   777			p.fmtUint64(uint64(f), verb)
   778		case uint16:
   779			p.fmtUint64(uint64(f), verb)
   780		case uint32:
   781			p.fmtUint64(uint64(f), verb)
   782		case uint64:
   783			p.fmtUint64(f, verb)
   784		case uintptr:
   785			p.fmtUint64(uint64(f), verb)
   786		case string:
   787			p.fmtString(f, verb)
   788			wasString = verb == 's' || verb == 'v'
   789		case []byte:
   790			p.fmtBytes(f, verb, nil, depth)
   791			wasString = verb == 's'
   792		default:
   793			// If the type is not simple, it might have methods.
   794			if handled := p.handleMethods(verb, depth); handled {
   795				return false
   796			}
   797			// Need to use reflection
   798			return p.printReflectValue(reflect.ValueOf(arg), verb, depth)
   799		}
   800		p.arg = nil
   801		return
   802	}
   803	
   804	// printValue is like printArg but starts with a reflect value, not an interface{} value.
   805	func (p *pp) printValue(value reflect.Value, verb rune, depth int) (wasString bool) {
   806		if !value.IsValid() {
   807			if verb == 'T' || verb == 'v' {
   808				p.buf.Write(nilAngleBytes)
   809			} else {
   810				p.badVerb(verb)
   811			}
   812			return false
   813		}
   814	
   815		// Special processing considerations.
   816		// %T (the value's type) and %p (its address) are special; we always do them first.
   817		switch verb {
   818		case 'T':
   819			p.printArg(value.Type().String(), 's', 0)
   820			return false
   821		case 'p':
   822			p.fmtPointer(value, verb)
   823			return false
   824		}
   825	
   826		// Handle values with special methods.
   827		// Call always, even when arg == nil, because handleMethods clears p.fmt.plus for us.
   828		p.arg = nil // Make sure it's cleared, for safety.
   829		if value.CanInterface() {
   830			p.arg = value.Interface()
   831		}
   832		if handled := p.handleMethods(verb, depth); handled {
   833			return false
   834		}
   835	
   836		return p.printReflectValue(value, verb, depth)
   837	}
   838	
   839	var byteType = reflect.TypeOf(byte(0))
   840	
   841	// printReflectValue is the fallback for both printArg and printValue.
   842	// It uses reflect to print the value.
   843	func (p *pp) printReflectValue(value reflect.Value, verb rune, depth int) (wasString bool) {
   844		oldValue := p.value
   845		p.value = value
   846	BigSwitch:
   847		switch f := value; f.Kind() {
   848		case reflect.Bool:
   849			p.fmtBool(f.Bool(), verb)
   850		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   851			p.fmtInt64(f.Int(), verb)
   852		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   853			p.fmtUint64(f.Uint(), verb)
   854		case reflect.Float32, reflect.Float64:
   855			if f.Type().Size() == 4 {
   856				p.fmtFloat32(float32(f.Float()), verb)
   857			} else {
   858				p.fmtFloat64(f.Float(), verb)
   859			}
   860		case reflect.Complex64, reflect.Complex128:
   861			if f.Type().Size() == 8 {
   862				p.fmtComplex64(complex64(f.Complex()), verb)
   863			} else {
   864				p.fmtComplex128(f.Complex(), verb)
   865			}
   866		case reflect.String:
   867			p.fmtString(f.String(), verb)
   868		case reflect.Map:
   869			if p.fmt.sharpV {
   870				p.buf.WriteString(f.Type().String())
   871				if f.IsNil() {
   872					p.buf.WriteString("(nil)")
   873					break
   874				}
   875				p.buf.WriteByte('{')
   876			} else {
   877				p.buf.Write(mapBytes)
   878			}
   879			keys := f.MapKeys()
   880			for i, key := range keys {
   881				if i > 0 {
   882					if p.fmt.sharpV {
   883						p.buf.Write(commaSpaceBytes)
   884					} else {
   885						p.buf.WriteByte(' ')
   886					}
   887				}
   888				p.printValue(key, verb, depth+1)
   889				p.buf.WriteByte(':')
   890				p.printValue(f.MapIndex(key), verb, depth+1)
   891			}
   892			if p.fmt.sharpV {
   893				p.buf.WriteByte('}')
   894			} else {
   895				p.buf.WriteByte(']')
   896			}
   897		case reflect.Struct:
   898			if p.fmt.sharpV {
   899				p.buf.WriteString(value.Type().String())
   900			}
   901			p.add('{')
   902			v := f
   903			t := v.Type()
   904			for i := 0; i < v.NumField(); i++ {
   905				if i > 0 {
   906					if p.fmt.sharpV {
   907						p.buf.Write(commaSpaceBytes)
   908					} else {
   909						p.buf.WriteByte(' ')
   910					}
   911				}
   912				if p.fmt.plusV || p.fmt.sharpV {
   913					if f := t.Field(i); f.Name != "" {
   914						p.buf.WriteString(f.Name)
   915						p.buf.WriteByte(':')
   916					}
   917				}
   918				p.printValue(getField(v, i), verb, depth+1)
   919			}
   920			p.buf.WriteByte('}')
   921		case reflect.Interface:
   922			value := f.Elem()
   923			if !value.IsValid() {
   924				if p.fmt.sharpV {
   925					p.buf.WriteString(f.Type().String())
   926					p.buf.Write(nilParenBytes)
   927				} else {
   928					p.buf.Write(nilAngleBytes)
   929				}
   930			} else {
   931				wasString = p.printValue(value, verb, depth+1)
   932			}
   933		case reflect.Array, reflect.Slice:
   934			// Byte slices are special:
   935			// - Handle []byte (== []uint8) with fmtBytes.
   936			// - Handle []T, where T is a named byte type, with fmtBytes only
   937			//   for the s, q, an x verbs. For other verbs, T might be a
   938			//   Stringer, so we use printValue to print each element.
   939			if typ := f.Type(); typ.Elem().Kind() == reflect.Uint8 && (typ.Elem() == byteType || verb == 's' || verb == 'q' || verb == 'x') {
   940				var bytes []byte
   941				if f.Kind() == reflect.Slice {
   942					bytes = f.Bytes()
   943				} else if f.CanAddr() {
   944					bytes = f.Slice(0, f.Len()).Bytes()
   945				} else {
   946					// We have an array, but we cannot Slice() a non-addressable array,
   947					// so we build a slice by hand. This is a rare case but it would be nice
   948					// if reflection could help a little more.
   949					bytes = make([]byte, f.Len())
   950					for i := range bytes {
   951						bytes[i] = byte(f.Index(i).Uint())
   952					}
   953				}
   954				p.fmtBytes(bytes, verb, typ, depth)
   955				wasString = verb == 's'
   956				break
   957			}
   958			if p.fmt.sharpV {
   959				p.buf.WriteString(value.Type().String())
   960				if f.Kind() == reflect.Slice && f.IsNil() {
   961					p.buf.WriteString("(nil)")
   962					break
   963				}
   964				p.buf.WriteByte('{')
   965			} else {
   966				p.buf.WriteByte('[')
   967			}
   968			for i := 0; i < f.Len(); i++ {
   969				if i > 0 {
   970					if p.fmt.sharpV {
   971						p.buf.Write(commaSpaceBytes)
   972					} else {
   973						p.buf.WriteByte(' ')
   974					}
   975				}
   976				p.printValue(f.Index(i), verb, depth+1)
   977			}
   978			if p.fmt.sharpV {
   979				p.buf.WriteByte('}')
   980			} else {
   981				p.buf.WriteByte(']')
   982			}
   983		case reflect.Ptr:
   984			v := f.Pointer()
   985			// pointer to array or slice or struct?  ok at top level
   986			// but not embedded (avoid loops)
   987			if v != 0 && depth == 0 {
   988				switch a := f.Elem(); a.Kind() {
   989				case reflect.Array, reflect.Slice:
   990					p.buf.WriteByte('&')
   991					p.printValue(a, verb, depth+1)
   992					break BigSwitch
   993				case reflect.Struct:
   994					p.buf.WriteByte('&')
   995					p.printValue(a, verb, depth+1)
   996					break BigSwitch
   997				case reflect.Map:
   998					p.buf.WriteByte('&')
   999					p.printValue(a, verb, depth+1)
  1000					break BigSwitch
  1001				}
  1002			}
  1003			fallthrough
  1004		case reflect.Chan, reflect.Func, reflect.UnsafePointer:
  1005			p.fmtPointer(value, verb)
  1006		default:
  1007			p.unknownType(f)
  1008		}
  1009		p.value = oldValue
  1010		return wasString
  1011	}
  1012	
  1013	// intFromArg gets the argNumth element of a. On return, isInt reports whether the argument has type int.
  1014	func intFromArg(a []interface{}, argNum int) (num int, isInt bool, newArgNum int) {
  1015		newArgNum = argNum
  1016		if argNum < len(a) {
  1017			num, isInt = a[argNum].(int)
  1018			newArgNum = argNum + 1
  1019		}
  1020		return
  1021	}
  1022	
  1023	// parseArgNumber returns the value of the bracketed number, minus 1
  1024	// (explicit argument numbers are one-indexed but we want zero-indexed).
  1025	// The opening bracket is known to be present at format[0].
  1026	// The returned values are the index, the number of bytes to consume
  1027	// up to the closing paren, if present, and whether the number parsed
  1028	// ok. The bytes to consume will be 1 if no closing paren is present.
  1029	func parseArgNumber(format string) (index int, wid int, ok bool) {
  1030		// Find closing bracket.
  1031		for i := 1; i < len(format); i++ {
  1032			if format[i] == ']' {
  1033				width, ok, newi := parsenum(format, 1, i)
  1034				if !ok || newi != i {
  1035					return 0, i + 1, false
  1036				}
  1037				return width - 1, i + 1, true // arg numbers are one-indexed and skip paren.
  1038			}
  1039		}
  1040		return 0, 1, false
  1041	}
  1042	
  1043	// argNumber returns the next argument to evaluate, which is either the value of the passed-in
  1044	// argNum or the value of the bracketed integer that begins format[i:]. It also returns
  1045	// the new value of i, that is, the index of the next byte of the format to process.
  1046	func (p *pp) argNumber(argNum int, format string, i int, numArgs int) (newArgNum, newi int, found bool) {
  1047		if len(format) <= i || format[i] != '[' {
  1048			return argNum, i, false
  1049		}
  1050		p.reordered = true
  1051		index, wid, ok := parseArgNumber(format[i:])
  1052		if ok && 0 <= index && index < numArgs {
  1053			return index, i + wid, true
  1054		}
  1055		p.goodArgNum = false
  1056		return argNum, i + wid, true
  1057	}
  1058	
  1059	func (p *pp) doPrintf(format string, a []interface{}) {
  1060		end := len(format)
  1061		argNum := 0         // we process one argument per non-trivial format
  1062		afterIndex := false // previous item in format was an index like [3].
  1063		p.reordered = false
  1064		for i := 0; i < end; {
  1065			p.goodArgNum = true
  1066			lasti := i
  1067			for i < end && format[i] != '%' {
  1068				i++
  1069			}
  1070			if i > lasti {
  1071				p.buf.WriteString(format[lasti:i])
  1072			}
  1073			if i >= end {
  1074				// done processing format string
  1075				break
  1076			}
  1077	
  1078			// Process one verb
  1079			i++
  1080	
  1081			// Do we have flags?
  1082			p.fmt.clearflags()
  1083		F:
  1084			for ; i < end; i++ {
  1085				switch format[i] {
  1086				case '#':
  1087					p.fmt.sharp = true
  1088				case '0':
  1089					p.fmt.zero = true
  1090				case '+':
  1091					p.fmt.plus = true
  1092				case '-':
  1093					p.fmt.minus = true
  1094				case ' ':
  1095					p.fmt.space = true
  1096				default:
  1097					break F
  1098				}
  1099			}
  1100	
  1101			// Do we have an explicit argument index?
  1102			argNum, i, afterIndex = p.argNumber(argNum, format, i, len(a))
  1103	
  1104			// Do we have width?
  1105			if i < end && format[i] == '*' {
  1106				i++
  1107				p.fmt.wid, p.fmt.widPresent, argNum = intFromArg(a, argNum)
  1108				if !p.fmt.widPresent {
  1109					p.buf.Write(badWidthBytes)
  1110				}
  1111				afterIndex = false
  1112			} else {
  1113				p.fmt.wid, p.fmt.widPresent, i = parsenum(format, i, end)
  1114				if afterIndex && p.fmt.widPresent { // "%[3]2d"
  1115					p.goodArgNum = false
  1116				}
  1117			}
  1118	
  1119			// Do we have precision?
  1120			if i+1 < end && format[i] == '.' {
  1121				i++
  1122				if afterIndex { // "%[3].2d"
  1123					p.goodArgNum = false
  1124				}
  1125				argNum, i, afterIndex = p.argNumber(argNum, format, i, len(a))
  1126				if format[i] == '*' {
  1127					i++
  1128					p.fmt.prec, p.fmt.precPresent, argNum = intFromArg(a, argNum)
  1129					if !p.fmt.precPresent {
  1130						p.buf.Write(badPrecBytes)
  1131					}
  1132					afterIndex = false
  1133				} else {
  1134					p.fmt.prec, p.fmt.precPresent, i = parsenum(format, i, end)
  1135					if !p.fmt.precPresent {
  1136						p.fmt.prec = 0
  1137						p.fmt.precPresent = true
  1138					}
  1139				}
  1140			}
  1141	
  1142			if !afterIndex {
  1143				argNum, i, afterIndex = p.argNumber(argNum, format, i, len(a))
  1144			}
  1145	
  1146			if i >= end {
  1147				p.buf.Write(noVerbBytes)
  1148				continue
  1149			}
  1150			c, w := utf8.DecodeRuneInString(format[i:])
  1151			i += w
  1152			// percent is special - absorbs no operand
  1153			if c == '%' {
  1154				p.buf.WriteByte('%') // We ignore width and prec.
  1155				continue
  1156			}
  1157			if !p.goodArgNum {
  1158				p.buf.Write(percentBangBytes)
  1159				p.add(c)
  1160				p.buf.Write(badIndexBytes)
  1161				continue
  1162			} else if argNum >= len(a) { // out of operands
  1163				p.buf.Write(percentBangBytes)
  1164				p.add(c)
  1165				p.buf.Write(missingBytes)
  1166				continue
  1167			}
  1168			arg := a[argNum]
  1169			argNum++
  1170	
  1171			if c == 'v' {
  1172				if p.fmt.sharp {
  1173					// Go syntax. Set the flag in the fmt and clear the sharp flag.
  1174					p.fmt.sharp = false
  1175					p.fmt.sharpV = true
  1176				}
  1177				if p.fmt.plus {
  1178					// Struct-field syntax. Set the flag in the fmt and clear the plus flag.
  1179					p.fmt.plus = false
  1180					p.fmt.plusV = true
  1181				}
  1182			}
  1183			p.printArg(arg, c, 0)
  1184		}
  1185	
  1186		// Check for extra arguments unless the call accessed the arguments
  1187		// out of order, in which case it's too expensive to detect if they've all
  1188		// been used and arguably OK if they're not.
  1189		if !p.reordered && argNum < len(a) {
  1190			p.buf.Write(extraBytes)
  1191			for ; argNum < len(a); argNum++ {
  1192				arg := a[argNum]
  1193				if arg != nil {
  1194					p.buf.WriteString(reflect.TypeOf(arg).String())
  1195					p.buf.WriteByte('=')
  1196				}
  1197				p.printArg(arg, 'v', 0)
  1198				if argNum+1 < len(a) {
  1199					p.buf.Write(commaSpaceBytes)
  1200				}
  1201			}
  1202			p.buf.WriteByte(')')
  1203		}
  1204	}
  1205	
  1206	func (p *pp) doPrint(a []interface{}, addspace, addnewline bool) {
  1207		prevString := false
  1208		for argNum := 0; argNum < len(a); argNum++ {
  1209			p.fmt.clearflags()
  1210			// always add spaces if we're doing Println
  1211			arg := a[argNum]
  1212			if argNum > 0 {
  1213				isString := arg != nil && reflect.TypeOf(arg).Kind() == reflect.String
  1214				if addspace || !isString && !prevString {
  1215					p.buf.WriteByte(' ')
  1216				}
  1217			}
  1218			prevString = p.printArg(arg, 'v', 0)
  1219		}
  1220		if addnewline {
  1221			p.buf.WriteByte('\n')
  1222		}
  1223	}
  1224	

View as plain text