status-im
/
nim-stew
mirror of https://github.com/status-im/nim-stew.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

reduce compiler warnings

This commit is contained in:
jangko 2023-02-14 20:29:30 +07:00
parent 407a598836
commit faabd40c30
No known key found for this signature in database
GPG Key ID: 31702AE10541E6B9
11 changed files with 86 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
stew/byteutils.nim
View File

@ -25,7 +25,7 @@ else:
##################################### Hex utilities ################################################
proc readHexChar*(c: char): byte
{.raises: [ValueError, Defect], noSideEffect, inline.} =
{.raises: [ValueError], noSideEffect, inline.} =
## Converts an hex char to a byte
case c
of '0'..'9': result = byte(ord(c) - ord('0'))
@ -42,7 +42,7 @@ template skip0xPrefix(hexStr: openArray[char]): int =
func hexToByteArrayImpl(
hexStr: openArray[char], output: var openArray[byte], fromIdx, toIdx: int):
int {.raises: [ValueError, Defect].} =
int {.raises: [ValueError].} =
var sIdx = skip0xPrefix(hexStr)
# Fun with closed intervals
doAssert fromIdx >= 0 and
@ -65,7 +65,7 @@ func hexToByteArrayImpl(
func hexToByteArray*(
hexStr: openArray[char], output: var openArray[byte], fromIdx, toIdx: int)
{.raises: [ValueError, Defect].} =
{.raises: [ValueError].} =
## Read hex-encoded data from `hexStr[mapHex(fromIdx..toIdx)]` and store
## corresponding bytes in `output[fromIdx..toIdx]` where `mapHex` takes into
## account stripped characters.
@ -80,7 +80,7 @@ func hexToByteArray*(
discard hexToByteArrayImpl(hexStr, output, fromIdx, toIdx)
func hexToByteArray*(hexStr: openArray[char], output: var openArray[byte])
{.raises: [ValueError, Defect].} =
{.raises: [ValueError].} =
## Read hex-encoded data from `hexStr` and store corresponding bytes in
## `output`.
##
@ -92,7 +92,7 @@ func hexToByteArray*(hexStr: openArray[char], output: var openArray[byte])
hexToByteArray(hexStr, output, 0, output.high)
func hexToByteArray*[N: static[int]](hexStr: openArray[char]): array[N, byte]
{.raises: [ValueError, Defect], noinit.}=
{.raises: [ValueError], noinit.}=
## Read hex-encoded data from `hexStr` returning an array of N bytes.
##
## * `0x`/`0X` is stripped if present
@ -103,7 +103,7 @@ func hexToByteArray*[N: static[int]](hexStr: openArray[char]): array[N, byte]
hexToByteArray(hexStr, result)
func hexToByteArray*(hexStr: openArray[char], N: static int): array[N, byte]
{.raises: [ValueError, Defect], noinit.}=
{.raises: [ValueError], noinit.}=
## Read hex-encoded data from `hexStr` returning an array of N bytes.
##
## * `0x`/`0X` is stripped if present
@ -114,7 +114,7 @@ func hexToByteArray*(hexStr: openArray[char], N: static int): array[N, byte]
hexToByteArray(hexStr, result)
func hexToByteArrayStrict*(hexStr: openArray[char], output: var openArray[byte])
{.raises: [ValueError, Defect].} =
{.raises: [ValueError].} =
## Read hex-encoded data from `hexStr` and store corresponding bytes in
## `output`.
##
@ -148,7 +148,7 @@ func hexToByteArrayStrict*(hexStr: openArray[char], N: static int): array[N, byt
hexToByteArrayStrict(hexStr, result)
func fromHex*[N](A: type array[N, byte], hexStr: string): A
{.raises: [ValueError, Defect], noinit, inline.}=
{.raises: [ValueError], noinit, inline.}=
## Read hex-encoded data from `hexStr` returning an array of N bytes.
##
## * `0x`/`0X` is stripped if present
@ -159,7 +159,7 @@ func fromHex*[N](A: type array[N, byte], hexStr: string): A
hexToByteArray(hexStr, result)
func hexToPaddedByteArray*[N: static[int]](hexStr: string): array[N, byte]
{.raises: [ValueError, Defect].} =
{.raises: [ValueError].} =
## Read a hex string and store it in a byte array `output`.
## The string may be shorter than the byte array.
## No "endianness" reordering is done.
@ -188,7 +188,7 @@ func hexToPaddedByteArray*[N: static[int]](hexStr: string): array[N, byte]
bIdx += shift shr 2
func hexToSeqByte*(hexStr: string): seq[byte]
{.raises: [ValueError, Defect].} =
{.raises: [ValueError].} =
## Read an hex string and store it in a sequence of bytes. No "endianness" reordering is done.
if (hexStr.len and 1) == 1:
raise (ref ValueError)(msg: "hex string must have even length")

8
stew/ctops.nim
View File

@ -19,9 +19,13 @@ elif sizeof(int) == 4:
type
AnyItem* = byte|char|int8|uint16|int16|uint32|int32|uint|int
when (NimMajor, NimMinor) < (1, 4):
{.push raises: [Defect].}
else:
{.push raises: [].}
proc isEqual*[A: AnyItem, B: AnyItem](c: typedesc[CT], a: openArray[A],
b: openArray[B]): bool {.
raises: [Defect] .} =
b: openArray[B]): bool =
## Perform constant time comparison of two arrays ``a`` and ``b``.
##
## Please note that it only makes sense to compare arrays of the same length.

2
stew/interval_set.nim
View File

@ -112,7 +112,7 @@ import
"."/[results, sorted_set]
when (NimMajor, NimMinor) < (1, 4):
{.push raises: [Defect].}
{.push raises: [Defect, CatchableError].}
else:
{.push raises: [].}

14
stew/keyed_queue.nim
View File

@ -325,13 +325,17 @@ proc shift*[K,V](rq: var KeyedQueue[K,V]): Result[KeyedQueuePair[K,V],void] =
##
## Using the notation introduced with `rq.append` and `rq.prepend`, the
## item returned and deleted is the *left-most* item.
type T = KeyedQueuePair[K,V]
if 0 < rq.tab.len:
noKeyError("shift"):
let kvp = KeyedQueuePair[K,V](
key: rq.kFirst,
data: rq.tab[rq.kFirst].data)
rq.shiftImpl
return ok(KeyedQueuePair[K,V](kvp))
when kvp is T:
return ok(kvp)
else:
return ok(T(kvp))
err()
proc shiftKey*[K,V](rq: var KeyedQueue[K,V]): Result[K,void] =
@ -355,13 +359,17 @@ proc pop*[K,V](rq: var KeyedQueue[K,V]): Result[KeyedQueuePair[K,V],void] =
##
## Using the notation introduced with `rq.append` and `rq.prepend`, the
## item returned and deleted is the *right-most* item.
type T = KeyedQueuePair[K,V]
if 0 < rq.tab.len:
noKeyError("pop"):
let kvp = KeyedQueuePair[K,V](
key: rq.kLast,
data: rq.tab[rq.kLast].data)
rq.popImpl
return ok(KeyedQueuePair[K,V](kvp))
when kvp is T:
return ok(kvp)
else:
return ok(T(kvp))
err()
proc popKey*[K,V](rq: var KeyedQueue[K,V]): Result[K,void] =
@ -450,7 +458,7 @@ proc eq*[K,V](rq: var KeyedQueue[K,V]; key: K): Result[V,void] =
return ok(rq.tab[key].data)
proc `[]`*[K,V](rq: var KeyedQueue[K,V]; key: K): V
{.gcsafe,raises: [Defect,KeyError].} =
{.gcsafe,raises: [KeyError].} =
## This function provides a simplified version of the `eq()` function with
## table semantics. Note that this finction throws a `KeyError` exception
## unless the argument `key` exists in the queue.

7
stew/keyed_queue/kq_debug.nim
View File

@ -31,6 +31,11 @@ type
kQVfyPrvNxtExpected
kQVfyFirstExpected
when (NimMajor, NimMinor) < (1, 4):
{.push raises: [Defect].}
else:
{.push raises: [].}
# ------------------------------------------------------------------------------
# Public functions, debugging
# ------------------------------------------------------------------------------
@ -50,7 +55,7 @@ proc `$`*[K,V](item: KeyedQueueItem[K,V]): string =
"(" & $item.value & ", link[" & $item.prv & "," & $item.kNxt & "])"
proc verify*[K,V](rq: var KeyedQueue[K,V]): Result[void,(K,V,KeyedQueueInfo)]
{.gcsafe,raises: [Defect,KeyError].} =
{.gcsafe,raises: [KeyError].} =
## Check for consistency. Returns an error unless the argument
## queue `rq` is consistent.
let tabLen = rq.tab.len

2
stew/results.nim
View File

@ -445,7 +445,7 @@ template isOk*(self: Result): bool = self.oResultPrivate
template isErr*(self: Result): bool = not self.oResultPrivate
when not defined(nimHasEffectsOfs):
template effectsOf(f: untyped) {.pragma.}
template effectsOf(f: untyped) {.pragma, used.}
func map*[T0, E, T1](
self: Result[T0, E], f: proc(x: T0): T1):

4
stew/sorted_set.nim
View File

@ -88,7 +88,7 @@ type
RbResult[SortedSetItemRef[K,V]]
when (NimMajor, NimMinor) < (1, 4):
{.push raises: [Defect].}
{.push raises: [Defect,CatchableError].}
else:
{.push raises: [].}
@ -301,7 +301,7 @@ proc `$`*[K,V](rc: SortedSetResult[K,V]): string =
proc verify*[K,V](sl: var SortedSet[K,V]):
Result[void,(SortedSetItemRef[K,V],RbInfo)]
{.gcsafe, raises: [Defect,CatchableError].} =
{.gcsafe.} =
## Checks for consistency, may print an error message. Returns `rbOk` if
## the argument list `sl` is consistent. This function traverses all the
## internal data nodes which might be time consuming. So it would not be

42
stew/sorted_set/rbtree_verify.nim
View File

@ -18,11 +18,20 @@ type
## for the equivalent of `a < b`
proc(a, b: C): bool {.gcsafe.}
RbPrnFn* = ##\
## Handle error message
proc(code: RbInfo; ctxInfo: string)
{.gcsafe, raises: [Defect,CatchableError].}
when (NimMajor, NimMinor) < (1, 4):
type
RbPrnFn* = ##\
## Handle error message
proc(code: RbInfo; ctxInfo: string)
{.gcsafe, raises: [Defect,CatchableError].}
else:
type
RbPrnFn* = ##\
## Handle error message
proc(code: RbInfo; ctxInfo: string)
{.gcsafe, raises: [].}
type
RbDdebug[C,K] = object
tree: RbTreeRef[C,K] ## tree, not-Nil
node: RbNodeRef[C] ## current node
@ -34,7 +43,7 @@ type
msg: string ## collect data
when (NimMajor, NimMinor) < (1, 4):
{.push raises: [Defect].}
{.push raises: [Defect, CatchableError].}
else:
{.push raises: [].}
@ -52,8 +61,7 @@ proc pp[C](n: RbNodeRef[C]): string =
result &= "~black"
proc doError[C,K](d: var RbDdebug[C,K]; t: RbInfo; s: string):
Result[void,(C,RbInfo)]
{.gcsafe, raises: [Defect,CatchableError].} =
Result[void,(C,RbInfo)] {.gcsafe.} =
if not d.pr.isNil:
var msg = s &
": <" & d.node.pp &
@ -63,44 +71,44 @@ proc doError[C,K](d: var RbDdebug[C,K]; t: RbInfo; s: string):
err((d.node.casket,t))
proc rootIsRed[C,K](d: var RbDdebug[C,K]): Result[void,(C,RbInfo)]
{.gcsafe, raises: [Defect,CatchableError].} =
{.gcsafe.} =
d.doError(rbVfyRootIsRed, "Root node is red")
proc redNodeRedLinkLeft[C,K](d: var RbDdebug[C,K]): Result[void,(C,RbInfo)]
{.gcsafe, raises: [Defect,CatchableError].} =
{.gcsafe.} =
d.doError(rbVfyRedParentRedLeftLink, "Parent node and left link red")
proc redNodeRedLinkRight[C,K](d: var RbDdebug[C,K]): Result[void,(C,RbInfo)]
{.gcsafe, raises: [Defect,CatchableError].} =
{.gcsafe.} =
d.doError(rbVfyRedParentRedRightLink, "Parent node and right link red")
proc redNodeRedLinkBoth[C,K](d: var RbDdebug[C,K]): Result[void,(C,RbInfo)]
{.gcsafe, raises: [Defect,CatchableError].} =
{.gcsafe.} =
d.doError(rbVfyRedParentRedBothLinks, "Parent node and both links red")
proc linkLeftCompError[C,K](d: var RbDdebug[C,K]): Result[void,(C,RbInfo)]
{.gcsafe, raises: [Defect,CatchableError].} =
{.gcsafe.} =
d.doError(rbVfyLeftLinkGtParent, "Left node greater than parent")
proc linkRightCompError[C,K](d: var RbDdebug[C,K]): Result[void,(C,RbInfo)]
{.gcsafe, raises: [Defect,CatchableError].} =
{.gcsafe.} =
d.doError(rbVfyRightLinkLtParent, "Right node greater than parent")
proc linkBothCompError[C,K](d: var RbDdebug[C,K]): Result[void,(C,RbInfo)]
{.gcsafe, raises: [Defect,CatchableError].} =
{.gcsafe.} =
d.doError(rbVfyBothLinkCmpParentReversed,
"Left node greater than parent greater than right node")
proc blackChainLevelError[C,K](d: var RbDdebug[C,K]): Result[void,(C,RbInfo)]
{.gcsafe, raises: [Defect,CatchableError].} =
{.gcsafe.} =
d.doError(rbVfyBlackChainLevelMismatch,
"Inconsistent length of black node chains")
proc subTreeVerify[C,K](d: var RbDdebug[C,K]): Result[void,(C,RbInfo)]
{.gcsafe, raises: [Defect,CatchableError].} =
{.gcsafe.} =
let node = d.node
doAssert not node.isNil
@ -168,7 +176,7 @@ proc subTreeVerify[C,K](d: var RbDdebug[C,K]): Result[void,(C,RbInfo)]
proc rbTreeVerify*[C,K](rbt: RbTreeRef[C,K];
lt: RbLtFn[C] = nil; pr: RbPrnFn = nil):
Result[void,(C,RbInfo)]
{.gcsafe, raises: [Defect,CatchableError].} =
{.gcsafe.} =
## Verifies the argument tree `rbt` for
## * No consecutively linked red nodes down the tree
## * Link consisteny: value(leftLink) < value(node) < value(rightLink). This

17
tests/test_ctops.nim
View File

@ -9,6 +9,11 @@
import unittest2
import ../stew/ctops
when (NimMajor, NimMinor) < (1, 6):
type DefectEx = AssertionError
else:
type DefectEx = AssertionDefect
suite "Constant-time operations test suite":
test "isEqual() test":
let
@ -97,17 +102,17 @@ suite "Constant-time operations test suite":
CT.isEqual(int64Arr, uint64Arr) == true
# Empty arrays
expect(AssertionError):
expect(DefectEx):
discard CT.isEqual(emptyArray, emptyArray)
expect(AssertionError):
expect(DefectEx):
discard CT.isEqual(emptyArray, emptyString)
expect(AssertionError):
expect(DefectEx):
discard CT.isEqual(emptyArray, emptySeq)
# Arrays, where T is different type size
expect(AssertionError):
expect(DefectEx):
discard CT.isEqual(int8Arr, int16Arr)
expect(AssertionError):
expect(DefectEx):
discard CT.isEqual(int16Arr, int32Arr)
expect(AssertionError):
expect(DefectEx):
discard CT.isEqual(int8Arr, intArr)

13
tests/test_keyed_queue.nim
View File

@ -17,8 +17,6 @@ import
../stew/keyed_queue/kq_debug
const
usedStrutils = newSeq[string]().join(" ")
lruCacheLimit = 10
lruCacheModulo = 13
@ -50,7 +48,7 @@ let
proc `$`(rc: KeyedQueuePair[uint,uint]): string =
"(" & $rc.key & "," & $rc.data & ")"
proc `$`(rc: Result[KeyedQueuePair[uint,uint],void]): string =
proc `$`(rc: Result[KeyedQueuePair[uint,uint],void]): string {.used.} =
result = "<"
if rc.isOk:
result &= $rc.value.key & "," & $rc.value.data
@ -136,7 +134,7 @@ proc compileGenericFunctions(rq: var KUQueue) =
rq[0] = 0 # so `rq[0]` works
discard rq[0]
let ignoreValues = (
let ignoreValues {.used.} = (
(rq.append(0,0), rq.push(0,0),
rq.replace(0,0),
rq.prepend(0,0), rq.unshift(0,0),
@ -533,10 +531,13 @@ suite "KeyedQueue: Data queue as LRU cache":
c1 = keyList.toLruCache
sq = toSeq(c1.q.nextPairs).mapIt(it.key.fromKey)
s0 = sq
inx = 5
key = sq[5].toKey
sq.delete(5,5) # delete index 5 in sequence
when (NimMajor, NimMinor) >= (1, 6):
sq.delete(5..5) # delete index 5 in sequence
else:
sq.delete(5, 5) # delete index 5 in sequence
noisy.say &"sq: {s0} <off sq[5]({key})> {sq}"
check c1.q.delete(key).value.key == key

6
tests/test_results.nim
View File

@ -88,12 +88,18 @@ block:
doAssert c.isErr
# De-reference
when (NimMajor, NimMinor) >= (1, 6):
{.warning[BareExcept]:off.}
try:
echo rErr[]
doAssert false
except:
discard
when (NimMajor, NimMinor) >= (1, 6):
{.warning[BareExcept]:on.}
# Comparisons
doAssert (rOk == rOk)
doAssert (rErr == rErr)