jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

tyInt tyUint fit target int bit width (#20829)

Browse source
This commit is contained in:
Bung 2022-12-01 20:34:00 +08:00 • committed by GitHub
commit 658b28dc57
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
17 changed files with 306 additions and 267 deletions
Download patch file Download diff file Expand all files Collapse all files

6
lib/std/private/digitsutils.nim
View file

@ -34,7 +34,7 @@ proc utoa2Digits*(buf: var openArray[char]; pos: int; digits: uint32) {.inline.}
#copyMem(buf, unsafeAddr(digits100[2 * digits]), 2 * sizeof((char)))
proc trailingZeros2Digits*(digits: uint32): int32 {.inline.} =
return trailingZeros100[digits]
return trailingZeros100[digits.int8]
when defined(js):
proc numToString(a: SomeInteger): cstring {.importjs: "((#) + \"\")".}
@ -63,14 +63,14 @@ func addIntImpl(result: var string, x: uint64) {.inline.} =
while num >= nbatch:
let originNum = num
num = num div nbatch
let index = (originNum - num * nbatch) shl 1
let index = int16((originNum - num * nbatch) shl 1)
tmp[next] = digits100[index + 1]
tmp[next - 1] = digits100[index]
dec(next, 2)
# process last 1-2 digits
if num < 10:
tmp[next] = chr(ord('0') + num)
tmp[next] = chr(ord('0') + num.uint8)
else:
let index = num * 2
tmp[next] = digits100[index + 1]

38
lib/std/private/dragonbox.nim
View file

@ -1146,7 +1146,7 @@ proc printDecimalDigitsBackwards*(buf: var openArray[char]; pos: int; output64:
buf[pos] = chr(ord('0') + q)
return tz
proc decimalLength*(v: uint64): int32 {.inline.} =
proc decimalLength*(v: uint64): int {.inline.} =
dragonbox_Assert(v >= 1)
dragonbox_Assert(v <= 99999999999999999'u64)
if cast[uint32](v shr 32) != 0:
@ -1166,48 +1166,48 @@ proc decimalLength*(v: uint64): int32 {.inline.} =
return 11
return 10
let v32: uint32 = cast[uint32](v)
if v32 >= 1000000000'u:
if v32 >= 1000000000'u32:
return 10
if v32 >= 100000000'u:
if v32 >= 100000000'u32:
return 9
if v32 >= 10000000'u:
if v32 >= 10000000'u32:
return 8
if v32 >= 1000000'u:
if v32 >= 1000000'u32:
return 7
if v32 >= 100000'u:
if v32 >= 100000'u32:
return 6
if v32 >= 10000'u:
if v32 >= 10000'u32:
return 5
if v32 >= 1000'u:
if v32 >= 1000'u32:
return 4
if v32 >= 100'u:
if v32 >= 100'u32:
return 3
if v32 >= 10'u:
if v32 >= 10'u32:
return 2
return 1
proc formatDigits*(buffer: var openArray[char]; pos: int; digits: uint64; decimalExponent: int32;
proc formatDigits*[T: Ordinal](buffer: var openArray[char]; pos: T; digits: uint64; decimalExponent: int;
forceTrailingDotZero = false): int {.inline.} =
const
minFixedDecimalPoint: int32 = -6
minFixedDecimalPoint = -6
const
maxFixedDecimalPoint: int32 = 17
var pos = pos
maxFixedDecimalPoint = 17
var pos:int = pos.int
assert(minFixedDecimalPoint <= -1, "internal error")
assert(maxFixedDecimalPoint >= 17, "internal error")
dragonbox_Assert(digits >= 1)
dragonbox_Assert(digits <= 99999999999999999'u64)
dragonbox_Assert(decimalExponent >= -999)
dragonbox_Assert(decimalExponent <= 999)
var numDigits: int32 = decimalLength(digits)
let decimalPoint: int32 = numDigits + decimalExponent
var numDigits = decimalLength(digits)
let decimalPoint = numDigits + decimalExponent
let useFixed: bool = minFixedDecimalPoint <= decimalPoint and
decimalPoint <= maxFixedDecimalPoint
## Prepare the buffer.
for i in 0..<32: buffer[pos+i] = '0'
assert(minFixedDecimalPoint >= -30, "internal error")
assert(maxFixedDecimalPoint <= 32, "internal error")
var decimalDigitsPosition: int32
var decimalDigitsPosition: int
if useFixed:
if decimalPoint <= 0:
## 0.[000]digits
@ -1258,7 +1258,7 @@ proc formatDigits*(buffer: var openArray[char]; pos: int; digits: uint64; decima
## d.igitsE+123
buffer[pos+1] = '.'
pos = digitsEnd
let scientificExponent: int32 = decimalPoint - 1
let scientificExponent: int = decimalPoint - 1
## SF_ASSERT(scientific_exponent != 0);
buffer[pos] = 'e'
buffer[pos+1] = if scientificExponent < 0: '-' else: '+'
@ -1291,7 +1291,7 @@ proc toChars*(buffer: var openArray[char]; v: float; forceTrailingDotZero = fals
if exponent != 0 or significand != 0:
## != 0
let dec = toDecimal64(significand, exponent)
return formatDigits(buffer, pos, dec.significand, dec.exponent,
return formatDigits(buffer, pos, dec.significand, dec.exponent.int,
forceTrailingDotZero)
else:
buffer[pos] = '0'

16
lib/std/private/schubfach.nim
View file

@ -244,7 +244,7 @@ proc toDecimal32(ieeeSignificand: uint32; ieeeExponent: uint32): FloatingDecimal
## ToChars
## ==================================================================================================
proc printDecimalDigitsBackwards(buf: var openArray[char]; pos: int; output: uint32): int32 {.inline.} =
proc printDecimalDigitsBackwards[T: Ordinal](buf: var openArray[char]; pos: T; output: uint32): int32 {.inline.} =
var output = output
var pos = pos
var tz: int32 = 0
@ -300,7 +300,7 @@ proc printDecimalDigitsBackwards(buf: var openArray[char]; pos: int; output: uin
buf[pos] = chr(uint32('0') + q)
return tz
proc decimalLength(v: uint32): int32 {.inline.} =
proc decimalLength(v: uint32): int {.inline.} =
sf_Assert(v >= 1)
sf_Assert(v <= 999999999'u)
if v >= 100000000'u:
@ -321,7 +321,7 @@ proc decimalLength(v: uint32): int32 {.inline.} =
return 2
return 1
proc formatDigits(buffer: var openArray[char]; pos: int; digits: uint32; decimalExponent: int32;
proc formatDigits[T: Ordinal](buffer: var openArray[char]; pos: T; digits: uint32; decimalExponent: int;
forceTrailingDotZero: bool = false): int {.inline.} =
const
minFixedDecimalPoint: int32 = -4
@ -333,8 +333,8 @@ proc formatDigits(buffer: var openArray[char]; pos: int; digits: uint32; decimal
sf_Assert(digits <= 999999999'u)
sf_Assert(decimalExponent >= -99)
sf_Assert(decimalExponent <= 99)
var numDigits: int32 = decimalLength(digits)
let decimalPoint: int32 = numDigits + decimalExponent
var numDigits = decimalLength(digits)
let decimalPoint = numDigits + decimalExponent
let useFixed: bool = minFixedDecimalPoint <= decimalPoint and
decimalPoint <= maxFixedDecimalPoint
## Prepare the buffer.
@ -342,7 +342,7 @@ proc formatDigits(buffer: var openArray[char]; pos: int; digits: uint32; decimal
for i in 0..<32: buffer[pos+i] = '0'
assert(minFixedDecimalPoint >= -30, "internal error")
assert(maxFixedDecimalPoint <= 32, "internal error")
var decimalDigitsPosition: int32
var decimalDigitsPosition: int
if useFixed:
if decimalPoint <= 0:
## 0.[000]digits
@ -386,7 +386,7 @@ proc formatDigits(buffer: var openArray[char]; pos: int; digits: uint32; decimal
## d.igitsE+123
buffer[pos+1] = '.'
pos = digitsEnd
let scientificExponent: int32 = decimalPoint - 1
let scientificExponent = decimalPoint - 1
## SF_ASSERT(scientific_exponent != 0);
buffer[pos] = 'e'
buffer[pos+1] = if scientificExponent < 0: '-' else: '+'
@ -412,7 +412,7 @@ proc float32ToChars*(buffer: var openArray[char]; v: float32; forceTrailingDotZe
if exponent != 0 or significand != 0:
## != 0
let dec: auto = toDecimal32(significand, exponent)
return formatDigits(buffer, pos, dec.digits, dec.exponent, forceTrailingDotZero)
return formatDigits(buffer, pos, dec.digits, dec.exponent.int, forceTrailingDotZero)
else:
buffer[pos] = '0'
buffer[pos+1] = '.'