renamed variables for consistency and improved writing small integers

Author: dchenk

msgp/defs.go

@@ -123,7 +123,7 @@ func wfixstr(u uint8) byte {
 }
 
 func rfixarray(b byte) uint8 {
-	return (b & last4)
+	return b & last4
 }
 
 func wfixarray(u uint8) byte {

msgp/extension.go

@@ -111,84 +111,84 @@ func (mw *Writer) WriteExtension(e Extension) error {
 	l := e.Len()
 	switch l {
 	case 0:
-		o, err := mw.require(3)
+		i, err := mw.require(3)
 		if err != nil {
 			return err
 		}
-		mw.buf[o] = mext8
-		mw.buf[o+1] = 0
-		mw.buf[o+2] = byte(e.ExtensionType())
+		mw.buf[i] = mext8
+		mw.buf[i+1] = 0
+		mw.buf[i+2] = byte(e.ExtensionType())
 	case 1:
-		o, err := mw.require(2)
+		i, err := mw.require(2)
 		if err != nil {
 			return err
 		}
-		mw.buf[o] = mfixext1
-		mw.buf[o+1] = byte(e.ExtensionType())
+		mw.buf[i] = mfixext1
+		mw.buf[i+1] = byte(e.ExtensionType())
 	case 2:
-		o, err := mw.require(2)
+		i, err := mw.require(2)
 		if err != nil {
 			return err
 		}
-		mw.buf[o] = mfixext2
-		mw.buf[o+1] = byte(e.ExtensionType())
+		mw.buf[i] = mfixext2
+		mw.buf[i+1] = byte(e.ExtensionType())
 	case 4:
-		o, err := mw.require(2)
+		i, err := mw.require(2)
 		if err != nil {
 			return err
 		}
-		mw.buf[o] = mfixext4
-		mw.buf[o+1] = byte(e.ExtensionType())
+		mw.buf[i] = mfixext4
+		mw.buf[i+1] = byte(e.ExtensionType())
 	case 8:
-		o, err := mw.require(2)
+		i, err := mw.require(2)
 		if err != nil {
 			return err
 		}
-		mw.buf[o] = mfixext8
-		mw.buf[o+1] = byte(e.ExtensionType())
+		mw.buf[i] = mfixext8
+		mw.buf[i+1] = byte(e.ExtensionType())
 	case 16:
-		o, err := mw.require(2)
+		i, err := mw.require(2)
 		if err != nil {
 			return err
 		}
-		mw.buf[o] = mfixext16
-		mw.buf[o+1] = byte(e.ExtensionType())
+		mw.buf[i] = mfixext16
+		mw.buf[i+1] = byte(e.ExtensionType())
 	default:
 		switch {
 		case l < math.MaxUint8:
-			o, err := mw.require(3)
+			i, err := mw.require(3)
 			if err != nil {
 				return err
 			}
-			mw.buf[o] = mext8
-			mw.buf[o+1] = byte(uint8(l))
-			mw.buf[o+2] = byte(e.ExtensionType())
+			mw.buf[i] = mext8
+			mw.buf[i+1] = byte(uint8(l))
+			mw.buf[i+2] = byte(e.ExtensionType())
 		case l < math.MaxUint16:
-			o, err := mw.require(4)
+			i, err := mw.require(4)
 			if err != nil {
 				return err
 			}
-			mw.buf[o] = mext16
-			big.PutUint16(mw.buf[o+1:], uint16(l))
-			mw.buf[o+3] = byte(e.ExtensionType())
+			mw.buf[i] = mext16
+			big.PutUint16(mw.buf[i+1:], uint16(l))
+			mw.buf[i+3] = byte(e.ExtensionType())
 		default:
-			o, err := mw.require(6)
+			i, err := mw.require(6)
 			if err != nil {
 				return err
 			}
-			mw.buf[o] = mext32
-			big.PutUint32(mw.buf[o+1:], uint32(l))
-			mw.buf[o+5] = byte(e.ExtensionType())
+			mw.buf[i] = mext32
+			big.PutUint32(mw.buf[i+1:], uint32(l))
+			mw.buf[i+5] = byte(e.ExtensionType())
 		}
 	}
 	// We can only write directly to the buffer if we're sure that it
 	// fits the object.
 	if l <= len(mw.buf) {
-		o, err := mw.require(l)
+		i, err := mw.require(l)
 		if err != nil {
 			return err
 		}
-		return e.MarshalBinaryTo(mw.buf[o:])
+		return e.MarshalBinaryTo(mw.buf[i:])
 	}
 	// Here we create a new buffer just large enough for the body
 	// and save it as the write buffer.

msgp/write.go

@@ -309,7 +309,15 @@ func (mw *Writer) WriteInt64(i int64) error {
 }
 
 // WriteInt8 writes an int8 to the writer.
-func (mw *Writer) WriteInt8(i int8) error { return mw.WriteInt64(int64(i)) }
+func (mw *Writer) WriteInt8(i int8) error {
+	if i >= 0 {
+		return mw.push(wfixint(uint8(i)))
+	}
+	if i >= -32 {
+		return mw.push(wnfixint(i))
+	}
+	return mw.prefix8(mint8, uint8(i))
+}
 
 // WriteInt16 writes an int16 to the writer.
 func (mw *Writer) WriteInt16(i int16) error { return mw.WriteInt64(int64(i)) }

msgp/write_bytes.go

@@ -126,11 +126,18 @@ func AppendInt64(b []byte, i int64) []byte {
 	}
 }
 
-// AppendInt appends an int b.
-func AppendInt(b []byte, i int) []byte { return AppendInt64(b, int64(i)) }
-
 // AppendInt8 appends an int8 b.
-func AppendInt8(b []byte, i int8) []byte { return AppendInt64(b, int64(i)) }
+func AppendInt8(b []byte, i int8) []byte {
+	if i >= 0 {
+		return append(b, wfixint(uint8(i)))
+	}
+	if i >= -32 {
+		return append(b, wnfixint(int8(i)))
+	}
+	o, n := ensure(b, 2)
+	putMint8(o[n:], i)
+	return o
+}
 
 // AppendInt16 appends an int16 b.
 func AppendInt16(b []byte, i int16) []byte { return AppendInt64(b, int64(i)) }
@@ -141,7 +148,7 @@ func AppendInt32(b []byte, i int32) []byte { return AppendInt64(b, int64(i)) }
 // AppendUint64 appends a uint64 b.
 func AppendUint64(b []byte, u uint64) []byte {
 	switch {
-	case u <= 127:
+	case u <= math.MaxInt8:
 		return append(b, wfixint(uint8(u)))
 	case u <= math.MaxUint8:
 		o, n := ensure(b, 2)
@@ -166,17 +173,27 @@ func AppendUint64(b []byte, u uint64) []byte {
 func AppendUint(b []byte, u uint) []byte { return AppendUint64(b, uint64(u)) }
 
 // AppendUint8 appends a uint8 b.
-func AppendUint8(b []byte, u uint8) []byte { return AppendUint64(b, uint64(u)) }
-
-// AppendByte is analogous to AppendUint8
-func AppendByte(b []byte, u byte) []byte { return AppendUint8(b, uint8(u)) }
+func AppendUint8(b []byte, u uint8) []byte {
+	if u <= math.MaxInt8 {
+		return append(b, wfixint(uint8(u)))
+	}
+	o, n := ensure(b, 2)
+	putMuint8(o[n:], u)
+	return o
+}
 
 // AppendUint16 appends a uint16 b.
 func AppendUint16(b []byte, u uint16) []byte { return AppendUint64(b, uint64(u)) }
 
 // AppendUint32 appends a uint32 b.
 func AppendUint32(b []byte, u uint32) []byte { return AppendUint64(b, uint64(u)) }
 
+// AppendInt appends an int b.
+func AppendInt(b []byte, i int) []byte { return AppendInt64(b, int64(i)) }
+
+// AppendByte does the same thing as AppendUint8
+func AppendByte(b []byte, u byte) []byte { return AppendUint8(b, u) }
+
 // AppendBytes appends bytes b as MessagePack 'bin' data.
 func AppendBytes(b []byte, bts []byte) []byte {
 	sz := len(bts)