update decoder

Author: IncSW

README.md

@@ -56,7 +56,7 @@ data, err := bencode.Unmarshal(value)
 
 | Library             |    Time    | Bytes Allocated | Objects Allocated |
 | :------------------ | :--------: | :-------------: | :---------------: |
-| IncSW/go-bencode    | 1149 ns/op |    960 B/op     |   18 allocs/op    |
+| IncSW/go-bencode    | 1001 ns/op |    960 B/op     |   18 allocs/op    |
 | cristalhq/bencode   | 1160 ns/op |    960 B/op     |   18 allocs/op    |
 | nabilanam/bencode   | 1379 ns/op |    1240 B/op    |   39 allocs/op    |
 | aleksatr/go-bencode | 2270 ns/op |    1816 B/op    |   51 allocs/op    |

bencode.go

@@ -16,5 +16,6 @@ func Marshal(data interface{}) ([]byte, error) {
 }
 
 func Unmarshal(data []byte) (interface{}, error) {
-	return decoder.Unmarshal(data)
+	var d decoder.Decoder
+	return d.Decode(data)
 }

decoder_test.go

@@ -59,7 +59,7 @@ func TestUnmarshal(t *testing.T) {
 	}
 
 	result, err = Unmarshal([]byte("i38qe"))
-	if !assert.Error(err) || !assert.Nil(result) || !assert.Equal(`strconv.ParseInt: parsing "38q": invalid syntax`, err.Error()) {
+	if !assert.Error(err) || !assert.Nil(result) || !assert.Equal("bencode: invalid integer byte: 113", err.Error()) {
 		return
 	}
 

internal/decoder/bytes.go

@@ -0,0 +1,29 @@
+package decoder
+
+import (
+	"bytes"
+	"errors"
+)
+
+func (d *Decoder) decodeBytes() ([]byte, error) {
+	if d.data[d.cursor] < '0' || d.data[d.cursor] > '9' {
+		return nil, errors.New("bencode: invalid string field")
+	}
+	index := bytes.IndexByte(d.data[d.cursor:], ':')
+	if index == -1 {
+		return nil, errors.New("bencode: invalid string field")
+	}
+	index += d.cursor
+	stringLength, err := d.parseInt(d.data[d.cursor:index])
+	if err != nil {
+		return nil, err
+	}
+	index += 1
+	endIndex := index + int(stringLength)
+	if endIndex > d.length {
+		return nil, errors.New("bencode: not a valid bencoded string")
+	}
+	value := d.data[index:endIndex]
+	d.cursor = endIndex
+	return value, nil
+}

internal/decoder/decoder.go

@@ -1,106 +1,67 @@
 package decoder
 
 import (
-	"bytes"
 	"errors"
-	"strconv"
+	_ "unsafe"
 
 	"github.com/IncSW/go-bencode/internal"
 )
 
-func Unmarshal(data []byte) (interface{}, error) {
-	return (&unmarshaler{
-		data:   data,
-		length: len(data),
-	}).unmarshal()
-}
-
-type unmarshaler struct {
+type Decoder struct {
 	data   []byte
 	length int
 	cursor int
 }
 
-func (u *unmarshaler) unmarshal() (interface{}, error) {
-	switch u.data[u.cursor] {
-	case 'i':
-		u.cursor += 1
-		index := bytes.IndexByte(u.data[u.cursor:], 'e')
-		if index == -1 {
-			return nil, errors.New("bencode: invalid integer field")
-		}
-		index += u.cursor
-		integer, err := strconv.ParseInt(internal.B2S(u.data[u.cursor:index]), 10, 64)
-		if err != nil {
-			return nil, err
-		}
-		u.cursor = index + 1
-		return integer, nil
+func (d *Decoder) Decode(data []byte) (interface{}, error) {
+	d.data = data
+	d.length = len(data)
+	return d.decode()
+}
 
+func (d *Decoder) decode() (interface{}, error) {
+	switch d.data[d.cursor] {
+	case 'i':
+		return d.decodeInt()
 	case 'l':
-		u.cursor += 1
+		d.cursor += 1
 		list := []interface{}{}
 		for {
-			if u.cursor == u.length {
+			if d.cursor == d.length {
 				return nil, errors.New("bencode: invalid list field")
 			}
-			if u.data[u.cursor] == 'e' {
-				u.cursor += 1
+			if d.data[d.cursor] == 'e' {
+				d.cursor += 1
 				return list, nil
 			}
-			value, err := u.unmarshal()
+			value, err := d.decode()
 			if err != nil {
 				return nil, err
 			}
 			list = append(list, value)
 		}
-
 	case 'd':
-		u.cursor += 1
+		d.cursor += 1
 		dictionary := map[string]interface{}{}
 		for {
-			if u.cursor == u.length {
+			if d.cursor == d.length {
 				return nil, errors.New("bencode: invalid dictionary field")
 			}
-			if u.data[u.cursor] == 'e' {
-				u.cursor += 1
+			if d.data[d.cursor] == 'e' {
+				d.cursor += 1
 				return dictionary, nil
 			}
-			key, err := u.unmarshalString()
+			key, err := d.decodeBytes()
 			if err != nil {
 				return nil, errors.New("bencode: non-string dictionary key")
 			}
-			value, err := u.unmarshal()
+			value, err := d.decode()
 			if err != nil {
 				return nil, err
 			}
 			dictionary[internal.B2S(key)] = value
 		}
-
 	default:
-		return u.unmarshalString()
-	}
-}
-
-func (u *unmarshaler) unmarshalString() ([]byte, error) {
-	if u.data[u.cursor] < '0' || u.data[u.cursor] > '9' {
-		return nil, errors.New("bencode: invalid string field")
-	}
-	index := bytes.IndexByte(u.data[u.cursor:], ':')
-	if index == -1 {
-		return nil, errors.New("bencode: invalid string field")
-	}
-	index += u.cursor
-	stringLength, err := strconv.ParseInt(internal.B2S(u.data[u.cursor:index]), 10, 64)
-	if err != nil {
-		return nil, err
-	}
-	index += 1
-	endIndex := index + int(stringLength)
-	if endIndex > u.length {
-		return nil, errors.New("bencode: not a valid bencoded string")
+		return d.decodeBytes()
 	}
-	value := u.data[index:endIndex]
-	u.cursor = endIndex
-	return value, nil
 }

internal/decoder/int.go

@@ -0,0 +1,55 @@
+package decoder
+
+import (
+	"bytes"
+	"errors"
+	"strconv"
+)
+
+var (
+	pow10i64 = [...]int64{
+		1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,
+		1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18,
+	}
+	pow10i64Len = len(pow10i64)
+)
+
+func (d *Decoder) parseInt(data []byte) (int64, error) {
+	isNegative := false
+	if data[0] == '-' {
+		data = data[1:]
+		isNegative = true
+	}
+	maxDigit := len(data)
+	if maxDigit > pow10i64Len {
+		return 0, errors.New("bencode: invalid length of number")
+	}
+	sum := int64(0)
+	for i, b := range data {
+		if b < '0' || b > '9' {
+			return 0, errors.New("bencode: invalid integer byte: " + strconv.FormatUint(uint64(b), 10))
+		}
+		c := int64(b) - 48
+		digitValue := pow10i64[maxDigit-i-1]
+		sum += c * digitValue
+	}
+	if isNegative {
+		return -1 * sum, nil
+	}
+	return sum, nil
+}
+
+func (d *Decoder) decodeInt() (interface{}, error) {
+	d.cursor += 1
+	index := bytes.IndexByte(d.data[d.cursor:], 'e')
+	if index == -1 {
+		return nil, errors.New("bencode: invalid integer field")
+	}
+	index += d.cursor
+	integer, err := d.parseInt(d.data[d.cursor:index])
+	if err != nil {
+		return nil, err
+	}
+	d.cursor = index + 1
+	return integer, nil
+}