nim-stint/stint/private/datatypes.nim

# Stint
# Copyright 2018 Status Research & Development GmbH
# Licensed under either of
#
#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
#  * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
#
# at your option. This file may not be copied, modified, or distributed except according to those terms.

import
  # Status lib
  stew/bitops2

when sizeof(int) == 8 and not defined(Stint32):
  type Word* = uint64
else:
  type Word* = uint32

const WordBitWidth* = sizeof(Word) * 8

func wordsRequired*(bits: int): int {.compileTime.} =
  ## Compute the number of limbs required
  ## from the **announced** bit length
  (bits + WordBitWidth - 1) div WordBitWidth

type
  Limbs*[N: static int] = array[N, Word]

  StUint*[bits: static[int]] = object
    ## Stack-based integer
    ## Unsigned
    limbs*: Limbs[bits.wordsRequired]

  StInt*[bits: static[int]] = object
    ## Stack-based integer
    ## Signed
    limbs*: Limbs[bits.wordsRequired]

  Carry* = uint8  # distinct range[0'u8 .. 1]
  Borrow* = uint8 # distinct range[0'u8 .. 1]

const GCC_Compatible* = defined(gcc) or defined(clang) or defined(llvm_gcc)
const X86* = defined(amd64) or defined(i386)

when sizeof(int) == 8 and GCC_Compatible:
  type
    uint128*{.importc: "unsigned __int128".} = object

template leastSignificantWord*(num: SomeInteger): auto =
  num

func leastSignificantWord*(limbs: Limbs): auto {.inline.} =
  when cpuEndian == littleEndian:
    limbs[0]
  else:
    limbs[^1]

func mostSignificantWord*(limbs: Limbs): auto {.inline.} =
  when cpuEndian == littleEndian:
    limbs[^1]
  else:
    limbs[0]

iterator leastToMostSig*(limbs: Limbs): Word =
  ## Iterate from least to most significant word
  when cpuEndian == littleEndian:
    for i in 0 ..< limbs.len:
      yield limbs[i]
  else:
    for i in countdown(limbs.len-1, 0):
      yield limbs[i]

iterator leastToMostSig*(limbs: var Limbs): var Word =
  ## Iterate from least to most significant word
  when cpuEndian == littleEndian:
    for i in 0 ..< limbs.len:
      yield limbs[i]
  else:
    for i in countdown(limbs.len-1, 0):
      yield limbs[i]

iterator leastToMostSig*(aLimbs, bLimbs: Limbs): (Word, Word) =
  ## Iterate from least to most significant word
  when cpuEndian == littleEndian:
    for i in 0 ..< aLimbs.len:
      yield (aLimbs[i], bLimbs[i])
  else:
    for i in countdown(aLimbs.len-1, 0):
      yield (aLimbs[i], bLimbs[i])

iterator leastToMostSig*(aLimbs: var Limbs, bLimbs: Limbs): (var Word, Word) =
  ## Iterate from least to most significant word
  when cpuEndian == littleEndian:
    for i in 0 ..< aLimbs.len:
      yield (aLimbs[i], bLimbs[i])
  else:
    for i in countdown(aLimbs.len-1, 0):
      yield (aLimbs[i], bLimbs[i])

iterator leastToMostSig*(cLimbs: var Limbs, aLimbs: Limbs, bLimbs: Limbs): (var Word, Word, Word) =
  ## Iterate from least to most significant word
  when cpuEndian == littleEndian:
    for i in 0 ..< aLimbs.len:
      yield (cLimbs[i], aLimbs[i], bLimbs[i])
  else:
    for i in countdown(aLimbs.len-1, 0):
      yield (cLimbs[i], aLimbs[i], bLimbs[i])

import std/macros

proc replaceNodes(ast: NimNode, what: NimNode, by: NimNode): NimNode =
  # Replace "what" ident node by "by"
  proc inspect(node: NimNode): NimNode =
    case node.kind:
    of {nnkIdent, nnkSym}:
      if node.eqIdent(what):
        return by
      return node
    of nnkEmpty:
      return node
    of nnkLiterals:
      return node
    else:
      var rTree = node.kind.newTree()
      for child in node:
        rTree.add inspect(child)
      return rTree
  result = inspect(ast)

macro staticFor*(idx: untyped{nkIdent}, start, stopEx: static int, body: untyped): untyped =
  ## staticFor [min inclusive, max exclusive)
  result = newStmtList()
  for i in start ..< stopEx:
    result.add nnkBlockStmt.newTree(
      ident("unrolledIter_" & $idx & $i),
      body.replaceNodes(idx, newLit i)
    )