default:
return "", fmt.Errorf("unknown const value type %T", vi)
}
- panic("unreachable")
}
// resolveName finds a top-level node named name and returns the node
return buf.Bytes(), err
}
- panic("unreachable")
}
// mkdir makes the named directory.
return b.buf, ErrBufferFull
}
}
- panic("not reached")
}
// ReadLine is a low-level line-reading primitive. Most callers should use
}
s.end += n
}
- panic("not reached")
}
// advance consumes n bytes of the buffer. It reports whether the advance was legal.
nodeIndex = node.right
}
}
-
- panic("unreachable")
}
// newHuffmanTree builds a Huffman tree from a slice containing the code
}
<-b.ready
}
- panic("unreachable")
}
func (b *syncBuffer) signal() {
}
f.step(f)
}
- panic("unreachable")
}
func (f *decompressor) Close() error {
return
}
}
- panic("unreached")
}
// copyHist copies f.copyLen bytes from f.hist (f.copyDist bytes ago) to itself.
default:
return offsetCodes[off>>14] + 28
}
- panic("unreachable")
}
}
d.decode()
}
- panic("unreachable")
}
// decode decompresses bytes from r and leaves them in d.toRead.
params.G = g
return
}
-
- panic("unreachable")
}
// GenerateKey generates a public&private key pair. The Parameters of the
default:
return nil, fmt.Errorf("crypto/x509: PKCS#8 wrapping contained private key with unknown algorithm: %v", privKey.Algo.Algorithm)
}
-
- panic("unreachable")
}
default:
return nil, nil
}
- panic("unreachable")
}
func parseCertificate(in *certificate) (*Certificate, error) {
nn, d.readErr = d.r.Read(d.buf[d.nbuf:])
d.nbuf += nn
}
- panic("unreachable")
}
x |= uint64(b&0x7f) << s
s += 7
}
- panic("unreachable")
}
// ReadVarint reads an encoded signed integer from r and returns it as an int64.
}
records = append(records, record)
}
- panic("unreachable")
}
// readRune reads one rune from r, folding \r\n to \n and keeping track
switch d.scanWhile(scanSkipSpace) {
default:
d.error(errPhase)
+ panic("unreachable")
case scanBeginArray:
return d.arrayInterface()
case scanBeginObject:
case scanBeginLiteral:
return d.literalInterface()
}
- panic("unreachable")
}
// arrayInterface is like array but returns []interface{}.
return true, nil
}
}
- panic("unreachable")
}
// Skip reads tokens until it has consumed the end element
return nil
}
}
- panic("unreachable")
}
prev = pos
}
}
-
- panic("unreachable")
}
// compareErrors compares the map of expected error messages with the list
}
k = j
}
- panic("unreachable")
}
var elementContentType = [...]state{
return err
}
}
- panic("unreachable")
}
func (d *decoder) readGraphicControl() error {
return
}
}
- panic("unreachable")
}
// Discard is an io.Writer on which all Write calls succeed
return x
}
}
- panic("unreachable")
}
var ke = [256]uint32{
return x
}
}
- panic("unreachable")
}
var kn = [128]uint32{
return nil, fmt.Errorf("multipart: unexpected line in Next(): %q", line)
}
- panic("unreachable")
}
// isFinalBoundary returns whether line is the final boundary line
case p := <-ch:
return p.Conn, p.error
}
- panic("unreachable")
}
type stringAddr struct {
return b, err
}
}
- panic("unreachable")
}
func TestClient(t *testing.T) {
c := newChild(rw, handler)
go c.serve()
}
- panic("unreachable")
}
}
go c.serve()
}
- panic("not reached")
}
// ListenAndServe listens on the TCP network address addr
return
}
}
- panic("unreachable")
}
func (t *Transport) setReqConn(r *Request, pc *persistConn) {
func (WriteFailCodec) ReadResponseHeader(*Response) error {
select {}
- panic("unreachable")
}
func (WriteFailCodec) ReadResponseBody(interface{}) error {
select {}
- panic("unreachable")
}
func (WriteFailCodec) Close() error {
return m, err
}
}
- panic("unreachable")
}
// CanonicalMIMEHeaderKey returns the canonical format of the
return n, err
}
- panic("not reached")
}
// pwrite writes len(b) bytes to the File starting at byte offset off.