const commaSpaceString … const nilAngleString … const nilParenString … const nilString … const mapString … const percentBangString … const missingString … const badIndexString … const panicString … const extraString … const badWidthString … const badPrecString … const noVerbString … const invReflectString … type State … type Formatter … type Stringer … type GoStringer … // FormatString returns a string representing the fully qualified formatting // directive captured by the [State], followed by the argument verb. ([State] does not // itself contain the verb.) The result has a leading percent sign followed by any // flags, the width, and the precision. Missing flags, width, and precision are // omitted. This function allows a [Formatter] to reconstruct the original // directive triggering the call to Format. func FormatString(state State, verb rune) string { … } type buffer … func (b *buffer) write(p []byte) { … } func (b *buffer) writeString(s string) { … } func (b *buffer) writeByte(c byte) { … } func (b *buffer) writeRune(r rune) { … } type pp … var ppFree … // newPrinter allocates a new pp struct or grabs a cached one. func newPrinter() *pp { … } // free saves used pp structs in ppFree; avoids an allocation per invocation. func (p *pp) free() { … } func (p *pp) Width() (wid int, ok bool) { … } func (p *pp) Precision() (prec int, ok bool) { … } func (p *pp) Flag(b int) bool { … } // Write implements [io.Writer] so we can call [Fprintf] on a pp (through [State]), for // recursive use in custom verbs. func (p *pp) Write(b []byte) (ret int, err error) { … } // WriteString implements [io.StringWriter] so that we can call [io.WriteString] // on a pp (through state), for efficiency. func (p *pp) WriteString(s string) (ret int, err error) { … } // Fprintf formats according to a format specifier and writes to w. // It returns the number of bytes written and any write error encountered. func Fprintf(w io.Writer, format string, a ...any) (n int, err error) { … } // Printf formats according to a format specifier and writes to standard output. // It returns the number of bytes written and any write error encountered. func Printf(format string, a ...any) (n int, err error) { … } // Sprintf formats according to a format specifier and returns the resulting string. func Sprintf(format string, a ...any) string { … } // Appendf formats according to a format specifier, appends the result to the byte // slice, and returns the updated slice. func Appendf(b []byte, format string, a ...any) []byte { … } // Fprint formats using the default formats for its operands and writes to w. // Spaces are added between operands when neither is a string. // It returns the number of bytes written and any write error encountered. func Fprint(w io.Writer, a ...any) (n int, err error) { … } // Print formats using the default formats for its operands and writes to standard output. // Spaces are added between operands when neither is a string. // It returns the number of bytes written and any write error encountered. func Print(a ...any) (n int, err error) { … } // Sprint formats using the default formats for its operands and returns the resulting string. // Spaces are added between operands when neither is a string. func Sprint(a ...any) string { … } // Append formats using the default formats for its operands, appends the result to // the byte slice, and returns the updated slice. func Append(b []byte, a ...any) []byte { … } // Fprintln formats using the default formats for its operands and writes to w. // Spaces are always added between operands and a newline is appended. // It returns the number of bytes written and any write error encountered. func Fprintln(w io.Writer, a ...any) (n int, err error) { … } // Println formats using the default formats for its operands and writes to standard output. // Spaces are always added between operands and a newline is appended. // It returns the number of bytes written and any write error encountered. func Println(a ...any) (n int, err error) { … } // Sprintln formats using the default formats for its operands and returns the resulting string. // Spaces are always added between operands and a newline is appended. func Sprintln(a ...any) string { … } // Appendln formats using the default formats for its operands, appends the result // to the byte slice, and returns the updated slice. Spaces are always added // between operands and a newline is appended. func Appendln(b []byte, a ...any) []byte { … } // getField gets the i'th field of the struct value. // If the field itself is a non-nil interface, return a value for // the thing inside the interface, not the interface itself. func getField(v reflect.Value, i int) reflect.Value { … } // tooLarge reports whether the magnitude of the integer is // too large to be used as a formatting width or precision. func tooLarge(x int) bool { … } // parsenum converts ASCII to integer. num is 0 (and isnum is false) if no number present. func parsenum(s string, start, end int) (num int, isnum bool, newi int) { … } func (p *pp) unknownType(v reflect.Value) { … } func (p *pp) badVerb(verb rune) { … } func (p *pp) fmtBool(v bool, verb rune) { … } // fmt0x64 formats a uint64 in hexadecimal and prefixes it with 0x or // not, as requested, by temporarily setting the sharp flag. func (p *pp) fmt0x64(v uint64, leading0x bool) { … } // fmtInteger formats a signed or unsigned integer. func (p *pp) fmtInteger(v uint64, isSigned bool, verb rune) { … } // fmtFloat formats a float. The default precision for each verb // is specified as last argument in the call to fmt_float. func (p *pp) fmtFloat(v float64, size int, verb rune) { … } // fmtComplex formats a complex number v with // r = real(v) and j = imag(v) as (r+ji) using // fmtFloat for r and j formatting. func (p *pp) fmtComplex(v complex128, size int, verb rune) { … } func (p *pp) fmtString(v string, verb rune) { … } func (p *pp) fmtBytes(v []byte, verb rune, typeString string) { … } func (p *pp) fmtPointer(value reflect.Value, verb rune) { … } func (p *pp) catchPanic(arg any, verb rune, method string) { … } func (p *pp) handleMethods(verb rune) (handled bool) { … } func (p *pp) printArg(arg any, verb rune) { … } // printValue is similar to printArg but starts with a reflect value, not an interface{} value. // It does not handle 'p' and 'T' verbs because these should have been already handled by printArg. func (p *pp) printValue(value reflect.Value, verb rune, depth int) { … } // intFromArg gets the argNumth element of a. On return, isInt reports whether the argument has integer type. func intFromArg(a []any, argNum int) (num int, isInt bool, newArgNum int) { … } // parseArgNumber returns the value of the bracketed number, minus 1 // (explicit argument numbers are one-indexed but we want zero-indexed). // The opening bracket is known to be present at format[0]. // The returned values are the index, the number of bytes to consume // up to the closing paren, if present, and whether the number parsed // ok. The bytes to consume will be 1 if no closing paren is present. func parseArgNumber(format string) (index int, wid int, ok bool) { … } // argNumber returns the next argument to evaluate, which is either the value of the passed-in // argNum or the value of the bracketed integer that begins format[i:]. It also returns // the new value of i, that is, the index of the next byte of the format to process. func (p *pp) argNumber(argNum int, format string, i int, numArgs int) (newArgNum, newi int, found bool) { … } func (p *pp) badArgNum(verb rune) { … } func (p *pp) missingArg(verb rune) { … } func (p *pp) doPrintf(format string, a []any) { … } func (p *pp) doPrint(a []any) { … } // doPrintln is like doPrint but always adds a space between arguments // and a newline after the last argument. func (p *pp) doPrintln(a []any) { … }
Codebase Browser
go