Source file
src/fmt/print.go
Documentation: fmt
1
2
3
4
5 package fmt
6
7 import (
8 "internal/fmtsort"
9 "io"
10 "os"
11 "reflect"
12 "sync"
13 "unicode/utf8"
14 )
15
16
17
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
36
37
38 type State interface {
39
40 Write(b []byte) (n int, err error)
41
42 Width() (wid int, ok bool)
43
44 Precision() (prec int, ok bool)
45
46
47 Flag(c int) bool
48 }
49
50
51
52
53 type Formatter interface {
54 Format(f State, verb rune)
55 }
56
57
58
59
60
61
62 type Stringer interface {
63 String() string
64 }
65
66
67
68
69
70 type GoStringer interface {
71 GoString() string
72 }
73
74
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
105 type pp struct {
106 buf buffer
107
108
109 arg any
110
111
112 value reflect.Value
113
114
115 fmt fmt
116
117
118 reordered bool
119
120 goodArgNum bool
121
122 panicking bool
123
124 erroring bool
125
126 wrapErrs bool
127
128 wrappedErr error
129 }
130
131 var ppFree = sync.Pool{
132 New: func() any { return new(pp) },
133 }
134
135
136 func newPrinter() *pp {
137 p := ppFree.Get().(*pp)
138 p.panicking = false
139 p.erroring = false
140 p.wrapErrs = false
141 p.fmt.init(&p.buf)
142 return p
143 }
144
145
146 func (p *pp) free() {
147
148
149
150
151
152
153 if cap(p.buf) > 64<<10 {
154 return
155 }
156
157 p.buf = p.buf[:0]
158 p.arg = nil
159 p.value = reflect.Value{}
160 p.wrappedErr = nil
161 ppFree.Put(p)
162 }
163
164 func (p *pp) Width() (wid int, ok bool) { return p.fmt.wid, p.fmt.widPresent }
165
166 func (p *pp) Precision() (prec int, ok bool) { return p.fmt.prec, p.fmt.precPresent }
167
168 func (p *pp) Flag(b int) bool {
169 switch b {
170 case '-':
171 return p.fmt.minus
172 case '+':
173 return p.fmt.plus || p.fmt.plusV
174 case '#':
175 return p.fmt.sharp || p.fmt.sharpV
176 case ' ':
177 return p.fmt.space
178 case '0':
179 return p.fmt.zero
180 }
181 return false
182 }
183
184
185
186 func (p *pp) Write(b []byte) (ret int, err error) {
187 p.buf.write(b)
188 return len(b), nil
189 }
190
191
192
193 func (p *pp) WriteString(s string) (ret int, err error) {
194 p.buf.writeString(s)
195 return len(s), nil
196 }
197
198
199
200
201
202 func Fprintf(w io.Writer, format string, a ...any) (n int, err error) {
203 p := newPrinter()
204 p.doPrintf(format, a)
205 n, err = w.Write(p.buf)
206 p.free()
207 return
208 }
209
210
211
212 func Printf(format string, a ...any) (n int, err error) {
213 return Fprintf(os.Stdout, format, a...)
214 }
215
216
217 func Sprintf(format string, a ...any) string {
218 p := newPrinter()
219 p.doPrintf(format, a)
220 s := string(p.buf)
221 p.free()
222 return s
223 }
224
225
226
227 func Appendf(b []byte, format string, a ...any) []byte {
228 p := newPrinter()
229 p.doPrintf(format, a)
230 b = append(b, p.buf...)
231 p.free()
232 return b
233 }
234
235
236
237
238
239
240 func Fprint(w io.Writer, a ...any) (n int, err error) {
241 p := newPrinter()
242 p.doPrint(a)
243 n, err = w.Write(p.buf)
244 p.free()
245 return
246 }
247
248
249
250
251 func Print(a ...any) (n int, err error) {
252 return Fprint(os.Stdout, a...)
253 }
254
255
256
257 func Sprint(a ...any) string {
258 p := newPrinter()
259 p.doPrint(a)
260 s := string(p.buf)
261 p.free()
262 return s
263 }
264
265
266
267 func Append(b []byte, a ...any) []byte {
268 p := newPrinter()
269 p.doPrint(a)
270 b = append(b, p.buf...)
271 p.free()
272 return b
273 }
274
275
276
277
278
279
280
281
282 func Fprintln(w io.Writer, a ...any) (n int, err error) {
283 p := newPrinter()
284 p.doPrintln(a)
285 n, err = w.Write(p.buf)
286 p.free()
287 return
288 }
289
290
291
292
293 func Println(a ...any) (n int, err error) {
294 return Fprintln(os.Stdout, a...)
295 }
296
297
298
299 func Sprintln(a ...any) string {
300 p := newPrinter()
301 p.doPrintln(a)
302 s := string(p.buf)
303 p.free()
304 return s
305 }
306
307
308
309
310 func Appendln(b []byte, a ...any) []byte {
311 p := newPrinter()
312 p.doPrintln(a)
313 b = append(b, p.buf...)
314 p.free()
315 return b
316 }
317
318
319
320
321 func getField(v reflect.Value, i int) reflect.Value {
322 val := v.Field(i)
323 if val.Kind() == reflect.Interface && !val.IsNil() {
324 val = val.Elem()
325 }
326 return val
327 }
328
329
330
331 func tooLarge(x int) bool {
332 const max int = 1e6
333 return x > max || x < -max
334 }
335
336
337 func parsenum(s string, start, end int) (num int, isnum bool, newi int) {
338 if start >= end {
339 return 0, false, end
340 }
341 for newi = start; newi < end && '0' <= s[newi] && s[newi] <= '9'; newi++ {
342 if tooLarge(num) {
343 return 0, false, end
344 }
345 num = num*10 + int(s[newi]-'0')
346 isnum = true
347 }
348 return
349 }
350
351 func (p *pp) unknownType(v reflect.Value) {
352 if !v.IsValid() {
353 p.buf.writeString(nilAngleString)
354 return
355 }
356 p.buf.writeByte('?')
357 p.buf.writeString(v.Type().String())
358 p.buf.writeByte('?')
359 }
360
361 func (p *pp) badVerb(verb rune) {
362 p.erroring = true
363 p.buf.writeString(percentBangString)
364 p.buf.writeRune(verb)
365 p.buf.writeByte('(')
366 switch {
367 case p.arg != nil:
368 p.buf.writeString(reflect.TypeOf(p.arg).String())
369 p.buf.writeByte('=')
370 p.printArg(p.arg, 'v')
371 case p.value.IsValid():
372 p.buf.writeString(p.value.Type().String())
373 p.buf.writeByte('=')
374 p.printValue(p.value, 'v', 0)
375 default:
376 p.buf.writeString(nilAngleString)
377 }
378 p.buf.writeByte(')')
379 p.erroring = false
380 }
381
382 func (p *pp) fmtBool(v bool, verb rune) {
383 switch verb {
384 case 't', 'v':
385 p.fmt.fmtBoolean(v)
386 default:
387 p.badVerb(verb)
388 }
389 }
390
391
392
393 func (p *pp) fmt0x64(v uint64, leading0x bool) {
394 sharp := p.fmt.sharp
395 p.fmt.sharp = leading0x
396 p.fmt.fmtInteger(v, 16, unsigned, 'v', ldigits)
397 p.fmt.sharp = sharp
398 }
399
400
401 func (p *pp) fmtInteger(v uint64, isSigned bool, verb rune) {
402 switch verb {
403 case 'v':
404 if p.fmt.sharpV && !isSigned {
405 p.fmt0x64(v, true)
406 } else {
407 p.fmt.fmtInteger(v, 10, isSigned, verb, ldigits)
408 }
409 case 'd':
410 p.fmt.fmtInteger(v, 10, isSigned, verb, ldigits)
411 case 'b':
412 p.fmt.fmtInteger(v, 2, isSigned, verb, ldigits)
413 case 'o', 'O':
414 p.fmt.fmtInteger(v, 8, isSigned, verb, ldigits)
415 case 'x':
416 p.fmt.fmtInteger(v, 16, isSigned, verb, ldigits)
417 case 'X':
418 p.fmt.fmtInteger(v, 16, isSigned, verb, udigits)
419 case 'c':
420 p.fmt.fmtC(v)
421 case 'q':
422 p.fmt.fmtQc(v)
423 case 'U':
424 p.fmt.fmtUnicode(v)
425 default:
426 p.badVerb(verb)
427 }
428 }
429
430
431
432 func (p *pp) fmtFloat(v float64, size int, verb rune) {
433 switch verb {
434 case 'v':
435 p.fmt.fmtFloat(v, size, 'g', -1)
436 case 'b', 'g', 'G', 'x', 'X':
437 p.fmt.fmtFloat(v, size, verb, -1)
438 case 'f', 'e', 'E':
439 p.fmt.fmtFloat(v, size, verb, 6)
440 case 'F':
441 p.fmt.fmtFloat(v, size, 'f', 6)
442 default:
443 p.badVerb(verb)
444 }
445 }
446
447
448
449
450 func (p *pp) fmtComplex(v complex128, size int, verb rune) {
451
452
453 switch verb {
454 case 'v', 'b', 'g', 'G', 'x', 'X', 'f', 'F', 'e', 'E':
455 oldPlus := p.fmt.plus
456 p.buf.writeByte('(')
457 p.fmtFloat(real(v), size/2, verb)
458
459 p.fmt.plus = true
460 p.fmtFloat(imag(v), size/2, verb)
461 p.buf.writeString("i)")
462 p.fmt.plus = oldPlus
463 default:
464 p.badVerb(verb)
465 }
466 }
467
468 func (p *pp) fmtString(v string, verb rune) {
469 switch verb {
470 case 'v':
471 if p.fmt.sharpV {
472 p.fmt.fmtQ(v)
473 } else {
474 p.fmt.fmtS(v)
475 }
476 case 's':
477 p.fmt.fmtS(v)
478 case 'x':
479 p.fmt.fmtSx(v, ldigits)
480 case 'X':
481 p.fmt.fmtSx(v, udigits)
482 case 'q':
483 p.fmt.fmtQ(v)
484 default:
485 p.badVerb(verb)
486 }
487 }
488
489 func (p *pp) fmtBytes(v []byte, verb rune, typeString string) {
490 switch verb {
491 case 'v', 'd':
492 if p.fmt.sharpV {
493 p.buf.writeString(typeString)
494 if v == nil {
495 p.buf.writeString(nilParenString)
496 return
497 }
498 p.buf.writeByte('{')
499 for i, c := range v {
500 if i > 0 {
501 p.buf.writeString(commaSpaceString)
502 }
503 p.fmt0x64(uint64(c), true)
504 }
505 p.buf.writeByte('}')
506 } else {
507 p.buf.writeByte('[')
508 for i, c := range v {
509 if i > 0 {
510 p.buf.writeByte(' ')
511 }
512 p.fmt.fmtInteger(uint64(c), 10, unsigned, verb, ldigits)
513 }
514 p.buf.writeByte(']')
515 }
516 case 's':
517 p.fmt.fmtBs(v)
518 case 'x':
519 p.fmt.fmtBx(v, ldigits)
520 case 'X':
521 p.fmt.fmtBx(v, udigits)
522 case 'q':
523 p.fmt.fmtQ(string(v))
524 default:
525 p.printValue(reflect.ValueOf(v), verb, 0)
526 }
527 }
528
529 func (p *pp) fmtPointer(value reflect.Value, verb rune) {
530 var u uintptr
531 switch value.Kind() {
532 case reflect.Chan, reflect.Func, reflect.Map, reflect.Pointer, reflect.Slice, reflect.UnsafePointer:
533 u = value.Pointer()
534 default:
535 p.badVerb(verb)
536 return
537 }
538
539 switch verb {
540 case 'v':
541 if p.fmt.sharpV {
542 p.buf.writeByte('(')
543 p.buf.writeString(value.Type().String())
544 p.buf.writeString(")(")
545 if u == 0 {
546 p.buf.writeString(nilString)
547 } else {
548 p.fmt0x64(uint64(u), true)
549 }
550 p.buf.writeByte(')')
551 } else {
552 if u == 0 {
553 p.fmt.padString(nilAngleString)
554 } else {
555 p.fmt0x64(uint64(u), !p.fmt.sharp)
556 }
557 }
558 case 'p':
559 p.fmt0x64(uint64(u), !p.fmt.sharp)
560 case 'b', 'o', 'd', 'x', 'X':
561 p.fmtInteger(uint64(u), unsigned, verb)
562 default:
563 p.badVerb(verb)
564 }
565 }
566
567 func (p *pp) catchPanic(arg any, verb rune, method string) {
568 if err := recover(); err != nil {
569
570
571
572 if v := reflect.ValueOf(arg); v.Kind() == reflect.Pointer && v.IsNil() {
573 p.buf.writeString(nilAngleString)
574 return
575 }
576
577
578 if p.panicking {
579
580 panic(err)
581 }
582
583 oldFlags := p.fmt.fmtFlags
584
585 p.fmt.clearflags()
586
587 p.buf.writeString(percentBangString)
588 p.buf.writeRune(verb)
589 p.buf.writeString(panicString)
590 p.buf.writeString(method)
591 p.buf.writeString(" method: ")
592 p.panicking = true
593 p.printArg(err, 'v')
594 p.panicking = false
595 p.buf.writeByte(')')
596
597 p.fmt.fmtFlags = oldFlags
598 }
599 }
600
601 func (p *pp) handleMethods(verb rune) (handled bool) {
602 if p.erroring {
603 return
604 }
605 if verb == 'w' {
606
607
608 err, ok := p.arg.(error)
609 if !ok || !p.wrapErrs || p.wrappedErr != nil {
610 p.wrappedErr = nil
611 p.wrapErrs = false
612 p.badVerb(verb)
613 return true
614 }
615 p.wrappedErr = err
616
617 verb = 'v'
618 }
619
620
621 if formatter, ok := p.arg.(Formatter); ok {
622 handled = true
623 defer p.catchPanic(p.arg, verb, "Format")
624 formatter.Format(p, verb)
625 return
626 }
627
628
629 if p.fmt.sharpV {
630 if stringer, ok := p.arg.(GoStringer); ok {
631 handled = true
632 defer p.catchPanic(p.arg, verb, "GoString")
633
634 p.fmt.fmtS(stringer.GoString())
635 return
636 }
637 } else {
638
639
640
641 switch verb {
642 case 'v', 's', 'x', 'X', 'q':
643
644
645
646
647 switch v := p.arg.(type) {
648 case error:
649 handled = true
650 defer p.catchPanic(p.arg, verb, "Error")
651 p.fmtString(v.Error(), verb)
652 return
653
654 case Stringer:
655 handled = true
656 defer p.catchPanic(p.arg, verb, "String")
657 p.fmtString(v.String(), verb)
658 return
659 }
660 }
661 }
662 return false
663 }
664
665 func (p *pp) printArg(arg any, verb rune) {
666 p.arg = arg
667 p.value = reflect.Value{}
668
669 if arg == nil {
670 switch verb {
671 case 'T', 'v':
672 p.fmt.padString(nilAngleString)
673 default:
674 p.badVerb(verb)
675 }
676 return
677 }
678
679
680
681 switch verb {
682 case 'T':
683 p.fmt.fmtS(reflect.TypeOf(arg).String())
684 return
685 case 'p':
686 p.fmtPointer(reflect.ValueOf(arg), 'p')
687 return
688 }
689
690
691 switch f := arg.(type) {
692 case bool:
693 p.fmtBool(f, verb)
694 case float32:
695 p.fmtFloat(float64(f), 32, verb)
696 case float64:
697 p.fmtFloat(f, 64, verb)
698 case complex64:
699 p.fmtComplex(complex128(f), 64, verb)
700 case complex128:
701 p.fmtComplex(f, 128, verb)
702 case int:
703 p.fmtInteger(uint64(f), signed, verb)
704 case int8:
705 p.fmtInteger(uint64(f), signed, verb)
706 case int16:
707 p.fmtInteger(uint64(f), signed, verb)
708 case int32:
709 p.fmtInteger(uint64(f), signed, verb)
710 case int64:
711 p.fmtInteger(uint64(f), signed, verb)
712 case uint:
713 p.fmtInteger(uint64(f), unsigned, verb)
714 case uint8:
715 p.fmtInteger(uint64(f), unsigned, verb)
716 case uint16:
717 p.fmtInteger(uint64(f), unsigned, verb)
718 case uint32:
719 p.fmtInteger(uint64(f), unsigned, verb)
720 case uint64:
721 p.fmtInteger(f, unsigned, verb)
722 case uintptr:
723 p.fmtInteger(uint64(f), unsigned, verb)
724 case string:
725 p.fmtString(f, verb)
726 case []byte:
727 p.fmtBytes(f, verb, "[]byte")
728 case reflect.Value:
729
730
731 if f.IsValid() && f.CanInterface() {
732 p.arg = f.Interface()
733 if p.handleMethods(verb) {
734 return
735 }
736 }
737 p.printValue(f, verb, 0)
738 default:
739
740 if !p.handleMethods(verb) {
741
742
743 p.printValue(reflect.ValueOf(f), verb, 0)
744 }
745 }
746 }
747
748
749
750 func (p *pp) printValue(value reflect.Value, verb rune, depth int) {
751
752 if depth > 0 && value.IsValid() && value.CanInterface() {
753 p.arg = value.Interface()
754 if p.handleMethods(verb) {
755 return
756 }
757 }
758 p.arg = nil
759 p.value = value
760
761 switch f := value; value.Kind() {
762 case reflect.Invalid:
763 if depth == 0 {
764 p.buf.writeString(invReflectString)
765 } else {
766 switch verb {
767 case 'v':
768 p.buf.writeString(nilAngleString)
769 default:
770 p.badVerb(verb)
771 }
772 }
773 case reflect.Bool:
774 p.fmtBool(f.Bool(), verb)
775 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
776 p.fmtInteger(uint64(f.Int()), signed, verb)
777 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
778 p.fmtInteger(f.Uint(), unsigned, verb)
779 case reflect.Float32:
780 p.fmtFloat(f.Float(), 32, verb)
781 case reflect.Float64:
782 p.fmtFloat(f.Float(), 64, verb)
783 case reflect.Complex64:
784 p.fmtComplex(f.Complex(), 64, verb)
785 case reflect.Complex128:
786 p.fmtComplex(f.Complex(), 128, verb)
787 case reflect.String:
788 p.fmtString(f.String(), verb)
789 case reflect.Map:
790 if p.fmt.sharpV {
791 p.buf.writeString(f.Type().String())
792 if f.IsNil() {
793 p.buf.writeString(nilParenString)
794 return
795 }
796 p.buf.writeByte('{')
797 } else {
798 p.buf.writeString(mapString)
799 }
800 sorted := fmtsort.Sort(f)
801 for i, key := range sorted.Key {
802 if i > 0 {
803 if p.fmt.sharpV {
804 p.buf.writeString(commaSpaceString)
805 } else {
806 p.buf.writeByte(' ')
807 }
808 }
809 p.printValue(key, verb, depth+1)
810 p.buf.writeByte(':')
811 p.printValue(sorted.Value[i], verb, depth+1)
812 }
813 if p.fmt.sharpV {
814 p.buf.writeByte('}')
815 } else {
816 p.buf.writeByte(']')
817 }
818 case reflect.Struct:
819 if p.fmt.sharpV {
820 p.buf.writeString(f.Type().String())
821 }
822 p.buf.writeByte('{')
823 for i := 0; i < f.NumField(); i++ {
824 if i > 0 {
825 if p.fmt.sharpV {
826 p.buf.writeString(commaSpaceString)
827 } else {
828 p.buf.writeByte(' ')
829 }
830 }
831 if p.fmt.plusV || p.fmt.sharpV {
832 if name := f.Type().Field(i).Name; name != "" {
833 p.buf.writeString(name)
834 p.buf.writeByte(':')
835 }
836 }
837 p.printValue(getField(f, i), verb, depth+1)
838 }
839 p.buf.writeByte('}')
840 case reflect.Interface:
841 value := f.Elem()
842 if !value.IsValid() {
843 if p.fmt.sharpV {
844 p.buf.writeString(f.Type().String())
845 p.buf.writeString(nilParenString)
846 } else {
847 p.buf.writeString(nilAngleString)
848 }
849 } else {
850 p.printValue(value, verb, depth+1)
851 }
852 case reflect.Array, reflect.Slice:
853 switch verb {
854 case 's', 'q', 'x', 'X':
855
856 t := f.Type()
857 if t.Elem().Kind() == reflect.Uint8 {
858 var bytes []byte
859 if f.Kind() == reflect.Slice {
860 bytes = f.Bytes()
861 } else if f.CanAddr() {
862 bytes = f.Slice(0, f.Len()).Bytes()
863 } else {
864
865
866
867 bytes = make([]byte, f.Len())
868 for i := range bytes {
869 bytes[i] = byte(f.Index(i).Uint())
870 }
871 }
872 p.fmtBytes(bytes, verb, t.String())
873 return
874 }
875 }
876 if p.fmt.sharpV {
877 p.buf.writeString(f.Type().String())
878 if f.Kind() == reflect.Slice && f.IsNil() {
879 p.buf.writeString(nilParenString)
880 return
881 }
882 p.buf.writeByte('{')
883 for i := 0; i < f.Len(); i++ {
884 if i > 0 {
885 p.buf.writeString(commaSpaceString)
886 }
887 p.printValue(f.Index(i), verb, depth+1)
888 }
889 p.buf.writeByte('}')
890 } else {
891 p.buf.writeByte('[')
892 for i := 0; i < f.Len(); i++ {
893 if i > 0 {
894 p.buf.writeByte(' ')
895 }
896 p.printValue(f.Index(i), verb, depth+1)
897 }
898 p.buf.writeByte(']')
899 }
900 case reflect.Pointer:
901
902
903 if depth == 0 && f.Pointer() != 0 {
904 switch a := f.Elem(); a.Kind() {
905 case reflect.Array, reflect.Slice, reflect.Struct, reflect.Map:
906 p.buf.writeByte('&')
907 p.printValue(a, verb, depth+1)
908 return
909 }
910 }
911 fallthrough
912 case reflect.Chan, reflect.Func, reflect.UnsafePointer:
913 p.fmtPointer(f, verb)
914 default:
915 p.unknownType(f)
916 }
917 }
918
919
920 func intFromArg(a []any, argNum int) (num int, isInt bool, newArgNum int) {
921 newArgNum = argNum
922 if argNum < len(a) {
923 num, isInt = a[argNum].(int)
924 if !isInt {
925
926 switch v := reflect.ValueOf(a[argNum]); v.Kind() {
927 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
928 n := v.Int()
929 if int64(int(n)) == n {
930 num = int(n)
931 isInt = true
932 }
933 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
934 n := v.Uint()
935 if int64(n) >= 0 && uint64(int(n)) == n {
936 num = int(n)
937 isInt = true
938 }
939 default:
940
941 }
942 }
943 newArgNum = argNum + 1
944 if tooLarge(num) {
945 num = 0
946 isInt = false
947 }
948 }
949 return
950 }
951
952
953
954
955
956
957
958 func parseArgNumber(format string) (index int, wid int, ok bool) {
959
960 if len(format) < 3 {
961 return 0, 1, false
962 }
963
964
965 for i := 1; i < len(format); i++ {
966 if format[i] == ']' {
967 width, ok, newi := parsenum(format, 1, i)
968 if !ok || newi != i {
969 return 0, i + 1, false
970 }
971 return width - 1, i + 1, true
972 }
973 }
974 return 0, 1, false
975 }
976
977
978
979
980 func (p *pp) argNumber(argNum int, format string, i int, numArgs int) (newArgNum, newi int, found bool) {
981 if len(format) <= i || format[i] != '[' {
982 return argNum, i, false
983 }
984 p.reordered = true
985 index, wid, ok := parseArgNumber(format[i:])
986 if ok && 0 <= index && index < numArgs {
987 return index, i + wid, true
988 }
989 p.goodArgNum = false
990 return argNum, i + wid, ok
991 }
992
993 func (p *pp) badArgNum(verb rune) {
994 p.buf.writeString(percentBangString)
995 p.buf.writeRune(verb)
996 p.buf.writeString(badIndexString)
997 }
998
999 func (p *pp) missingArg(verb rune) {
1000 p.buf.writeString(percentBangString)
1001 p.buf.writeRune(verb)
1002 p.buf.writeString(missingString)
1003 }
1004
1005 func (p *pp) doPrintf(format string, a []any) {
1006 end := len(format)
1007 argNum := 0
1008 afterIndex := false
1009 p.reordered = false
1010 formatLoop:
1011 for i := 0; i < end; {
1012 p.goodArgNum = true
1013 lasti := i
1014 for i < end && format[i] != '%' {
1015 i++
1016 }
1017 if i > lasti {
1018 p.buf.writeString(format[lasti:i])
1019 }
1020 if i >= end {
1021
1022 break
1023 }
1024
1025
1026 i++
1027
1028
1029 p.fmt.clearflags()
1030 simpleFormat:
1031 for ; i < end; i++ {
1032 c := format[i]
1033 switch c {
1034 case '#':
1035 p.fmt.sharp = true
1036 case '0':
1037 p.fmt.zero = !p.fmt.minus
1038 case '+':
1039 p.fmt.plus = true
1040 case '-':
1041 p.fmt.minus = true
1042 p.fmt.zero = false
1043 case ' ':
1044 p.fmt.space = true
1045 default:
1046
1047
1048 if 'a' <= c && c <= 'z' && argNum < len(a) {
1049 if c == 'v' {
1050
1051 p.fmt.sharpV = p.fmt.sharp
1052 p.fmt.sharp = false
1053
1054 p.fmt.plusV = p.fmt.plus
1055 p.fmt.plus = false
1056 }
1057 p.printArg(a[argNum], rune(c))
1058 argNum++
1059 i++
1060 continue formatLoop
1061 }
1062
1063 break simpleFormat
1064 }
1065 }
1066
1067
1068 argNum, i, afterIndex = p.argNumber(argNum, format, i, len(a))
1069
1070
1071 if i < end && format[i] == '*' {
1072 i++
1073 p.fmt.wid, p.fmt.widPresent, argNum = intFromArg(a, argNum)
1074
1075 if !p.fmt.widPresent {
1076 p.buf.writeString(badWidthString)
1077 }
1078
1079
1080
1081 if p.fmt.wid < 0 {
1082 p.fmt.wid = -p.fmt.wid
1083 p.fmt.minus = true
1084 p.fmt.zero = false
1085 }
1086 afterIndex = false
1087 } else {
1088 p.fmt.wid, p.fmt.widPresent, i = parsenum(format, i, end)
1089 if afterIndex && p.fmt.widPresent {
1090 p.goodArgNum = false
1091 }
1092 }
1093
1094
1095 if i+1 < end && format[i] == '.' {
1096 i++
1097 if afterIndex {
1098 p.goodArgNum = false
1099 }
1100 argNum, i, afterIndex = p.argNumber(argNum, format, i, len(a))
1101 if i < end && format[i] == '*' {
1102 i++
1103 p.fmt.prec, p.fmt.precPresent, argNum = intFromArg(a, argNum)
1104
1105 if p.fmt.prec < 0 {
1106 p.fmt.prec = 0
1107 p.fmt.precPresent = false
1108 }
1109 if !p.fmt.precPresent {
1110 p.buf.writeString(badPrecString)
1111 }
1112 afterIndex = false
1113 } else {
1114 p.fmt.prec, p.fmt.precPresent, i = parsenum(format, i, end)
1115 if !p.fmt.precPresent {
1116 p.fmt.prec = 0
1117 p.fmt.precPresent = true
1118 }
1119 }
1120 }
1121
1122 if !afterIndex {
1123 argNum, i, afterIndex = p.argNumber(argNum, format, i, len(a))
1124 }
1125
1126 if i >= end {
1127 p.buf.writeString(noVerbString)
1128 break
1129 }
1130
1131 verb, size := rune(format[i]), 1
1132 if verb >= utf8.RuneSelf {
1133 verb, size = utf8.DecodeRuneInString(format[i:])
1134 }
1135 i += size
1136
1137 switch {
1138 case verb == '%':
1139 p.buf.writeByte('%')
1140 case !p.goodArgNum:
1141 p.badArgNum(verb)
1142 case argNum >= len(a):
1143 p.missingArg(verb)
1144 case verb == 'v':
1145
1146 p.fmt.sharpV = p.fmt.sharp
1147 p.fmt.sharp = false
1148
1149 p.fmt.plusV = p.fmt.plus
1150 p.fmt.plus = false
1151 fallthrough
1152 default:
1153 p.printArg(a[argNum], verb)
1154 argNum++
1155 }
1156 }
1157
1158
1159
1160
1161 if !p.reordered && argNum < len(a) {
1162 p.fmt.clearflags()
1163 p.buf.writeString(extraString)
1164 for i, arg := range a[argNum:] {
1165 if i > 0 {
1166 p.buf.writeString(commaSpaceString)
1167 }
1168 if arg == nil {
1169 p.buf.writeString(nilAngleString)
1170 } else {
1171 p.buf.writeString(reflect.TypeOf(arg).String())
1172 p.buf.writeByte('=')
1173 p.printArg(arg, 'v')
1174 }
1175 }
1176 p.buf.writeByte(')')
1177 }
1178 }
1179
1180 func (p *pp) doPrint(a []any) {
1181 prevString := false
1182 for argNum, arg := range a {
1183 isString := arg != nil && reflect.TypeOf(arg).Kind() == reflect.String
1184
1185 if argNum > 0 && !isString && !prevString {
1186 p.buf.writeByte(' ')
1187 }
1188 p.printArg(arg, 'v')
1189 prevString = isString
1190 }
1191 }
1192
1193
1194
1195 func (p *pp) doPrintln(a []any) {
1196 for argNum, arg := range a {
1197 if argNum > 0 {
1198 p.buf.writeByte(' ')
1199 }
1200 p.printArg(arg, 'v')
1201 }
1202 p.buf.writeByte('\n')
1203 }
1204
View as plain text