func fmt.Errorf
270 uses
fmt (current package)
errors.go#L17: func Errorf(format string, a ...interface{}) error {
compress/flate
deflate.go#L606: return fmt.Errorf("flate: invalid compression level %d: want value in range [-2, 9]", level)
compress/gzip
gzip.go#L62: return nil, fmt.Errorf("gzip: invalid compression level: %d", level)
crypto/tls
auth.go#L27: return fmt.Errorf("expected an ECDSA public key, got %T", pubkey)
auth.go#L35: return fmt.Errorf("expected an Ed25519 public key, got %T", pubkey)
auth.go#L43: return fmt.Errorf("expected an RSA public key, got %T", pubkey)
auth.go#L51: return fmt.Errorf("expected an RSA public key, got %T", pubkey)
auth.go#L109: return 0, 0, fmt.Errorf("unsupported signature algorithm: %v", signatureAlgorithm)
auth.go#L123: return 0, 0, fmt.Errorf("unsupported signature algorithm: %v", signatureAlgorithm)
auth.go#L142: return 0, 0, fmt.Errorf("tls: Ed25519 public keys are not supported before TLS 1.2")
auth.go#L144: return 0, 0, fmt.Errorf("tls: unsupported public key: %T", pub)
auth.go#L256: return fmt.Errorf("tls: unsupported certificate: private key is %T, expected *%T",
auth.go#L259: return fmt.Errorf("tls: unsupported certificate: private key is *ed25519.PrivateKey, expected ed25519.PrivateKey")
auth.go#L264: return fmt.Errorf("tls: certificate private key (%T) does not implement crypto.Signer",
auth.go#L275: return fmt.Errorf("tls: unsupported certificate curve (%s)", pub.Curve.Params().Name)
auth.go#L278: return fmt.Errorf("tls: certificate RSA key size too small for supported signature algorithms")
auth.go#L281: return fmt.Errorf("tls: unsupported certificate key (%T)", pub)
auth.go#L285: return fmt.Errorf("tls: peer doesn't support the certificate custom signature algorithms")
auth.go#L288: return fmt.Errorf("tls: internal error: unsupported key (%T)", cert.PrivateKey)
common.go#L1088: return fmt.Errorf("failed to parse certificate: %w", err)
common.go#L1091: return fmt.Errorf("certificate is not valid for requested server name: %w", err)
common.go#L1237: return fmt.Errorf("failed to parse certificate #%d in the chain: %w", j, err)
common.go#L1504: return fmt.Errorf("tls: received unexpected handshake message of type %T when waiting for %T", got, wanted)
conn.go#L1017: return nil, c.in.setErrorLocked(fmt.Errorf("tls: handshake message of length %d bytes exceeds maximum of %d bytes", n, maxHandshake))
conn.go#L1224: return fmt.Errorf("tls: received unexpected handshake message of type %T", msg)
conn.go#L1331: alertErr = fmt.Errorf("tls: failed to send closeNotify alert (but connection was closed anyway): %w", err)
handshake_client.go#L358: return fmt.Errorf("tls: server selected unsupported protocol version %x", peerVersion)
handshake_client.go#L592: return fmt.Errorf("tls: client certificate private key of type %T does not implement crypto.Signer", chainToSend.PrivateKey)
handshake_client.go#L859: return fmt.Errorf("tls: server's certificate contains an unsupported type of public key: %T", certs[0].PublicKey)
handshake_messages.go#L27: return fmt.Errorf("invalid value length: expected %d, got %d", n, len(v))
handshake_server.go#L158: return nil, fmt.Errorf("tls: client offered only unsupported versions: %x", clientVersions)
handshake_server.go#L257: return fmt.Errorf("tls: unsupported signing key type (%T)", priv.Public())
handshake_server.go#L266: return fmt.Errorf("tls: unsupported decryption key type (%T)", priv.Public())
handshake_server.go#L817: return fmt.Errorf("tls: client certificate contains an unsupported public key of type %T", certs[0].PublicKey)
key_agreement.go#L178: return nil, fmt.Errorf("tls: certificate private key of type %T does not implement crypto.Signer", cert.PrivateKey)
prf.go#L259: return nil, fmt.Errorf("crypto/tls: reserved ExportKeyingMaterial label: %s", label)
prf.go#L273: return nil, fmt.Errorf("crypto/tls: ExportKeyingMaterial context too long")
tls.go#L301: return fail(fmt.Errorf("tls: failed to find \"CERTIFICATE\" PEM block in certificate input after skipping PEM blocks of the following types: %v", skippedBlockTypes))
tls.go#L315: return fail(fmt.Errorf("tls: failed to find PEM block with type ending in \"PRIVATE KEY\" in key input after skipping PEM blocks of the following types: %v", skippedBlockTypes))
crypto/x509
pkcs8.go#L70: return nil, fmt.Errorf("x509: invalid Ed25519 private key: %v", err)
pkcs8.go#L73: return nil, fmt.Errorf("x509: invalid Ed25519 private key length: %d", l)
pkcs8.go#L78: return nil, fmt.Errorf("x509: PKCS#8 wrapping contained private key with unknown algorithm: %v", privKey.Algo.Algorithm)
pkcs8.go#L127: return nil, fmt.Errorf("x509: failed to marshal private key: %v", err)
pkcs8.go#L132: return nil, fmt.Errorf("x509: unknown key type while marshaling PKCS#8: %T", key)
sec1.go#L80: return nil, fmt.Errorf("x509: unknown EC private key version %d", privKey.Version)
verify.go#L421: return false, fmt.Errorf("x509: internal error: cannot parse constraint %q", constraint)
verify.go#L442: return false, fmt.Errorf("URI with empty host (%q) cannot be matched against constraints", uri.String())
verify.go#L455: return false, fmt.Errorf("URI with IP (%q) cannot be matched against constraints", uri.String())
verify.go#L484: return false, fmt.Errorf("x509: internal error: cannot parse domain %q", domain)
verify.go#L500: return false, fmt.Errorf("x509: internal error: cannot parse domain %q", constraint)
verify.go#L638: return fmt.Errorf("x509: cannot parse rfc822Name %q", mailbox)
verify.go#L651: return fmt.Errorf("x509: cannot parse dnsName %q", name)
verify.go#L665: return fmt.Errorf("x509: internal error: URI SAN %q failed to parse", name)
verify.go#L678: return fmt.Errorf("x509: internal error: IP SAN %x failed to parse", data)
verify.go#L767: return nil, fmt.Errorf("crypto/x509: error fetching intermediate: %w", err)
x509.go#L104: return nil, pkix.AlgorithmIdentifier{}, fmt.Errorf("x509: unsupported public key type: %T", pub)
x509.go#L807: return fmt.Errorf("x509: signature algorithm specifies an %s public key, but have public key of type %T", expectedPubKeyAlgo.String(), pubKey)
x509.go#L1085: return fmt.Errorf("x509: cannot parse URI %q: %s", uriStr, err)
x509.go#L1089: return fmt.Errorf("x509: cannot parse URI %q: invalid domain", uriStr)
x509.go#L1174: return nil, nil, nil, nil, fmt.Errorf("x509: invalid NameConstraints extension")
x509.go#L1200: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse dnsName constraint %q", domain)
x509.go#L1218: return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained value of length %d", l)
x509.go#L1222: return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained invalid mask %x", mask)
x509.go#L1237: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
x509.go#L1246: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
x509.go#L1258: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q: cannot be IP address", domain)
x509.go#L1270: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q", domain)
x509.go#L1682: return fmt.Errorf("x509: %q cannot be encoded as an IA5String", s)
x509.go#L2248: return nil, fmt.Errorf("x509: signature over certificate returned by signer is invalid: %w", err)
encoding/asn1
asn1.go#L353: err = fmt.Errorf("asn1: time did not serialize back to the original value and may be invalid: given %q, but serialized as %q", s, serialized)
asn1.go#L376: err = fmt.Errorf("asn1: time did not serialize back to the original value and may be invalid: given %q, but serialized as %q", s, serialized)
marshal.go#L581: return nil, fmt.Errorf("asn1: cannot marshal nil value")
encoding/gob
error.go#L24: error_(fmt.Errorf("gob: "+format, args...))
encoding/json
decode.go#L722: d.saveError(fmt.Errorf("json: cannot set embedded pointer to unexported struct: %v", subv.Type().Elem()))
decode.go#L738: d.saveError(fmt.Errorf("json: unknown field %q", key))
decode.go#L762: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
decode.go#L854: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L865: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L881: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L895: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L908: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L914: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L932: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L953: return fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", item)
decode.go#L967: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L981: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
encode.go#L628: e.error(fmt.Errorf("json: invalid number literal %q", numStr))
encode.go#L802: e.error(fmt.Errorf("json: encoding error for type %q: %q", v.Type().String(), err.Error()))
flag
flag.go#L433: return fmt.Errorf("no such flag -%v", name)
flag.go#L892: err := fmt.Errorf(format, a...)
go.etcd.io/bbolt
bolt_unix.go#L61: return fmt.Errorf("madvise: %s", err)
bucket.go#L235: return fmt.Errorf("delete bucket: %s", err)
db.go#L334: return fmt.Errorf("mmap stat error: %s", err)
db.go#L336: return fmt.Errorf("file size too small")
db.go#L383: return fmt.Errorf("unmap error: " + err.Error())
db.go#L401: return 0, fmt.Errorf("mmap too large")
db.go#L514: return fmt.Errorf("db file close: %s", err)
db.go#L940: return nil, fmt.Errorf("mmap allocate error: %s", err)
db.go#L970: return fmt.Errorf("file resize error: %s", err)
db.go#L974: return fmt.Errorf("file sync error: %s", err)
page.go#L168: panic(fmt.Errorf("mergepgids bad len %d < %d + %d", len(dst), len(a), len(b)))
tx.go#L359: return n, fmt.Errorf("meta 0 copy: %s", err)
tx.go#L369: return n, fmt.Errorf("meta 1 copy: %s", err)
tx.go#L374: return n, fmt.Errorf("seek: %s", err)
tx.go#L428: ch <- fmt.Errorf("page %d: already freed", id)
tx.go#L450: ch <- fmt.Errorf("page %d: unreachable unfreed", int(i))
tx.go#L467: ch <- fmt.Errorf("page %d: out of bounds: %d", int(p.id), int(b.tx.meta.pgid))
tx.go#L474: ch <- fmt.Errorf("page %d: multiple references", int(id))
tx.go#L481: ch <- fmt.Errorf("page %d: reachable freed", int(p.id))
tx.go#L483: ch <- fmt.Errorf("page %d: invalid type: %s", int(p.id), p.typ())
math/big
floatconv.go#L129: err = fmt.Errorf("exponent overflow")
floatconv.go#L279: err = fmt.Errorf("expected end of string, found %q", ch)
floatmarsh.go#L72: return fmt.Errorf("Float.GobDecode: encoding version %d not supported", buf[0])
floatmarsh.go#L117: err = fmt.Errorf("math/big: cannot unmarshal %q into a *big.Float (%v)", text, err)
intconv.go#L224: err = fmt.Errorf("invalid rune %#U", ch)
intmarsh.go#L41: return fmt.Errorf("Int.GobDecode: encoding version %d not supported", b>>1)
intmarsh.go#L59: return fmt.Errorf("math/big: cannot unmarshal %q into a *big.Int", text)
ratmarsh.go#L50: return fmt.Errorf("Rat.GobDecode: encoding version %d not supported", b>>1)
ratmarsh.go#L72: return fmt.Errorf("math/big: cannot unmarshal %q into a *big.Rat", text)
mime
encodedword.go#L343: return fmt.Errorf("mime: unhandled charset %q", charset)
encodedword.go#L423: return 0, fmt.Errorf("mime: invalid hex byte %#02x", b)
mediatype.go#L368: return "", fmt.Errorf("mime: bogus characters after %%: %q", s)
type.go#L166: return fmt.Errorf("mime: extension %q missing leading dot", ext)
mime/multipart
multipart.go#L323: return nil, fmt.Errorf("multipart: boundary is empty")
multipart.go#L338: return nil, fmt.Errorf("multipart: NextPart: %v", err)
multipart.go#L357: return nil, fmt.Errorf("multipart: expecting a new Part; got line %q", string(line))
multipart.go#L374: return nil, fmt.Errorf("multipart: unexpected line in Next(): %q", line)
mime/quotedprintable
reader.go#L40: return 0, fmt.Errorf("quotedprintable: invalid hex byte 0x%02x", b)
reader.go#L99: r.rerr = fmt.Errorf("quotedprintable: invalid bytes after =: %q", rightStripped)
reader.go#L131: return n, fmt.Errorf("quotedprintable: invalid unescaped byte 0x%02x in body", b)
net/http
client.go#L268: return nil, didTimeout, fmt.Errorf("http: RoundTripper implementation (%T) returned a nil *Response with a nil error", rt)
client.go#L282: return nil, didTimeout, fmt.Errorf("http: RoundTripper implementation (%T) returned a *Response with content length %d but a nil Body", rt, resp.ContentLength)
client.go#L637: return nil, uerr(fmt.Errorf("%d response missing Location header", resp.StatusCode))
client.go#L642: return nil, uerr(fmt.Errorf("failed to parse Location header %q: %v", loc, err))
h2_bundle.go#L3817: return fmt.Errorf("http2: TLSConfig.CipherSuites index %d contains an HTTP/2-approved cipher suite (%#04x), but it comes after unapproved cipher suites. With this configuration, clients that don't support previous, approved cipher suites may be given an unapproved one and reject the connection.", i, cs)
h2_bundle.go#L3821: return fmt.Errorf("http2: TLSConfig.CipherSuites is missing an HTTP/2-required AES_128_GCM_SHA256 cipher (need at least one of TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 or TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256).")
h2_bundle.go#L4539: errc <- fmt.Errorf("bogus greeting %q", buf)
h2_bundle.go#L5252: st.body.CloseWithError(fmt.Errorf("sender tried to send more than declared Content-Length of %d bytes", st.declBodyBytes))
h2_bundle.go#L5316: st.body.CloseWithError(fmt.Errorf("request declared a Content-Length of %d but only wrote %d bytes",
h2_bundle.go#L6327: return fmt.Errorf("target must be an absolute URL or an absolute path: %q", target)
h2_bundle.go#L6333: return fmt.Errorf("cannot push URL with scheme %q from request with scheme %q", u.Scheme, wantScheme)
h2_bundle.go#L6341: return fmt.Errorf("promised request headers cannot include pseudo header %q", k)
h2_bundle.go#L6349: return fmt.Errorf("promised request headers cannot include %q", k)
h2_bundle.go#L6360: return fmt.Errorf("method %q must be GET or HEAD", opts.Method)
h2_bundle.go#L6511: return fmt.Errorf("request header %q is not valid in HTTP/2", k)
h2_bundle.go#L7057: return nil, fmt.Errorf("http2: Transport: cannot retry err [%v] after Request.Body was written; define Request.GetBody to avoid this error", err)
h2_bundle.go#L7118: return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, http2NextProtoTLS)
h2_bundle.go#L7479: return "", fmt.Errorf("invalid Trailer key %q", k)
h2_bundle.go#L7506: return fmt.Errorf("http2: invalid Upgrade request header: %q", req.Header["Upgrade"])
h2_bundle.go#L7509: return fmt.Errorf("http2: invalid Transfer-Encoding request header: %q", vv)
h2_bundle.go#L7512: return fmt.Errorf("http2: invalid Connection request header: %q", vv)
h2_bundle.go#L7993: return nil, fmt.Errorf("invalid request :path %q from URL.Opaque = %q", orig, req.URL.Opaque)
h2_bundle.go#L7995: return nil, fmt.Errorf("invalid request :path %q", orig)
h2_bundle.go#L8006: return nil, fmt.Errorf("invalid HTTP header name %q", k)
h2_bundle.go#L8010: return nil, fmt.Errorf("invalid HTTP header value %q for header %q", v, k)
h2_bundle.go#L9183: err = fmt.Errorf("%v", e)
request.go#L85: func badStringError(what, val string) error { return fmt.Errorf("%s %q", what, val) }
request.go#L861: return nil, fmt.Errorf("net/http: invalid method %q", method)
server.go#L324: return nil, nil, fmt.Errorf("unexpected Peek failure reading buffered byte: %v", err)
transfer.go#L83: return nil, fmt.Errorf("http: Request.ContentLength=%d with nil Body", rr.ContentLength)
transfer.go#L387: return fmt.Errorf("http: ContentLength=%d with Body length %d",
transfer.go#L678: return 0, fmt.Errorf("http: message cannot contain multiple Content-Length headers; got %q", contentLens)
transfer.go#L696: return 0, fmt.Errorf("http: method cannot contain a Content-Length; got %q", contentLens)
transport.go#L521: return nil, fmt.Errorf("net/http: invalid header field name %q", k)
transport.go#L526: return nil, fmt.Errorf("net/http: invalid header field value %q for key %v", v, k)
transport.go#L552: return nil, fmt.Errorf("net/http: invalid method %q", req.Method)
transport.go#L1917: return 0, fmt.Errorf("read limit of %d bytes exhausted", pc.maxHeaderResponseSize())
transport.go#L2038: return fmt.Errorf("net/http: HTTP/1.x transport connection broken: %v", err)
transport.go#L2106: err = fmt.Errorf("net/http: server response headers exceeded %d bytes; aborted", pc.maxHeaderResponseSize())
transport.go#L2245: pc.closeLocked(fmt.Errorf("readLoopPeekFailLocked: %v", peekErr))
transport.go#L2616: pc.close(fmt.Errorf("write error: %v", err))
net/textproto
reader.go#L129: return nil, fmt.Errorf("missing validateFirstLine func")
net/url
url.go#L629: return "", fmt.Errorf("invalid port %q after host", colonPort)
url.go#L657: return "", fmt.Errorf("invalid port %q after host", colonPort)
os/user
cgo_lookup_unix.go#L72: return nil, fmt.Errorf("user: lookup username %s: %v", username, err)
cgo_lookup_unix.go#L101: return nil, fmt.Errorf("user: lookup userid %d: %v", uid, err)
cgo_lookup_unix.go#L140: return nil, fmt.Errorf("user: lookup groupname %s: %v", groupname, err)
cgo_lookup_unix.go#L169: return nil, fmt.Errorf("user: lookup groupid %d: %v", gid, err)
cgo_lookup_unix.go#L242: return fmt.Errorf("internal buffer exceeds %d bytes", maxBufferSize)
getgrouplist_darwin.go#L52: return fmt.Errorf("user: %q is a member of more than %d groups", username, maxGroups)
listgroups_unix.go#L30: return nil, fmt.Errorf("user: list groups for %s: invalid gid %q", u.Username, u.Gid)
runtime/pprof
pprof.go#L780: return fmt.Errorf("cpu profiling already in use")
proto.go#L278: return fmt.Errorf("truncated profile")
proto.go#L281: return fmt.Errorf("malformed profile")
proto.go#L307: return fmt.Errorf("truncated profile")
proto.go#L310: return fmt.Errorf("malformed profile")
src.elv.sh/pkg/cli/mode
histlist.go#L42: return nil, fmt.Errorf("db error: %v", err.Error())
lastcmd.go#L46: return nil, fmt.Errorf("db error: %v", err)
location.go#L82: return nil, fmt.Errorf("db error: %v", err)
src.elv.sh/pkg/cli/term
setup_unix.go#L21: return nil, fmt.Errorf("can't get terminal attribute: %s", err)
setup_unix.go#L38: return nil, fmt.Errorf("can't set up terminal attribute: %s", err)
setup_unix.go#L44: errSetupVT = fmt.Errorf("can't setup VT: %s", err)
src.elv.sh/pkg/daemon
spawn.go#L53: pathError = fmt.Errorf("%s is required for spawning daemon", name)
spawn.go#L58: pathError = fmt.Errorf("cannot resolve %s to absolute path: %s", name, err)
src.elv.sh/pkg/diag
context.go#L105: return fmt.Errorf("%s, unknown position", c.Name)
context.go#L107: return fmt.Errorf("%s, invalid position %d-%d", c.Name, c.From, c.To)
src.elv.sh/pkg/edit
complete_getopt.go#L199: err = fmt.Errorf("arg should be string, got %s", vals.Kind(v))
complete_getopt.go#L227: err = fmt.Errorf("opt should be map, got %s", vals.Kind(v))
complete_getopt.go#L242: fmt.Errorf("%s should be string, got %s", k, vals.Kind(v))
complete_getopt.go#L253: fmt.Errorf("%s should be fn, got %s", k, vals.Kind(v))
complete_getopt.go#L264: fmt.Errorf("%s should be bool, got %s", k, vals.Kind(v))
complete_getopt.go#L270: err = fmt.Errorf(
complete_getopt.go#L352: err = fmt.Errorf(
complete_getopt.go#L359: err = fmt.Errorf(
completion.go#L442: return nil, fmt.Errorf("arg completer for %s not a function", args[0])
src.elv.sh/pkg/edit/complete
generators.go#L103: return nil, fmt.Errorf("cannot list directory %s: %v", dirToRead, err)
src.elv.sh/pkg/eval
builtin_fn_container.go#L129: errMakeMap = fmt.Errorf("internal bug: collected %v values", len(elems))
builtin_fn_container.go#L427: return fmt.Errorf("expect a single value, got %d", n)
builtin_fn_container.go#L653: return 0, fmt.Errorf("cannot get length of a %s", vals.Kind(v))
builtin_fn_io.go#L686: return nil, fmt.Errorf("unexpected json type: %T", v)
builtin_fn_misc.go#L296: return "", fmt.Errorf("%s: source is not valid UTF-8", fname)
builtin_fn_misc.go#L416: return fmt.Errorf("sleep duration must be >= zero")
builtin_fn_styled.go#L149: return nil, fmt.Errorf("expected string, styled segment or styled text; got %s", vals.Kind(input))
builtin_fn_styled.go#L157: return nil, fmt.Errorf("%s is not a valid style transformer", parse.Quote(styling))
builtin_fn_styled.go#L170: return nil, fmt.Errorf("styling function must return a single segment; got %d values", n)
builtin_fn_styled.go#L172: return nil, fmt.Errorf("styling function must return a segment; got %s", vals.Kind(vs[0]))
builtin_fn_styled.go#L179: return nil, fmt.Errorf("need string or callable; got %s", vals.Kind(styling))
compile_value.go#L192: return nil, fmt.Errorf("tilde doesn't work on value of type %s", vals.Kind(v))
frame.go#L225: return fm.errorp(r, fmt.Errorf(format, args...))
glob.go#L106: badRangeExpr := fmt.Errorf("bad range modifier: %s", parse.Quote(rangeExpr))
glob.go#L125: return nil, fmt.Errorf("unknown modifier %s", vals.Repr(modifierv, vals.NoPretty))
glob.go#L204: return nil, fmt.Errorf("bad wildcard: %q", s)
go_fn.go#L211: return fmt.Errorf("wrong type of argument %d: %v", i, err)
go_fn.go#L224: return fmt.Errorf("%s cannot be iterated", vals.Kind(iterable))
options.go#L24: return fmt.Errorf(
options.go#L47: return fmt.Errorf("unknown option %s", parse.Quote(k))
src.elv.sh/pkg/eval/mods/re
re.go#L90: return "", fmt.Errorf(
re.go#L113: errReplace = fmt.Errorf("replacement function must output exactly one value, got %d", len(values))
re.go#L118: errReplace = fmt.Errorf(
re.go#L127: return "", fmt.Errorf(
src.elv.sh/pkg/eval/vals
conversion.go#L93: return fmt.Errorf("internal bug: need pointer to scan to, got %T", ptr)
src.elv.sh/pkg/fsutil
gethome.go#L36: return "", fmt.Errorf("can't resolve ~%s: %s", uname, err.Error())
src.elv.sh/pkg/parse
parse.go#L172: ps.error(fmt.Errorf("bad rune at form head: %q", ps.peek()))
parser.go#L58: ps.error(fmt.Errorf("unexpected rune %q", r))
src.elv.sh/pkg/parse/cmpd
cmpd.go#L47: return "", fmt.Errorf("%s must be string literal, found %s", what, Shape(n))
src.elv.sh/pkg/persistent/hashmap
hashmap.go#L168: return "", fmt.Errorf("unsupported key type %T", k)
src.elv.sh/pkg/shell
interact.go#L119: return fmt.Errorf("cannot get full path of rc.elv: %v", err)
paths_unix.go#L31: return "", fmt.Errorf("mkdir: %v", err)
paths_unix.go#L34: return "", fmt.Errorf("cannot create %v as a secure run directory", runDir)
runtime.go#L110: return cl, fmt.Errorf("socket file %s inaccessible: %v", sockpath, err)
runtime.go#L115: return cl, fmt.Errorf("failed to remove socket file: %v", err)
runtime.go#L119: return cl, fmt.Errorf("unexpected RPC error on socket %s: %v", sockpath, err)
runtime.go#L126: return cl, fmt.Errorf("failed to kill old daemon: %v", err)
runtime.go#L130: return cl, fmt.Errorf("code bug: unknown daemon status %d", status)
runtime.go#L139: return cl, fmt.Errorf("failed to spawn daemon: %v", err)
runtime.go#L154: return cl, fmt.Errorf("socket file %s inaccessible: %v", sockpath, err)
runtime.go#L158: return cl, fmt.Errorf("unexpected RPC error on socket %s: %v", sockpath, err)
runtime.go#L162: return cl, fmt.Errorf("code bug: newly spawned daemon is outdated")
runtime.go#L164: return cl, fmt.Errorf("code bug: unknown daemon status %d", status)
runtime.go#L168: return cl, fmt.Errorf("daemon unreachable after waiting for %s", daemonWaitLoops*daemonWaitPerLoop)
runtime.go#L200: return fmt.Errorf("cannot get pid of daemon: %v", err)
runtime.go#L204: return fmt.Errorf("cannot find daemon process (pid=%d): %v", pid, err)
src.elv.sh/pkg/store
db_store.go#L64: return fmt.Errorf("failed to %s: %v", name, err)
src.elv.sh/pkg/ui
key.go#L186: return Key{}, fmt.Errorf("bad modifier: %s", parse.Quote(modname))
key.go#L194: return Key{}, fmt.Errorf("Ctrl modifier with literal control char: %q", k.Rune)
key.go#L230: return Key{}, fmt.Errorf("bad key: %s", parse.Quote(s))
style.go#L92: return fmt.Errorf("unrecognized option '%s'", k)
style.go#L96: return fmt.Errorf("value for option '%s' must be a %s", k, need)
testing
benchmark.go#L54: return fmt.Errorf("invalid count")
benchmark.go#L61: return fmt.Errorf("invalid duration")
vendor/golang.org/x/crypto/cryptobyte
asn1.go#L112: b.err = fmt.Errorf("cryptobyte: cannot represent %v as a GeneralizedTime", t)
asn1.go#L171: b.err = fmt.Errorf("cryptobyte: invalid OID: %v", oid)
asn1.go#L224: b.err = fmt.Errorf("cryptobyte: high-tag number identifier octects not supported: 0x%x", tag)
builder.go#L273: b.err = fmt.Errorf("cryptobyte: pending child length %d exceeds %d-byte length prefix", length, child.pendingLenLen)
vendor/golang.org/x/crypto/curve25519
curve25519.go#L77: return nil, fmt.Errorf("bad scalar length: %d, expected %d", l, 32)
curve25519.go#L80: return nil, fmt.Errorf("bad point length: %d, expected %d", l, 32)
curve25519.go#L91: return nil, fmt.Errorf("bad input point: low order point")
vendor/golang.org/x/net/http/httpproxy
proxy.go#L165: return nil, fmt.Errorf("invalid proxy address %q: %v", proxy, err)
vendor/golang.org/x/text/unicode/norm
iter.go#L76: return 0, fmt.Errorf("norm: invalid whence")
iter.go#L79: return 0, fmt.Errorf("norm: negative position")