More minor cleanup (#8)

Author: klauspost

README.md

@@ -27,17 +27,20 @@ but retain high decompression speed.
 * Fast detection of pre-compressed data
 * Powerful commandline utility
 
-This package implements the MinLZ specification v1.0.
+This package implements the MinLZ specification v1.0 in Go.
 
 For format specification see the included [SPEC.md](SPEC.md).
 
 # Changelog
 
 * [v1.0.0](https://github.com/minio/minlz/releases/tag/v1.0.0)
-  * [Initial Release Blog Post](https://gist.github.com/klauspost/a25b66198cdbdf7b5b224f670c894ed5).
+  * [Initial Release Blog Post](https://blog.min.io/minlz-compression-algorithm/).
 
 # Usage
 
+[![Go Reference](https://pkg.go.dev/badge/minio/minlz.svg)](https://pkg.go.dev/github.com/minio/minlz?tab=subdirectories)
+[![Go](https://github.com/minio/minlz/actions/workflows/go.yml/badge.svg)](https://github.com/minio/minlz/actions/workflows/go.yml)
+
 MinLZ can operate on *blocks* up to 8 MB or *streams* with unlimited length.
 
 Blocks are the simplest, but do not provide any output validation. 
@@ -808,9 +811,11 @@ If you are interested in porting MinLZ to another language, open a discussion to
 
 If you do a port, feel free to send in a PR for this table:
 
-| Language | Repository Link                                          | License    | Features as described in SPEC.md                                                                                |
-|----------|----------------------------------------------------------|------------|-----------------------------------------------------------------------------------------------------------------|
-| Go       | [github.com/minio/minlz](https://github.com/minio/minlz) | Apache 2.0 | `[x] Block Read [x] Block Write [x] Stream Read [x] Stream Write [x] Index Support [x] Snappy Read Fallback`    |
+| Language | Repository Link                                                                         | License    | Block Read | Block Write | Stream Read | Stream Write | Index | Snappy Fallback |
+|----------|-----------------------------------------------------------------------------------------|------------|------------|-------------|-------------|--------------|-------|-----------------|
+| Go       | [github.com/minio/minlz](https://github.com/minio/minlz)                                | Apache 2.0 | ✅          | ✅           | ✅           | ✅            | ✅     | ✅               |  
+| C        | [Experimental GIST](https://gist.github.com/klauspost/5796a5aa116a15eb7341ffa8427bbe7a) | CC0        | ✅          | ✅           |             |              |       |                 |                                                                                                                 
+
 
 Indicated features must support all parts of each feature as described in the specification.
 However, it is up to the implementation to decide the encoding implementation(s).  

decode.go

@@ -18,7 +18,6 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
-	"strconv"
 
 	"github.com/klauspost/compress/s2"
 )
@@ -410,7 +409,7 @@ func minLZDecodeGo(dst, src []byte) int {
 				goto doCopy2
 			}
 
-			if length > len(dst)-d || length > len(src)-s || (strconv.IntSize == 32 && length <= 0) {
+			if length > len(dst)-d || length > len(src)-s {
 				if debugErrors {
 					fmt.Println("corrupt: lit size", length, "dst avail:", len(dst)-d, "src avail:", len(src)-s, "dst pos:", d)
 				}

encode.go

@@ -46,7 +46,7 @@ const (
 	minCopy2Length = 64
 
 	maxCopy3Lits   = 1<<copyLitBits - 1
-	minCopy3Offset = 65536         // 2MiB
+	minCopy3Offset = 65536
 	maxCopy3Offset = 2<<20 + 65535 // 2MiB
 	minCopy3Length = 64
 )

encode_l1.go

@@ -174,18 +174,6 @@ func encodeBlockGo(dst, src []byte) (d int) {
 		}
 
 		// A 4-byte match has been found. We'll later see if more than 4 bytes match.
-
-		// Call emitCopy, and then see if another emitCopy could be our next
-		// move. Repeat until we find no match for the input immediately after
-		// what was consumed by the last emitCopy call.
-		//
-		// If we exit this loop normally then we need to call emitLiteral next,
-		// though we don't yet know how big the literal will be. We handle that
-		// by proceeding to the next iteration of the main loop. We also can
-		// exit this loop via goto if we get close to exhausting the input.
-
-		// Invariant: we have a 4-byte match at s, and no need to emit any
-		// literal bytes prior to s.
 		base := s
 		repeat = base - candidate
 
@@ -429,18 +417,6 @@ func encodeBlockGo64K(dst, src []byte) (d int) {
 		}
 
 		// A 4-byte match has been found. We'll later see if more than 4 bytes match.
-
-		// Call emitCopy, and then see if another emitCopy could be our next
-		// move. Repeat until we find no match for the input immediately after
-		// what was consumed by the last emitCopy call.
-		//
-		// If we exit this loop normally then we need to call emitLiteral next,
-		// though we don't yet know how big the literal will be. We handle that
-		// by proceeding to the next iteration of the main loop. We also can
-		// exit this loop via goto if we get close to exhausting the input.
-
-		// Invariant: we have a 4-byte match at s, and no need to emit any
-		// literal bytes prior to s.
 		base := s
 		repeat = base - candidate