diff options
Diffstat (limited to 'lib')
| -rw-r--r-- | lib/pure/collections/sequtils.nim | 2 | ||||
| -rwxr-xr-x | lib/pure/colors.nim | 6 | ||||
| -rwxr-xr-x | lib/pure/os.nim | 4 | ||||
| -rwxr-xr-x | lib/system.nim | 26 | ||||
| -rwxr-xr-x | lib/system/excpt.nim | 2 | ||||
| -rwxr-xr-x | lib/system/gc.nim | 2 | ||||
| -rwxr-xr-x | lib/wrappers/sdl/sdl.nim | 4 |
7 files changed, 23 insertions, 23 deletions
diff --git a/lib/pure/collections/sequtils.nim b/lib/pure/collections/sequtils.nim index b7a57ac0c..e3034d635 100644 --- a/lib/pure/collections/sequtils.nim +++ b/lib/pure/collections/sequtils.nim @@ -50,7 +50,7 @@ proc filter*[T](seq1: seq[T], pred: proc(item: T): bool): seq[T] = ## Returns all items in a sequence that fulfilled the predicate. accumulateResult(filter(seq1, pred)) -template filterIt*(seq1, pred: expr): expr = +template filterIt*(seq1, pred: expr): expr {.immediate.} = ## Finds a specific item in a sequence as long as the ## predicate returns true. The predicate needs to be an expression ## containing ``it``: ``filterIt("abcxyz", it == 'x')``. diff --git a/lib/pure/colors.nim b/lib/pure/colors.nim index 6a86a43c4..00edaad9c 100755 --- a/lib/pure/colors.nim +++ b/lib/pure/colors.nim @@ -17,15 +17,15 @@ type proc `==` *(a, b: TColor): bool {.borrow.} ## compares two colors. -template extract(a: TColor, r, g, b: expr) = +template extract(a: TColor, r, g, b: expr) {.immediate.}= var r = a.int shr 16 and 0xff var g = a.int shr 8 and 0xff var b = a.int and 0xff -template rawRGB(r, g, b: expr): expr = +template rawRGB(r, g, b: int): expr = TColor(r shl 16 or g shl 8 or b) -template colorOp(op: expr) = +template colorOp(op: expr) {.immediate.} = extract(a, ar, ag, ab) extract(b, br, bg, bb) result = rawRGB(op(ar, br), op(ag, bg), op(ab, bb)) diff --git a/lib/pure/os.nim b/lib/pure/os.nim index 76f934c04..5ea93eb06 100755 --- a/lib/pure/os.nim +++ b/lib/pure/os.nim @@ -242,12 +242,12 @@ proc UnixToNativePath*(path: string): string {. inc(i) when defined(windows): - template wrapUnary(varname, winApiProc, arg: expr) = + template wrapUnary(varname, winApiProc, arg: expr) {.immediate.} = var tmp = allocWideCString(arg) var varname = winApiProc(tmp) dealloc tmp - template wrapBinary(varname, winApiProc, arg, arg2: expr) = + template wrapBinary(varname, winApiProc, arg, arg2: expr) {.immediate.} = var tmp2 = allocWideCString(arg) var varname = winApiProc(tmp2, arg2) dealloc tmp2 diff --git a/lib/system.nim b/lib/system.nim index 3248276ee..6583e4f15 100755 --- a/lib/system.nim +++ b/lib/system.nim @@ -624,15 +624,15 @@ proc `<` *[T](x, y: ref T): bool {.magic: "LtPtr", noSideEffect.} proc `<` *[T](x, y: ptr T): bool {.magic: "LtPtr", noSideEffect.} proc `<` *(x, y: pointer): bool {.magic: "LtPtr", noSideEffect.} -template `!=` * (x, y: expr): expr = +template `!=` * (x, y: expr): expr {.immediate.} = ## unequals operator. This is a shorthand for ``not (x == y)``. not (x == y) -template `>=` * (x, y: expr): expr = +template `>=` * (x, y: expr): expr {.immediate.} = ## "is greater or equals" operator. This is the same as ``y <= x``. y <= x -template `>` * (x, y: expr): expr = +template `>` * (x, y: expr): expr {.immediate.} = ## "is greater" operator. This is the same as ``y < x``. y < x @@ -655,11 +655,11 @@ proc contains*[T](x: set[T], y: T): bool {.magic: "InSet", noSideEffect.} ## is achieved by reversing the parameters for ``contains``; ``in`` then ## passes its arguments in reverse order. -template `in` * (x, y: expr): expr = contains(y, x) -template `not_in` * (x, y: expr): expr = not contains(y, x) +template `in` * (x, y: expr): expr {.immediate.} = contains(y, x) +template `not_in` * (x, y: expr): expr {.immediate.} = not contains(y, x) proc `is` *[T, S](x: T, y: S): bool {.magic: "Is", noSideEffect.} -template `is_not` *(x, y: expr): expr = not (x is y) +template `is_not` *(x, y: expr): expr {.immediate.} = not (x is y) proc `of` *[T, S](x: T, y: S): bool {.magic: "Of", noSideEffect.} @@ -842,7 +842,7 @@ proc quit*(errorcode: int = QuitSuccess) {. ## It does *not* call the garbage collector to free all the memory, ## unless a quit procedure calls ``GC_collect``. -template sysAssert(cond, msg: expr) = +template sysAssert(cond: bool, msg: string) = when defined(useSysAssert): if not cond: echo "[SYSASSERT] ", msg @@ -1090,11 +1090,11 @@ proc swap*[T](a, b: var T) {.magic: "Swap", noSideEffect.} ## swaps the values `a` and `b`. This is often more efficient than ## ``tmp = a; a = b; b = tmp``. Particularly useful for sorting algorithms. -template `>=%` *(x, y: expr): expr = y <=% x +template `>=%` *(x, y: expr): expr {.immediate.} = y <=% x ## treats `x` and `y` as unsigned and compares them. ## Returns true iff ``unsigned(x) >= unsigned(y)``. -template `>%` *(x, y: expr): expr = y <% x +template `>%` *(x, y: expr): expr {.immediate.} = y <% x ## treats `x` and `y` as unsigned and compares them. ## Returns true iff ``unsigned(x) > unsigned(y)``. @@ -1590,7 +1590,7 @@ proc echo*[Ty](x: openarray[Ty]) {.magic: "Echo", noSideEffect.} ## Unlike other IO operations this is guaranteed to be thread-safe as ## ``echo`` is very often used for debugging convenience. -template newException*(exceptn, message: expr): expr = +template newException*(exceptn: typeDesc, message: string): expr = ## creates an exception object of type ``exceptn`` and sets its ``msg`` field ## to `message`. Returns the new exception object. block: # open a new scope @@ -2033,7 +2033,7 @@ proc `[]`*(s: string, x: TSlice[int]): string {.inline.} = ## slice operation for strings. Negative indexes are supported. result = s.substr(x.a-|s, x.b-|s) -template spliceImpl(s, a, L, b: expr): stmt = +template spliceImpl(s, a, L, b: expr): stmt {.immediate.} = # make room for additional elements or cut: var slen = s.len var shift = b.len - L @@ -2176,7 +2176,7 @@ proc InstantiationInfo*(index = -1): tuple[filename: string, line: int] {. proc raiseAssert(msg: string) {.noinline.} = raise newException(EAssertionFailed, msg) -template assert*(cond: expr, msg = "") = +template assert*(cond: bool, msg = "") = ## provides a means to implement `programming by contracts`:idx: in Nimrod. ## ``assert`` evaluates expression ``cond`` and if ``cond`` is false, it ## raises an ``EAssertionFailure`` exception. However, the compiler may @@ -2188,7 +2188,7 @@ template assert*(cond: expr, msg = "") = if not cond: raiseAssert(astToStr(cond) & ' ' & msg) -template doAssert*(cond: expr, msg = "") = +template doAssert*(cond: bool, msg = "") = ## same as `assert` but is always turned on and not affected by the ## ``--assertions`` command line switch. bind raiseAssert, InstantiationInfo diff --git a/lib/system/excpt.nim b/lib/system/excpt.nim index 8260ba725..8ffca90fb 100755 --- a/lib/system/excpt.nim +++ b/lib/system/excpt.nim @@ -251,7 +251,7 @@ when defined(endb): dbgAborting: bool # whether the debugger wants to abort proc signalHandler(sig: cint) {.exportc: "signalHandler", noconv.} = - template processSignal(s, action: expr) = + template processSignal(s, action: expr) {.immediate.} = if s == SIGINT: action("SIGINT: Interrupted by Ctrl-C.\n") elif s == SIGSEGV: action("SIGSEGV: Illegal storage access. (Attempt to read from nil?)\n") diff --git a/lib/system/gc.nim b/lib/system/gc.nim index 31f0fd022..f01e9c04a 100755 --- a/lib/system/gc.nim +++ b/lib/system/gc.nim @@ -170,7 +170,7 @@ when traceGC: cfprintf(cstdout, "Allocations: %ld; ZCT freed: %ld; CYC freed: %ld\n", e, z, y) -template gcTrace(cell, state: expr): stmt = +template gcTrace(cell, state: expr): stmt {.immediate.} = when traceGC: traceCell(cell, state) # ----------------------------------------------------------------------------- diff --git a/lib/wrappers/sdl/sdl.nim b/lib/wrappers/sdl/sdl.nim index 8ddab49dd..cf4eb452d 100755 --- a/lib/wrappers/sdl/sdl.nim +++ b/lib/wrappers/sdl/sdl.nim @@ -1284,9 +1284,9 @@ type # This is the system-independent thread info struc TProcedure* = proc () type TEventSeq = set[TEventKind] -template evconv(procName: expr, ptrName: typeDesc, assertions: TEventSeq): stmt = +template evconv(procName: expr, ptrName: typeDesc, assertions: TEventSeq): stmt {.immediate.} = proc `procName`*(event: PEvent): ptrName = - assert(assertions.contains(event.kind)) + assert(contains(assertions, event.kind)) result = cast[ptrName](event) evconv(EvActive, PActiveEvent, {ACTIVEEVENT}) |