- Kind
- Pure package
- Name
- v2
- Namespace
- moul / vendor / nt / ufmt
- Exported functions
- n/a — not supported for pure packages by the node (vm/qfuncs)
- Module
- gno.land/p/moul/vendor/nt/ufmt/v2
- gno
- 0.9
ufmt.gnogno
1package ufmt23import (4 "io"5 "strings"6)78
not supported for pure packages by the node (vm/qfuncs)
Signatures reconstructed verbatim from vm/qfuncs — interface params keep their inline definitions.
// State is what a Formatter's Format method is handed: the flags, width and
9// precision of the verb being printed, and somewhere to write.
10type State interface {
11 // Write emits formatted output.
12 Write(b []byte) (n int, err error)
13 // Width returns the width and whether one was set.
14 Width() (wid int, ok bool)
15 // Precision returns the precision and whether one was set.
16 Precision() (prec int, ok bool)
17 // Flag reports whether the flag c, a character, was set.
18 Flag(c int) bool
19}
20
21// Formatter is implemented by a value that formats itself. Format is called
22// for every verb, and its output replaces what ufmt would have printed.
23type Formatter interface {
24 Format(f State, verb rune)
25}
26
27// Stringer is implemented by a value that has a natural string form. It is
28// used for %v, %s, %q, %x and %X, and by Print.
29type Stringer interface {
30 String() string
31}
32
33// GoStringer is implemented by a value that has a Go-syntax form, used for %#v.
34type GoStringer interface {
35 GoString() string
36}
37
38// Sprintf formats according to a format specifier and returns the string.
39func Sprintf(format string, a ...any) string {
40 p := newPrinter()
41 p.doPrintf(format, a)
42 return string(p.buf)
43}
44
45// Appendf formats according to a format specifier and appends the result to b.
46func Appendf(b []byte, format string, a ...any) []byte {
47 p := newPrinter()
48 p.doPrintf(format, a)
49 return append(b, p.buf...)
50}
51
52// Fprintf formats according to a format specifier and writes to w.
53func Fprintf(w io.Writer, format string, a ...any) (n int, err error) {
54 p := newPrinter()
55 p.doPrintf(format, a)
56 return w.Write(p.buf)
57}
58
59// Printf formats according to a format specifier and prints the result with
60// the print builtin, which is what a test or a filetest captures.
61func Printf(format string, a ...any) (n int, err error) {
62 return printOut(Sprintf(format, a...))
63}
64
65// Sprint formats its operands with %v and returns the string. A space is added
66// between two operands when neither is a string.
67func Sprint(a ...any) string {
68 p := newPrinter()
69 p.doPrint(a)
70 return string(p.buf)
71}
72
73// Append formats its operands as Sprint does and appends the result to b.
74func Append(b []byte, a ...any) []byte {
75 p := newPrinter()
76 p.doPrint(a)
77 return append(b, p.buf...)
78}
79
80// Fprint formats its operands as Sprint does and writes to w.
81func Fprint(w io.Writer, a ...any) (n int, err error) {
82 p := newPrinter()
83 p.doPrint(a)
84 return w.Write(p.buf)
85}
86
87// Print formats its operands as Sprint does and prints the result.
88func Print(a ...any) (n int, err error) {
89 return printOut(Sprint(a...))
90}
91
92// Sprintln formats its operands with %v, always separated by a space, and
93// appends a newline.
94func Sprintln(a ...any) string {
95 p := newPrinter()
96 p.doPrintln(a)
97 return string(p.buf)
98}
99
100// Appendln formats its operands as Sprintln does and appends the result to b.
101func Appendln(b []byte, a ...any) []byte {
102 p := newPrinter()
103 p.doPrintln(a)
104 return append(b, p.buf...)
105}
106
107// Fprintln formats its operands as Sprintln does and writes to w.
108func Fprintln(w io.Writer, a ...any) (n int, err error) {
109 p := newPrinter()
110 p.doPrintln(a)
111 return w.Write(p.buf)
112}
113
114// Println formats its operands as Sprintln does and prints the result.
115func Println(a ...any) (n int, err error) {
116 return printOut(Sprintln(a...))
117}
118
119func printOut(s string) (int, error) {
120 var sb strings.Builder
121 n, err := sb.WriteString(s)
122 print(sb.String())
123 return n, err
124}
125
126// Errorf formats according to a format specifier and returns the string as an
127// error. Each %w operand must be an error; it is printed as %v and returned by
128// the error's Unwrap method, so errors.Is and errors.Unwrap can find it. One %w
129// gives an Unwrap() error, several give an Unwrap() []error, as in Go.
130func Errorf(format string, a ...any) error {
131 p := newPrinter()
132 p.wrapErrs = true
133 p.doPrintf(format, a)
134 s := string(p.buf)
135
136 switch len(p.wrapped) {
137 case 0:
138 return &errorString{s}
139 case 1:
140 w := &wrapError{msg: s}
141 w.err, _ = a[p.wrapped[0]].(error)
142 return w
143 default:
144 if p.reordered {
145 sortInts(p.wrapped)
146 }
147 var errs []error
148 for i, argNum := range p.wrapped {
149 if i > 0 && p.wrapped[i-1] == argNum {
150 continue
151 }
152 if e, ok := a[argNum].(error); ok {
153 errs = append(errs, e)
154 }
155 }
156 return &wrapErrors{s, errs}
157 }
158}
159
160type errorString struct {
161 s string
162}
163
164func (e *errorString) Error() string { return e.s }
165
166type wrapError struct {
167 msg string
168 err error
169}
170
171func (e *wrapError) Error() string { return e.msg }
172func (e *wrapError) Unwrap() error { return e.err }
173
174type wrapErrors struct {
175 msg string
176 errs []error
177}
178
179func (e *wrapErrors) Error() string { return e.msg }
180func (e *wrapErrors) Unwrap() []error { return e.errs }
181
182// sortInts is an insertion sort: the slice holds one entry per %w.
183func sortInts(a []int) {
184 for i := 1; i < len(a); i++ {
185 for j := i; j > 0 && a[j] < a[j-1]; j-- {
186 a[j], a[j-1] = a[j-1], a[j]
187 }
188 }
189}
190