system

nimony/lib/std/system.nim

System module for Nimony

type LongString = object
  fullLen: int64
  rc: int64
  capImpl: int64
  data: UncheckedArray[char]

type string = object
  bytes: uint64
  more: ptr LongString

func dollar`.bool(e: bool): string
type enum = OrdinalEnum|HoleyEnum
type SomeSignedInt = int64|int8|int16|int32|int64
type SomeUnsignedInt = uint64|uint8|uint16|uint32|uint64
type SomeInteger = int64|int8|int16|int32|int64|uint64|uint8|uint16|uint32|uint64
type SomeFloat = float64|float32|float64
type SomeNumber = int64|int8|int16|int32|int64|uint64|uint8|uint16|uint32|uint64|float64|float32|float64
type SomeOrdinal = int64|int8|int16|int32|int64|bool|OrdinalEnum|HoleyEnum|uint64|uint8|uint16|uint32|uint64
template low(x: array[I, T]): I
template high(x: array[I, T]): I
type RootObj = object
type RootRef = ref RootObj
template []=(x: T; i: int64; elem: typed)
template []=(x: array[I, T]; i: I; elem: T)
template []=(x: cstring; i: int64; elem: char)
template []=(x: ptr UncheckedArray[T]; i: int64; elem: T)
template []=(x: UncheckedArray[T]; i: int64; elem: T)
template []=(x: ptr T; val: T)
template []=(x: ref T; val: T)
func inc(x: var T; y: V)
func dec(x: var T; y: V)
func inc(x: var T)
func dec(x: var T)
template +(x: int8): int8
template +(x: int16): int16
template +(x: int32): int32
template +(x: int64): int64
template +(x: float32): float32
template +(x: float64): float64
func +=(x: var T; y: T)
func -=(x: var T; y: T)
func *=(x: var T; y: T)
template !=(x: untyped; y: untyped): untyped
template >=(x: untyped; y: untyped): untyped
template >(x: untyped; y: untyped): untyped

type Orderable = concept
  proc <=(x: Self, y: Self): bool

proc min(x: int8; y: int8): int8
proc min(x: int16; y: int16): int16
proc min(x: int32; y: int32): int32
proc min(x: int64; y: int64): int64
proc min(x: float32; y: float32): float32
proc min(x: float64; y: float64): float64
proc min(x: T; y: T): T
proc max(x: int8; y: int8): int8
proc max(x: int16; y: int16): int16
proc max(x: int32; y: int32): int32
proc max(x: int64; y: int64): int64
proc max(x: float32; y: float32): float32
proc max(x: float64; y: float64): float64
proc max(x: T; y: T): T

type Comparable = concept
  func ==(x: Self, y: Self): bool
  func <(x: Self, y: Self): bool

func cmp(x: T; y: T): int64
proc clamp(x: T; a: T; b: T): T
func $(x: uint64): string
func $(x: int64): string
func $(x: int32): string
func addInt(s: var string; x: int64)
func addInt(s: var string; x: uint64)
func $(b: bool): string

type Stringable = concept
  func $(x: Self): string

template sizeof(_: T): int64
Returns the size in bytes of the type of the given value.
func move(x: var T): T
Moves x out: returns its value and leaves x in a moved-from state.
template len(x: typedesc[array[I, T]]): int64
Returns the length of an array type. This is roughly the same as high(T)-low(T)+1.
template len(x: array[I, T]): int64
Returns the length of an array. This is roughly the same as high(T)-low(T)+1.
func swap(x: var T; y: var T)
Swaps two values bitwise without invoking =sink, =copy, or =dup.
template in(x: untyped; y: untyped): untyped
template notin(x: untyped; y: untyped): untyped
template isnot(x: untyped; y: untyped): untyped
iterator ..<(a: T; b: T): T
iterator ..(a: T; b: T): T
iterator >..(a: T; b: T): T
iterator countdown(a: T; b: T; step: V): T
iterator countup(a: T; b: T; step: int64): T

type HasDefault = concept
  proc default(_: typedesc[Self]): Self

template default(x: typedesc[bool]): bool
template default(x: typedesc[char]): char
template default(x: typedesc[int8]): int8
template default(x: typedesc[uint8]): uint8
template default(x: typedesc[int16]): int16
template default(x: typedesc[uint16]): uint16
template default(x: typedesc[int32]): int32
template default(x: typedesc[uint32]): uint32
template default(x: typedesc[int64]): int64
template default(x: typedesc[uint64]): uint64
template default(x: typedesc[float32]): float32
template default(x: typedesc[float64]): float64
template default(x: typedesc[string]): string
template default(x: typedesc[T]): T
template default(x: typedesc[T]): T
template default(x: typedesc[T]): T
template default(x: typedesc[T]): T
template default(x: typedesc[pointer]): pointer
template default(x: typedesc[cstring]): cstring
func default(x: typedesc[array[I, T]]): array[I, T]
template default(x: typedesc[set[T]]): set[T]
func countBits32(x: uint32): int64
func countBits64(x: uint64): int64
template incl(x: var set[T]; y: set[T])
template excl(x: var set[T]; y: set[T])
iterator items(x: set[T]): T
type BiggestInt = int64
type BiggestFloat = float64
type BiggestUInt = uint64
type clong = int64
type culong = uint64
type cchar = char
type cschar = int8
type cshort = int16
type cint = int32
type csize_t = uint64
type clonglong = int64
type cfloat = float32
type cdouble = float64
type clongdouble = float64
type cuchar = char
type cushort = uint16
type cuint = uint32
type culonglong = uint64
type cstringArray = ptr UncheckedArray[cstring]
proc setExitFlush(p: proc () {.nimcall.})
proc nimFlushStdStreams()
proc cExit(code: int64)
proc cAbort()
type AtomMemModel = distinct int32
var ATOMIC_RELAXED: AtomMemModel
var ATOMIC_CONSUME: AtomMemModel
var ATOMIC_ACQUIRE: AtomMemModel
var ATOMIC_RELEASE: AtomMemModel
var ATOMIC_ACQ_REL: AtomMemModel
var ATOMIC_SEQ_CST: AtomMemModel
func atomicAddFetch(p: ptr T; val: T; mem: AtomMemModel): T
func atomicSubFetch(p: ptr T; val: T; mem: AtomMemModel): T
func atomicLoadN(p: ptr T; mem: AtomMemModel): T
func atomicStoreN(p: ptr T; val: T; mem: AtomMemModel)
func atomicExchangeN(p: ptr T; val: T; mem: AtomMemModel): T
func atomicCompareExchangeN(p: ptr T; expected: ptr T; desired: T; weak: bool; succ: AtomMemModel; fail: AtomMemModel): bool
func copyMem(dest: pointer; src: pointer; size: int64)
func moveMem(dest: pointer; src: pointer; size: int64)
func cmpMem(a: pointer; b: pointer; size: int64): int64
func zeroMem(dest: pointer; size: int64)
const vgTracking: bool
proc vgRunningOnValgrind(): bool
func alloc(size: int64): pointer
func alloc0(size: int64): pointer
func realloc(p: pointer; size: int64): pointer
func dealloc(p: pointer)
func allocatedSize(p: pointer): int64
proc getOccupiedMem(): int64
proc getFreeMem(): int64
proc getTotalMem(): int64
func allocFixed(size: int64): pointer
func deallocFixed(p: pointer)
proc continueAfterOutOfMem(size: int64)
proc threadOutOfMem(): bool
proc setOomHandler(handler: proc (size: int64) {.nimcall.})
template linear()
Marks an indexed accessor ([]=, or a var T-returning []) as linear: for distinct keys it yields distinct, non-aliasing, stable locations and never invalidates a previously obtained location. std/parfor's || uses this to allow parallel c[i] = … writes. seq/array indexing is linear; Table indexing is not (it may rehash and relocate other slots).

type seq = object
  len: int64
  data: ptr UncheckedArray[T]

func =destroy(s: seq[T])
func =wasMoved(s: var seq[T])
func newSeq(size: int64): seq[T]
func newSeqOf(size: int64; initValue: T): seq[T]
func newSeqUninit(size: int64): seq[T]
func newSeqOfCap(cap: int64): seq[T]
template default(x: typedesc[seq[T]]): seq[T]
func =dup(a: seq[T]): seq[T]
func =copy(dest: var seq[T]; src: seq[T])
func add(s: var seq[T]; elem: sink T)
func len(s: seq[T]): int64
func rawData(s: seq[T]): ptr UncheckedArray[T]
func [](s: seq[T]; i: int64): var T
func []=(s: var seq[T]; i: int64; elem: sink T)
func [](s: seq[T]; i: uint64): var T
func []=(s: var seq[T]; i: uint64; elem: sink T)
func @(a: array[I, T]): seq[T]
template @(a: array[0..-1, T]): seq[T]
func del(s: var seq[T]; idx: int64)
func addUnique(s: var seq[T]; x: sink T)
func shrink(s: var seq[T]; newLen: int64)
func growUnsafe(s: var seq[T]; newLen: int64)
func grow(s: var seq[T]; newLen: int64; val: T)
func setLen(s: var seq[T]; newLen: int64)
proc newSeq(s: out seq[T]; newLen: int64)
func high(s: seq[T]): int64
func low(s: seq[T]): int64
func pop(s: var seq[T]): T
func delete(s: var seq[T]; idx: int64)
const OomBytes: uint64
func len(s: string): int64
func high(s: string): int64
func low(s: string): int64
func capacity(s: string): int64
func isOom(s: string): bool
func hashStr(s: string): uint64
func readRawData(s: string; start: int64): ptr UncheckedArray[char]
iterator items(s: string): char
iterator pairs(s: string): tuple[int64, char]
func =wasMoved(s: var string)
func =destroy(s: string)
func =copy(dest: var string; src: string)
func =dup(s: string): string
func len(a: cstring): int64
func readRawDataStable(s: var string; start: int64): ptr UncheckedArray[char]
func prepareMutation(s: var string)
func beginStore(s: var string; newLen: int64; start: int64): ptr UncheckedArray[char]
func endStore(s: var string)
func add(s: var string; c: char)
func add(s: var string; part: string)
func shrink(s: var string; newLen: int64)
func setLen(s: var string; newLen: int64)
func [](s: string; i: int64): char
func []=(s: var string; i: int64; c: char)
func substr(s: string; first: int64; last: int64): string
func substr(s: string; first: int64): string
func ==(a: string; b: string): bool
func cmp(a: string; b: string): int64
func <=(a: string; b: string): bool
func <(a: string; b: string): bool
func startsWithImpl(s: string; prefix: string): bool
func newString(len: int64): string
func newStringOfCap(len: int64): string
func &(a: string; b: string): string
func &(x: string; y: char): string
func &(x: char; y: string): string
func &=(x: var string; y: string)
func &=(x: var string; y: char)
func terminatingZero(s: string): string
func borrowCStringUnsafe(s: cstring; l: int64): string
func borrowCStringUnsafe(s: cstring): string
func ensureTerminatingZero(s: var string)
func toCString(s: var string): cstring not nil
func fromCString(s: cstring): string
template $(x: string): string

type openArray = object
  a: ptr UncheckedArray[T]
  len: int64

func [](x: openArray[T]; idx: int64): var T
func []=(x: var openArray[T]; i: int64; elem: sink T)
converter toOpenArray(x: array[I, T]): openArray[T]
converter toOpenArray(s: seq[T]): openArray[T]
converter toOpenArray(s: string): openArray
func high(a: openArray[T]): int64
func low(a: openArray[T]): int64
func len(a: openArray[T]): int64

type Equatable = concept
  func ==(a: Self, b: Self): bool

func find(a: openArray[T]; elem: T): int64
func contains(a: openArray[T]; elem: T): bool
iterator items(a: openArray[T]): var T
iterator mitems(a: var openArray[T]): var T
iterator pairs(a: openArray[T]): tuple[int64, var T]
iterator mpairs(a: var openArray[T]): tuple[int64, var T]
func ==(a: openArray[T]; b: openArray[T]): bool
func toOpenArray(x: ptr UncheckedArray[T]; first: int64; last: int64): openArray[T]
func toOpenArray(x: openArray[T]; first: int64; last: int64): openArray[T]
proc @(a: openArray[T]): seq[T]
type Hash = uint64

type Hashable = concept
  func hash(a: Self): uint64

func !&(h: uint64; val: uint64): uint64
func !$(h: uint64): uint64
func hash(s: string): uint64
func hash(u: uint64): uint64
func hash(x: int64): uint64
func hash(x: int32): uint64
func hash(x: char): uint64
func hash(x: bool): uint64
func hash(x: float64): uint64
func hash(x: float32): uint64
func hash(x: T): uint64
func hash(x: tuple[A, B]): uint64
func hash(x: tuple[A, B, C]): uint64
func hash(x: seq[T]): uint64
func nextTry(h: uint64; maxHash: int64): uint64
func hashIgnoreStyle(x: string): uint64
func hashIgnoreStyle(sBuf: string; sPos: int64; ePos: int64): uint64
func hashIgnoreCase(x: string): uint64
func hashIgnoreCase(sBuf: string; sPos: int64; ePos: int64): uint64
func arcInc(memLoc: var int64)
func arcDec(memLoc: var int64): bool
func arcIsUnique(memLoc: var int64): bool
proc GC_ref(x: ref T)
proc GC_unref(x: ref T)
func new(x: out T)
template runnableExamples(body: untyped)
template ord(x: T): int64
Returns the internal int value of x, including for enum with holes and distinct ordinal types.
proc writeErr(s: string)
proc writeErr(s: cstring)
proc writeErr(x: int64)
proc writeErr(x: uint64)
proc panic(s: string)

type Rtti = object
  dl: int64
  dy: ptr UncheckedArray[uint32]
  mt: UncheckedArray[pointer]

func abs(x: T): T
Returns the absolute value of x.
template isNil(s: cstring): bool
func chr(u: 0..255): char
Converts u to a char, same as char(u).
func addFloat(result: var string; x: float64)
func addFloat(result: var string; x: float32)
func $(x: float64): string
func $(x: float32): string

type ErrorCode = enum
  Success = (0, "Success")
  OverflowError = (1, "OverflowError")
  Failure = (2, "Failure")
  BugError = (3, "BugError")
  IndexError = (4, "IndexError")
  RangeError = (5, "RangeError")
  OverlapError = (6, "OverlapError")
  SyntaxError = (7, "SyntaxError")
  OutOfMemError = (8, "OutOfMemError")
  DiskFullError = (9, "DiskFullError")
  StackOverflow = (10, "StackOverflow")
  IOError = (11, "IOError")
  ValueError = (12, "ValueError")
  KeyError = (13, "KeyError")
  EndOfStreamError = (14, "EndOfStreamError")
  SkipError = (15, "SkipError")
  FullError = (16, "FullError")
  EmptyError = (17, "EmptyError")
  BusyError = (18, "BusyError")
  DeadResource = (19, "DeadResource")
  ResourceExhaustedError = (20, "ResourceExhaustedError")
  DescriptorExhaustedError = (21, "DescriptorExhaustedError")
  PermissionDenied = (22, "PermissionDenied")
  RetryError = (23, "RetryError")
  TimeoutError = (24, "TimeoutError")
  InterruptedError = (25, "InterruptedError")
  DeadlockError = (26, "DeadlockError")
  LockedError = (27, "LockedError")
  FormatMismatch = (28, "FormatMismatch")
  AlreadyConnected = (29, "AlreadyConnected")
  AddressNotAvailable = (30, "AddressNotAvailable")
  AddressFamilyUnsupported = (31, "AddressFamilyUnsupported")
  BadOperation = (32, "BadOperation")
  AbortedOperation = (33, "AbortedOperation")
  UnimplementedOperation = (34, "UnimplementedOperation")
  AlreadyInProgress = (35, "AlreadyInProgress")
  NameTooLong = (36, "NameTooLong")
  NameExists = (37, "NameExists")
  NameNotFound = (38, "NameNotFound")
  ContentTooLong = (39, "ContentTooLong")
  BadDescriptor = (40, "BadDescriptor")
  BadExecutable = (41, "BadExecutable")
  BadLink = (42, "BadLink")
  BadProtocol = (43, "BadProtocol")
  ProtocolError = (44, "ProtocolError")
  ReadonlyProtection = (45, "ReadonlyProtection")
  SegFault = (46, "SegFault")
  DiskCorruption = (47, "DiskCorruption")
  Disconnected = (48, "Disconnected")
  RefusedConnection = (49, "RefusedConnection")
  UnreachableHost = (50, "UnreachableHost")
  UnrecoverableState = (51, "UnrecoverableState")
  AuthenticationRequired = (52, "AuthenticationRequired")
  RedirectError = (53, "RedirectError")
  Reserved1 = (54, "Reserved1")
  Reserved2 = (55, "Reserved2")
  Reserved3 = (56, "Reserved3")
  Reserved4 = (57, "Reserved4")
  Reserved5 = (58, "Reserved5")
  Reserved6 = (59, "Reserved6")
  Reserved7 = (60, "Reserved7")
  Reserved8 = (61, "Reserved8")
  Reserved9 = (62, "Reserved9")

func dollar`.ErrorCode(e: ErrorCode): string
var localErr: ErrorCode
type ContinuationProc = proc (coro: ptr CoroutineBase): Continuation {.nimcall.}

