Merge branch 'master' into ct-fixes

.github/workflows/ci.yml

@@ -26,10 +26,10 @@ jobs:
         include:
           - target:
               os: linux
-            builder: ubuntu-20.04
+            builder: ubuntu-latest
           - target:
               os: macos
-            builder: macos-12
+            builder: macos-latest
           - target:
               os: windows
             builder: windows-latest
@@ -42,7 +42,7 @@ jobs:
     runs-on: ${{ matrix.builder }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Set GCC 10 as default compiler (Linux)
         if: runner.os == 'Linux' && matrix.target.cpu != 'i386'
@@ -74,7 +74,7 @@ jobs:
       - name: Restore llvm-mingw (Windows) from cache
         if: runner.os == 'Windows'
         id: windows-mingw-cache
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: external/mingw-${{ matrix.target.cpu }}
           key: 'mingw-llvm-17-${{ matrix.target.cpu }}'
@@ -100,7 +100,7 @@ jobs:
       - name: Restore Nim DLLs dependencies (Windows) from cache
         if: runner.os == 'Windows'
         id: windows-dlls-cache
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: external/dlls
           key: 'dlls'
@@ -168,6 +168,6 @@ jobs:
           env TEST_LANG="c" nimble test
           # run test against intx
           env TEST_LANG="cpp" nimble test
-          # test conditional compilation for arm654 arch
+          # test conditional compilation for arm64 arch
           # without running the binary
           nim c -c --cpu:arm64 --os:linux tests/all_tests

.gitignore

@@ -6,3 +6,4 @@
 
 nimcache/
 build/
+nimble.paths

config.nims

@@ -0,0 +1,4 @@
+# begin Nimble config (version 1)
+when fileExists("nimble.paths"):
+  include "nimble.paths"
+# end Nimble config

stint/intops.nim

@@ -168,7 +168,7 @@ func `xor`*(a, b: StInt): StInt =
   ## `Bitwise xor` of numbers x and y
   result.impl.bitxor(a.impl, b.impl)
 
-{.pop.} # End noInit
+{.pop.} # End noinit
 
 {.push raises: [], inline, gcsafe.}
 

stint/io.nim

@@ -194,7 +194,8 @@ func readHexChar(c: char): int8 {.inline.}=
   of 'a'..'f': result = int8 ord(c) - ord('a') + 10
   of 'A'..'F': result = int8 ord(c) - ord('A') + 10
   else:
-    raise newException(ValueError, $c & "is not a hexadecimal character")
+    raise newException(ValueError,
+                       "[" & $c & "] is not a hexadecimal character")
 
 func skipPrefixes(current_idx: var int, str: string, radix: range[2..16]) {.inline.} =
   ## Returns the index of the first meaningful char in `hexStr` by skipping
@@ -229,10 +230,14 @@ func nextNonBlank(current_idx: var int, s: string) {.inline.} =
   while current_idx < s.len and s[current_idx] in blanks:
     inc current_idx
 
-func readDecChar(c: range['0'..'9']): int {.inline.}=
+func readDecChar(c: char): int8 {.inline.}=
   ## Converts a decimal char to an int
   # specialization without branching for base <= 10.
-  ord(c) - ord('0')
+  case c
+  of '0'..'9':
+    int8(ord(c) - ord('0'))
+  else:
+    raise newException(ValueError, "[" & $c & "] is not a decimal character")
 
 func parse*[bits: static[int]](input: string,
                                T: typedesc[StUint[bits]],

stint/private/primitives/addcarry_subborrow.nim

@@ -88,6 +88,10 @@ const
   useIntrinsics = X86 and not stintNoIntrinsics
   useInt128 = GCC_Compatible and sizeof(int) == 8 and not stintNoIntrinsics
 
+const
+  newerNim = (NimMajor, NimMinor) > (1, 6)
+  noExplicitPtrDeref = defined(cpp) or newerNim
+
 when useIntrinsics:
   when defined(windows):
     {.pragma: intrinsics, header:"<intrin.h>", nodecl.}
@@ -97,8 +101,8 @@ when useIntrinsics:
   func addcarry_u32(carryIn: Carry, a, b: uint32, sum: var uint32): Carry {.importc: "_addcarry_u32", intrinsics.}
   func subborrow_u32(borrowIn: Borrow, a, b: uint32, diff: var uint32): Borrow {.importc: "_subborrow_u32", intrinsics.}
 
-  func addcarry_u64(carryIn: Carry, a, b: uint64, sum: var uint64): Carry {.importc: "_addcarry_u64", intrinsics.}
-  func subborrow_u64(borrowIn: Borrow, a, b:uint64, diff: var uint64): Borrow {.importc: "_subborrow_u64", intrinsics.}
+  func addcarry_u64(carryIn: Carry, a, b: uint64, sum: var culonglong): Carry {.importc: "_addcarry_u64", intrinsics.}
+  func subborrow_u64(borrowIn: Borrow, a, b:uint64, diff: var culonglong): Borrow {.importc: "_subborrow_u64", intrinsics.}
 
 # ############################################################
 #
@@ -146,13 +150,13 @@ func addC*(cOut: var Carry, sum: var uint64, a, b: uint64, cIn: Carry) {.inline.
     addC_nim(cOut, sum, a, b, cIn)
   else:
     when useIntrinsics:
-      cOut = addcarry_u64(cIn, a, b, sum)
+      cOut = addcarry_u64(cIn, a, b, culonglong(sum))
     elif useInt128:
-      var dblPrec {.noInit.}: uint128
+      var dblPrec {.noinit.}: uint128
       {.emit:[dblPrec, " = (unsigned __int128)", a," + (unsigned __int128)", b, " + (unsigned __int128)",cIn,";"].}
 
       # Don't forget to dereference the var param in C mode
-      when defined(cpp):
+      when noExplicitPtrDeref:
         {.emit:[cOut, " = (NU64)(", dblPrec," >> ", 64'u64, ");"].}
         {.emit:[sum, " = (NU64)", dblPrec,";"].}
       else:
@@ -168,14 +172,14 @@ func subB*(bOut: var Borrow, diff: var uint64, a, b: uint64, bIn: Borrow) {.inli
     subB_nim(bOut, diff, a, b, bIn)
   else:
     when useIntrinsics:
-      bOut = subborrow_u64(bIn, a, b, diff)
+      bOut = subborrow_u64(bIn, a, b, culonglong(diff))
     elif useInt128:
-      var dblPrec {.noInit.}: uint128
+      var dblPrec {.noinit.}: uint128
       {.emit:[dblPrec, " = (unsigned __int128)", a," - (unsigned __int128)", b, " - (unsigned __int128)",bIn,";"].}
 
       # Don't forget to dereference the var param in C mode
       # On borrow the high word will be 0b1111...1111 and needs to be masked
-      when defined(cpp):
+      when noExplicitPtrDeref:
         {.emit:[bOut, " = (NU64)(", dblPrec," >> ", 64'u64, ") & 1;"].}
         {.emit:[diff, " = (NU64)", dblPrec,";"].}
       else:

stint/uintops.nim

@@ -123,7 +123,7 @@ func `xor`*(a, b: StUint): StUint =
   ## `Bitwise xor` of numbers x and y
   result.bitxor(a, b)
 
-{.pop.} # End noInit
+{.pop.} # End noinit
 
 export
   countOnes,
@@ -270,4 +270,4 @@ func divmod*(x, y: StUint): tuple[quot, rem: StUint] =
   ## Division and remainder operations for multi-precision unsigned uint
   divRem(result.quot.limbs, result.rem.limbs, x.limbs, y.limbs)
 
-{.pop.}
+{.pop.}