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

View as plain text