diff --git a/.travis.yml b/.travis.yml index 6321d932..8c875c1a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,7 +1,5 @@ language: go go: - - 1.7.x - - 1.8.x - 1.9.x - master diff --git a/README.md b/README.md index 7cf066e2..249ad096 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,8 @@ wagon `wagon` is a [WebAssembly](http://webassembly.org)-based interpreter in [Go](https://golang.org), for [Go](https://golang.org). +**NOTE:** `wagon` requires `Go >= 1.9.x`. + ## Purpose `wagon` aims to provide tools (executables+libraries) to: diff --git a/vendor/math/bits/bits.go b/vendor/math/bits/bits.go deleted file mode 100644 index 989baacc..00000000 --- a/vendor/math/bits/bits.go +++ /dev/null @@ -1,330 +0,0 @@ -// Copyright 2017 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. - -//go:generate go run make_tables.go - -// Package bits implements bit counting and manipulation -// functions for the predeclared unsigned integer types. -package bits - -const uintSize = 32 << (^uint(0) >> 32 & 1) // 32 or 64 - -// UintSize is the size of a uint in bits. -const UintSize = uintSize - -// --- LeadingZeros --- - -// LeadingZeros returns the number of leading zero bits in x; the result is UintSize for x == 0. -func LeadingZeros(x uint) int { return UintSize - Len(x) } - -// LeadingZeros8 returns the number of leading zero bits in x; the result is 8 for x == 0. -func LeadingZeros8(x uint8) int { return 8 - Len8(x) } - -// LeadingZeros16 returns the number of leading zero bits in x; the result is 16 for x == 0. -func LeadingZeros16(x uint16) int { return 16 - Len16(x) } - -// LeadingZeros32 returns the number of leading zero bits in x; the result is 32 for x == 0. -func LeadingZeros32(x uint32) int { return 32 - Len32(x) } - -// LeadingZeros64 returns the number of leading zero bits in x; the result is 64 for x == 0. -func LeadingZeros64(x uint64) int { return 64 - Len64(x) } - -// --- TrailingZeros --- - -// See http://supertech.csail.mit.edu/papers/debruijn.pdf -const deBruijn32 = 0x077CB531 - -var deBruijn32tab = [32]byte{ - 0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, - 31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9, -} - -const deBruijn64 = 0x03f79d71b4ca8b09 - -var deBruijn64tab = [64]byte{ - 0, 1, 56, 2, 57, 49, 28, 3, 61, 58, 42, 50, 38, 29, 17, 4, - 62, 47, 59, 36, 45, 43, 51, 22, 53, 39, 33, 30, 24, 18, 12, 5, - 63, 55, 48, 27, 60, 41, 37, 16, 46, 35, 44, 21, 52, 32, 23, 11, - 54, 26, 40, 15, 34, 20, 31, 10, 25, 14, 19, 9, 13, 8, 7, 6, -} - -// TrailingZeros returns the number of trailing zero bits in x; the result is UintSize for x == 0. -func TrailingZeros(x uint) int { - if UintSize == 32 { - return TrailingZeros32(uint32(x)) - } - return TrailingZeros64(uint64(x)) -} - -// TrailingZeros8 returns the number of trailing zero bits in x; the result is 8 for x == 0. -func TrailingZeros8(x uint8) int { - return int(ntz8tab[x]) -} - -// TrailingZeros16 returns the number of trailing zero bits in x; the result is 16 for x == 0. -func TrailingZeros16(x uint16) (n int) { - if x == 0 { - return 16 - } - // see comment in TrailingZeros64 - return int(deBruijn32tab[uint32(x&-x)*deBruijn32>>(32-5)]) -} - -// TrailingZeros32 returns the number of trailing zero bits in x; the result is 32 for x == 0. -func TrailingZeros32(x uint32) int { - if x == 0 { - return 32 - } - // see comment in TrailingZeros64 - return int(deBruijn32tab[(x&-x)*deBruijn32>>(32-5)]) -} - -// TrailingZeros64 returns the number of trailing zero bits in x; the result is 64 for x == 0. -func TrailingZeros64(x uint64) int { - if x == 0 { - return 64 - } - // If popcount is fast, replace code below with return popcount(^x & (x - 1)). - // - // x & -x leaves only the right-most bit set in the word. Let k be the - // index of that bit. Since only a single bit is set, the value is two - // to the power of k. Multiplying by a power of two is equivalent to - // left shifting, in this case by k bits. The de Bruijn (64 bit) constant - // is such that all six bit, consecutive substrings are distinct. - // Therefore, if we have a left shifted version of this constant we can - // find by how many bits it was shifted by looking at which six bit - // substring ended up at the top of the word. - // (Knuth, volume 4, section 7.3.1) - return int(deBruijn64tab[(x&-x)*deBruijn64>>(64-6)]) -} - -// --- OnesCount --- - -const m0 = 0x5555555555555555 // 01010101 ... -const m1 = 0x3333333333333333 // 00110011 ... -const m2 = 0x0f0f0f0f0f0f0f0f // 00001111 ... -const m3 = 0x00ff00ff00ff00ff // etc. -const m4 = 0x0000ffff0000ffff - -// OnesCount returns the number of one bits ("population count") in x. -func OnesCount(x uint) int { - if UintSize == 32 { - return OnesCount32(uint32(x)) - } - return OnesCount64(uint64(x)) -} - -// OnesCount8 returns the number of one bits ("population count") in x. -func OnesCount8(x uint8) int { - return int(pop8tab[x]) -} - -// OnesCount16 returns the number of one bits ("population count") in x. -func OnesCount16(x uint16) int { - return int(pop8tab[x>>8] + pop8tab[x&0xff]) -} - -// OnesCount32 returns the number of one bits ("population count") in x. -func OnesCount32(x uint32) int { - return int(pop8tab[x>>24] + pop8tab[x>>16&0xff] + pop8tab[x>>8&0xff] + pop8tab[x&0xff]) -} - -// OnesCount64 returns the number of one bits ("population count") in x. -func OnesCount64(x uint64) int { - // Implementation: Parallel summing of adjacent bits. - // See "Hacker's Delight", Chap. 5: Counting Bits. - // The following pattern shows the general approach: - // - // x = x>>1&(m0&m) + x&(m0&m) - // x = x>>2&(m1&m) + x&(m1&m) - // x = x>>4&(m2&m) + x&(m2&m) - // x = x>>8&(m3&m) + x&(m3&m) - // x = x>>16&(m4&m) + x&(m4&m) - // x = x>>32&(m5&m) + x&(m5&m) - // return int(x) - // - // Masking (& operations) can be left away when there's no - // danger that a field's sum will carry over into the next - // field: Since the result cannot be > 64, 8 bits is enough - // and we can ignore the masks for the shifts by 8 and up. - // Per "Hacker's Delight", the first line can be simplified - // more, but it saves at best one instruction, so we leave - // it alone for clarity. - const m = 1<<64 - 1 - x = x>>1&(m0&m) + x&(m0&m) - x = x>>2&(m1&m) + x&(m1&m) - x = (x>>4 + x) & (m2 & m) - x += x >> 8 - x += x >> 16 - x += x >> 32 - return int(x) & (1<<7 - 1) -} - -// --- RotateLeft --- - -// RotateLeft returns the value of x rotated left by (k mod UintSize) bits. -// To rotate x right by k bits, call RotateLeft(x, -k). -func RotateLeft(x uint, k int) uint { - if UintSize == 32 { - return uint(RotateLeft32(uint32(x), k)) - } - return uint(RotateLeft64(uint64(x), k)) -} - -// RotateLeft8 returns the value of x rotated left by (k mod 8) bits. -// To rotate x right by k bits, call RotateLeft8(x, -k). -func RotateLeft8(x uint8, k int) uint8 { - const n = 8 - s := uint(k) & (n - 1) - return x<>(n-s) -} - -// RotateLeft16 returns the value of x rotated left by (k mod 16) bits. -// To rotate x right by k bits, call RotateLeft16(x, -k). -func RotateLeft16(x uint16, k int) uint16 { - const n = 16 - s := uint(k) & (n - 1) - return x<>(n-s) -} - -// RotateLeft32 returns the value of x rotated left by (k mod 32) bits. -// To rotate x right by k bits, call RotateLeft32(x, -k). -func RotateLeft32(x uint32, k int) uint32 { - const n = 32 - s := uint(k) & (n - 1) - return x<>(n-s) -} - -// RotateLeft64 returns the value of x rotated left by (k mod 64) bits. -// To rotate x right by k bits, call RotateLeft64(x, -k). -func RotateLeft64(x uint64, k int) uint64 { - const n = 64 - s := uint(k) & (n - 1) - return x<>(n-s) -} - -// --- Reverse --- - -// Reverse returns the value of x with its bits in reversed order. -func Reverse(x uint) uint { - if UintSize == 32 { - return uint(Reverse32(uint32(x))) - } - return uint(Reverse64(uint64(x))) -} - -// Reverse8 returns the value of x with its bits in reversed order. -func Reverse8(x uint8) uint8 { - return rev8tab[x] -} - -// Reverse16 returns the value of x with its bits in reversed order. -func Reverse16(x uint16) uint16 { - return uint16(rev8tab[x>>8]) | uint16(rev8tab[x&0xff])<<8 -} - -// Reverse32 returns the value of x with its bits in reversed order. -func Reverse32(x uint32) uint32 { - const m = 1<<32 - 1 - x = x>>1&(m0&m) | x&(m0&m)<<1 - x = x>>2&(m1&m) | x&(m1&m)<<2 - x = x>>4&(m2&m) | x&(m2&m)<<4 - x = x>>8&(m3&m) | x&(m3&m)<<8 - return x>>16 | x<<16 -} - -// Reverse64 returns the value of x with its bits in reversed order. -func Reverse64(x uint64) uint64 { - const m = 1<<64 - 1 - x = x>>1&(m0&m) | x&(m0&m)<<1 - x = x>>2&(m1&m) | x&(m1&m)<<2 - x = x>>4&(m2&m) | x&(m2&m)<<4 - x = x>>8&(m3&m) | x&(m3&m)<<8 - x = x>>16&(m4&m) | x&(m4&m)<<16 - return x>>32 | x<<32 -} - -// --- ReverseBytes --- - -// ReverseBytes returns the value of x with its bytes in reversed order. -func ReverseBytes(x uint) uint { - if UintSize == 32 { - return uint(ReverseBytes32(uint32(x))) - } - return uint(ReverseBytes64(uint64(x))) -} - -// ReverseBytes16 returns the value of x with its bytes in reversed order. -func ReverseBytes16(x uint16) uint16 { - return x>>8 | x<<8 -} - -// ReverseBytes32 returns the value of x with its bytes in reversed order. -func ReverseBytes32(x uint32) uint32 { - const m = 1<<32 - 1 - x = x>>8&(m3&m) | x&(m3&m)<<8 - return x>>16 | x<<16 -} - -// ReverseBytes64 returns the value of x with its bytes in reversed order. -func ReverseBytes64(x uint64) uint64 { - const m = 1<<64 - 1 - x = x>>8&(m3&m) | x&(m3&m)<<8 - x = x>>16&(m4&m) | x&(m4&m)<<16 - return x>>32 | x<<32 -} - -// --- Len --- - -// Len returns the minimum number of bits required to represent x; the result is 0 for x == 0. -func Len(x uint) int { - if UintSize == 32 { - return Len32(uint32(x)) - } - return Len64(uint64(x)) -} - -// Len8 returns the minimum number of bits required to represent x; the result is 0 for x == 0. -func Len8(x uint8) int { - return int(len8tab[x]) -} - -// Len16 returns the minimum number of bits required to represent x; the result is 0 for x == 0. -func Len16(x uint16) (n int) { - if x >= 1<<8 { - x >>= 8 - n = 8 - } - return n + int(len8tab[x]) -} - -// Len32 returns the minimum number of bits required to represent x; the result is 0 for x == 0. -func Len32(x uint32) (n int) { - if x >= 1<<16 { - x >>= 16 - n = 16 - } - if x >= 1<<8 { - x >>= 8 - n += 8 - } - return n + int(len8tab[x]) -} - -// Len64 returns the minimum number of bits required to represent x; the result is 0 for x == 0. -func Len64(x uint64) (n int) { - if x >= 1<<32 { - x >>= 32 - n = 32 - } - if x >= 1<<16 { - x >>= 16 - n += 16 - } - if x >= 1<<8 { - x >>= 8 - n += 8 - } - return n + int(len8tab[x]) -} diff --git a/vendor/math/bits/bits_tables.go b/vendor/math/bits/bits_tables.go deleted file mode 100644 index f1e15a0d..00000000 --- a/vendor/math/bits/bits_tables.go +++ /dev/null @@ -1,83 +0,0 @@ -// Copyright 2017 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. - -// Code generated by go run make_tables.go. DO NOT EDIT. - -package bits - -var ntz8tab = [256]uint8{ - 0x08, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, - 0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, - 0x05, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, - 0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, - 0x06, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, - 0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, - 0x05, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, - 0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, - 0x07, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, - 0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, - 0x05, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, - 0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, - 0x06, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, - 0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, - 0x05, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, - 0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, -} - -var pop8tab = [256]uint8{ - 0x00, 0x01, 0x01, 0x02, 0x01, 0x02, 0x02, 0x03, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x04, - 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x04, 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, - 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x04, 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, - 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06, - 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x04, 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, - 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06, - 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06, - 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06, 0x04, 0x05, 0x05, 0x06, 0x05, 0x06, 0x06, 0x07, - 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x04, 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, - 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06, - 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06, - 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06, 0x04, 0x05, 0x05, 0x06, 0x05, 0x06, 0x06, 0x07, - 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06, - 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06, 0x04, 0x05, 0x05, 0x06, 0x05, 0x06, 0x06, 0x07, - 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x06, 0x04, 0x05, 0x05, 0x06, 0x05, 0x06, 0x06, 0x07, - 0x04, 0x05, 0x05, 0x06, 0x05, 0x06, 0x06, 0x07, 0x05, 0x06, 0x06, 0x07, 0x06, 0x07, 0x07, 0x08, -} - -var rev8tab = [256]uint8{ - 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0, - 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, - 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4, - 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, - 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, - 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, - 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6, - 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, - 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1, - 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, - 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, - 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd, - 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, - 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, - 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, - 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff, -} - -var len8tab = [256]uint8{ - 0x00, 0x01, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, - 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, - 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, - 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, - 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, - 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, - 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, - 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, - 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, - 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, - 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, - 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, - 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, - 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, - 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, - 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, -} diff --git a/vendor/math/bits/bits_test.go b/vendor/math/bits/bits_test.go deleted file mode 100644 index 95878b7f..00000000 --- a/vendor/math/bits/bits_test.go +++ /dev/null @@ -1,747 +0,0 @@ -// Copyright 2017 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 bits - -import ( - "testing" - "unsafe" -) - -func TestUintSize(t *testing.T) { - var x uint - if want := unsafe.Sizeof(x) * 8; UintSize != want { - t.Fatalf("UintSize = %d; want %d", UintSize, want) - } -} - -func TestLeadingZeros(t *testing.T) { - for i := 0; i < 256; i++ { - nlz := tab[i].nlz - for k := 0; k < 64-8; k++ { - x := uint64(i) << uint(k) - if x <= 1<<8-1 { - got := LeadingZeros8(uint8(x)) - want := nlz - k + (8 - 8) - if x == 0 { - want = 8 - } - if got != want { - t.Fatalf("LeadingZeros8(%#02x) == %d; want %d", x, got, want) - } - } - - if x <= 1<<16-1 { - got := LeadingZeros16(uint16(x)) - want := nlz - k + (16 - 8) - if x == 0 { - want = 16 - } - if got != want { - t.Fatalf("LeadingZeros16(%#04x) == %d; want %d", x, got, want) - } - } - - if x <= 1<<32-1 { - got := LeadingZeros32(uint32(x)) - want := nlz - k + (32 - 8) - if x == 0 { - want = 32 - } - if got != want { - t.Fatalf("LeadingZeros32(%#08x) == %d; want %d", x, got, want) - } - if UintSize == 32 { - got = LeadingZeros(uint(x)) - if got != want { - t.Fatalf("LeadingZeros(%#08x) == %d; want %d", x, got, want) - } - } - } - - if x <= 1<<64-1 { - got := LeadingZeros64(uint64(x)) - want := nlz - k + (64 - 8) - if x == 0 { - want = 64 - } - if got != want { - t.Fatalf("LeadingZeros64(%#016x) == %d; want %d", x, got, want) - } - if UintSize == 64 { - got = LeadingZeros(uint(x)) - if got != want { - t.Fatalf("LeadingZeros(%#016x) == %d; want %d", x, got, want) - } - } - } - } - } -} - -// Exported (global) variable serving as input for some -// of the benchmarks to ensure side-effect free calls -// are not optimized away. -var Input uint64 = deBruijn64 - -// Exported (global) variable to store function results -// during benchmarking to ensure side-effect free calls -// are not optimized away. -var Output int - -func BenchmarkLeadingZeros(b *testing.B) { - var s int - for i := 0; i < b.N; i++ { - s += LeadingZeros(uint(Input) >> (uint(i) % UintSize)) - } - Output = s -} - -func BenchmarkLeadingZeros8(b *testing.B) { - var s int - for i := 0; i < b.N; i++ { - s += LeadingZeros8(uint8(Input) >> (uint(i) % 8)) - } - Output = s -} - -func BenchmarkLeadingZeros16(b *testing.B) { - var s int - for i := 0; i < b.N; i++ { - s += LeadingZeros16(uint16(Input) >> (uint(i) % 16)) - } - Output = s -} - -func BenchmarkLeadingZeros32(b *testing.B) { - var s int - for i := 0; i < b.N; i++ { - s += LeadingZeros32(uint32(Input) >> (uint(i) % 32)) - } - Output = s -} - -func BenchmarkLeadingZeros64(b *testing.B) { - var s int - for i := 0; i < b.N; i++ { - s += LeadingZeros64(uint64(Input) >> (uint(i) % 64)) - } - Output = s -} - -func TestTrailingZeros(t *testing.T) { - for i := 0; i < 256; i++ { - ntz := tab[i].ntz - for k := 0; k < 64-8; k++ { - x := uint64(i) << uint(k) - want := ntz + k - if x <= 1<<8-1 { - got := TrailingZeros8(uint8(x)) - if x == 0 { - want = 8 - } - if got != want { - t.Fatalf("TrailingZeros8(%#02x) == %d; want %d", x, got, want) - } - } - - if x <= 1<<16-1 { - got := TrailingZeros16(uint16(x)) - if x == 0 { - want = 16 - } - if got != want { - t.Fatalf("TrailingZeros16(%#04x) == %d; want %d", x, got, want) - } - } - - if x <= 1<<32-1 { - got := TrailingZeros32(uint32(x)) - if x == 0 { - want = 32 - } - if got != want { - t.Fatalf("TrailingZeros32(%#08x) == %d; want %d", x, got, want) - } - if UintSize == 32 { - got = TrailingZeros(uint(x)) - if got != want { - t.Fatalf("TrailingZeros(%#08x) == %d; want %d", x, got, want) - } - } - } - - if x <= 1<<64-1 { - got := TrailingZeros64(uint64(x)) - if x == 0 { - want = 64 - } - if got != want { - t.Fatalf("TrailingZeros64(%#016x) == %d; want %d", x, got, want) - } - if UintSize == 64 { - got = TrailingZeros(uint(x)) - if got != want { - t.Fatalf("TrailingZeros(%#016x) == %d; want %d", x, got, want) - } - } - } - } - } -} - -func BenchmarkTrailingZeros(b *testing.B) { - var s int - for i := 0; i < b.N; i++ { - s += TrailingZeros(uint(Input) << (uint(i) % UintSize)) - } - Output = s -} - -func BenchmarkTrailingZeros8(b *testing.B) { - var s int - for i := 0; i < b.N; i++ { - s += TrailingZeros8(uint8(Input) << (uint(i) % 8)) - } - Output = s -} - -func BenchmarkTrailingZeros16(b *testing.B) { - var s int - for i := 0; i < b.N; i++ { - s += TrailingZeros16(uint16(Input) << (uint(i) % 16)) - } - Output = s -} - -func BenchmarkTrailingZeros32(b *testing.B) { - var s int - for i := 0; i < b.N; i++ { - s += TrailingZeros32(uint32(Input) << (uint(i) % 32)) - } - Output = s -} - -func BenchmarkTrailingZeros64(b *testing.B) { - var s int - for i := 0; i < b.N; i++ { - s += TrailingZeros64(uint64(Input) << (uint(i) % 64)) - } - Output = s -} - -func TestOnesCount(t *testing.T) { - var x uint64 - for i := 0; i <= 64; i++ { - testOnesCount(t, x, i) - x = x<<1 | 1 - } - - for i := 64; i >= 0; i-- { - testOnesCount(t, x, i) - x = x << 1 - } - - for i := 0; i < 256; i++ { - for k := 0; k < 64-8; k++ { - testOnesCount(t, uint64(i)<>(8-k&0x7) - if got8 != want8 { - t.Fatalf("RotateLeft8(%#02x, %d) == %#02x; want %#02x", x8, k, got8, want8) - } - got8 = RotateLeft8(want8, -int(k)) - if got8 != x8 { - t.Fatalf("RotateLeft8(%#02x, -%d) == %#02x; want %#02x", want8, k, got8, x8) - } - - x16 := uint16(m) - got16 := RotateLeft16(x16, int(k)) - want16 := x16<<(k&0xf) | x16>>(16-k&0xf) - if got16 != want16 { - t.Fatalf("RotateLeft16(%#04x, %d) == %#04x; want %#04x", x16, k, got16, want16) - } - got16 = RotateLeft16(want16, -int(k)) - if got16 != x16 { - t.Fatalf("RotateLeft16(%#04x, -%d) == %#04x; want %#04x", want16, k, got16, x16) - } - - x32 := uint32(m) - got32 := RotateLeft32(x32, int(k)) - want32 := x32<<(k&0x1f) | x32>>(32-k&0x1f) - if got32 != want32 { - t.Fatalf("RotateLeft32(%#08x, %d) == %#08x; want %#08x", x32, k, got32, want32) - } - got32 = RotateLeft32(want32, -int(k)) - if got32 != x32 { - t.Fatalf("RotateLeft32(%#08x, -%d) == %#08x; want %#08x", want32, k, got32, x32) - } - if UintSize == 32 { - x := uint(m) - got := RotateLeft(x, int(k)) - want := x<<(k&0x1f) | x>>(32-k&0x1f) - if got != want { - t.Fatalf("RotateLeft(%#08x, %d) == %#08x; want %#08x", x, k, got, want) - } - got = RotateLeft(want, -int(k)) - if got != x { - t.Fatalf("RotateLeft(%#08x, -%d) == %#08x; want %#08x", want, k, got, x) - } - } - - x64 := uint64(m) - got64 := RotateLeft64(x64, int(k)) - want64 := x64<<(k&0x3f) | x64>>(64-k&0x3f) - if got64 != want64 { - t.Fatalf("RotateLeft64(%#016x, %d) == %#016x; want %#016x", x64, k, got64, want64) - } - got64 = RotateLeft64(want64, -int(k)) - if got64 != x64 { - t.Fatalf("RotateLeft64(%#016x, -%d) == %#016x; want %#016x", want64, k, got64, x64) - } - if UintSize == 64 { - x := uint(m) - got := RotateLeft(x, int(k)) - want := x<<(k&0x3f) | x>>(64-k&0x3f) - if got != want { - t.Fatalf("RotateLeft(%#016x, %d) == %#016x; want %#016x", x, k, got, want) - } - got = RotateLeft(want, -int(k)) - if got != x { - t.Fatalf("RotateLeft(%#08x, -%d) == %#08x; want %#08x", want, k, got, x) - } - } - } -} - -func BenchmarkRotateLeft(b *testing.B) { - var s uint - for i := 0; i < b.N; i++ { - s += RotateLeft(uint(Input), i) - } - Output = int(s) -} - -func BenchmarkRotateLeft8(b *testing.B) { - var s uint8 - for i := 0; i < b.N; i++ { - s += RotateLeft8(uint8(Input), i) - } - Output = int(s) -} - -func BenchmarkRotateLeft16(b *testing.B) { - var s uint16 - for i := 0; i < b.N; i++ { - s += RotateLeft16(uint16(Input), i) - } - Output = int(s) -} - -func BenchmarkRotateLeft32(b *testing.B) { - var s uint32 - for i := 0; i < b.N; i++ { - s += RotateLeft32(uint32(Input), i) - } - Output = int(s) -} - -func BenchmarkRotateLeft64(b *testing.B) { - var s uint64 - for i := 0; i < b.N; i++ { - s += RotateLeft64(uint64(Input), i) - } - Output = int(s) -} - -func TestReverse(t *testing.T) { - // test each bit - for i := uint(0); i < 64; i++ { - testReverse(t, uint64(1)<> (64 - 8)) - if got8 != want8 { - t.Fatalf("Reverse8(%#02x) == %#02x; want %#02x", x8, got8, want8) - } - - x16 := uint16(x64) - got16 := Reverse16(x16) - want16 := uint16(want64 >> (64 - 16)) - if got16 != want16 { - t.Fatalf("Reverse16(%#04x) == %#04x; want %#04x", x16, got16, want16) - } - - x32 := uint32(x64) - got32 := Reverse32(x32) - want32 := uint32(want64 >> (64 - 32)) - if got32 != want32 { - t.Fatalf("Reverse32(%#08x) == %#08x; want %#08x", x32, got32, want32) - } - if UintSize == 32 { - x := uint(x32) - got := Reverse(x) - want := uint(want32) - if got != want { - t.Fatalf("Reverse(%#08x) == %#08x; want %#08x", x, got, want) - } - } - - got64 := Reverse64(x64) - if got64 != want64 { - t.Fatalf("Reverse64(%#016x) == %#016x; want %#016x", x64, got64, want64) - } - if UintSize == 64 { - x := uint(x64) - got := Reverse(x) - want := uint(want64) - if got != want { - t.Fatalf("Reverse(%#08x) == %#016x; want %#016x", x, got, want) - } - } -} - -func BenchmarkReverse(b *testing.B) { - var s uint - for i := 0; i < b.N; i++ { - s += Reverse(uint(i)) - } - Output = int(s) -} - -func BenchmarkReverse8(b *testing.B) { - var s uint8 - for i := 0; i < b.N; i++ { - s += Reverse8(uint8(i)) - } - Output = int(s) -} - -func BenchmarkReverse16(b *testing.B) { - var s uint16 - for i := 0; i < b.N; i++ { - s += Reverse16(uint16(i)) - } - Output = int(s) -} - -func BenchmarkReverse32(b *testing.B) { - var s uint32 - for i := 0; i < b.N; i++ { - s += Reverse32(uint32(i)) - } - Output = int(s) -} - -func BenchmarkReverse64(b *testing.B) { - var s uint64 - for i := 0; i < b.N; i++ { - s += Reverse64(uint64(i)) - } - Output = int(s) -} - -func TestReverseBytes(t *testing.T) { - for _, test := range []struct { - x, r uint64 - }{ - {0, 0}, - {0x01, 0x01 << 56}, - {0x0123, 0x2301 << 48}, - {0x012345, 0x452301 << 40}, - {0x01234567, 0x67452301 << 32}, - {0x0123456789, 0x8967452301 << 24}, - {0x0123456789ab, 0xab8967452301 << 16}, - {0x0123456789abcd, 0xcdab8967452301 << 8}, - {0x0123456789abcdef, 0xefcdab8967452301 << 0}, - } { - testReverseBytes(t, test.x, test.r) - testReverseBytes(t, test.r, test.x) - } -} - -func testReverseBytes(t *testing.T, x64, want64 uint64) { - x16 := uint16(x64) - got16 := ReverseBytes16(x16) - want16 := uint16(want64 >> (64 - 16)) - if got16 != want16 { - t.Fatalf("ReverseBytes16(%#04x) == %#04x; want %#04x", x16, got16, want16) - } - - x32 := uint32(x64) - got32 := ReverseBytes32(x32) - want32 := uint32(want64 >> (64 - 32)) - if got32 != want32 { - t.Fatalf("ReverseBytes32(%#08x) == %#08x; want %#08x", x32, got32, want32) - } - if UintSize == 32 { - x := uint(x32) - got := ReverseBytes(x) - want := uint(want32) - if got != want { - t.Fatalf("ReverseBytes(%#08x) == %#08x; want %#08x", x, got, want) - } - } - - got64 := ReverseBytes64(x64) - if got64 != want64 { - t.Fatalf("ReverseBytes64(%#016x) == %#016x; want %#016x", x64, got64, want64) - } - if UintSize == 64 { - x := uint(x64) - got := ReverseBytes(x) - want := uint(want64) - if got != want { - t.Fatalf("ReverseBytes(%#016x) == %#016x; want %#016x", x, got, want) - } - } -} - -func BenchmarkReverseBytes(b *testing.B) { - var s uint - for i := 0; i < b.N; i++ { - s += ReverseBytes(uint(i)) - } - Output = int(s) -} - -func BenchmarkReverseBytes16(b *testing.B) { - var s uint16 - for i := 0; i < b.N; i++ { - s += ReverseBytes16(uint16(i)) - } - Output = int(s) -} - -func BenchmarkReverseBytes32(b *testing.B) { - var s uint32 - for i := 0; i < b.N; i++ { - s += ReverseBytes32(uint32(i)) - } - Output = int(s) -} - -func BenchmarkReverseBytes64(b *testing.B) { - var s uint64 - for i := 0; i < b.N; i++ { - s += ReverseBytes64(uint64(i)) - } - Output = int(s) -} - -func TestLen(t *testing.T) { - for i := 0; i < 256; i++ { - len := 8 - tab[i].nlz - for k := 0; k < 64-8; k++ { - x := uint64(i) << uint(k) - want := 0 - if x != 0 { - want = len + k - } - if x <= 1<<8-1 { - got := Len8(uint8(x)) - if got != want { - t.Fatalf("Len8(%#02x) == %d; want %d", x, got, want) - } - } - - if x <= 1<<16-1 { - got := Len16(uint16(x)) - if got != want { - t.Fatalf("Len16(%#04x) == %d; want %d", x, got, want) - } - } - - if x <= 1<<32-1 { - got := Len32(uint32(x)) - if got != want { - t.Fatalf("Len32(%#08x) == %d; want %d", x, got, want) - } - if UintSize == 32 { - got := Len(uint(x)) - if got != want { - t.Fatalf("Len(%#08x) == %d; want %d", x, got, want) - } - } - } - - if x <= 1<<64-1 { - got := Len64(uint64(x)) - if got != want { - t.Fatalf("Len64(%#016x) == %d; want %d", x, got, want) - } - if UintSize == 64 { - got := Len(uint(x)) - if got != want { - t.Fatalf("Len(%#016x) == %d; want %d", x, got, want) - } - } - } - } - } -} - -// ---------------------------------------------------------------------------- -// Testing support - -type entry struct { - nlz, ntz, pop int -} - -// tab contains results for all uint8 values -var tab [256]entry - -func init() { - tab[0] = entry{8, 8, 0} - for i := 1; i < len(tab); i++ { - // nlz - x := i // x != 0 - n := 0 - for x&0x80 == 0 { - n++ - x <<= 1 - } - tab[i].nlz = n - - // ntz - x = i // x != 0 - n = 0 - for x&1 == 0 { - n++ - x >>= 1 - } - tab[i].ntz = n - - // pop - x = i // x != 0 - n = 0 - for x != 0 { - n += int(x & 1) - x >>= 1 - } - tab[i].pop = n - } -} diff --git a/vendor/math/bits/example_test.go b/vendor/math/bits/example_test.go deleted file mode 100644 index f4ed2590..00000000 --- a/vendor/math/bits/example_test.go +++ /dev/null @@ -1,140 +0,0 @@ -// Copyright 2017 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. - -// Code generated by go run make_examples.go. DO NOT EDIT. - -package bits_test - -import ( - "fmt" - "math/bits" -) - -func ExampleLeadingZeros8() { - fmt.Printf("LeadingZeros8(%08b) = %d\n", 1, bits.LeadingZeros8(1)) - // Output: - // LeadingZeros8(00000001) = 7 -} - -func ExampleLeadingZeros16() { - fmt.Printf("LeadingZeros16(%016b) = %d\n", 1, bits.LeadingZeros16(1)) - // Output: - // LeadingZeros16(0000000000000001) = 15 -} - -func ExampleLeadingZeros32() { - fmt.Printf("LeadingZeros32(%032b) = %d\n", 1, bits.LeadingZeros32(1)) - // Output: - // LeadingZeros32(00000000000000000000000000000001) = 31 -} - -func ExampleLeadingZeros64() { - fmt.Printf("LeadingZeros64(%064b) = %d\n", 1, bits.LeadingZeros64(1)) - // Output: - // LeadingZeros64(0000000000000000000000000000000000000000000000000000000000000001) = 63 -} - -func ExampleTrailingZeros8() { - fmt.Printf("TrailingZeros8(%08b) = %d\n", 14, bits.TrailingZeros8(14)) - // Output: - // TrailingZeros8(00001110) = 1 -} - -func ExampleTrailingZeros16() { - fmt.Printf("TrailingZeros16(%016b) = %d\n", 14, bits.TrailingZeros16(14)) - // Output: - // TrailingZeros16(0000000000001110) = 1 -} - -func ExampleTrailingZeros32() { - fmt.Printf("TrailingZeros32(%032b) = %d\n", 14, bits.TrailingZeros32(14)) - // Output: - // TrailingZeros32(00000000000000000000000000001110) = 1 -} - -func ExampleTrailingZeros64() { - fmt.Printf("TrailingZeros64(%064b) = %d\n", 14, bits.TrailingZeros64(14)) - // Output: - // TrailingZeros64(0000000000000000000000000000000000000000000000000000000000001110) = 1 -} - -func ExampleOnesCount8() { - fmt.Printf("OnesCount8(%08b) = %d\n", 14, bits.OnesCount8(14)) - // Output: - // OnesCount8(00001110) = 3 -} - -func ExampleOnesCount16() { - fmt.Printf("OnesCount16(%016b) = %d\n", 14, bits.OnesCount16(14)) - // Output: - // OnesCount16(0000000000001110) = 3 -} - -func ExampleOnesCount32() { - fmt.Printf("OnesCount32(%032b) = %d\n", 14, bits.OnesCount32(14)) - // Output: - // OnesCount32(00000000000000000000000000001110) = 3 -} - -func ExampleOnesCount64() { - fmt.Printf("OnesCount64(%064b) = %d\n", 14, bits.OnesCount64(14)) - // Output: - // OnesCount64(0000000000000000000000000000000000000000000000000000000000001110) = 3 -} - -func ExampleLen8() { - fmt.Printf("Len8(%08b) = %d\n", 8, bits.Len8(8)) - // Output: - // Len8(00001000) = 4 -} - -func ExampleLen16() { - fmt.Printf("Len16(%016b) = %d\n", 8, bits.Len16(8)) - // Output: - // Len16(0000000000001000) = 4 -} - -func ExampleLen32() { - fmt.Printf("Len32(%032b) = %d\n", 8, bits.Len32(8)) - // Output: - // Len32(00000000000000000000000000001000) = 4 -} - -func ExampleLen64() { - fmt.Printf("Len64(%064b) = %d\n", 8, bits.Len64(8)) - // Output: - // Len64(0000000000000000000000000000000000000000000000000000000000001000) = 4 -} - -func ExampleReverse8() { - fmt.Printf("%08b\n", 19) - fmt.Printf("%08b\n", bits.Reverse8(19)) - // Output: - // 00010011 - // 11001000 -} - -func ExampleReverse16() { - fmt.Printf("%016b\n", 19) - fmt.Printf("%016b\n", bits.Reverse16(19)) - // Output: - // 0000000000010011 - // 1100100000000000 -} - -func ExampleReverse32() { - fmt.Printf("%032b\n", 19) - fmt.Printf("%032b\n", bits.Reverse32(19)) - // Output: - // 00000000000000000000000000010011 - // 11001000000000000000000000000000 -} - -func ExampleReverse64() { - fmt.Printf("%064b\n", 19) - fmt.Printf("%064b\n", bits.Reverse64(19)) - // Output: - // 0000000000000000000000000000000000000000000000000000000000010011 - // 1100100000000000000000000000000000000000000000000000000000000000 -} diff --git a/vendor/math/bits/make_examples.go b/vendor/math/bits/make_examples.go deleted file mode 100644 index caef0b1b..00000000 --- a/vendor/math/bits/make_examples.go +++ /dev/null @@ -1,174 +0,0 @@ -// Copyright 2017 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. - -// +build ignore - -// This program generates example_test.go. - -package main - -import ( - "bytes" - "fmt" - "go/format" - "io" - "io/ioutil" - "log" - "math/bits" - "sort" -) - -var ( - header = []byte(`// Copyright 2017 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. - -// Code generated by go run make_examples.go. DO NOT EDIT. - -package bits_test - -import ( - "fmt" - "math/bits" -) - -`) - - exampleRegF = ` -func Example%s() { - fmt.Printf("%s\n", %d, bits.%s(%d)) - // Output: - // %s -} -` - exampleRevF = ` -func Example%s() { - fmt.Printf("%s\n", %d) - fmt.Printf("%s\n", bits.%s(%d)) - // Output: - // %s - // %s -} -` -) - -func main() { - buf := bytes.NewBuffer(header) - - genReg(buf) - genRev(buf) - - out, err := format.Source(buf.Bytes()) - if err != nil { - log.Fatal(err) - } - - err = ioutil.WriteFile("example_test.go", out, 0666) - if err != nil { - log.Fatal(err) - } -} - -func genReg(w io.Writer) { - examples := []struct { - name string - in int - out map[uint]interface{} - }{ - { - name: "LeadingZeros", - in: 1, - out: map[uint]interface{}{ - 8: bits.LeadingZeros8(1), - 16: bits.LeadingZeros16(1), - 32: bits.LeadingZeros32(1), - 64: bits.LeadingZeros64(1), - }, - }, { - name: "TrailingZeros", - in: 14, - out: map[uint]interface{}{ - 8: bits.TrailingZeros8(14), - 16: bits.TrailingZeros16(14), - 32: bits.TrailingZeros32(14), - 64: bits.TrailingZeros64(14), - }, - }, { - name: "OnesCount", - in: 14, - out: map[uint]interface{}{ - 8: bits.OnesCount8(14), - 16: bits.OnesCount16(14), - 32: bits.OnesCount32(14), - 64: bits.OnesCount64(14), - }, - }, { - name: "Len", - in: 8, - out: map[uint]interface{}{ - 8: bits.Len8(8), - 16: bits.Len16(8), - 32: bits.Len32(8), - 64: bits.Len64(8), - }, - }, - } - - for _, e := range examples { - sizes := sortedSizes(e.out) - - for _, size := range sizes { - fnName := fmt.Sprintf("%s%d", e.name, size) - outF := fmt.Sprintf("%s(%%0%db) = %%d", fnName, size) - out := fmt.Sprintf(outF, e.in, e.out[size]) - - fmt.Fprintf(w, exampleRegF, fnName, outF, e.in, fnName, e.in, out) - } - } -} - -func genRev(w io.Writer) { - examples := []struct { - name string - in int - out map[uint]interface{} - }{ - { - name: "Reverse", - in: 19, - out: map[uint]interface{}{ - 8: bits.Reverse8(19), - 16: bits.Reverse16(19), - 32: bits.Reverse32(19), - 64: bits.Reverse64(19), - }, - }, - } - - for _, e := range examples { - sizes := sortedSizes(e.out) - - for _, size := range sizes { - fnName := fmt.Sprintf("%s%d", e.name, size) - outF := fmt.Sprintf("%%0%db", size) - out := fmt.Sprintf(outF, e.in) - secOut := fmt.Sprintf(outF, e.out[size]) - - fmt.Fprintf(w, exampleRevF, fnName, outF, e.in, outF, fnName, e.in, out, secOut) - } - } -} - -func sortedSizes(out map[uint]interface{}) []uint { - sizes := make([]uint, 0, len(out)) - for size := range out { - sizes = append(sizes, size) - } - - sort.Slice(sizes, func(i, j int) bool { - return sizes[i] < sizes[j] - }) - - return sizes -} diff --git a/vendor/math/bits/make_tables.go b/vendor/math/bits/make_tables.go deleted file mode 100644 index ff2fe2e3..00000000 --- a/vendor/math/bits/make_tables.go +++ /dev/null @@ -1,92 +0,0 @@ -// Copyright 2017 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. - -// +build ignore - -// This program generates bits_tables.go. - -package main - -import ( - "bytes" - "fmt" - "go/format" - "io" - "io/ioutil" - "log" -) - -var header = []byte(`// Copyright 2017 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. - -// Code generated by go run make_tables.go. DO NOT EDIT. - -package bits - -`) - -func main() { - buf := bytes.NewBuffer(header) - - gen(buf, "ntz8tab", ntz8) - gen(buf, "pop8tab", pop8) - gen(buf, "rev8tab", rev8) - gen(buf, "len8tab", len8) - - out, err := format.Source(buf.Bytes()) - if err != nil { - log.Fatal(err) - } - - err = ioutil.WriteFile("bits_tables.go", out, 0666) - if err != nil { - log.Fatal(err) - } -} - -func gen(w io.Writer, name string, f func(uint8) uint8) { - fmt.Fprintf(w, "var %s = [256]uint8{", name) - for i := 0; i < 256; i++ { - if i%16 == 0 { - fmt.Fprint(w, "\n\t") - } else { - fmt.Fprint(w, " ") - } - fmt.Fprintf(w, "%#02x,", f(uint8(i))) - } - fmt.Fprint(w, "\n}\n\n") -} - -func ntz8(x uint8) (n uint8) { - for x&1 == 0 && n < 8 { - x >>= 1 - n++ - } - return -} - -func pop8(x uint8) (n uint8) { - for x != 0 { - x &= x - 1 - n++ - } - return -} - -func rev8(x uint8) (r uint8) { - for i := 8; i > 0; i-- { - r = r<<1 | x&1 - x >>= 1 - } - return -} - -func len8(x uint8) (n uint8) { - for x != 0 { - x >>= 1 - n++ - } - return -} diff --git a/wagon_test.go b/wagon_test.go index 40487541..c6a0a4c3 100644 --- a/wagon_test.go +++ b/wagon_test.go @@ -23,11 +23,7 @@ func TestGovet(t *testing.T) { var pkgs []string s := bufio.NewScanner(buf) for s.Scan() { - pkg := s.Text() - if pkg == "github.com/go-interpreter/wagon/vendor/math/bits" { - continue - } - pkgs = append(pkgs, pkg) + pkgs = append(pkgs, s.Text()) } if err = s.Err(); err != nil { t.Fatalf("error parsing package list: %v", err)