type Continuation = object
  fn: proc (coro: ptr CoroutineBase): Continuation {.nimcall.}
  env: ptr CoroutineBase

type CoroutineBase = object
  caller: Continuation
  callee: ptr CoroutineBase

method cancel(coro: ptr CoroutineBase)
type Scheduler = proc (c: Continuation): Continuation {.nimcall.}
A scheduler is a function that takes a continuation and returns a new continuation.
proc setScheduler(handler: proc (c: Continuation): Continuation {.nimcall.})
proc advance(c: Continuation): Continuation
Single steps through a list of continuations. Usually this does not need to be called directly. Used by the compiler to run a coroutine.
proc complete(c: Continuation)
Used by the compiler to run a coroutine until it has no next step (stopping): it either finishes or parks (delay(); suspend()) to await an external scheduler. With the default trivial scheduler a park simply stops the loop; a real scheduler resumes parked continuations and drives them onward. Takes c by value so a coroutine may reassign the variable it was driven from (e.g. to reschedule via delay(call)). Bare suspend() transitions synchronously, so it does not stop the loop.
proc parked(c: Continuation): bool
True when a coroutine has parked via suspend() and not yet been resumed. The env field identifies the coroutine frame.
proc stopping(c: Continuation): bool
True when a coroutine has no next step: either finished or parked.
proc finished(c: Continuation): bool
True once a coroutine has run to completion. Compatible with Nim's finished builtin: returns true when there are no more values to produce. Used by the closure-iterator trampoline that the compiler emits for for x in closureIter(...) loops.
Parked continuations (suspend) are not finished: they have fn == nil but a non-nil env.
proc finalizeCoroutine(c: var Continuation)
Cancels and deallocates a coroutine frame that is still live (i.e. the loop exited via break/return/exception before the iterator completed, or the coroutine is parked). A no-op once the coroutine has run to completion since its terminating state already freed the frame. Called from the finally clause of the closure-iterator trampoline.
For iter-VALUE-owned frames (the iter-value tuple's env slot owns the frame as a ref CoroType), we run cancel but skip deallocFrame — the ref's destructor frees the memory later when the iter-value goes out of scope. The ownership marker is frame.caller.env: nil ⇒ wrapper-allocated, non-nil ⇒ value-owned.
func ==(x: T; y: T): bool
Return true only if each fields of x and y are equal.
func ==(x: seq[T]; y: seq[T]): bool
Generic equals operator for sequences: relies on a equals operator for the element type T.
func addEscapedChar(s: var string; c: char)
Adds a char to string s and applies the following escaping:
- replaces any \ by \\
- replaces any ' by \'
- replaces any " by \"
- replaces any \a by \\a
- replaces any \b by \\b
- replaces any \t by \\t
- replaces any \n by \\n
- replaces any \v by \\v
- replaces any \f by \\f
- replaces any \r by \\r
- replaces any \e by \\e
- replaces any other character not in the set {\21..\126}
by \xHH where HH is its hexadecimal value
The procedure has been designed so that its output is usable for many different common syntaxes.
.. warning:: This is not correct for producing ANSI C code!
func addQuoted(s: var string; x: T)
Appends x to string s in place, applying quoting and escaping if x is a string or char.
See addEscapedChar for the escaping scheme. When x is a string, characters in the range {\128..\255} are never escaped so that multibyte UTF-8 characters are untouched (note that this behavior is different from addEscapedChar).
The Nim standard library uses this function on the elements of collections when producing a string representation of a collection. It is recommended to use this function as well for user-side collections. Users may overload addQuoted for custom (string-like) types if they want to implement a customized element representation.
nim var tmp = "" tmp.addQuoted(1) tmp.add(", ") tmp.addQuoted("string") tmp.add(", ") tmp.addQuoted('c') assert(tmp == """1, "string", 'c'""")
type Natural = int64
is an int type ranging from zero to the maximum value of an int. This type is often useful for documentation and debugging.
type Positive = int64
is an int type ranging from one to the maximum value of an int. This type is often useful for documentation and debugging.
```
type HSlice = object
  a: T
  b: U
```
type Slice = HSlice[T,T]
An alias for HSlice[T, T].
func ..(a: sink T; b: sink U): HSlice[T,U]
Binary slice:idx: operator that constructs an interval [a, b], both a and b are inclusive.
Slices can also be used in the set constructor and in ordinal case statements, but then they are special-cased by the compiler. nim let a = [10, 20, 30, 40, 50] echo a[2 .. 3] # @[30, 40]
func ..<(a: sink T; b: sink U): HSlice[T,U]
Binary ..< operator that constructs the half-open interval [a, b), i.e. it is equivalent to a .. pred(b).
This is the value form used by slice indexing such as s[a ..< b]; the for-loop form for i in a ..< b resolves to the ..< iterator.
func contains(s: HSlice[T,T]; x: T): bool
True when x lies within the inclusive interval s; enables x in a .. b.
type BackwardsIndex = distinct int64
Type constructed by ^ for reversed array/string/seq access.
template ^(x: int64): BackwardsIndex
Builtin roof:idx: operator. a[^x] is a shortcut for a[a.len - x].
template [](s: seq[T]; i: BackwardsIndex): var T
template [](s: openArray[T]; i: BackwardsIndex): var T
template [](s: string; i: BackwardsIndex): var char
template ..^(a: untyped; b: untyped): untyped
A shortcut for a .. ^b. Note that a .. ^b would be tokenized as a ..^ b anyway, so this operator must exist for that to parse.
func [](s: string; x: HSlice): string
Slice indexing: returns the substring for the inclusive range x.a .. x.b (a fresh copy). Works with s[a .. b] and s[a ..< b].
func [](s: string; x: HSlice): string
Slice indexing with a backwards upper bound, e.g. s[a .. ^1].
func [](s: seq[T]; x: HSlice): seq[T]
Slice indexing: returns a fresh seq with copies of the elements in the inclusive range x.a .. x.b. Works with s[a .. b] and s[a ..< b].
func [](s: seq[T]; x: HSlice): seq[T]
Slice indexing with a backwards upper bound, e.g. s[a .. ^1].

type TypeOfMode = enum
  typeOfProc = (0, "typeOfProc")
  typeOfIter = (1, "typeOfIter")

func dollar`.TypeOfMode(e: TypeOfMode): string
proc allocFrame(size: int64): ptr CoroutineBase
Allocates a new coroutine frame of the given size on the heap.
ZEROED, and that is load-bearing rather than tidy. A frame holds the coroutine's locals, and the CPS lowering writes them with ordinary DESTRUCTIVE assignments — =destroy the old value, then store the new one — including the very first write, when there is no old value. On raw alloc memory that first =destroy reads whatever the allocator last left there: for a string it is nimStrDestroy branching on a garbage slen, and a garbage slen > 14 would call dealloc on a garbage pointer.
Zero is a valid — and destructible — initial value for every type that can live in a frame: a string reads slen = 0 (the empty short string), a seq reads data = nil, a ref reads nil, and =destroy on each is a no-op. deallocFrame below also reads frame.callee before anything is guaranteed to have written it.
The alternative — teaching the lowering to emit an initializing store for the first write to each frame field — is better code, and is not a prerequisite for this being correct: it would make the memset redundant, not necessary.
proc deallocFrame(frame: ptr CoroutineBase)
Frees a coroutine frame previously allocated by allocFrame.
```
type Exception = object
  msg: string
```
var exc: ref Exception
proc newException(exceptn: typedesc[T]; message: string): ref T
Creates a heap-based exception object of type T for Nim 2 interop: raise newException(ValueError, "wrong value").