src/encoding/hex/hex.go - go - Git at Google

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 // Package hex implements hexadecimal encoding and decoding.
 package hex

 import (
 	"errors"
 	"fmt"
 	"io"
 	"strings"
 )

 const hextable = "0123456789abcdef"

 // EncodedLen returns the length of an encoding of n source bytes.
 // Specifically, it returns n * 2.
 func EncodedLen(n int) int { return n * 2 }

 // Encode encodes src into EncodedLen(len(src))
 // bytes of dst. As a convenience, it returns the number
 // of bytes written to dst, but this value is always EncodedLen(len(src)).
 // Encode implements hexadecimal encoding.
 func Encode(dst, src []byte) int {
 	j := 0
 	for _, v := range src {
 		dst[j] = hextable[v>>4]
 		dst[j+1] = hextable[v&0x0f]
 		j += 2
 	}
 	return len(src) * 2
 }

 // ErrLength reports an attempt to decode an odd-length input
 // using Decode or DecodeString.
 // The stream-based Decoder returns io.ErrUnexpectedEOF instead of ErrLength.
 var ErrLength = errors.New("encoding/hex: odd length hex string")

 // InvalidByteError values describe errors resulting from an invalid byte in a hex string.
 type InvalidByteError byte

 func (e InvalidByteError) Error() string {
 	return fmt.Sprintf("encoding/hex: invalid byte: %#U", rune(e))
 }

 // DecodedLen returns the length of a decoding of x source bytes.
 // Specifically, it returns x / 2.
 func DecodedLen(x int) int { return x / 2 }

 // Decode decodes src into DecodedLen(len(src)) bytes,
 // returning the actual number of bytes written to dst.
 //
 // Decode expects that src contains only hexadecimal
 // characters and that src has even length.
 // If the input is malformed, Decode returns the number
 // of bytes decoded before the error.
 func Decode(dst, src []byte) (int, error) {
 	i, j := 0, 1
 	for ; j < len(src); j += 2 {
 		a, ok := fromHexChar(src[j-1])
 		if !ok {
 			return i, InvalidByteError(src[j-1])
 		}
 		b, ok := fromHexChar(src[j])
 		if !ok {
 			return i, InvalidByteError(src[j])
 		}
 		dst[i] = (a << 4) | b
 		i++
 	}
 	if len(src)%2 == 1 {
 		// Check for invalid char before reporting bad length,
 		// since the invalid char (if present) is an earlier problem.
 		if _, ok := fromHexChar(src[j-1]); !ok {
 			return i, InvalidByteError(src[j-1])
 		}
 		return i, ErrLength
 	}
 	return i, nil
 }

 // fromHexChar converts a hex character into its value and a success flag.
 func fromHexChar(c byte) (byte, bool) {
 	switch {
 	case '0' <= c && c <= '9':
 		return c - '0', true
 	case 'a' <= c && c <= 'f':
 		return c - 'a' + 10, true
 	case 'A' <= c && c <= 'F':
 		return c - 'A' + 10, true
 	}

 	return 0, false
 }

 // EncodeToString returns the hexadecimal encoding of src.
 func EncodeToString(src []byte) string {
 	dst := make([]byte, EncodedLen(len(src)))
 	Encode(dst, src)
 	return string(dst)
 }

 // DecodeString returns the bytes represented by the hexadecimal string s.
 //
 // DecodeString expects that src contains only hexadecimal
 // characters and that src has even length.
 // If the input is malformed, DecodeString returns
 // the bytes decoded before the error.
 func DecodeString(s string) ([]byte, error) {
 	src := []byte(s)
 	// We can use the source slice itself as the destination
 	// because the decode loop increments by one and then the 'seen' byte is not used anymore.
 	n, err := Decode(src, src)
 	return src[:n], err
 }

 // Dump returns a string that contains a hex dump of the given data. The format
 // of the hex dump matches the output of `hexdump -C` on the command line.
 func Dump(data []byte) string {
 	if len(data) == 0 {
 		return ""
 	}

 	var buf strings.Builder
 	// Dumper will write 79 bytes per complete 16 byte chunk, and at least
 	// 64 bytes for whatever remains. Round the allocation up, since only a
 	// maximum of 15 bytes will be wasted.
 	buf.Grow((1 + ((len(data) - 1) / 16)) * 79)

 	dumper := Dumper(&buf)
 	dumper.Write(data)
 	dumper.Close()
 	return buf.String()
 }

 // bufferSize is the number of hexadecimal characters to buffer in encoder and decoder.
 const bufferSize = 1024

 type encoder struct {
 	w   io.Writer
 	err error
 	out [bufferSize]byte // output buffer
 }

 // NewEncoder returns an io.Writer that writes lowercase hexadecimal characters to w.
 func NewEncoder(w io.Writer) io.Writer {
 	return &encoder{w: w}
 }

 func (e *encoder) Write(p []byte) (n int, err error) {
 	for len(p) > 0 && e.err == nil {
 		chunkSize := bufferSize / 2
 		if len(p) < chunkSize {
 			chunkSize = len(p)
 		}

 		var written int
 		encoded := Encode(e.out[:], p[:chunkSize])
 		written, e.err = e.w.Write(e.out[:encoded])
 		n += written / 2
 		p = p[chunkSize:]
 	}
 	return n, e.err
 }

 type decoder struct {
 	r   io.Reader
 	err error
 	in  []byte           // input buffer (encoded form)
 	arr [bufferSize]byte // backing array for in
 }

 // NewDecoder returns an io.Reader that decodes hexadecimal characters from r.
 // NewDecoder expects that r contain only an even number of hexadecimal characters.
 func NewDecoder(r io.Reader) io.Reader {
 	return &decoder{r: r}
 }

 func (d *decoder) Read(p []byte) (n int, err error) {
 	// Fill internal buffer with sufficient bytes to decode
 	if len(d.in) < 2 && d.err == nil {
 		var numCopy, numRead int
 		numCopy = copy(d.arr[:], d.in) // Copies either 0 or 1 bytes
 		numRead, d.err = d.r.Read(d.arr[numCopy:])
 		d.in = d.arr[:numCopy+numRead]
 		if d.err == io.EOF && len(d.in)%2 != 0 {
 			if _, ok := fromHexChar(d.in[len(d.in)-1]); !ok {
 				d.err = InvalidByteError(d.in[len(d.in)-1])
 			} else {
 				d.err = io.ErrUnexpectedEOF
 			}
 		}
 	}

 	// Decode internal buffer into output buffer
 	if numAvail := len(d.in) / 2; len(p) > numAvail {
 		p = p[:numAvail]
 	}
 	numDec, err := Decode(p, d.in[:len(p)*2])
 	d.in = d.in[2*numDec:]
 	if err != nil {
 		d.in, d.err = nil, err // Decode error; discard input remainder
 	}

 	if len(d.in) < 2 {
 		return numDec, d.err // Only expose errors when buffer fully consumed
 	}
 	return numDec, nil
 }

 // Dumper returns a WriteCloser that writes a hex dump of all written data to
 // w. The format of the dump matches the output of `hexdump -C` on the command
 // line.
 func Dumper(w io.Writer) io.WriteCloser {
 	return &dumper{w: w}
 }

 type dumper struct {
 	w          io.Writer
 	rightChars [18]byte
 	buf        [14]byte
 	used       int  // number of bytes in the current line
 	n          uint // number of bytes, total
 	closed     bool
 }

 func toChar(b byte) byte {
 	if b < 32 || b > 126 {
 		return '.'
 	}
 	return b
 }

 func (h *dumper) Write(data []byte) (n int, err error) {
 	if h.closed {
 		return 0, errors.New("encoding/hex: dumper closed")
 	}

 	// Output lines look like:
 	// 00000010  2e 2f 30 31 32 33 34 35  36 37 38 39 3a 3b 3c 3d  |./0123456789:;<=|
 	// ^ offset                          ^ extra space              ^ ASCII of line.
 	for i := range data {
 		if h.used == 0 {
 			// At the beginning of a line we print the current
 			// offset in hex.
 			h.buf[0] = byte(h.n >> 24)
 			h.buf[1] = byte(h.n >> 16)
 			h.buf[2] = byte(h.n >> 8)
 			h.buf[3] = byte(h.n)
 			Encode(h.buf[4:], h.buf[:4])
 			h.buf[12] = ' '
 			h.buf[13] = ' '
 			_, err = h.w.Write(h.buf[4:])
 			if err != nil {
 				return
 			}
 		}
 		Encode(h.buf[:], data[i:i+1])
 		h.buf[2] = ' '
 		l := 3
 		if h.used == 7 {
 			// There's an additional space after the 8th byte.
 			h.buf[3] = ' '
 			l = 4
 		} else if h.used == 15 {
 			// At the end of the line there's an extra space and
 			// the bar for the right column.
 			h.buf[3] = ' '
 			h.buf[4] = '|'
 			l = 5
 		}
 		_, err = h.w.Write(h.buf[:l])
 		if err != nil {
 			return
 		}
 		n++
 		h.rightChars[h.used] = toChar(data[i])
 		h.used++
 		h.n++
 		if h.used == 16 {
 			h.rightChars[16] = '|'
 			h.rightChars[17] = '\n'
 			_, err = h.w.Write(h.rightChars[:])
 			if err != nil {
 				return
 			}
 			h.used = 0
 		}
 	}
 	return
 }

 func (h *dumper) Close() (err error) {
 	// See the comments in Write() for the details of this format.
 	if h.closed {
 		return
 	}
 	h.closed = true
 	if h.used == 0 {
 		return
 	}
 	h.buf[0] = ' '
 	h.buf[1] = ' '
 	h.buf[2] = ' '
 	h.buf[3] = ' '
 	h.buf[4] = '|'
 	nBytes := h.used
 	for h.used < 16 {
 		l := 3
 		if h.used == 7 {
 			l = 4
 		} else if h.used == 15 {
 			l = 5
 		}
 		_, err = h.w.Write(h.buf[:l])
 		if err != nil {
 			return
 		}
 		h.used++
 	}
 	h.rightChars[nBytes] = '|'
 	h.rightChars[nBytes+1] = '\n'
 	_, err = h.w.Write(h.rightChars[:nBytes+2])
 	return
 }
	// Copyright 2009 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	// Package hex implements hexadecimal encoding and decoding.
	package hex

	import (
	"errors"
	"fmt"
	"io"
	"strings"
	)

	const hextable = "0123456789abcdef"

	// EncodedLen returns the length of an encoding of n source bytes.
	// Specifically, it returns n * 2.
	func EncodedLen(n int) int { return n * 2 }

	// Encode encodes src into EncodedLen(len(src))
	// bytes of dst. As a convenience, it returns the number
	// of bytes written to dst, but this value is always EncodedLen(len(src)).
	// Encode implements hexadecimal encoding.
	func Encode(dst, src []byte) int {
	j := 0
	for _, v := range src {
	dst[j] = hextable[v>>4]
	dst[j+1] = hextable[v&0x0f]
	j += 2
	}
	return len(src) * 2
	}

	// ErrLength reports an attempt to decode an odd-length input
	// using Decode or DecodeString.
	// The stream-based Decoder returns io.ErrUnexpectedEOF instead of ErrLength.
	var ErrLength = errors.New("encoding/hex: odd length hex string")

	// InvalidByteError values describe errors resulting from an invalid byte in a hex string.
	type InvalidByteError byte

	func (e InvalidByteError) Error() string {
	return fmt.Sprintf("encoding/hex: invalid byte: %#U", rune(e))
	}

	// DecodedLen returns the length of a decoding of x source bytes.
	// Specifically, it returns x / 2.
	func DecodedLen(x int) int { return x / 2 }

	// Decode decodes src into DecodedLen(len(src)) bytes,
	// returning the actual number of bytes written to dst.
	//
	// Decode expects that src contains only hexadecimal
	// characters and that src has even length.
	// If the input is malformed, Decode returns the number
	// of bytes decoded before the error.
	func Decode(dst, src []byte) (int, error) {
	i, j := 0, 1
	for ; j < len(src); j += 2 {
	a, ok := fromHexChar(src[j-1])
	if !ok {
	return i, InvalidByteError(src[j-1])
	}
	b, ok := fromHexChar(src[j])
	if !ok {
	return i, InvalidByteError(src[j])
	}
	dst[i] = (a << 4) \| b
	i++
	}
	if len(src)%2 == 1 {
	// Check for invalid char before reporting bad length,
	// since the invalid char (if present) is an earlier problem.
	if _, ok := fromHexChar(src[j-1]); !ok {
	return i, InvalidByteError(src[j-1])
	}
	return i, ErrLength
	}
	return i, nil
	}

	// fromHexChar converts a hex character into its value and a success flag.
	func fromHexChar(c byte) (byte, bool) {
	switch {
	case '0' <= c && c <= '9':
	return c - '0', true
	case 'a' <= c && c <= 'f':
	return c - 'a' + 10, true
	case 'A' <= c && c <= 'F':
	return c - 'A' + 10, true
	}

	return 0, false
	}

	// EncodeToString returns the hexadecimal encoding of src.
	func EncodeToString(src []byte) string {
	dst := make([]byte, EncodedLen(len(src)))
	Encode(dst, src)
	return string(dst)
	}

	// DecodeString returns the bytes represented by the hexadecimal string s.
	//
	// DecodeString expects that src contains only hexadecimal
	// characters and that src has even length.
	// If the input is malformed, DecodeString returns
	// the bytes decoded before the error.
	func DecodeString(s string) ([]byte, error) {
	src := []byte(s)
	// We can use the source slice itself as the destination
	// because the decode loop increments by one and then the 'seen' byte is not used anymore.
	n, err := Decode(src, src)
	return src[:n], err
	}

	// Dump returns a string that contains a hex dump of the given data. The format
	// of the hex dump matches the output of `hexdump -C` on the command line.
	func Dump(data []byte) string {
	if len(data) == 0 {
	return ""
	}

	var buf strings.Builder
	// Dumper will write 79 bytes per complete 16 byte chunk, and at least
	// 64 bytes for whatever remains. Round the allocation up, since only a
	// maximum of 15 bytes will be wasted.
	buf.Grow((1 + ((len(data) - 1) / 16)) * 79)

	dumper := Dumper(&buf)
	dumper.Write(data)
	dumper.Close()
	return buf.String()
	}

	// bufferSize is the number of hexadecimal characters to buffer in encoder and decoder.
	const bufferSize = 1024

	type encoder struct {
	w io.Writer
	err error
	out [bufferSize]byte // output buffer
	}

	// NewEncoder returns an io.Writer that writes lowercase hexadecimal characters to w.
	func NewEncoder(w io.Writer) io.Writer {
	return &encoder{w: w}
	}

	func (e *encoder) Write(p []byte) (n int, err error) {
	for len(p) > 0 && e.err == nil {
	chunkSize := bufferSize / 2
	if len(p) < chunkSize {
	chunkSize = len(p)
	}

	var written int
	encoded := Encode(e.out[:], p[:chunkSize])
	written, e.err = e.w.Write(e.out[:encoded])
	n += written / 2
	p = p[chunkSize:]
	}
	return n, e.err
	}

	type decoder struct {
	r io.Reader
	err error
	in []byte // input buffer (encoded form)
	arr [bufferSize]byte // backing array for in
	}

	// NewDecoder returns an io.Reader that decodes hexadecimal characters from r.
	// NewDecoder expects that r contain only an even number of hexadecimal characters.
	func NewDecoder(r io.Reader) io.Reader {
	return &decoder{r: r}
	}

	func (d *decoder) Read(p []byte) (n int, err error) {
	// Fill internal buffer with sufficient bytes to decode
	if len(d.in) < 2 && d.err == nil {
	var numCopy, numRead int
	numCopy = copy(d.arr[:], d.in) // Copies either 0 or 1 bytes
	numRead, d.err = d.r.Read(d.arr[numCopy:])
	d.in = d.arr[:numCopy+numRead]
	if d.err == io.EOF && len(d.in)%2 != 0 {
	if _, ok := fromHexChar(d.in[len(d.in)-1]); !ok {
	d.err = InvalidByteError(d.in[len(d.in)-1])
	} else {
	d.err = io.ErrUnexpectedEOF
	}
	}
	}

	// Decode internal buffer into output buffer
	if numAvail := len(d.in) / 2; len(p) > numAvail {
	p = p[:numAvail]
	}
	numDec, err := Decode(p, d.in[:len(p)*2])
	d.in = d.in[2*numDec:]
	if err != nil {
	d.in, d.err = nil, err // Decode error; discard input remainder
	}

	if len(d.in) < 2 {
	return numDec, d.err // Only expose errors when buffer fully consumed
	}
	return numDec, nil
	}

	// Dumper returns a WriteCloser that writes a hex dump of all written data to
	// w. The format of the dump matches the output of `hexdump -C` on the command
	// line.
	func Dumper(w io.Writer) io.WriteCloser {
	return &dumper{w: w}
	}

	type dumper struct {
	w io.Writer
	rightChars [18]byte
	buf [14]byte
	used int // number of bytes in the current line
	n uint // number of bytes, total
	closed bool
	}

	func toChar(b byte) byte {
	if b < 32 \|\| b > 126 {
	return '.'
	}
	return b
	}

	func (h *dumper) Write(data []byte) (n int, err error) {
	if h.closed {
	return 0, errors.New("encoding/hex: dumper closed")
	}

	// Output lines look like:
	// 00000010 2e 2f 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d \|./0123456789:;<=\|
	// ^ offset ^ extra space ^ ASCII of line.
	for i := range data {
	if h.used == 0 {
	// At the beginning of a line we print the current
	// offset in hex.
	h.buf[0] = byte(h.n >> 24)
	h.buf[1] = byte(h.n >> 16)
	h.buf[2] = byte(h.n >> 8)
	h.buf[3] = byte(h.n)
	Encode(h.buf[4:], h.buf[:4])
	h.buf[12] = ' '
	h.buf[13] = ' '
	_, err = h.w.Write(h.buf[4:])
	if err != nil {
	return
	}
	}
	Encode(h.buf[:], data[i:i+1])
	h.buf[2] = ' '
	l := 3
	if h.used == 7 {
	// There's an additional space after the 8th byte.
	h.buf[3] = ' '
	l = 4
	} else if h.used == 15 {
	// At the end of the line there's an extra space and
	// the bar for the right column.
	h.buf[3] = ' '
	h.buf[4] = '\|'
	l = 5
	}
	_, err = h.w.Write(h.buf[:l])
	if err != nil {
	return
	}
	n++
	h.rightChars[h.used] = toChar(data[i])
	h.used++
	h.n++
	if h.used == 16 {
	h.rightChars[16] = '\|'
	h.rightChars[17] = '\n'
	_, err = h.w.Write(h.rightChars[:])
	if err != nil {
	return
	}
	h.used = 0
	}
	}
	return
	}

	func (h *dumper) Close() (err error) {
	// See the comments in Write() for the details of this format.
	if h.closed {
	return
	}
	h.closed = true
	if h.used == 0 {
	return
	}
	h.buf[0] = ' '
	h.buf[1] = ' '
	h.buf[2] = ' '
	h.buf[3] = ' '
	h.buf[4] = '\|'
	nBytes := h.used
	for h.used < 16 {
	l := 3
	if h.used == 7 {
	l = 4
	} else if h.used == 15 {
	l = 5
	}
	_, err = h.w.Write(h.buf[:l])
	if err != nil {
	return
	}
	h.used++
	}
	h.rightChars[nBytes] = '\|'
	h.rightChars[nBytes+1] = '\n'
	_, err = h.w.Write(h.rightChars[:nBytes+2])
	return
	}