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

added a bunch of hostOS standalone conditions

Browse source
This commit is contained in:
Simon Hafner 2013-06-30 16:41:21 -05:00
commit 36b00a107c
3 changed files with 826 additions and 787 deletions
Download patch file Download diff file Expand all files Collapse all files

221
lib/system.nim
View file

@ -111,25 +111,26 @@ proc `or`*(x, y: bool): bool {.magic: "Or", noSideEffect.}
proc `xor`*(x, y: bool): bool {.magic: "Xor", noSideEffect.} proc `xor`*(x, y: bool): bool {.magic: "Xor", noSideEffect.}
## Boolean `exclusive or`; returns true iff ``x != y``. ## Boolean `exclusive or`; returns true iff ``x != y``.
proc new*[T](a: var ref T) {.magic: "New", noSideEffect.} when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc new*[T](a: var ref T) {.magic: "New", noSideEffect.}
## creates a new object of type ``T`` and returns a safe (traced) ## creates a new object of type ``T`` and returns a safe (traced)
## reference to it in ``a``. ## reference to it in ``a``.
proc new*(T: typedesc): ref T = proc new*(T: typedesc): ref T =
## creates a new object of type ``T`` and returns a safe (traced) ## creates a new object of type ``T`` and returns a safe (traced)
## reference to it as result value ## reference to it as result value
new(result) new(result)
proc unsafeNew*[T](a: var ref T, size: int) {.magic: "New", noSideEffect.} proc unsafeNew*[T](a: var ref T, size: int) {.magic: "New", noSideEffect.}
## creates a new object of type ``T`` and returns a safe (traced) ## creates a new object of type ``T`` and returns a safe (traced)
## reference to it in ``a``. This is **unsafe** as it allocates an object ## reference to it in ``a``. This is **unsafe** as it allocates an object
## of the passed ``size``. This should only be used for optimization ## of the passed ``size``. This should only be used for optimization
## purposes when you know what you're doing! ## purposes when you know what you're doing!
proc internalNew*[T](a: var ref T) {.magic: "New", noSideEffect.} proc internalNew*[T](a: var ref T) {.magic: "New", noSideEffect.}
## leaked implementation detail. Do not use. ## leaked implementation detail. Do not use.
proc new*[T](a: var ref T, finalizer: proc (x: ref T) {.nimcall.}) {. proc new*[T](a: var ref T, finalizer: proc (x: ref T) {.nimcall.}) {.
magic: "NewFinalize", noSideEffect.} magic: "NewFinalize", noSideEffect.}
## creates a new object of type ``T`` and returns a safe (traced) ## creates a new object of type ``T`` and returns a safe (traced)
## reference to it in ``a``. When the garbage collector frees the object, ## reference to it in ``a``. When the garbage collector frees the object,
@ -139,7 +140,7 @@ proc new*[T](a: var ref T, finalizer: proc (x: ref T) {.nimcall.}) {.
## the object! This means that for each object of type `T` the finalizer ## the object! This means that for each object of type `T` the finalizer
## will be called! ## will be called!
proc reset*[T](obj: var T) {.magic: "Reset", noSideEffect.} proc reset*[T](obj: var T) {.magic: "Reset", noSideEffect.}
## resets an object `obj` to its initial (binary zero) value. This needs to ## resets an object `obj` to its initial (binary zero) value. This needs to
## be called before any possible `object branch transition`:idx:. ## be called before any possible `object branch transition`:idx:.
@ -164,9 +165,12 @@ type
## pointer to the array data and a ## pointer to the array data and a
## length field. ## length field.
varargs*{.magic: "Varargs".}[T] ## Generic type to construct a varargs type. varargs*{.magic: "Varargs".}[T] ## Generic type to construct a varargs type.
seq*{.magic: "Seq".}[T] ## Generic type to construct sequences.
set*{.magic: "Set".}[T] ## Generic type to construct bit sets. set*{.magic: "Set".}[T] ## Generic type to construct bit sets.
when not defined(noDynamicAlloc) and not defined(nimrodVM):
type
seq*{.magic: "Seq".}[T] ## Generic type to construct sequences.
type type
TSlice* {.final, pure.}[T] = object ## builtin slice type TSlice* {.final, pure.}[T] = object ## builtin slice type
a*, b*: T ## the bounds a*, b*: T ## the bounds
@ -187,6 +191,7 @@ when not defined(niminheritable):
{.pragma: inheritable.} {.pragma: inheritable.}
when not defined(JS) and not defined(NimrodVM): when not defined(JS) and not defined(NimrodVM):
when not defined(noDynamicAlloc):
type type
TGenericSeq {.compilerproc, pure, inheritable.} = object TGenericSeq {.compilerproc, pure, inheritable.} = object
len, reserved: int len, reserved: int
@ -369,7 +374,8 @@ proc dec*[T](x: var ordinal[T], y = 1) {.magic: "Dec", noSideEffect.}
## exist, ``EOutOfRange`` is raised or a compile time error occurs. This is a ## exist, ``EOutOfRange`` is raised or a compile time error occurs. This is a
## short notation for: ``x = pred(x, y)``. ## short notation for: ``x = pred(x, y)``.
proc newSeq*[T](s: var seq[T], len: int) {.magic: "NewSeq", noSideEffect.} when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc newSeq*[T](s: var seq[T], len: int) {.magic: "NewSeq", noSideEffect.}
## creates a new sequence of type ``seq[T]`` with length ``len``. ## creates a new sequence of type ``seq[T]`` with length ``len``.
## This is equivalent to ``s = @[]; setlen(s, len)``, but more ## This is equivalent to ``s = @[]; setlen(s, len)``, but more
## efficient since no reallocation is needed. ## efficient since no reallocation is needed.
@ -387,7 +393,7 @@ proc newSeq*[T](s: var seq[T], len: int) {.magic: "NewSeq", noSideEffect.}
## inputStrings[2] = "would crash" ## inputStrings[2] = "would crash"
## #inputStrings[3] = "out of bounds" ## #inputStrings[3] = "out of bounds"
proc newSeq*[T](len = 0): seq[T] = proc newSeq*[T](len = 0): seq[T] =
## creates a new sequence of type ``seq[T]`` with length ``len``. ## creates a new sequence of type ``seq[T]`` with length ``len``.
## ##
## Note that the sequence will be filled with uninitialized entries, which ## Note that the sequence will be filled with uninitialized entries, which
@ -408,7 +414,8 @@ proc len*[TOpenArray: openArray|varargs](x: TOpenArray): int {.
proc len*(x: string): int {.magic: "LengthStr", noSideEffect.} proc len*(x: string): int {.magic: "LengthStr", noSideEffect.}
proc len*(x: cstring): int {.magic: "LengthStr", noSideEffect.} proc len*(x: cstring): int {.magic: "LengthStr", noSideEffect.}
proc len*[I, T](x: array[I, T]): int {.magic: "LengthArray", noSideEffect.} proc len*[I, T](x: array[I, T]): int {.magic: "LengthArray", noSideEffect.}
proc len*[T](x: seq[T]): int {.magic: "LengthSeq", noSideEffect.} when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc len*[T](x: seq[T]): int {.magic: "LengthSeq", noSideEffect.}
## returns the length of an array, an openarray, a sequence or a string. ## returns the length of an array, an openarray, a sequence or a string.
## This is rougly the same as ``high(T)-low(T)+1``, but its resulting type is ## This is rougly the same as ``high(T)-low(T)+1``, but its resulting type is
## always an int. ## always an int.
@ -747,13 +754,14 @@ proc cmp*[T](x, y: T): int {.procvar.} =
proc cmp*(x, y: string): int {.noSideEffect, procvar.} proc cmp*(x, y: string): int {.noSideEffect, procvar.}
## Compare proc for strings. More efficient than the generic version. ## Compare proc for strings. More efficient than the generic version.
proc `@` * [IDX, T](a: array[IDX, T]): seq[T] {. when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc `@` * [IDX, T](a: array[IDX, T]): seq[T] {.
magic: "ArrToSeq", nosideeffect.} magic: "ArrToSeq", nosideeffect.}
## turns an array into a sequence. This most often useful for constructing ## turns an array into a sequence. This most often useful for constructing
## sequences with the array constructor: ``@[1, 2, 3]`` has the type ## sequences with the array constructor: ``@[1, 2, 3]`` has the type
## ``seq[int]``, while ``[1, 2, 3]`` has the type ``array[0..2, int]``. ## ``seq[int]``, while ``[1, 2, 3]`` has the type ``array[0..2, int]``.
proc setLen*[T](s: var seq[T], newlen: int) {. proc setLen*[T](s: var seq[T], newlen: int) {.
magic: "SetLengthSeq", noSideEffect.} magic: "SetLengthSeq", noSideEffect.}
## sets the length of `s` to `newlen`. ## sets the length of `s` to `newlen`.
## ``T`` may be any sequence type. ## ``T`` may be any sequence type.
@ -761,14 +769,14 @@ proc setLen*[T](s: var seq[T], newlen: int) {.
## ``s`` will be truncated. `s` cannot be nil! To initialize a sequence with ## ``s`` will be truncated. `s` cannot be nil! To initialize a sequence with
## a size, use ``newSeq`` instead. ## a size, use ``newSeq`` instead.
proc setLen*(s: var string, newlen: int) {. proc setLen*(s: var string, newlen: int) {.
magic: "SetLengthStr", noSideEffect.} magic: "SetLengthStr", noSideEffect.}
## sets the length of `s` to `newlen`. ## sets the length of `s` to `newlen`.
## If the current length is greater than the new length, ## If the current length is greater than the new length,
## ``s`` will be truncated. `s` cannot be nil! To initialize a string with ## ``s`` will be truncated. `s` cannot be nil! To initialize a string with
## a size, use ``newString`` instead. ## a size, use ``newString`` instead.
proc newString*(len: int): string {. proc newString*(len: int): string {.
magic: "NewString", importc: "mnewString", noSideEffect.} magic: "NewString", importc: "mnewString", noSideEffect.}
## returns a new string of length ``len`` but with uninitialized ## returns a new string of length ``len`` but with uninitialized
## content. One needs to fill the string character after character ## content. One needs to fill the string character after character
@ -776,27 +784,27 @@ proc newString*(len: int): string {.
## optimization purposes; the same effect can be achieved with the ## optimization purposes; the same effect can be achieved with the
## ``&`` operator or with ``add``. ## ``&`` operator or with ``add``.
proc newStringOfCap*(cap: int): string {. proc newStringOfCap*(cap: int): string {.
magic: "NewStringOfCap", importc: "rawNewString", noSideEffect.} magic: "NewStringOfCap", importc: "rawNewString", noSideEffect.}
## returns a new string of length ``0`` but with capacity `cap`.This ## returns a new string of length ``0`` but with capacity `cap`.This
## procedure exists only for optimization purposes; the same effect can ## procedure exists only for optimization purposes; the same effect can
## be achieved with the ``&`` operator or with ``add``. ## be achieved with the ``&`` operator or with ``add``.
proc `&` * (x: string, y: char): string {. proc `&` * (x: string, y: char): string {.
magic: "ConStrStr", noSideEffect, merge.} magic: "ConStrStr", noSideEffect, merge.}
proc `&` * (x: char, y: char): string {. proc `&` * (x: char, y: char): string {.
magic: "ConStrStr", noSideEffect, merge.} magic: "ConStrStr", noSideEffect, merge.}
proc `&` * (x, y: string): string {. proc `&` * (x, y: string): string {.
magic: "ConStrStr", noSideEffect, merge.} magic: "ConStrStr", noSideEffect, merge.}
proc `&` * (x: char, y: string): string {. proc `&` * (x: char, y: string): string {.
magic: "ConStrStr", noSideEffect, merge.} magic: "ConStrStr", noSideEffect, merge.}
## is the `concatenation operator`. It concatenates `x` and `y`. ## is the `concatenation operator`. It concatenates `x` and `y`.
# implementation note: These must all have the same magic value "ConStrStr" so # implementation note: These must all have the same magic value "ConStrStr" so
# that the merge optimization works properly. # that the merge optimization works properly.
proc add*(x: var string, y: char) {.magic: "AppendStrCh", noSideEffect.} proc add*(x: var string, y: char) {.magic: "AppendStrCh", noSideEffect.}
proc add*(x: var string, y: string) {.magic: "AppendStrStr", noSideEffect.} proc add*(x: var string, y: string) {.magic: "AppendStrStr", noSideEffect.}
type type
TEndian* = enum ## is a type describing the endianness of a processor. TEndian* = enum ## is a type describing the endianness of a processor.
@ -936,8 +944,9 @@ include "system/inclrtl"
when not defined(JS) and not defined(nimrodVm) and hostOS != "standalone": when not defined(JS) and not defined(nimrodVm) and hostOS != "standalone":
include "system/cgprocs" include "system/cgprocs"
proc add *[T](x: var seq[T], y: T) {.magic: "AppendSeqElem", noSideEffect.} when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc add *[T](x: var seq[T], y: openArray[T]) {.noSideEffect.} = proc add *[T](x: var seq[T], y: T) {.magic: "AppendSeqElem", noSideEffect.}
proc add *[T](x: var seq[T], y: openArray[T]) {.noSideEffect.} =
## Generic proc for adding a data item `y` to a container `x`. ## Generic proc for adding a data item `y` to a container `x`.
## For containers that have an order, `add` means *append*. New generic ## For containers that have an order, `add` means *append*. New generic
## containers should also call their adding proc `add` for consistency. ## containers should also call their adding proc `add` for consistency.
@ -947,28 +956,28 @@ proc add *[T](x: var seq[T], y: openArray[T]) {.noSideEffect.} =
setLen(x, xl + y.len) setLen(x, xl + y.len)
for i in 0..high(y): x[xl+i] = y[i] for i in 0..high(y): x[xl+i] = y[i]
proc shallowCopy*[T](x: var T, y: T) {.noSideEffect, magic: "ShallowCopy".} proc shallowCopy*[T](x: var T, y: T) {.noSideEffect, magic: "ShallowCopy".}
## use this instead of `=` for a `shallow copy`:idx:. The shallow copy ## use this instead of `=` for a `shallow copy`:idx:. The shallow copy
## only changes the semantics for sequences and strings (and types which ## only changes the semantics for sequences and strings (and types which
## contain those). Be careful with the changed semantics though! There ## contain those). Be careful with the changed semantics though! There
## is a reason why the default assignment does a deep copy of sequences ## is a reason why the default assignment does a deep copy of sequences
## and strings. ## and strings.
proc del*[T](x: var seq[T], i: int) {.noSideEffect.} = proc del*[T](x: var seq[T], i: int) {.noSideEffect.} =
## deletes the item at index `i` by putting ``x[high(x)]`` into position `i`. ## deletes the item at index `i` by putting ``x[high(x)]`` into position `i`.
## This is an O(1) operation. ## This is an O(1) operation.
var xl = x.len var xl = x.len
shallowCopy(x[i], x[xl-1]) shallowCopy(x[i], x[xl-1])
setLen(x, xl-1) setLen(x, xl-1)
proc delete*[T](x: var seq[T], i: int) {.noSideEffect.} = proc delete*[T](x: var seq[T], i: int) {.noSideEffect.} =
## deletes the item at index `i` by moving ``x[i+1..]`` by one position. ## deletes the item at index `i` by moving ``x[i+1..]`` by one position.
## This is an O(n) operation. ## This is an O(n) operation.
var xl = x.len var xl = x.len
for j in i..xl-2: shallowCopy(x[j], x[j+1]) for j in i..xl-2: shallowCopy(x[j], x[j+1])
setLen(x, xl-1) setLen(x, xl-1)
proc insert*[T](x: var seq[T], item: T, i = 0) {.noSideEffect.} = proc insert*[T](x: var seq[T], item: T, i = 0) {.noSideEffect.} =
## inserts `item` into `x` at position `i`. ## inserts `item` into `x` at position `i`.
var xl = x.len var xl = x.len
setLen(x, xl+1) setLen(x, xl+1)
@ -978,7 +987,7 @@ proc insert*[T](x: var seq[T], item: T, i = 0) {.noSideEffect.} =
dec(j) dec(j)
x[i] = item x[i] = item
proc repr*[T](x: T): string {.magic: "Repr", noSideEffect.} proc repr*[T](x: T): string {.magic: "Repr", noSideEffect.}
## takes any Nimrod variable and returns its string representation. It ## takes any Nimrod variable and returns its string representation. It
## works even for complex data graphs with cycles. This is a great ## works even for complex data graphs with cycles. This is a great
## debugging tool. ## debugging tool.
@ -1078,9 +1087,10 @@ proc addQuitProc*(QuitProc: proc() {.noconv.}) {.importc: "atexit", nodecl.}
# In case of an unhandled exeption the exit handlers should # In case of an unhandled exeption the exit handlers should
# not be called explicitly! The user may decide to do this manually though. # not be called explicitly! The user may decide to do this manually though.
proc copy*(s: string, first = 0): string {. when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc copy*(s: string, first = 0): string {.
magic: "CopyStr", importc: "copyStr", noSideEffect, deprecated.} magic: "CopyStr", importc: "copyStr", noSideEffect, deprecated.}
proc copy*(s: string, first, last: int): string {. proc copy*(s: string, first, last: int): string {.
magic: "CopyStrLast", importc: "copyStrLast", noSideEffect, magic: "CopyStrLast", importc: "copyStrLast", noSideEffect,
deprecated.} deprecated.}
## copies a slice of `s` into a new string and returns this new ## copies a slice of `s` into a new string and returns this new
@ -1089,9 +1099,9 @@ proc copy*(s: string, first, last: int): string {.
## is omitted, it is treated as ``high(s)``. ## is omitted, it is treated as ``high(s)``.
## **Deprecated since version 0.8.12**: Use ``substr`` instead. ## **Deprecated since version 0.8.12**: Use ``substr`` instead.
proc substr*(s: string, first = 0): string {. proc substr*(s: string, first = 0): string {.
magic: "CopyStr", importc: "copyStr", noSideEffect.} magic: "CopyStr", importc: "copyStr", noSideEffect.}
proc substr*(s: string, first, last: int): string {. proc substr*(s: string, first, last: int): string {.
magic: "CopyStrLast", importc: "copyStrLast", noSideEffect.} magic: "CopyStrLast", importc: "copyStrLast", noSideEffect.}
## copies a slice of `s` into a new string and returns this new ## copies a slice of `s` into a new string and returns this new
## string. The bounds `first` and `last` denote the indices of ## string. The bounds `first` and `last` denote the indices of
@ -1126,6 +1136,7 @@ when not defined(nimrodVM):
## otherwise. Like any procedure dealing with raw memory this is ## otherwise. Like any procedure dealing with raw memory this is
## *unsafe*. ## *unsafe*.
when not defined(noDynamicAlloc):
proc alloc*(size: int): pointer {.noconv, rtl, tags: [].} proc alloc*(size: int): pointer {.noconv, rtl, tags: [].}
## allocates a new memory block with at least ``size`` bytes. The ## allocates a new memory block with at least ``size`` bytes. The
## block has to be freed with ``realloc(block, 0)`` or ## block has to be freed with ``realloc(block, 0)`` or
@ -1194,51 +1205,52 @@ template `>%` *(x, y: expr): expr {.immediate.} = y <% x
## treats `x` and `y` as unsigned and compares them. ## treats `x` and `y` as unsigned and compares them.
## Returns true iff ``unsigned(x) > unsigned(y)``. ## Returns true iff ``unsigned(x) > unsigned(y)``.
proc `$` *(x: int): string {.magic: "IntToStr", noSideEffect.} when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc `$` *(x: int): string {.magic: "IntToStr", noSideEffect.}
## The stingify operator for an integer argument. Returns `x` ## The stingify operator for an integer argument. Returns `x`
## converted to a decimal string. ## converted to a decimal string.
proc `$` *(x: int64): string {.magic: "Int64ToStr", noSideEffect.} proc `$` *(x: int64): string {.magic: "Int64ToStr", noSideEffect.}
## The stingify operator for an integer argument. Returns `x` ## The stingify operator for an integer argument. Returns `x`
## converted to a decimal string. ## converted to a decimal string.
when not defined(NimrodVM): when not defined(NimrodVM):
when not defined(JS): when not defined(JS):
proc `$` *(x: uint64): string {.noSideEffect.} proc `$` *(x: uint64): string {.noSideEffect.}
## The stingify operator for an unsigned integer argument. Returns `x` ## The stingify operator for an unsigned integer argument. Returns `x`
## converted to a decimal string. ## converted to a decimal string.
proc `$` *(x: float): string {.magic: "FloatToStr", noSideEffect.} proc `$` *(x: float): string {.magic: "FloatToStr", noSideEffect.}
## The stingify operator for a float argument. Returns `x` ## The stingify operator for a float argument. Returns `x`
## converted to a decimal string. ## converted to a decimal string.
proc `$` *(x: bool): string {.magic: "BoolToStr", noSideEffect.} proc `$` *(x: bool): string {.magic: "BoolToStr", noSideEffect.}
## The stingify operator for a boolean argument. Returns `x` ## The stingify operator for a boolean argument. Returns `x`
## converted to the string "false" or "true". ## converted to the string "false" or "true".
proc `$` *(x: char): string {.magic: "CharToStr", noSideEffect.} proc `$` *(x: char): string {.magic: "CharToStr", noSideEffect.}
## The stingify operator for a character argument. Returns `x` ## The stingify operator for a character argument. Returns `x`
## converted to a string. ## converted to a string.
proc `$` *(x: Cstring): string {.magic: "CStrToStr", noSideEffect.} proc `$` *(x: Cstring): string {.magic: "CStrToStr", noSideEffect.}
## The stingify operator for a CString argument. Returns `x` ## The stingify operator for a CString argument. Returns `x`
## converted to a string. ## converted to a string.
proc `$` *(x: string): string {.magic: "StrToStr", noSideEffect.} proc `$` *(x: string): string {.magic: "StrToStr", noSideEffect.}
## The stingify operator for a string argument. Returns `x` ## The stingify operator for a string argument. Returns `x`
## as it is. This operator is useful for generic code, so ## as it is. This operator is useful for generic code, so
## that ``$expr`` also works if ``expr`` is already a string. ## that ``$expr`` also works if ``expr`` is already a string.
proc `$` *[TEnum: enum](x: TEnum): string {.magic: "EnumToStr", noSideEffect.} proc `$` *[TEnum: enum](x: TEnum): string {.magic: "EnumToStr", noSideEffect.}
## The stingify operator for an enumeration argument. This works for ## The stingify operator for an enumeration argument. This works for
## any enumeration type thanks to compiler magic. If ## any enumeration type thanks to compiler magic. If
## a ``$`` operator for a concrete enumeration is provided, this is ## a ``$`` operator for a concrete enumeration is provided, this is
## used instead. (In other words: *Overwriting* is possible.) ## used instead. (In other words: *Overwriting* is possible.)
# undocumented: # undocumented:
proc getRefcount*[T](x: ref T): int {.importc: "getRefcount", noSideEffect.} proc getRefcount*[T](x: ref T): int {.importc: "getRefcount", noSideEffect.}
proc getRefcount*(x: string): int {.importc: "getRefcount", noSideEffect.} proc getRefcount*(x: string): int {.importc: "getRefcount", noSideEffect.}
proc getRefcount*[T](x: seq[T]): int {.importc: "getRefcount", noSideEffect.} proc getRefcount*[T](x: seq[T]): int {.importc: "getRefcount", noSideEffect.}
## retrieves the reference count of an heap-allocated object. The ## retrieves the reference count of an heap-allocated object. The
## value is implementation-dependent. ## value is implementation-dependent.
@ -1255,8 +1267,7 @@ const
## in the module ``math`` for checking for NaN. ## in the module ``math`` for checking for NaN.
# GC interface: # GC interface:
when not defined(noDynamicAlloc) and not defined(nimrodVM):
when not defined(nimrodVM):
proc getOccupiedMem*(): int {.rtl.} proc getOccupiedMem*(): int {.rtl.}
## returns the number of bytes that are owned by the process and hold data. ## returns the number of bytes that are owned by the process and hold data.
@ -1267,7 +1278,6 @@ when not defined(nimrodVM):
proc getTotalMem*(): int {.rtl.} proc getTotalMem*(): int {.rtl.}
## returns the number of bytes that are owned by the process. ## returns the number of bytes that are owned by the process.
iterator countdown*[T](a, b: T, step = 1): T {.inline.} = iterator countdown*[T](a, b: T, step = 1): T {.inline.} =
## Counts from ordinal value `a` down to `b` with the given ## Counts from ordinal value `a` down to `b` with the given
## step count. `T` may be any ordinal type, `step` may only ## step count. `T` may be any ordinal type, `step` may only
@ -1352,7 +1362,8 @@ iterator items*[IX, T](a: array[IX, T]): T {.inline.} =
if i >= high(IX): break if i >= high(IX): break
inc(i) inc(i)
iterator items*[T](a: seq[T]): T {.inline.} = when not defined(noDynamicAlloc) and not defined(nimrodVM):
iterator items*[T](a: seq[T]): T {.inline.} =
## iterates over each item of `a`. ## iterates over each item of `a`.
var i = 0 var i = 0
while i < len(a): while i < len(a):
@ -1405,7 +1416,8 @@ iterator pairs*[IX, T](a: array[IX, T]): tuple[key: IX, val: T] {.inline.} =
if i >= high(IX): break if i >= high(IX): break
inc(i) inc(i)
iterator pairs*[T](a: seq[T]): tuple[key: int, val: T] {.inline.} = when not defined(noDynamicAlloc) and not defined(nimrodVM):
iterator pairs*[T](a: seq[T]): tuple[key: int, val: T] {.inline.} =
## iterates over each item of `a`. Yields ``(index, a[index])`` pairs. ## iterates over each item of `a`. Yields ``(index, a[index])`` pairs.
var i = 0 var i = 0
while i < len(a): while i < len(a):
@ -1419,8 +1431,8 @@ iterator pairs*(a: string): tuple[key: int, val: char] {.inline.} =
yield (i, a[i]) yield (i, a[i])
inc(i) inc(i)
when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc isNil*[T](x: seq[T]): bool {.noSideEffect, magic: "IsNil".} proc isNil*[T](x: seq[T]): bool {.noSideEffect, magic: "IsNil".}
proc isNil*[T](x: ref T): bool {.noSideEffect, magic: "IsNil".} proc isNil*[T](x: ref T): bool {.noSideEffect, magic: "IsNil".}
proc isNil*(x: string): bool {.noSideEffect, magic: "IsNil".} proc isNil*(x: string): bool {.noSideEffect, magic: "IsNil".}
proc isNil*[T](x: ptr T): bool {.noSideEffect, magic: "IsNil".} proc isNil*[T](x: ptr T): bool {.noSideEffect, magic: "IsNil".}
@ -1430,33 +1442,35 @@ proc isNil*[T: proc](x: T): bool {.noSideEffect, magic: "IsNil".}
## Fast check whether `x` is nil. This is sometimes more efficient than ## Fast check whether `x` is nil. This is sometimes more efficient than
## ``== nil``. ## ``== nil``.
proc `@`*[T](a: openArray[T]): seq[T] = when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc `@`*[T](a: openArray[T]): seq[T] =
## turns an openarray into a sequence. This is not as efficient as turning ## turns an openarray into a sequence. This is not as efficient as turning
## a fixed length array into a sequence as it always copies every element ## a fixed length array into a sequence as it always copies every element
## of `a`. ## of `a`.
newSeq(result, a.len) newSeq(result, a.len)
for i in 0..a.len-1: result[i] = a[i] for i in 0..a.len-1: result[i] = a[i]
proc `&` *[T](x, y: seq[T]): seq[T] {.noSideEffect.} = when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc `&` *[T](x, y: seq[T]): seq[T] {.noSideEffect.} =
newSeq(result, x.len + y.len) newSeq(result, x.len + y.len)
for i in 0..x.len-1: for i in 0..x.len-1:
result[i] = x[i] result[i] = x[i]
for i in 0..y.len-1: for i in 0..y.len-1:
result[i+x.len] = y[i] result[i+x.len] = y[i]
proc `&` *[T](x: seq[T], y: T): seq[T] {.noSideEffect.} = proc `&` *[T](x: seq[T], y: T): seq[T] {.noSideEffect.} =
newSeq(result, x.len + 1) newSeq(result, x.len + 1)
for i in 0..x.len-1: for i in 0..x.len-1:
result[i] = x[i] result[i] = x[i]
result[x.len] = y result[x.len] = y
proc `&` *[T](x: T, y: seq[T]): seq[T] {.noSideEffect.} = proc `&` *[T](x: T, y: seq[T]): seq[T] {.noSideEffect.} =
newSeq(result, y.len + 1) newSeq(result, y.len + 1)
for i in 0..y.len-1: for i in 0..y.len-1:
result[i] = y[i] result[i] = y[i]
result[y.len] = x result[y.len] = x
when not defined(NimrodVM): when not defined(noDynamicAlloc) and not defined(nimrodVM):
when not defined(JS): when not defined(JS):
proc seqToPtr[T](x: seq[T]): pointer {.inline, nosideeffect.} = proc seqToPtr[T](x: seq[T]): pointer {.inline, nosideeffect.} =
result = cast[pointer](x) result = cast[pointer](x)
@ -1489,14 +1503,16 @@ proc contains*[T](a: openArray[T], item: T): bool {.inline.}=
## for ``find(a, item) >= 0``. ## for ``find(a, item) >= 0``.
return find(a, item) >= 0 return find(a, item) >= 0
proc pop*[T](s: var seq[T]): T {.inline, noSideEffect.} = when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc pop*[T](s: var seq[T]): T {.inline, noSideEffect.} =
## returns the last item of `s` and decreases ``s.len`` by one. This treats ## returns the last item of `s` and decreases ``s.len`` by one. This treats
## `s` as a stack and implements the common *pop* operation. ## `s` as a stack and implements the common *pop* operation.
var L = s.len-1 var L = s.len-1
result = s[L] result = s[L]
setLen(s, L) setLen(s, L)
proc each*[T, S](data: openArray[T], op: proc (x: T): S {.closure.}): seq[S] {. when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc each*[T, S](data: openArray[T], op: proc (x: T): S {.closure.}): seq[S] {.
deprecated.} = deprecated.} =
## The well-known ``map`` operation from functional programming. Applies ## The well-known ``map`` operation from functional programming. Applies
## `op` to every item in `data` and returns the result as a sequence. ## `op` to every item in `data` and returns the result as a sequence.
@ -1513,7 +1529,8 @@ proc each*[T](data: var openArray[T], op: proc (x: var T) {.closure.}) {.
## **Deprecated since version 0.9:** Use the ``map`` proc instead. ## **Deprecated since version 0.9:** Use the ``map`` proc instead.
for i in 0..data.len-1: op(data[i]) for i in 0..data.len-1: op(data[i])
proc map*[T, S](data: openArray[T], op: proc (x: T): S {.closure.}): seq[S] = when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc map*[T, S](data: openArray[T], op: proc (x: T): S {.closure.}): seq[S] =
## Returns a new sequence with the results of `op` applied to every item in ## Returns a new sequence with the results of `op` applied to every item in
## `data`. ## `data`.
## ##
@ -1633,8 +1650,7 @@ when false:
result.add("]") result.add("]")
# ----------------- GC interface --------------------------------------------- # ----------------- GC interface ---------------------------------------------
when not defined(noDynamicAlloc) and not defined(nimrodVM):
when not defined(nimrodVM):
proc GC_disable*() {.rtl, inl.} proc GC_disable*() {.rtl, inl.}
## disables the GC. If called n-times, n calls to `GC_enable` are needed to ## disables the GC. If called n-times, n calls to `GC_enable` are needed to
## reactivate the GC. Note that in most circumstances one should only disable ## reactivate the GC. Note that in most circumstances one should only disable
@ -1670,19 +1686,19 @@ when not defined(nimrodVM):
## returns an informative string about the GC's activity. This may be useful ## returns an informative string about the GC's activity. This may be useful
## for tweaking. ## for tweaking.
proc GC_ref*[T](x: ref T) {.magic: "GCref".} proc GC_ref*[T](x: ref T) {.magic: "GCref".}
proc GC_ref*[T](x: seq[T]) {.magic: "GCref".} proc GC_ref*[T](x: seq[T]) {.magic: "GCref".}
proc GC_ref*(x: string) {.magic: "GCref".} proc GC_ref*(x: string) {.magic: "GCref".}
## marks the object `x` as referenced, so that it will not be freed until ## marks the object `x` as referenced, so that it will not be freed until
## it is unmarked via `GC_unref`. If called n-times for the same object `x`, ## it is unmarked via `GC_unref`. If called n-times for the same object `x`,
## n calls to `GC_unref` are needed to unmark `x`. ## n calls to `GC_unref` are needed to unmark `x`.
proc GC_unref*[T](x: ref T) {.magic: "GCunref".} proc GC_unref*[T](x: ref T) {.magic: "GCunref".}
proc GC_unref*[T](x: seq[T]) {.magic: "GCunref".} proc GC_unref*[T](x: seq[T]) {.magic: "GCunref".}
proc GC_unref*(x: string) {.magic: "GCunref".} proc GC_unref*(x: string) {.magic: "GCunref".}
## see the documentation of `GC_ref`. ## see the documentation of `GC_ref`.
template accumulateResult*(iter: expr) = template accumulateResult*(iter: expr) =
## helps to convert an iterator to a proc. ## helps to convert an iterator to a proc.
result = @[] result = @[]
for x in iter: add(result, x) for x in iter: add(result, x)
@ -1696,7 +1712,8 @@ const nimrodStackTrace = compileOption("stacktrace")
# however, stack-traces are available for most parts # however, stack-traces are available for most parts
# of the code # of the code
var when not defined(noDynamicAlloc) and not defined(nimrodVM):
var
globalRaiseHook*: proc (e: ref E_Base): bool {.nimcall.} globalRaiseHook*: proc (e: ref E_Base): bool {.nimcall.}
## with this hook you can influence exception handling on a global level. ## with this hook you can influence exception handling on a global level.
## If not nil, every 'raise' statement ends up calling this hook. Ordinary ## If not nil, every 'raise' statement ends up calling this hook. Ordinary
@ -1743,7 +1760,8 @@ type
filename*: cstring ## filename of the proc that is currently executing filename*: cstring ## filename of the proc that is currently executing
len*: int ## length of the inspectable slots len*: int ## length of the inspectable slots
when not defined(JS): when not defined(noDynamicAlloc) and not defined(nimrodVM):
when not defined(JS):
{.push stack_trace:off, profiler:off.} {.push stack_trace:off, profiler:off.}
proc add*(x: var string, y: cstring) {.noStackFrame.} = proc add*(x: var string, y: cstring) {.noStackFrame.} =
var i = 0 var i = 0
@ -1751,7 +1769,7 @@ when not defined(JS):
add(x, y[i]) add(x, y[i])
inc(i) inc(i)
{.pop.} {.pop.}
else: else:
proc add*(x: var string, y: cstring) {.noStackFrame.} = proc add*(x: var string, y: cstring) {.noStackFrame.} =
asm """ asm """
var len = `x`[0].length-1; var len = `x`[0].length-1;
@ -1779,7 +1797,8 @@ proc debugEcho*[T](x: varargs[T, `$`]) {.magic: "Echo", noSideEffect,
## to be free of side effects, so that it can be used for debugging routines ## to be free of side effects, so that it can be used for debugging routines
## marked as ``noSideEffect``. ## marked as ``noSideEffect``.
template newException*(exceptn: typeDesc, message: string): expr = when not defined(noDynamicAlloc) and not defined(nimrodVM):
template newException*(exceptn: typeDesc, message: string): expr =
## creates an exception object of type ``exceptn`` and sets its ``msg`` field ## creates an exception object of type ``exceptn`` and sets its ``msg`` field
## to `message`. Returns the new exception object. ## to `message`. Returns the new exception object.
var var
@ -1795,7 +1814,9 @@ proc getTypeInfo*[T](x: T): pointer {.magic: "GetTypeInfo".}
when not defined(JS): #and not defined(NimrodVM): when not defined(JS): #and not defined(NimrodVM):
{.push stack_trace: off, profiler:off.} {.push stack_trace: off, profiler:off.}
when not defined(NimrodVM): when not defined(nimrodVM):
# TODO: apply boolean logic
when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc initGC() proc initGC()
when not defined(boehmgc) and not defined(useMalloc): when not defined(boehmgc) and not defined(useMalloc):
proc initAllocator() {.inline.} proc initAllocator() {.inline.}
@ -1840,6 +1861,7 @@ when not defined(JS): #and not defined(NimrodVM):
when defined(endb): when defined(endb):
proc endbStep() proc endbStep()
when hostOS != "standalone":
# ----------------- IO Part ------------------------------------------------ # ----------------- IO Part ------------------------------------------------
type type
CFile {.importc: "FILE", nodecl, final, incompletestruct.} = object CFile {.importc: "FILE", nodecl, final, incompletestruct.} = object
@ -2010,6 +2032,7 @@ when not defined(JS): #and not defined(NimrodVM):
## returns the OS file handle of the file ``f``. This is only useful for ## returns the OS file handle of the file ``f``. This is only useful for
## platform specific programming. ## platform specific programming.
when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc cstringArrayToSeq*(a: cstringArray, len: int): seq[string] = proc cstringArrayToSeq*(a: cstringArray, len: int): seq[string] =
## converts a ``cstringArray`` to a ``seq[string]``. `a` is supposed to be ## converts a ``cstringArray`` to a ``seq[string]``. `a` is supposed to be
## of length ``len``. ## of length ``len``.
@ -2026,6 +2049,7 @@ when not defined(JS): #and not defined(NimrodVM):
# ------------------------------------------------------------------------- # -------------------------------------------------------------------------
when not defined(NimrodVM): when not defined(NimrodVM):
when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc allocCStringArray*(a: openArray[string]): cstringArray = proc allocCStringArray*(a: openArray[string]): cstringArray =
## creates a NULL terminated cstringArray from `a`. The result has to ## creates a NULL terminated cstringArray from `a`. The result has to
## be freed with `deallocCStringArray` after it's not needed anymore. ## be freed with `deallocCStringArray` after it's not needed anymore.
@ -2059,7 +2083,10 @@ when not defined(JS): #and not defined(NimrodVM):
status: int status: int
context: C_JmpBuf context: C_JmpBuf
hasRaiseAction: bool hasRaiseAction: bool
when not defined(noDynamicAlloc) and not defined(nimrodVM):
raiseAction: proc (e: ref E_Base): bool {.closure.} raiseAction: proc (e: ref E_Base): bool {.closure.}
elif defined(noDynamicAlloc):
raiseAction: proc (e: ptr E_Base): bool {.closure.}
when defined(initAllocator): when defined(initAllocator):
initAllocator() initAllocator()
@ -2070,7 +2097,7 @@ when not defined(JS): #and not defined(NimrodVM):
when not defined(useNimRtl) and not defined(createNimRtl): initStackBottom() when not defined(useNimRtl) and not defined(createNimRtl): initStackBottom()
initGC() initGC()
when not defined(NimrodVM): when not defined(NimrodVM) and hostOS != "standalone":
proc setControlCHook*(hook: proc () {.noconv.}) proc setControlCHook*(hook: proc () {.noconv.})
## allows you to override the behaviour of your application when CTRL+C ## allows you to override the behaviour of your application when CTRL+C
## is pressed. Only one such hook is supported. ## is pressed. Only one such hook is supported.
@ -2078,7 +2105,7 @@ when not defined(JS): #and not defined(NimrodVM):
proc writeStackTrace*() {.tags: [FWriteIO].} proc writeStackTrace*() {.tags: [FWriteIO].}
## writes the current stack trace to ``stderr``. This is only works ## writes the current stack trace to ``stderr``. This is only works
## for debug builds. ## for debug builds.
when hostOS != "standalone":
proc getStackTrace*(): string proc getStackTrace*(): string
## gets the current stack trace. This only works for debug builds. ## gets the current stack trace. This only works for debug builds.
@ -2086,6 +2113,7 @@ when not defined(JS): #and not defined(NimrodVM):
## gets the stack trace associated with `e`, which is the stack that ## gets the stack trace associated with `e`, which is the stack that
## lead to the ``raise`` statement. This only works for debug builds. ## lead to the ``raise`` statement. This only works for debug builds.
when not defined(NimrodVM):
{.push stack_trace: off, profiler:off.} {.push stack_trace: off, profiler:off.}
when hostOS == "standalone": when hostOS == "standalone":
include "system/embedded" include "system/embedded"
@ -2126,17 +2154,20 @@ when not defined(JS): #and not defined(NimrodVM):
else: else:
result = n.sons[n.len] result = n.sons[n.len]
when not defined(noDynamicAlloc) and not defined(nimrodVM):
include "system/mmdisp" include "system/mmdisp"
{.push stack_trace: off, profiler:off.} {.push stack_trace: off, profiler:off.}
when hostOS != "standalone": include "system/sysstr" when hostOS != "standalone": include "system/sysstr"
{.pop.} {.pop.}
when not defined(noDynamicAlloc) and not defined(nimrodVM):
include "system/sysio" include "system/sysio"
when hasThreadSupport: when hasThreadSupport:
include "system/channels" include "system/channels"
else: elif not defined(noDynamicAlloc) and not defined(nimrodVM):
include "system/sysio" include "system/sysio"
when not defined(noDynamicAlloc) and not defined(nimrodVM):
iterator lines*(filename: string): TaintedString {.tags: [FReadIO].} = iterator lines*(filename: string): TaintedString {.tags: [FReadIO].} =
## Iterate over any line in the file named `filename`. ## Iterate over any line in the file named `filename`.
## If the file does not exist `EIO` is raised. ## If the file does not exist `EIO` is raised.
@ -2262,14 +2293,15 @@ proc `/`*(x, y: int): float {.inline, noSideEffect.} =
## integer division that results in a float. ## integer division that results in a float.
result = toFloat(x) / toFloat(y) result = toFloat(x) / toFloat(y)
template `-|`*(b, s: expr): expr = when not defined(noDynamicAlloc) and not defined(nimrodVM):
template `-|`*(b, s: expr): expr =
(if b >= 0: b else: s.len + b) (if b >= 0: b else: s.len + b)
proc `[]`*(s: string, x: TSlice[int]): string {.inline.} = proc `[]`*(s: string, x: TSlice[int]): string {.inline.} =
## slice operation for strings. Negative indexes are supported. ## slice operation for strings. Negative indexes are supported.
result = s.substr(x.a-|s, x.b-|s) result = s.substr(x.a-|s, x.b-|s)
template spliceImpl(s, a, L, b: expr): stmt {.immediate.} = template spliceImpl(s, a, L, b: expr): stmt {.immediate.} =
# make room for additional elements or cut: # make room for additional elements or cut:
var slen = s.len var slen = s.len
var shift = b.len - L var shift = b.len - L
@ -2285,7 +2317,7 @@ template spliceImpl(s, a, L, b: expr): stmt {.immediate.} =
# fill the hole: # fill the hole:
for i in 0 .. <b.len: s[i+a] = b[i] for i in 0 .. <b.len: s[i+a] = b[i]
proc `[]=`*(s: var string, x: TSlice[int], b: string) = proc `[]=`*(s: var string, x: TSlice[int], b: string) =
## slice assignment for strings. Negative indexes are supported. If ## slice assignment for strings. Negative indexes are supported. If
## ``b.len`` is not exactly the number of elements that are referred to ## ``b.len`` is not exactly the number of elements that are referred to
## by `x`, a `splice`:idx: is performed: ## by `x`, a `splice`:idx: is performed:
@ -2301,14 +2333,14 @@ proc `[]=`*(s: var string, x: TSlice[int], b: string) =
else: else:
spliceImpl(s, a, L, b) spliceImpl(s, a, L, b)
proc `[]`*[Idx, T](a: array[Idx, T], x: TSlice[int]): seq[T] = proc `[]`*[Idx, T](a: array[Idx, T], x: TSlice[int]): seq[T] =
## slice operation for arrays. Negative indexes are **not** supported ## slice operation for arrays. Negative indexes are **not** supported
## because the array might have negative bounds. ## because the array might have negative bounds.
var L = x.b - x.a + 1 var L = x.b - x.a + 1
newSeq(result, L) newSeq(result, L)
for i in 0.. <L: result[i] = a[i + x.a] for i in 0.. <L: result[i] = a[i + x.a]
proc `[]=`*[Idx, T](a: var array[Idx, T], x: TSlice[int], b: openArray[T]) = proc `[]=`*[Idx, T](a: var array[Idx, T], x: TSlice[int], b: openArray[T]) =
## slice assignment for arrays. Negative indexes are **not** supported ## slice assignment for arrays. Negative indexes are **not** supported
## because the array might have negative bounds. ## because the array might have negative bounds.
var L = x.b - x.a + 1 var L = x.b - x.a + 1
@ -2317,7 +2349,7 @@ proc `[]=`*[Idx, T](a: var array[Idx, T], x: TSlice[int], b: openArray[T]) =
else: else:
raise newException(EOutOfRange, "differing lengths for slice assignment") raise newException(EOutOfRange, "differing lengths for slice assignment")
proc `[]`*[Idx, T](a: array[Idx, T], x: TSlice[Idx]): seq[T] = proc `[]`*[Idx, T](a: array[Idx, T], x: TSlice[Idx]): seq[T] =
## slice operation for arrays. Negative indexes are **not** supported ## slice operation for arrays. Negative indexes are **not** supported
## because the array might have negative bounds. ## because the array might have negative bounds.
var L = ord(x.b) - ord(x.a) + 1 var L = ord(x.b) - ord(x.a) + 1
@ -2327,7 +2359,7 @@ proc `[]`*[Idx, T](a: array[Idx, T], x: TSlice[Idx]): seq[T] =
result[i] = a[j] result[i] = a[j]
inc(j) inc(j)
proc `[]=`*[Idx, T](a: var array[Idx, T], x: TSlice[Idx], b: openArray[T]) = proc `[]=`*[Idx, T](a: var array[Idx, T], x: TSlice[Idx], b: openArray[T]) =
## slice assignment for arrays. Negative indexes are **not** supported ## slice assignment for arrays. Negative indexes are **not** supported
## because the array might have negative bounds. ## because the array might have negative bounds.
var L = ord(x.b) - ord(x.a) + 1 var L = ord(x.b) - ord(x.a) + 1
@ -2339,14 +2371,14 @@ proc `[]=`*[Idx, T](a: var array[Idx, T], x: TSlice[Idx], b: openArray[T]) =
else: else:
raise newException(EOutOfRange, "differing lengths for slice assignment") raise newException(EOutOfRange, "differing lengths for slice assignment")
proc `[]`*[T](s: seq[T], x: TSlice[int]): seq[T] = proc `[]`*[T](s: seq[T], x: TSlice[int]): seq[T] =
## slice operation for sequences. Negative indexes are supported. ## slice operation for sequences. Negative indexes are supported.
var a = x.a-|s var a = x.a-|s
var L = x.b-|s - a + 1 var L = x.b-|s - a + 1
newSeq(result, L) newSeq(result, L)
for i in 0.. <L: result[i] = s[i + a] for i in 0.. <L: result[i] = s[i + a]
proc `[]=`*[T](s: var seq[T], x: TSlice[int], b: openArray[T]) = proc `[]=`*[T](s: var seq[T], x: TSlice[int], b: openArray[T]) =
## slice assignment for sequences. Negative indexes are supported. If ## slice assignment for sequences. Negative indexes are supported. If
## ``b.len`` is not exactly the number of elements that are referred to ## ``b.len`` is not exactly the number of elements that are referred to
## by `x`, a `splice`:idx: is performed. ## by `x`, a `splice`:idx: is performed.
@ -2357,8 +2389,8 @@ proc `[]=`*[T](s: var seq[T], x: TSlice[int], b: openArray[T]) =
else: else:
spliceImpl(s, a, L, b) spliceImpl(s, a, L, b)
proc slurp*(filename: string): string {.magic: "Slurp".} proc slurp*(filename: string): string {.magic: "Slurp".}
proc staticRead*(filename: string): string {.magic: "Slurp".} proc staticRead*(filename: string): string {.magic: "Slurp".}
## compile-time ``readFile`` proc for easy `resource`:idx: embedding: ## compile-time ``readFile`` proc for easy `resource`:idx: embedding:
## ##
## .. code-block:: nimrod ## .. code-block:: nimrod
@ -2366,9 +2398,9 @@ proc staticRead*(filename: string): string {.magic: "Slurp".}
## ##
## ``slurp`` is an alias for ``staticRead``. ## ``slurp`` is an alias for ``staticRead``.
proc gorge*(command: string, input = ""): string {. proc gorge*(command: string, input = ""): string {.
magic: "StaticExec".} = nil magic: "StaticExec".} = nil
proc staticExec*(command: string, input = ""): string {. proc staticExec*(command: string, input = ""): string {.
magic: "StaticExec".} = nil magic: "StaticExec".} = nil
## executes an external process at compile-time. ## executes an external process at compile-time.
## if `input` is not an empty string, it will be passed as a standard input ## if `input` is not an empty string, it will be passed as a standard input
@ -2406,7 +2438,8 @@ proc `/=`*[T: float|float32|float64] (x: var T, y: T) {.inline, noSideEffect.} =
## Divides in place a floating point number ## Divides in place a floating point number
x = x / y x = x / y
proc `&=`* (x: var string, y: string) {.magic: "AppendStrStr", noSideEffect.} when not defined(noDynamicAlloc) and not defined(nimrodVM):
proc `&=`* (x: var string, y: string) {.magic: "AppendStrStr", noSideEffect.}
proc rand*(max: int): int {.magic: "Rand", sideEffect.} proc rand*(max: int): int {.magic: "Rand", sideEffect.}
## compile-time `random` function. Useful for debugging. ## compile-time `random` function. Useful for debugging.

72
lib/system/ansi_c.nim
View file

@ -28,13 +28,15 @@ type
C_JmpBuf {.importc: "jmp_buf".} = array[0..31, int] C_JmpBuf {.importc: "jmp_buf".} = array[0..31, int]
var when not defined(noIO):
var
c_stdin {.importc: "stdin", noDecl.}: C_TextFileStar c_stdin {.importc: "stdin", noDecl.}: C_TextFileStar
c_stdout {.importc: "stdout", noDecl.}: C_TextFileStar c_stdout {.importc: "stdout", noDecl.}: C_TextFileStar
c_stderr {.importc: "stderr", noDecl.}: C_TextFileStar c_stderr {.importc: "stderr", noDecl.}: C_TextFileStar
# constants faked as variables: when hostOS != "standalone":
when not defined(SIGINT): # constants faked as variables:
when not defined(SIGINT):
var var
SIGINT {.importc: "SIGINT", nodecl.}: cint SIGINT {.importc: "SIGINT", nodecl.}: cint
SIGSEGV {.importc: "SIGSEGV", nodecl.}: cint SIGSEGV {.importc: "SIGSEGV", nodecl.}: cint
@ -42,11 +44,11 @@ when not defined(SIGINT):
SIGFPE {.importc: "SIGFPE", nodecl.}: cint SIGFPE {.importc: "SIGFPE", nodecl.}: cint
SIGILL {.importc: "SIGILL", nodecl.}: cint SIGILL {.importc: "SIGILL", nodecl.}: cint
when defined(macosx): when defined(macosx):
var var
SIGBUS {.importc: "SIGBUS", nodecl.}: cint SIGBUS {.importc: "SIGBUS", nodecl.}: cint
# hopefully this does not lead to new bugs # hopefully this does not lead to new bugs
else: else:
var var
SIGBUS {.importc: "SIGSEGV", nodecl.}: cint SIGBUS {.importc: "SIGSEGV", nodecl.}: cint
# only Mac OS X has this shit # only Mac OS X has this shit
@ -54,56 +56,62 @@ else:
proc c_longjmp(jmpb: C_JmpBuf, retval: cint) {.nodecl, importc: "longjmp".} proc c_longjmp(jmpb: C_JmpBuf, retval: cint) {.nodecl, importc: "longjmp".}
proc c_setjmp(jmpb: var C_JmpBuf): cint {.nodecl, importc: "setjmp".} proc c_setjmp(jmpb: var C_JmpBuf): cint {.nodecl, importc: "setjmp".}
proc c_signal(sig: cint, handler: proc (a: cint) {.noconv.}) {. when hostOS != "standalone":
proc c_signal(sig: cint, handler: proc (a: cint) {.noconv.}) {.
importc: "signal", header: "<signal.h>".} importc: "signal", header: "<signal.h>".}
proc c_raise(sig: cint) {.importc: "raise", header: "<signal.h>".} proc c_raise(sig: cint) {.importc: "raise", header: "<signal.h>".}
proc c_fputs(c: cstring, f: C_TextFileStar) {.importc: "fputs", noDecl.} when hostOS != "standalone":
proc c_fgets(c: cstring, n: int, f: C_TextFileStar): cstring {. proc c_fputs(c: cstring, f: C_TextFileStar) {.importc: "fputs", noDecl.}
proc c_fgets(c: cstring, n: int, f: C_TextFileStar): cstring {.
importc: "fgets", noDecl.} importc: "fgets", noDecl.}
proc c_fgetc(stream: C_TextFileStar): int {.importc: "fgetc", nodecl.} proc c_fgetc(stream: C_TextFileStar): int {.importc: "fgetc", nodecl.}
proc c_ungetc(c: int, f: C_TextFileStar) {.importc: "ungetc", nodecl.} proc c_ungetc(c: int, f: C_TextFileStar) {.importc: "ungetc", nodecl.}
proc c_putc(c: Char, stream: C_TextFileStar) {.importc: "putc", nodecl.} proc c_putc(c: Char, stream: C_TextFileStar) {.importc: "putc", nodecl.}
proc c_fprintf(f: C_TextFileStar, frmt: CString) {. proc c_fprintf(f: C_TextFileStar, frmt: CString) {.
importc: "fprintf", nodecl, varargs.} importc: "fprintf", nodecl, varargs.}
proc c_printf(frmt: CString) {. proc c_printf(frmt: CString) {.
importc: "printf", nodecl, varargs.} importc: "printf", nodecl, varargs.}
proc c_fopen(filename, mode: cstring): C_TextFileStar {. when hostOS != "standalone":
proc c_fopen(filename, mode: cstring): C_TextFileStar {.
importc: "fopen", nodecl.} importc: "fopen", nodecl.}
proc c_fclose(f: C_TextFileStar) {.importc: "fclose", nodecl.} proc c_fclose(f: C_TextFileStar) {.importc: "fclose", nodecl.}
proc c_sprintf(buf, frmt: CString) {.nodecl, importc: "sprintf", varargs, proc c_sprintf(buf, frmt: CString) {.nodecl, importc: "sprintf", varargs,
noSideEffect.} noSideEffect.}
# we use it only in a way that cannot lead to security issues # we use it only in a way that cannot lead to security issues
proc c_fread(buf: Pointer, size, n: int, f: C_BinaryFileStar): int {. when hostOS != "standalone":
proc c_fread(buf: Pointer, size, n: int, f: C_BinaryFileStar): int {.
importc: "fread", noDecl.} importc: "fread", noDecl.}
proc c_fseek(f: C_BinaryFileStar, offset: clong, whence: int): int {. proc c_fseek(f: C_BinaryFileStar, offset: clong, whence: int): int {.
importc: "fseek", noDecl.} importc: "fseek", noDecl.}
proc c_fwrite(buf: Pointer, size, n: int, f: C_BinaryFileStar): int {. proc c_fwrite(buf: Pointer, size, n: int, f: C_BinaryFileStar): int {.
importc: "fwrite", noDecl.} importc: "fwrite", noDecl.}
proc c_exit(errorcode: cint) {.importc: "exit", nodecl.} proc c_exit(errorcode: cint) {.importc: "exit", nodecl.}
proc c_ferror(stream: C_TextFileStar): bool {.importc: "ferror", nodecl.} proc c_ferror(stream: C_TextFileStar): bool {.importc: "ferror", nodecl.}
proc c_fflush(stream: C_TextFileStar) {.importc: "fflush", nodecl.} proc c_fflush(stream: C_TextFileStar) {.importc: "fflush", nodecl.}
proc c_abort() {.importc: "abort", nodecl.} proc c_abort() {.importc: "abort", nodecl.}
proc c_feof(stream: C_TextFileStar): bool {.importc: "feof", nodecl.} proc c_feof(stream: C_TextFileStar): bool {.importc: "feof", nodecl.}
proc c_malloc(size: int): pointer {.importc: "malloc", nodecl.} when not defined(noDynamicAlloc):
proc c_free(p: pointer) {.importc: "free", nodecl.} proc c_malloc(size: int): pointer {.importc: "malloc", nodecl.}
proc c_realloc(p: pointer, newsize: int): pointer {.importc: "realloc", nodecl.} proc c_free(p: pointer) {.importc: "free", nodecl.}
proc c_realloc(p: pointer, newsize: int): pointer {.importc: "realloc", nodecl.}
when not defined(errno): when hostOS != "standalone":
when not defined(errno):
var errno {.importc, header: "<errno.h>".}: cint ## error variable var errno {.importc, header: "<errno.h>".}: cint ## error variable
proc strerror(errnum: cint): cstring {.importc, header: "<string.h>".} proc strerror(errnum: cint): cstring {.importc, header: "<string.h>".}
proc c_remove(filename: CString): cint {.importc: "remove", noDecl.} proc c_remove(filename: CString): cint {.importc: "remove", noDecl.}
proc c_rename(oldname, newname: CString): cint {.importc: "rename", noDecl.} proc c_rename(oldname, newname: CString): cint {.importc: "rename", noDecl.}
proc c_system(cmd: CString): cint {.importc: "system", header: "<stdlib.h>".} proc c_system(cmd: CString): cint {.importc: "system", header: "<stdlib.h>".}
proc c_getenv(env: CString): CString {.importc: "getenv", noDecl.} proc c_getenv(env: CString): CString {.importc: "getenv", noDecl.}
proc c_putenv(env: CString): cint {.importc: "putenv", noDecl.} proc c_putenv(env: CString): cint {.importc: "putenv", noDecl.}
{.pop} {.pop}

10
lib/system/embedded.nim
View file

@ -7,10 +7,13 @@
# distribution, for details about the copyright. # distribution, for details about the copyright.
# #
when defined(arduino):
include "system/arduino"
# Bare-bones implementation of some things for embedded targets. # Bare-bones implementation of some things for embedded targets.
proc writeToStdErr(msg: CString) = write(stdout, msg) when not defined(arduino):
proc writeToStdErr(msg: CString) = write(stdout, msg)
proc chckIndx(i, a, b: int): int {.inline, compilerproc.} proc chckIndx(i, a, b: int): int {.inline, compilerproc.}
proc chckRange(i, a, b: int): int {.inline, compilerproc.} proc chckRange(i, a, b: int): int {.inline, compilerproc.}
@ -42,11 +45,6 @@ proc reraiseException() {.compilerRtl.} =
proc WriteStackTrace() = nil proc WriteStackTrace() = nil
proc setControlCHook(hook: proc () {.noconv.}) =
# ugly cast, but should work on all architectures:
type TSignalHandler = proc (sig: cint) {.noconv.}
c_signal(SIGINT, cast[TSignalHandler](hook))
proc raiseRangeError(val: biggestInt) {.compilerproc, noreturn, noinline.} = proc raiseRangeError(val: biggestInt) {.compilerproc, noreturn, noinline.} =
writeToStdErr("value out of range") writeToStdErr("value out of range")