For printf, a linter checks that the format string is a constant literal, so the implementation can assume it's always safe.

SetMode changes the output mode.

Sprintf formats the arguments and encloses unsafe bits between redaction markers. If either safe and unsafe bits of data contain the markers in their

WriteByte emits a single byte.

WriteString appends the contents of s to the buffer, growing the buffer as needed. The return value n is the length of s; err is always nil. If the bu

Print emits its arguments separated by spaces. For each argument it dynamically checks for the SafeFormatter or SafeValue interface and either use tha

Redact replaces all occurrences of unsafe substrings by the "Redacted" marker, ‹×›. Hash markers (‹†value›) are replaced with hashed values (‹hash›) i

Safe turns any value into an object that is considered as safe by the formatter. This is provided as an “escape hatch” for cases where the other inte

WriteRune emits a single rune.

DisableHashing disables hash-based redaction. Hash markers will be fully redacted instead of being replaced with hashes.

EnableHashing enables hash-based redaction with an optional salt. Hash markers (‹†value›) will be replaced with hashes instead of being fully redacted

Unsafe turns any value that would otherwise be considered safe, into an unsafe value.

Write appends the contents of p to the buffer, growing the buffer as needed. The return value n is the length of p; err is always nil. If the buffer b

fmtInteger formats a signed or unsigned integer.

RedactableString returns the bytes in the buffer.

Reset resets the buffer to be empty, but it retains the underlying storage for use by future writes. It also resets the output mode to UnsafeEscaped.

StripMarkers removes the redaction markers from the RedactableBytes. This returns an unsafe string where all safe and unsafe bits are mixed together.

Write is the function to call to emit formatted output to be printed.

pad appends b to f.buf, padded on left (!f.minus) or right (f.minus).

SafeRune is part of the SafeWriter interface.

Implement WriteString so that we can call io.WriteString on a pp (through state), for efficiency.

free saves used pp structs in ppFree; avoids an allocation per invocation.

newPrinter allocates a new pp struct or grabs a cached one.

SafeRune emits a safe rune.

Sprint prints out the arguments and encloses unsafe bits between redaction markers. If either safe and unsafe bits of data contain the markers in thei

writePadding generates n bytes of padding.

GetMode retrieves the output mode.

SafeString is part of the SafeWriter interface.

appendHash computes a truncated hash of value and appends the hex result directly to dst, avoiding an intermediate allocation. Must only be called whe

finalize ensures that all the buffer is properly marked.

fmtFloat formats a float. The default precision for each verb is specified as last argument in the call to fmt_float.

grow grows the buffer to guarantee space for n more bytes. It returns the index where bytes should be written. If the buffer can't grow it will panic

tryGrowByReslice is a inlineable version of grow for the fast-case where the internal buffer only needs to be resliced. It returns the index where byt

padString appends s to f.buf, padded on left (!f.minus) or right (f.minus).

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

Flag reports whether the flag c, a character, has been set.

RedactableBytes returns the bytes in the buffer.

TakeRedactableString returns the buffer contents and reinitializes the buffer. This saves a memory allocation compared to RedactableString().

fmt0x64 formats a uint64 in hexadecimal and prefixes it with 0x or not, as requested, by temporarily setting the sharp flag.

DisableHashing disables hash-based redaction. The pool and salt are intentionally left intact so that in-flight hashers (which captured the pool point

EnableHashing enables hash-based redaction with an optional salt. When salt is nil, hash markers use plain SHA-256. When salt is provided, hash marker

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string

WriteByte shadows the ib.Buffer.WriteByte method.

WriteRune shadows the ib.Buffer.WriteRune method.

WriteString shadows the ib.Buffer.WriteString method.

fmtComplex formats a complex number v with r = real(v) and j = imag(v) as (r+ji) using fmtFloat for r and j formatting.

fmtS formats a string.

InternalEscapeBytes escapes redaction markers in the provided buf starting at the location startLoc. The bytes before startLoc are considered safe (al

Printf is part of the SafeWriter interface.

SafeString emits a safe string.

TakeRedactableBytes returns the buffer contents and reinitializes the buffer. This saves a memory allocation compared to RedactableBytes().

ToBytes converts the string to a byte slice.

UnsafeRune writes an unsafe rune.

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 f

floatCompare compares two floating-point values. NaNs compare low.

fmtQ formats a string as a double-quoted, escaped Go string constant. If f.sharp is set a raw (backquoted) string may be returned instead if the strin

parsenum converts ASCII to integer. num is 0 (and isnum is false) if no number present.

stripMarkersBytes scans data for marker characters (‹, ›, †) and either removes them (when replacement is nil) or replaces them with the replacement b

EscapeMarkers escapes the special delimiters from the provided byte slice.

These routines do not take a format string Fprint formats using the default formats for its operands and writes to w. Spaces are added between operand

Fprintf is like Sprintf but outputs the redactable string to the provided Writer.

These routines end in 'f' and take a format string. Fprintf formats according to a format specifier and writes to w. It returns the number of bytes wr

HelperForErrorf is a helper to implement a redaction-aware fmt.Errorf-compatible function in a different package. It formats the string according to t

JoinTo writes the given slice of values delimited by the provided delimiter to the given SafeWriter.

MakeFormat reproduces the format currently active in fmt.State and verb. This is provided because Go's standard fmt.State does not make the original f

Print is part of the SafeWriter interface.

ReproducePrintf calls fmt.Print/fmt.Printf on the argument based on the details present in the fmt.State and writes to the io.Writer.

UnsafeByte writes an unsafe byte.

UnsafeByte is part of the SafeWriter interface.

UnsafeString writes an unsafe string.

UnsafeString is part of the SafeWriter interface.

doPrintln is like doPrint but always adds a space between arguments and a newline after the last argument.

endRedactable adds the closing redaction marker.