From 8a405309c660d1ceca8d505e340850e5b18f83a8 Mon Sep 17 00:00:00 2001 From: Jacek Sieka Date: Thu, 2 Dec 2021 16:24:02 +0100 Subject: [PATCH] enable styleCheck:usages (#93) --- stew.nimble | 2 +- stew/arrayops.nim | 4 +-- stew/base10.nim | 6 ++--- stew/base32.nim | 16 ++++++------ stew/base58.nim | 12 ++++----- stew/base64.nim | 12 ++++----- stew/bitops2.nim | 52 ++++++++++++++++++------------------- stew/bitseqs.nim | 10 +++---- stew/byteutils.nim | 10 +++---- stew/io.nim | 2 +- stew/objects.nim | 2 +- stew/ranges/memranges.nim | 6 ++--- stew/ranges/ptr_arith.nim | 2 +- stew/ranges/typedranges.nim | 14 +++++----- stew/shims/macros.nim | 4 +-- stew/shims/strings.nim | 2 +- stew/sorted_set.nim | 2 +- stew/strings.nim | 2 +- stew/varints.nim | 2 +- tests/test_base58.nim | 2 +- tests/test_keyed_queue.nim | 50 +++++++++++++++++------------------ tests/test_sorted_set.nim | 2 +- 22 files changed, 108 insertions(+), 108 deletions(-) diff --git a/stew.nimble b/stew.nimble index b13467d..b18f801 100644 --- a/stew.nimble +++ b/stew.nimble @@ -17,7 +17,7 @@ proc test(env, path: string) = lang = getEnv"TEST_LANG" exec "nim " & lang & " " & env & - " -r --hints:off --skipParentCfg " & path + " -r --hints:off --skipParentCfg --styleCheck:usages --styleCheck:error " & path task test, "Run all tests": test "--threads:off", "tests/all_tests" diff --git a/stew/arrayops.nim b/stew/arrayops.nim index 8b8d055..94b78c0 100644 --- a/stew/arrayops.nim +++ b/stew/arrayops.nim @@ -54,13 +54,13 @@ func copyFrom*[T]( assign(v.toOpenArray(0, elems - 1), src.toOpenArray(0, elems - 1)) elems -func initArrayWith*[N: static[int], T](value: T): array[N, T] {.noInit, inline.}= +func initArrayWith*[N: static[int], T](value: T): array[N, T] {.noinit, inline.}= result.fill(value) func `&`*[N1, N2: static[int], T]( a: array[N1, T], b: array[N2, T] - ): array[N1 + N2, T] {.inline, noInit.}= + ): array[N1 + N2, T] {.inline, noinit.}= ## Array concatenation assign(result.toOpenArray(0, N1 - 1), a) assign(result.toOpenArray(N1, result.high), b) diff --git a/stew/base10.nim b/stew/base10.nim index 1d534e1..02faacf 100644 --- a/stew/base10.nim +++ b/stew/base10.nim @@ -40,7 +40,7 @@ type len*: int8 # >= 1 when holding valid unsigned integer proc decode*[A: byte|char](B: typedesc[Base10], T: typedesc[SomeUnsignedInt], - src: openarray[A]): Result[T, cstring] = + src: openArray[A]): Result[T, cstring] = ## Convert base10 encoded string or array of bytes to unsigned integer. const MaxValue = T(high(T) div 10) @@ -132,7 +132,7 @@ proc encodedLength*(B: typedesc[Base10], value: SomeUnsignedInt): int8 = return 12'i8 + B.encodedLength(value div P12) proc encode[A: byte|char](B: typedesc[Base10], value: SomeUnsignedInt, - output: var openarray[A], + output: var openArray[A], length: int8): Result[int8, cstring] = const Digits = cstring( "0001020304050607080910111213141516171819" & @@ -175,7 +175,7 @@ proc encode[A: byte|char](B: typedesc[Base10], value: SomeUnsignedInt, ok(length) proc encode*[A: byte|char](B: typedesc[Base10], value: SomeUnsignedInt, - output: var openarray[A]): Result[int8, cstring] = + output: var openArray[A]): Result[int8, cstring] = ## Encode integer value to array of characters or bytes. B.encode(value, output, B.encodedLength(value)) diff --git a/stew/base32.nim b/stew/base32.nim index 28fe674..fd69d17 100644 --- a/stew/base32.nim +++ b/stew/base32.nim @@ -82,7 +82,7 @@ proc decodedLength*(btype: typedesc[Base32Types], length: int): int = let reminder = length mod 8 result = (length div 8) * 5 + ((reminder * 5) div 8) -proc convert5to8(inbytes: openarray[byte], outbytes: var openarray[char], +proc convert5to8(inbytes: openArray[byte], outbytes: var openArray[char], length: int): int {.inline.} = if length >= 1: outbytes[0] = chr(inbytes[0] shr 3) @@ -107,7 +107,7 @@ proc convert5to8(inbytes: openarray[byte], outbytes: var openarray[char], outbytes[7] = chr(inbytes[4] and 31'u8) result = 8 -proc convert8to5(inbytes: openarray[byte], outbytes: var openarray[byte], +proc convert8to5(inbytes: openArray[byte], outbytes: var openArray[byte], length: int): int {.inline.} = if length >= 2: outbytes[0] = inbytes[0] shl 3 @@ -132,8 +132,8 @@ proc convert8to5(inbytes: openarray[byte], outbytes: var openarray[byte], outbytes[4] = outbytes[4] or (inbytes[7] and 31'u8) result = 5 -proc encode*(btype: typedesc[Base32Types], inbytes: openarray[byte], - outstr: var openarray[char], outlen: var int): Base32Status = +proc encode*(btype: typedesc[Base32Types], inbytes: openArray[byte], + outstr: var openArray[char], outlen: var int): Base32Status = ## Encode array of bytes ``inbytes`` using BASE32 encoding and store ## result to ``outstr``. On success ``Base32Status.Success`` will be returned ## and ``outlen`` will be set to number of characters stored inside of @@ -184,7 +184,7 @@ proc encode*(btype: typedesc[Base32Types], inbytes: openarray[byte], result = Base32Status.Success proc encode*(btype: typedesc[Base32Types], - inbytes: openarray[byte]): string {.inline.} = + inbytes: openArray[byte]): string {.inline.} = ## Encode array of bytes ``inbytes`` using BASE32 encoding and return ## encoded string. if len(inbytes) == 0: @@ -197,8 +197,8 @@ proc encode*(btype: typedesc[Base32Types], else: result = "" -proc decode*[T: byte|char](btype: typedesc[Base32Types], instr: openarray[T], - outbytes: var openarray[byte], outlen: var int): Base32Status = +proc decode*[T: byte|char](btype: typedesc[Base32Types], instr: openArray[T], + outbytes: var openArray[byte], outlen: var int): Base32Status = ## Decode BASE32 string and store array of bytes to ``outbytes``. On success ## ``Base32Status.Success`` will be returned and ``outlen`` will be set ## to number of bytes stored. @@ -271,7 +271,7 @@ proc decode*[T: byte|char](btype: typedesc[Base32Types], instr: openarray[T], result = Base32Status.Success proc decode*[T: byte|char](btype: typedesc[Base32Types], - instr: openarray[T]): seq[byte] = + instr: openArray[T]): seq[byte] = ## Decode BASE32 string ``instr`` and return sequence of bytes as result. if len(instr) == 0: result = newSeq[byte]() diff --git a/stew/base58.nim b/stew/base58.nim index 4356893..ce38904 100644 --- a/stew/base58.nim +++ b/stew/base58.nim @@ -24,7 +24,7 @@ type ## Type to use Bitcoin alphabet FLCBase58* = object ## Type to use Flickr alphabet - Base58* = BtcBase58 + Base58* = BTCBase58 ## By default we are using Bitcoin alphabet Base58C* = BTCBase58 | FLCBase58 ## Supported types @@ -57,8 +57,8 @@ proc decodedLength*(btype: typedesc[Base58C], length: int): int = ## ``length``. result = length + 4 -proc encode*(btype: typedesc[Base58C], inbytes: openarray[byte], - outstr: var openarray[char], outlen: var int): Base58Status = +proc encode*(btype: typedesc[Base58C], inbytes: openArray[byte], + outstr: var openArray[char], outlen: var int): Base58Status = ## Encode array of bytes ``inbytes`` using BASE58 encoding and store ## result to ``outstr``. On success ``Base58Status.Success`` will be returned ## and ``outlen`` will be set to number of characters stored inside of @@ -112,7 +112,7 @@ proc encode*(btype: typedesc[Base58C], inbytes: openarray[byte], result = Base58Status.Success proc encode*(btype: typedesc[Base58C], - inbytes: openarray[byte]): string {.inline.} = + inbytes: openArray[byte]): string {.inline.} = ## Encode array of bytes ``inbytes`` using BASE58 encoding and return ## encoded string. var size = (len(inbytes) * 138) div 100 + 1 @@ -123,8 +123,8 @@ proc encode*(btype: typedesc[Base58C], else: result = "" -proc decode*[T: byte|char](btype: typedesc[Base58C], instr: openarray[T], - outbytes: var openarray[byte], outlen: var int): Base58Status = +proc decode*[T: byte|char](btype: typedesc[Base58C], instr: openArray[T], + outbytes: var openArray[byte], outlen: var int): Base58Status = ## Decode BASE58 string and store array of bytes to ``outbytes``. On success ## ``Base58Status.Success`` will be returned and ``outlen`` will be set ## to number of bytes stored. diff --git a/stew/base64.nim b/stew/base64.nim index 961a129..d25a40b 100644 --- a/stew/base64.nim +++ b/stew/base64.nim @@ -68,8 +68,8 @@ proc decodedLength*(btype: typedesc[Base64Types], elif (btype is Base64) or (btype is Base64Url): result = (length * 4 + 3 - 1) div 3 -proc encode*(btype: typedesc[Base64Types], inbytes: openarray[byte], - outstr: var openarray[char], outlen: var int): Base64Status = +proc encode*(btype: typedesc[Base64Types], inbytes: openArray[byte], + outstr: var openArray[char], outlen: var int): Base64Status = ## Encode array of bytes ``inbytes`` using BASE64 encoding and store ## result to ``outstr``. ## @@ -127,7 +127,7 @@ proc encode*(btype: typedesc[Base64Types], inbytes: openarray[byte], result = Base64Status.Success proc encode*(btype: typedesc[Base64Types], - inbytes: openarray[byte]): string {.inline.} = + inbytes: openArray[byte]): string {.inline.} = ## Encode array of bytes ``inbytes`` using BASE64 encoding and return ## encoded string. var size = btype.encodedLength(len(inbytes)) @@ -138,8 +138,8 @@ proc encode*(btype: typedesc[Base64Types], else: result = "" -proc decode*[T: byte|char](btype: typedesc[Base64Types], instr: openarray[T], - outbytes: var openarray[byte], outlen: var int): Base64Status = +proc decode*[T: byte|char](btype: typedesc[Base64Types], instr: openArray[T], + outbytes: var openArray[byte], outlen: var int): Base64Status = ## Decode BASE64 string and store array of bytes to ``outbytes``. On success ## ``Base64Status.Success`` will be returned and ``outlen`` will be set ## to number of bytes stored. @@ -224,7 +224,7 @@ proc decode*[T: byte|char](btype: typedesc[Base64Types], instr: openarray[T], result = Base64Status.Success proc decode*[T: byte|char](btype: typedesc[Base64Types], - instr: openarray[T]): seq[byte] = + instr: openArray[T]): seq[byte] = ## Decode BASE64 string ``instr`` and return sequence of bytes as result. if len(instr) == 0: result = newSeq[byte]() diff --git a/stew/bitops2.nim b/stew/bitops2.nim index cb71f77..d1e1133 100644 --- a/stew/bitops2.nim +++ b/stew/bitops2.nim @@ -511,49 +511,49 @@ template byteIndex(pos: Natural): int = template bitIndex(pos: Natural): int = pos and 0b111 # same as pos mod 8 -func getBit*(bytes: openarray[byte], pos: Natural): bool {.inline.} = +func getBit*(bytes: openArray[byte], pos: Natural): bool {.inline.} = getBit(bytes[byteIndex pos], bitIndex pos) -template getBitLE*(bytes: openarray[byte], pos: Natural): bool = +template getBitLE*(bytes: openArray[byte], pos: Natural): bool = getBit(bytes, pos) -func getBitBE*(bytes: openarray[byte], pos: Natural): bool {.inline.} = +func getBitBE*(bytes: openArray[byte], pos: Natural): bool {.inline.} = getBitBE(bytes[byteIndex pos], bitIndex pos) -func changeBit*(bytes: var openarray[byte], pos: Natural, value: bool) {.inline.} = +func changeBit*(bytes: var openArray[byte], pos: Natural, value: bool) {.inline.} = changeBit(bytes[byteIndex pos], bitIndex pos, value) -template changeBitLE*(bytes: var openarray[byte], pos: Natural, value: bool) = +template changeBitLE*(bytes: var openArray[byte], pos: Natural, value: bool) = changeBit(bytes, pos, value) -func changeBitBE*(bytes: var openarray[byte], pos: Natural, value: bool) {.inline.} = +func changeBitBE*(bytes: var openArray[byte], pos: Natural, value: bool) {.inline.} = changeBitBE(bytes[byteIndex pos], bitIndex pos, value) -func setBit*(bytes: var openarray[byte], pos: Natural) {.inline.} = +func setBit*(bytes: var openArray[byte], pos: Natural) {.inline.} = setBit(bytes[byteIndex pos], bitIndex pos) -template setBitLE*(bytes: var openarray[byte], pos: Natural) = +template setBitLE*(bytes: var openArray[byte], pos: Natural) = setBit(bytes, pos) -func setBitBE*(bytes: var openarray[byte], pos: Natural) {.inline.} = +func setBitBE*(bytes: var openArray[byte], pos: Natural) {.inline.} = setBitBE(bytes[byteIndex pos], bitIndex pos) -func clearBit*(bytes: var openarray[byte], pos: Natural) {.inline.} = +func clearBit*(bytes: var openArray[byte], pos: Natural) {.inline.} = clearBit(bytes[byteIndex pos], bitIndex pos) -template clearBitLE*(bytes: var openarray[byte], pos: Natural) = +template clearBitLE*(bytes: var openArray[byte], pos: Natural) = clearBit(bytes, pos) -func clearBitBE*(bytes: var openarray[byte], pos: Natural) {.inline.} = +func clearBitBE*(bytes: var openArray[byte], pos: Natural) {.inline.} = clearBitBE(bytes[byteIndex pos], bitIndex pos) -func toggleBit*(bytes: var openarray[byte], pos: Natural) {.inline.} = +func toggleBit*(bytes: var openArray[byte], pos: Natural) {.inline.} = toggleBit(bytes[byteIndex pos], bitIndex pos) -template toggleBitLE*(bytes: var openarray[byte], pos: Natural) = +template toggleBitLE*(bytes: var openArray[byte], pos: Natural) = toggleBit(bytes, pos) -func toggleBitBE*(bytes: var openarray[byte], pos: Natural) {.inline.} = +func toggleBitBE*(bytes: var openArray[byte], pos: Natural) {.inline.} = toggleBitBE(bytes[byteIndex pos], bitIndex pos) template setBit*(x: var BitIndexable, bit: Natural, val: bool) {.deprecated: "changeBit".} = @@ -577,28 +577,28 @@ template lowerBitLE*(x: var BitIndexable, bit: Natural) {.deprecated: "clearBitL template lowerBitBE*(x: var BitIndexable, bit: Natural) {.deprecated: "clearBitBE".} = clearBitBE(x, bit) -template setBit*(bytes: var openarray[byte], pos: Natural, val: bool) {.deprecated: "changeBit".} = +template setBit*(bytes: var openArray[byte], pos: Natural, val: bool) {.deprecated: "changeBit".} = changeBit(bytes, pos, val) -template setBitLE*(bytes: var openarray[byte], pos: Natural, val: bool) {.deprecated: "changeBitLE".} = +template setBitLE*(bytes: var openArray[byte], pos: Natural, val: bool) {.deprecated: "changeBitLE".} = changeBitLE(bytes, pos, val) -template setBitBE*(bytes: var openarray[byte], pos: Natural, val: bool) {.deprecated: "changeBitBE".} = +template setBitBE*(bytes: var openArray[byte], pos: Natural, val: bool) {.deprecated: "changeBitBE".} = changeBitBE(bytes, pos, val) -template raiseBit*(bytes: var openarray[byte], pos: Natural) {.deprecated: "setBit".} = +template raiseBit*(bytes: var openArray[byte], pos: Natural) {.deprecated: "setBit".} = setBit(bytes, pos) -template raiseBitLE*(bytes: var openarray[byte], pos: Natural) {.deprecated: "setBitLE".} = +template raiseBitLE*(bytes: var openArray[byte], pos: Natural) {.deprecated: "setBitLE".} = setBitLE(bytes, pos) -template raiseBitBE*(bytes: var openarray[byte], pos: Natural) {.deprecated: "setBitBE".} = +template raiseBitBE*(bytes: var openArray[byte], pos: Natural) {.deprecated: "setBitBE".} = setBitBE(bytes, pos) -template lowerBit*(bytes: var openarray[byte], pos: Natural) {.deprecated: "clearBit".} = +template lowerBit*(bytes: var openArray[byte], pos: Natural) {.deprecated: "clearBit".} = clearBit(bytes, pos) -template lowerBitLE*(bytes: var openarray[byte], pos: Natural) {.deprecated: "clearBitLE".} = +template lowerBitLE*(bytes: var openArray[byte], pos: Natural) {.deprecated: "clearBitLE".} = clearBitLE(bytes, pos) -template lowerBitBE*(bytes: var openarray[byte], pos: Natural) {.deprecated: "clearBitBE".} = +template lowerBitBE*(bytes: var openArray[byte], pos: Natural) {.deprecated: "clearBitBE".} = clearBitBE(bytes, pos) -func getBitsBE*(data: openarray[byte], slice: HSlice, T: type[SomeUnsignedInt]): T = +func getBitsBE*(data: openArray[byte], slice: HSlice, T: type[SomeUnsignedInt]): T = ## Treats `data` as an unsigned big endian integer and returns a slice of bits ## extracted from it, assuming 0 to be the possition of the most significant bit. let totalBits = data.len * 8 @@ -638,6 +638,6 @@ func getBitsBE*(data: openarray[byte], slice: HSlice, T: type[SomeUnsignedInt]): else: (firstLimb shl firstLimbUnusedBits) shr (resultBits - sliceLen) -template getBitsBE*(data: openarray[byte], slice: HSlice): BiggestUInt = +template getBitsBE*(data: openArray[byte], slice: HSlice): BiggestUInt = getBitsBE(data, slice, BiggestUInt) diff --git a/stew/bitseqs.nim b/stew/bitseqs.nim index b358ec6..cdbfc33 100644 --- a/stew/bitseqs.nim +++ b/stew/bitseqs.nim @@ -29,7 +29,7 @@ type BitArray*[bits: static int] = object bytes*: array[(bits + 7) div 8, byte] -func bitsLen*(bytes: openarray[byte]): int = +func bitsLen*(bytes: openArray[byte]): int = let bytesCount = bytes.len lastByte = bytes[bytesCount - 1] @@ -58,14 +58,14 @@ func add*(s: var BitSeq, value: bool) = s.Bytes[lastBytePos].changeBit 7, value s.Bytes.add byte(1) -func loadLEBytes(WordType: type, bytes: openarray[byte]): WordType = +func loadLEBytes(WordType: type, bytes: openArray[byte]): WordType = # TODO: this is a temporary proc until the endians API is improved var shift = 0 for b in bytes: result = result or (WordType(b) shl shift) shift += 8 -func storeLEBytes(value: SomeUnsignedInt, dst: var openarray[byte]) = +func storeLEBytes(value: SomeUnsignedInt, dst: var openArray[byte]) = when system.cpuEndian == bigEndian: var shift = 0 for i in 0 ..< dst.len: @@ -212,8 +212,8 @@ template clearBit*(a: var BitArray, pos: Natural) = # TODO: Submit this to the standard library as `cmp` # At the moment, it doesn't work quite well because Nim selects # the generic cmp[T] from the system module instead of choosing -# the openarray overload -func compareArrays[T](a, b: openarray[T]): int = +# the openArray overload +func compareArrays[T](a, b: openArray[T]): int = result = cmp(a.len, b.len) if result != 0: return diff --git a/stew/byteutils.nim b/stew/byteutils.nim index 977362a..1894b94 100644 --- a/stew/byteutils.nim +++ b/stew/byteutils.nim @@ -59,17 +59,17 @@ func hexToByteArray*(hexStr: string, output: var openArray[byte]) hexToByteArray(hexStr, output, 0, output.high) func hexToByteArray*[N: static[int]](hexStr: string): array[N, byte] - {.raises: [ValueError, Defect], noInit, inline.}= + {.raises: [ValueError, Defect], noinit, inline.}= ## Read an hex string and store it in a byte array. No "endianness" reordering is done. hexToByteArray(hexStr, result) func hexToByteArray*(hexStr: string, N: static int): array[N, byte] - {.raises: [ValueError, Defect], noInit, inline.}= + {.raises: [ValueError, Defect], noinit, inline.}= ## Read an hex string and store it in a byte array. No "endianness" reordering is done. hexToByteArray(hexStr, result) func fromHex*[N](A: type array[N, byte], hexStr: string): A - {.raises: [ValueError, Defect], noInit, inline.}= + {.raises: [ValueError, Defect], noinit, inline.}= ## Read an hex string and store it in a byte array. No "endianness" reordering is done. hexToByteArray(hexStr, result) @@ -115,7 +115,7 @@ func hexToSeqByte*(hexStr: string): seq[byte] for i in 0 ..< N: result[i] = hexStr[2*i + skip].readHexChar shl 4 or hexStr[2*i + 1 + skip].readHexChar -func toHexAux(ba: openarray[byte]): string = +func toHexAux(ba: openArray[byte]): string = ## Convert a byte-array to its hex representation ## Output is in lowercase ## No "endianness" reordering is done. @@ -127,7 +127,7 @@ func toHexAux(ba: openarray[byte]): string = result[2*i] = hexChars[int ba[i] shr 4 and 0xF] result[2*i+1] = hexChars[int ba[i] and 0xF] -func toHex*(ba: openarray[byte]): string {.inline.} = +func toHex*(ba: openArray[byte]): string {.inline.} = ## Convert a byte-array to its hex representation ## Output is in lowercase ## No "endianness" reordering is done. diff --git a/stew/io.nim b/stew/io.nim index a193f7f..c21a254 100644 --- a/stew/io.nim +++ b/stew/io.nim @@ -1,5 +1,5 @@ when not compiles(writeFile("filename", @[byte(1)])): - proc writeFile*(filename: string, content: openarray[byte]) = + proc writeFile*(filename: string, content: openArray[byte]) = ## Opens a file named `filename` for writing. Then writes the ## `content` completely to the file and closes the file afterwards. ## Raises an IO exception in case of an error. diff --git a/stew/objects.nim b/stew/objects.nim index 6898ba5..3410b58 100644 --- a/stew/objects.nim +++ b/stew/objects.nim @@ -20,7 +20,7 @@ template init*(lvalue: var auto, a1, a2, a3: auto) = when not declared(default): proc default*(T: type): T = discard -proc toArray*[T](N: static int, data: openarray[T]): array[N, T] = +proc toArray*[T](N: static int, data: openArray[T]): array[N, T] = doAssert data.len == N copyMem(addr result[0], unsafeAddr data[0], N) diff --git a/stew/ranges/memranges.nim b/stew/ranges/memranges.nim index ea3780e..2614e91 100644 --- a/stew/ranges/memranges.nim +++ b/stew/ranges/memranges.nim @@ -20,15 +20,15 @@ proc toMemRange*(x: string): MemRange = result.start = x.cstring.pointer result.size = x.len -proc toMemRange*[T](x: openarray[T], fromIdx, toIdx: int): MemRange = +proc toMemRange*[T](x: openArray[T], fromIdx, toIdx: int): MemRange = doAssert(fromIdx >= 0 and toIdx >= fromIdx and fromIdx < x.len and toIdx < x.len) result.start = unsafeAddr x[fromIdx] result.size = (toIdx - fromIdx + 1) * T.sizeof -proc toMemRange*[T](x: openarray[T], fromIdx: int): MemRange {.inline.} = +proc toMemRange*[T](x: openArray[T], fromIdx: int): MemRange {.inline.} = toMemRange(x, fromIdx, x.high) -proc toMemRange*[T](x: openarray[T]): MemRange {.inline.} = +proc toMemRange*[T](x: openArray[T]): MemRange {.inline.} = toMemRange(x, 0, x.high) template toMemRange*(mr: MemRange): MemRange = mr diff --git a/stew/ranges/ptr_arith.nim b/stew/ranges/ptr_arith.nim index 3a00f6c..016074b 100644 --- a/stew/ranges/ptr_arith.nim +++ b/stew/ranges/ptr_arith.nim @@ -1,7 +1,7 @@ import ../ptrops export ptrops -proc baseAddr*[T](x: openarray[T]): pointer = cast[pointer](x) +proc baseAddr*[T](x: openArray[T]): pointer = cast[pointer](x) # Please note that we use templates here on purpose. # As much as I believe in the power of optimizing compilers, it turned diff --git a/stew/ranges/typedranges.nim b/stew/ranges/typedranges.nim index d61fa60..422c5f7 100644 --- a/stew/ranges/typedranges.nim +++ b/stew/ranges/typedranges.nim @@ -36,31 +36,31 @@ proc toImmutableRange[T](a: seq[T]): Range[T] = result.mLen = a.len when unsafeAPIEnabled: - proc toImmutableRangeNoGCHold[T](a: openarray[T]): Range[T] = + proc toImmutableRangeNoGCHold[T](a: openArray[T]): Range[T] = if a.len != 0: result.start = unsafeAddr a[0] result.mLen = a.len - proc toImmutableRange[T](a: openarray[T]): Range[T] {.inline.} = + proc toImmutableRange[T](a: openArray[T]): Range[T] {.inline.} = toImmutableRangeNoGCHold(a) proc toRange*[T](a: var seq[T]): MutRange[T] {.inline.} = MutRange[T](toImmutableRange(a)) when unsafeAPIEnabled: - proc toRange*[T](a: var openarray[T]): MutRange[T] {.inline.} = + proc toRange*[T](a: var openArray[T]): MutRange[T] {.inline.} = MutRange[T](toImmutableRange(a)) template initStackRange*[T](sz: static[int]): MutRange[T] = var data: array[sz, T] data.toRange() - proc toRange*[T](a: openarray[T]): Range[T] {.inline.} = toImmutableRange(a) + proc toRange*[T](a: openArray[T]): Range[T] {.inline.} = toImmutableRange(a) - proc unsafeRangeConstruction*[T](a: var openarray[T]): MutRange[T] {.inline.} = + proc unsafeRangeConstruction*[T](a: var openArray[T]): MutRange[T] {.inline.} = MutRange[T](toImmutableRange(a)) - proc unsafeRangeConstruction*[T](a: openarray[T]): Range[T] {.inline.} = + proc unsafeRangeConstruction*[T](a: openArray[T]): Range[T] {.inline.} = toImmutableRange(a) proc newRange*[T](sz: int): MutRange[T] {.inline.} = @@ -152,7 +152,7 @@ proc `[]`*[T, U, V](r: Range[T], s: HSlice[U, V]): Range[T] {.inline.} = proc `[]`*[T, U, V](r: MutRange[T], s: HSlice[U, V]): MutRange[T] {.inline.} = MutRange[T](sliceNormalized(r, r ^^ s.a, r ^^ s.b)) -proc `[]=`*[T, U, V](r: MutRange[T], s: HSlice[U, V], v: openarray[T]) = +proc `[]=`*[T, U, V](r: MutRange[T], s: HSlice[U, V], v: openArray[T]) = let a = r ^^ s.a let b = r ^^ s.b let L = b - a + 1 diff --git a/stew/shims/macros.nim b/stew/shims/macros.nim index 347fc5a..c26439c 100644 --- a/stew/shims/macros.nim +++ b/stew/shims/macros.nim @@ -36,7 +36,7 @@ proc writeMacroResultsNow* {.compileTime.} = file.add newCommentStmtNode("Generated at line " & $location.line) file.add macroOutput - for i in 0..< macroLocations.len: + for i in 0 ..< macroLocations.len: addToFile files.mgetOrPut(macroLocations[i].filename, nil), macroLocations[i], macroOutputs[i] @@ -408,7 +408,7 @@ macro unpackArgs*(callee: untyped, args: untyped): untyped = for arg in args: let arg = if arg.kind == nnkHiddenStdConv: arg[1] else: arg - if arg.kind == nnkArgList: + if arg.kind == nnkArglist: for subarg in arg: result.add subarg else: diff --git a/stew/shims/strings.nim b/stew/shims/strings.nim index 054cb07..2d593db 100644 --- a/stew/shims/strings.nim +++ b/stew/shims/strings.nim @@ -1,4 +1,4 @@ -proc add*(str: var string, chars: openarray[char]) = +proc add*(str: var string, chars: openArray[char]) = for c in chars: str.add c diff --git a/stew/sorted_set.nim b/stew/sorted_set.nim index 337deef..b053c3b 100644 --- a/stew/sorted_set.nim +++ b/stew/sorted_set.nim @@ -310,7 +310,7 @@ proc verify*[K,V](sl: var SortedSet[K,V]): ## proc `$`*[V](data: V): string {.gcsafe,raises:[Defect,CatchableError].} ## sl.tree.rbTreeVerify( - lt = proc(a, b: SortedSetItemRef[K,V]): bool = a.sLstLt(b), + lt = proc(a, b: SortedSetItemRef[K,V]): bool = a.slstLt(b), pr = proc(c: RbInfo; s: string) = c.slstPr(s)) # ------------------------------------------------------------------------------ diff --git a/stew/strings.nim b/stew/strings.nim index 4dca78d..fe8d48f 100644 --- a/stew/strings.nim +++ b/stew/strings.nim @@ -1,4 +1,4 @@ -proc add*(s: var string, data: openarray[char]) = +proc add*(s: var string, data: openArray[char]) = if data.len > 0: let prevEnd = s.len s.setLen(prevEnd + data.len) diff --git a/stew/varints.nim b/stew/varints.nim index 6bd68c7..98349c2 100644 --- a/stew/varints.nim +++ b/stew/varints.nim @@ -144,7 +144,7 @@ func getResult*[IntType, F](p: VarintParser[IntType, F]): IntType {.inline.} = else: p.res -func readVarint*(input: openarray[byte], +func readVarint*(input: openArray[byte], outVal: var SomeInteger, flavour: static VarintFlavour = ProtoBuf): int = ## Reads a varint from a buffer and stores it in `outVal`. diff --git a/tests/test_base58.nim b/tests/test_base58.nim index efc549f..8309cb3 100644 --- a/tests/test_base58.nim +++ b/tests/test_base58.nim @@ -3,7 +3,7 @@ import ../stew/base58 when defined(nimHasUsed): {.used.} -proc hexToBytes*(a: string, result: var openarray[byte]) = +proc hexToBytes*(a: string, result: var openArray[byte]) = doAssert(len(a) == 2 * len(result)) var i = 0 var k = 0 diff --git a/tests/test_keyed_queue.nim b/tests/test_keyed_queue.nim index b5012f0..ac2e8f3 100644 --- a/tests/test_keyed_queue.nim +++ b/tests/test_keyed_queue.nim @@ -50,13 +50,13 @@ proc `$`(rc: KeyedQueuePair[uint,uint]): string = proc `$`(rc: Result[KeyedQueuePair[uint,uint],void]): string = result = "<" - if rc.isOK: + if rc.isOk: result &= $rc.value.key & "," & $rc.value.data result &= ">" proc `$`(rc: Result[uint,void]): string = result = "<" - if rc.isOK: + if rc.isOk: result &= $rc.value result &= ">" @@ -93,7 +93,7 @@ proc lruValue(lru: var LruCache; n: int): uint = let key = n.toKey rc = lru.q.lruFetch(key) - if rc.isOK: + if rc.isOk: return rc.value lru.q.lruAppend(key, key.fromKey.toValue, lru.size) @@ -223,7 +223,7 @@ suite "KeyedQueue: Data queue with keyed random access": test "Delete corresponding entries by keyed access from previous queues": var seen: seq[int] let sub7 = keyList.len div 7 - for n in toSeq(countUp(0,sub7)).concat(toSeq(countUp(3*sub7,4*sub7))): + for n in toSeq(countup(0,sub7)).concat(toSeq(countup(3*sub7,4*sub7))): let key = keyList[n].toKey canDeleteOk = (key.fromKey notin seen) @@ -285,12 +285,12 @@ suite "KeyedQueue: Data queue with keyed random access": seen: seq[int] all: seq[uint] rc = rq.first - while rc.isOK: + while rc.isOk: let key = rc.value.key all.add key rc = rq.next(key) rq.addOrFlushGroupwise(groupLen, seen, key.fromKey, veryNoisy) - check rq.verify.isOK + check rq.verify.isOk check seen.len == rq.len check seen.len < groupLen check uniqueKeys == all @@ -303,7 +303,7 @@ suite "KeyedQueue: Data queue with keyed random access": for w in rq.nextKeys: all.add w rq.addOrFlushGroupwise(groupLen, seen, w.fromKey, veryNoisy) - check rq.verify.isOK + check rq.verify.isOk check seen.len == rq.len check seen.len < groupLen check uniqueKeys == all @@ -315,7 +315,7 @@ suite "KeyedQueue: Data queue with keyed random access": for w in rq.nextPairs: all.add w.key rq.addOrFlushGroupwise(groupLen, seen, w.key.fromKey, veryNoisy) - check rq.verify.isOK + check rq.verify.isOk check seen.len == rq.len check seen.len < groupLen check uniqueKeys == all @@ -328,7 +328,7 @@ suite "KeyedQueue: Data queue with keyed random access": let w = v.fromValue.toKey all.add w rq.addOrFlushGroupwise(groupLen, seen, w.fromKey, veryNoisy) - check rq.verify.isOK + check rq.verify.isOk check seen.len == rq.len check seen.len < groupLen check uniqueKeys == all @@ -340,12 +340,12 @@ suite "KeyedQueue: Data queue with keyed random access": seen: seq[int] all: seq[uint] rc = rq.last - while rc.isOK: + while rc.isOk: let key = rc.value.key all.add key rc = rq.prev(key) rq.addOrFlushGroupwise(groupLen, seen, key.fromKey, veryNoisy) - check rq.verify.isOK + check rq.verify.isOk check seen.len == rq.len check seen.len < groupLen check uniqueKeys == all.reversed @@ -358,7 +358,7 @@ suite "KeyedQueue: Data queue with keyed random access": for w in rq.prevKeys: all.add w rq.addOrFlushGroupwise(groupLen, seen, w.fromKey, veryNoisy) - check rq.verify.isOK + check rq.verify.isOk check seen.len == rq.len check seen.len < groupLen check uniqueKeys == all.reversed @@ -370,7 +370,7 @@ suite "KeyedQueue: Data queue with keyed random access": for w in rq.prevPairs: all.add w.key rq.addOrFlushGroupwise(groupLen, seen, w.key.fromKey, veryNoisy) - check rq.verify.isOK + check rq.verify.isOk check seen.len == rq.len check seen.len < groupLen check uniqueKeys == all.reversed @@ -383,7 +383,7 @@ suite "KeyedQueue: Data queue with keyed random access": let w = v.fromValue.toKey all.add w rq.addOrFlushGroupwise(groupLen, seen, w.fromKey, veryNoisy) - check rq.verify.isOK + check rq.verify.isOk check seen.len == rq.len check seen.len < groupLen check uniqueKeys == all.reversed @@ -400,7 +400,7 @@ suite "KeyedQueue: Data queue with keyed random access": check uniqueKeys[count] == rc.value rc = rq.nextKey(rc.value) count.inc - check rq.verify.isOK + check rq.verify.isOk check count == uniqueKeys.len block: var @@ -411,7 +411,7 @@ suite "KeyedQueue: Data queue with keyed random access": check uniqueKeys[count] == rc.value.data.fromValue.toKey rc = rq.next(rc.value.key) count.inc - check rq.verify.isOK + check rq.verify.isOk check count == uniqueKeys.len # reverse ... @@ -424,7 +424,7 @@ suite "KeyedQueue: Data queue with keyed random access": count.dec check uniqueKeys[count] == rc.value rc = rq.prevKey(rc.value) - check rq.verify.isOK + check rq.verify.isOk check count == 0 block: var @@ -435,7 +435,7 @@ suite "KeyedQueue: Data queue with keyed random access": count.dec check uniqueKeys[count] == rc.value.data.fromValue.toKey rc = rq.prev(rc.value.key) - check rq.verify.isOK + check rq.verify.isOk check count == 0 # -------------------------------------- @@ -450,8 +450,8 @@ suite "KeyedQueue: Data queue with keyed random access": break let key = rc.value check rq.second.value.data == rq[key] - check rq.delete(key).isOK - check rq.verify.isOK + check rq.delete(key).isOk + check rq.verify.isOk check rq.len == 1 block: @@ -463,8 +463,8 @@ suite "KeyedQueue: Data queue with keyed random access": break let key = rc.value check rq.beforeLast.value.data == rq[key] - check rq.delete(key).isOK - check rq.verify.isOK + check rq.delete(key).isOk + check rq.verify.isOk check rq.len == 1 # -------------------------------------- @@ -499,7 +499,7 @@ suite "KeyedQueue: Data queue as LRU cache": values = toSeq(cache.q.nextPairs).mapIt(it.data) infoPfx = if reSched: ">>> rotate" else: "+++ append" noisy.say infoPfx, &"{value} => {queue}" - check cache.q.verify.isOK + check cache.q.verify.isOk check queue.mapIt($it) == values.mapIt($it.fromValue) check item.toKey == cache.q.lastKey.value check toSeq(cache.q.nextPairs) == toSeq(cExpected.q.nextPairs) @@ -512,8 +512,8 @@ suite "KeyedQueue: Data queue as LRU cache": check c1 == c2 check c1.lruValue(77) == 77.toValue - check c1.q.verify.isOK - check c2.q.verify.isOK + check c1.q.verify.isOk + check c2.q.verify.isOk noisy.say &"c1Specs: {c1.size} {c1.q.firstKey} {c1.q.lastKey} ..." noisy.say &"c2Specs: {c2.size} {c2.q.firstKey} {c2.q.lastKey} ..." diff --git a/tests/test_sorted_set.nim b/tests/test_sorted_set.nim index a27d6d1..7583f67 100644 --- a/tests/test_sorted_set.nim +++ b/tests/test_sorted_set.nim @@ -115,7 +115,7 @@ suite "SortedSet: Sorted list based on red-black tree": test "Delete items": var seen: seq[int] let sub7 = keyList.len div 7 - for n in toSeq(countUp(0,sub7)).concat(toSeq(countUp(3*sub7,4*sub7))): + for n in toSeq(countup(0,sub7)).concat(toSeq(countup(3*sub7,4*sub7))): let key = keyList[n] canDeleteOk = (key notin seen)