remove deprecated procs (#12535)
This commit is contained in:
Andreas Rumpf
Miran
parent
ffa9a7405f
commit
3ba3307d61
39 changed files with 111 additions and 567 deletions
|
|
@ -357,11 +357,13 @@ iterator items*(pattern: Captures,
|
|||
|
||||
proc toSeq*(pattern: CaptureBounds,
|
||||
default = none(HSlice[int, int])): seq[Option[HSlice[int, int]]] =
|
||||
accumulateResult(pattern.items(default))
|
||||
result = @[]
|
||||
for it in pattern.items(default): result.add it
|
||||
|
||||
proc toSeq*(pattern: Captures,
|
||||
default: Option[string] = none(string)): seq[Option[string]] =
|
||||
accumulateResult(pattern.items(default))
|
||||
result = @[]
|
||||
for it in pattern.items(default): result.add it
|
||||
|
||||
proc `$`*(pattern: RegexMatch): string =
|
||||
return pattern.captures[-1]
|
||||
|
|
|
|||
|
|
@ -234,10 +234,6 @@ proc getBiggestInt*(n: JsonNode, default: BiggestInt = 0): BiggestInt =
|
|||
if n.isNil or n.kind != JInt: return default
|
||||
else: return n.num
|
||||
|
||||
proc getNum*(n: JsonNode, default: BiggestInt = 0): BiggestInt {.deprecated:
|
||||
"Deprecated since v0.18.2; use 'getInt' or 'getBiggestInt' instead".} =
|
||||
getBiggestInt(n, default)
|
||||
|
||||
proc getFloat*(n: JsonNode, default: float = 0.0): float =
|
||||
## Retrieves the float value of a `JFloat JsonNode`.
|
||||
##
|
||||
|
|
@ -248,10 +244,6 @@ proc getFloat*(n: JsonNode, default: float = 0.0): float =
|
|||
of JInt: return float(n.num)
|
||||
else: return default
|
||||
|
||||
proc getFNum*(n: JsonNode, default: float = 0.0): float {.deprecated:
|
||||
"Deprecated since v0.18.2; use 'getFloat' instead".} =
|
||||
getFloat(n, default)
|
||||
|
||||
proc getBool*(n: JsonNode, default: bool = false): bool =
|
||||
## Retrieves the bool value of a `JBool JsonNode`.
|
||||
##
|
||||
|
|
@ -259,10 +251,6 @@ proc getBool*(n: JsonNode, default: bool = false): bool =
|
|||
if n.isNil or n.kind != JBool: return default
|
||||
else: return n.bval
|
||||
|
||||
proc getBVal*(n: JsonNode, default: bool = false): bool {.deprecated:
|
||||
"Deprecated since v0.18.2; use 'getBool' instead".} =
|
||||
getBool(n, default)
|
||||
|
||||
proc getFields*(n: JsonNode,
|
||||
default = initOrderedTable[string, JsonNode](4)):
|
||||
OrderedTable[string, JsonNode] =
|
||||
|
|
@ -502,10 +490,6 @@ proc contains*(node: JsonNode, val: JsonNode): bool =
|
|||
assert(node.kind == JArray)
|
||||
find(node.elems, val) >= 0
|
||||
|
||||
proc existsKey*(node: JsonNode, key: string): bool {.
|
||||
deprecated: "use 'hasKey' instead".} =
|
||||
node.hasKey(key)
|
||||
|
||||
proc `{}`*(node: JsonNode, keys: varargs[string]): JsonNode =
|
||||
## Traverses the node and gets the given value. If any of the
|
||||
## keys do not exist, returns ``nil``. Also returns ``nil`` if one of the
|
||||
|
|
|
|||
|
|
@ -41,11 +41,6 @@
|
|||
## * `dynlib module <dynlib.html>`_
|
||||
## * `streams module <streams.html>`_
|
||||
|
||||
|
||||
{.deadCodeElim: on.} # dce option deprecated
|
||||
|
||||
{.push debugger: off.}
|
||||
|
||||
include "system/inclrtl"
|
||||
|
||||
import
|
||||
|
|
@ -3131,8 +3126,6 @@ proc getCurrentProcessId*(): int {.noNimScript.} =
|
|||
else:
|
||||
result = getpid()
|
||||
|
||||
{.pop.}
|
||||
|
||||
proc setLastModificationTime*(file: string, t: times.Time) {.noNimScript.} =
|
||||
## Sets the `file`'s last modification time. `OSError` is raised in case of
|
||||
## an error.
|
||||
|
|
|
|||
|
|
@ -1154,7 +1154,8 @@ proc findAll*(s: string, pattern: Peg, start = 0): seq[string] {.
|
|||
noSideEffect, rtl, extern: "npegs$1".} =
|
||||
## returns all matching *substrings* of `s` that match `pattern`.
|
||||
## If it does not match, @[] is returned.
|
||||
accumulateResult(findAll(s, pattern, start))
|
||||
result = @[]
|
||||
for it in findAll(s, pattern, start): result.add it
|
||||
|
||||
when not defined(nimhygiene):
|
||||
{.pragma: inject.}
|
||||
|
|
@ -1372,7 +1373,8 @@ iterator split*(s: string, sep: Peg): string =
|
|||
proc split*(s: string, sep: Peg): seq[string] {.
|
||||
noSideEffect, rtl, extern: "npegs$1".} =
|
||||
## Splits the string `s` into substrings.
|
||||
accumulateResult(split(s, sep))
|
||||
result = @[]
|
||||
for it in split(s, sep): result.add it
|
||||
|
||||
# ------------------- scanner -------------------------------------------------
|
||||
|
||||
|
|
|
|||
|
|
@ -80,21 +80,8 @@ when defined(nimVmExportFixed):
|
|||
from unicode import toLower, toUpper
|
||||
export toLower, toUpper
|
||||
|
||||
{.deadCodeElim: on.} # dce option deprecated
|
||||
|
||||
{.push debugger: off.} # the user does not want to trace a part
|
||||
# of the standard library!
|
||||
|
||||
include "system/inclrtl"
|
||||
|
||||
{.pop.}
|
||||
|
||||
# Support old split with set[char]
|
||||
when defined(nimOldSplit):
|
||||
{.pragma: deprecatedSplit, deprecated.}
|
||||
else:
|
||||
{.pragma: deprecatedSplit.}
|
||||
|
||||
const
|
||||
Whitespace* = {' ', '\t', '\v', '\r', '\l', '\f'}
|
||||
## All the characters that count as whitespace (space, tab, vertical tab,
|
||||
|
|
@ -2863,110 +2850,6 @@ iterator tokenize*(s: string, seps: set[char] = Whitespace): tuple[
|
|||
break
|
||||
i = j
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Deprecated procs
|
||||
|
||||
{.push warning[Deprecated]: off.}
|
||||
proc editDistance*(a, b: string): int {.noSideEffect,
|
||||
rtl, extern: "nsuEditDistance",
|
||||
deprecated: "use editdistance.editDistanceAscii instead".} =
|
||||
## Returns the edit distance between `a` and `b`.
|
||||
##
|
||||
## This uses the `Levenshtein`:idx: distance algorithm with only a linear
|
||||
## memory overhead.
|
||||
var len1 = a.len
|
||||
var len2 = b.len
|
||||
if len1 > len2:
|
||||
# make `b` the longer string
|
||||
return editDistance(b, a)
|
||||
|
||||
# strip common prefix:
|
||||
var s = 0
|
||||
while s < len1 and a[s] == b[s]:
|
||||
inc(s)
|
||||
dec(len1)
|
||||
dec(len2)
|
||||
# strip common suffix:
|
||||
while len1 > 0 and len2 > 0 and a[s+len1-1] == b[s+len2-1]:
|
||||
dec(len1)
|
||||
dec(len2)
|
||||
# trivial cases:
|
||||
if len1 == 0: return len2
|
||||
if len2 == 0: return len1
|
||||
|
||||
# another special case:
|
||||
if len1 == 1:
|
||||
for j in s..s+len2-1:
|
||||
if a[s] == b[j]: return len2 - 1
|
||||
return len2
|
||||
|
||||
inc(len1)
|
||||
inc(len2)
|
||||
var half = len1 shr 1
|
||||
# initialize first row:
|
||||
#var row = cast[ptr array[0..high(int) div 8, int]](alloc(len2*sizeof(int)))
|
||||
var row: seq[int]
|
||||
newSeq(row, len2)
|
||||
var e = s + len2 - 1 # end marker
|
||||
for i in 1..len2 - half - 1: row[i] = i
|
||||
row[0] = len1 - half - 1
|
||||
for i in 1 .. len1 - 1:
|
||||
var char1 = a[i + s - 1]
|
||||
var char2p: int
|
||||
var diff, x: int
|
||||
var p: int
|
||||
if i >= len1 - half:
|
||||
# skip the upper triangle:
|
||||
var offset = i - len1 + half
|
||||
char2p = offset
|
||||
p = offset
|
||||
var c3 = row[p] + ord(char1 != b[s + char2p])
|
||||
inc(p)
|
||||
inc(char2p)
|
||||
x = row[p] + 1
|
||||
diff = x
|
||||
if x > c3: x = c3
|
||||
row[p] = x
|
||||
inc(p)
|
||||
else:
|
||||
p = 1
|
||||
char2p = 0
|
||||
diff = i
|
||||
x = i
|
||||
if i <= half + 1:
|
||||
# skip the lower triangle:
|
||||
e = len2 + i - half - 2
|
||||
# main:
|
||||
while p <= e:
|
||||
dec(diff)
|
||||
var c3 = diff + ord(char1 != b[char2p + s])
|
||||
inc(char2p)
|
||||
inc(x)
|
||||
if x > c3: x = c3
|
||||
diff = row[p] + 1
|
||||
if x > diff: x = diff
|
||||
row[p] = x
|
||||
inc(p)
|
||||
# lower triangle sentinel:
|
||||
if i <= half:
|
||||
dec(diff)
|
||||
var c3 = diff + ord(char1 != b[char2p + s])
|
||||
inc(x)
|
||||
if x > c3: x = c3
|
||||
row[p] = x
|
||||
result = row[e]
|
||||
{.pop.}
|
||||
|
||||
proc isNilOrEmpty*(s: string): bool {.noSideEffect, procvar, rtl,
|
||||
extern: "nsuIsNilOrEmpty",
|
||||
deprecated: "use 'x.len == 0' instead".} =
|
||||
## Checks if `s` is nil or empty.
|
||||
result = len(s) == 0
|
||||
|
||||
proc isNilOrWhitespace*(s: string): bool {.noSideEffect, procvar, rtl,
|
||||
extern: "nsuIsNilOrWhitespace".} =
|
||||
## Checks if `s` is nil or consists entirely of whitespace characters.
|
||||
|
|
@ -2975,167 +2858,6 @@ proc isNilOrWhitespace*(s: string): bool {.noSideEffect, procvar, rtl,
|
|||
if not c.isSpaceAscii():
|
||||
return false
|
||||
|
||||
template isImpl(call) =
|
||||
if s.len == 0: return false
|
||||
result = true
|
||||
for c in s:
|
||||
if not call(c): return false
|
||||
|
||||
proc isAlphaAscii*(s: string): bool {.noSideEffect, procvar,
|
||||
rtl, extern: "nsuIsAlphaAsciiStr",
|
||||
deprecated: "Deprecated since version 0.20 since its semantics are unclear".} =
|
||||
## Checks whether or not `s` is alphabetical.
|
||||
##
|
||||
## This checks a-z, A-Z ASCII characters only.
|
||||
## Returns true if all characters in `s` are
|
||||
## alphabetic and there is at least one character
|
||||
## in `s`.
|
||||
## Use `Unicode module<unicode.html>`_ for UTF-8 support.
|
||||
runnableExamples:
|
||||
doAssert isAlphaAscii("fooBar") == true
|
||||
doAssert isAlphaAscii("fooBar1") == false
|
||||
doAssert isAlphaAscii("foo Bar") == false
|
||||
isImpl isAlphaAscii
|
||||
|
||||
proc isAlphaNumeric*(s: string): bool {.noSideEffect, procvar,
|
||||
rtl, extern: "nsuIsAlphaNumericStr",
|
||||
deprecated: "Deprecated since version 0.20 since its semantics are unclear".} =
|
||||
## Checks whether or not `s` is alphanumeric.
|
||||
##
|
||||
## This checks a-z, A-Z, 0-9 ASCII characters only.
|
||||
## Returns true if all characters in `s` are
|
||||
## alpanumeric and there is at least one character
|
||||
## in `s`.
|
||||
## Use `Unicode module<unicode.html>`_ for UTF-8 support.
|
||||
runnableExamples:
|
||||
doAssert isAlphaNumeric("fooBar") == true
|
||||
doAssert isAlphaNumeric("fooBar1") == true
|
||||
doAssert isAlphaNumeric("foo Bar") == false
|
||||
isImpl isAlphaNumeric
|
||||
|
||||
proc isDigit*(s: string): bool {.noSideEffect, procvar,
|
||||
rtl, extern: "nsuIsDigitStr",
|
||||
deprecated: "Deprecated since version 0.20 since its semantics are unclear".} =
|
||||
## Checks whether or not `s` is a numeric value.
|
||||
##
|
||||
## This checks 0-9 ASCII characters only.
|
||||
## Returns true if all characters in `s` are
|
||||
## numeric and there is at least one character
|
||||
## in `s`.
|
||||
runnableExamples:
|
||||
doAssert isDigit("1908") == true
|
||||
doAssert isDigit("fooBar1") == false
|
||||
isImpl isDigit
|
||||
|
||||
proc isSpaceAscii*(s: string): bool {.noSideEffect, procvar,
|
||||
rtl, extern: "nsuIsSpaceAsciiStr",
|
||||
deprecated: "Deprecated since version 0.20 since its semantics are unclear".} =
|
||||
## Checks whether or not `s` is completely whitespace.
|
||||
##
|
||||
## Returns true if all characters in `s` are whitespace
|
||||
## characters and there is at least one character in `s`.
|
||||
runnableExamples:
|
||||
doAssert isSpaceAscii(" ") == true
|
||||
doAssert isSpaceAscii("") == false
|
||||
isImpl isSpaceAscii
|
||||
|
||||
template isCaseImpl(s, charProc, skipNonAlpha) =
|
||||
var hasAtleastOneAlphaChar = false
|
||||
if s.len == 0: return false
|
||||
for c in s:
|
||||
if skipNonAlpha:
|
||||
var charIsAlpha = c.isAlphaAscii()
|
||||
if not hasAtleastOneAlphaChar:
|
||||
hasAtleastOneAlphaChar = charIsAlpha
|
||||
if charIsAlpha and (not charProc(c)):
|
||||
return false
|
||||
else:
|
||||
if not charProc(c):
|
||||
return false
|
||||
return if skipNonAlpha: hasAtleastOneAlphaChar else: true
|
||||
|
||||
proc isLowerAscii*(s: string, skipNonAlpha: bool): bool {.
|
||||
deprecated: "Deprecated since version 0.20 since its semantics are unclear".} =
|
||||
## Checks whether ``s`` is lower case.
|
||||
##
|
||||
## This checks ASCII characters only.
|
||||
##
|
||||
## If ``skipNonAlpha`` is true, returns true if all alphabetical
|
||||
## characters in ``s`` are lower case. Returns false if none of the
|
||||
## characters in ``s`` are alphabetical.
|
||||
##
|
||||
## If ``skipNonAlpha`` is false, returns true only if all characters
|
||||
## in ``s`` are alphabetical and lower case.
|
||||
##
|
||||
## For either value of ``skipNonAlpha``, returns false if ``s`` is
|
||||
## an empty string.
|
||||
## Use `Unicode module<unicode.html>`_ for UTF-8 support.
|
||||
runnableExamples:
|
||||
doAssert isLowerAscii("1foobar", false) == false
|
||||
doAssert isLowerAscii("1foobar", true) == true
|
||||
doAssert isLowerAscii("1fooBar", true) == false
|
||||
isCaseImpl(s, isLowerAscii, skipNonAlpha)
|
||||
|
||||
proc isUpperAscii*(s: string, skipNonAlpha: bool): bool {.
|
||||
deprecated: "Deprecated since version 0.20 since its semantics are unclear".} =
|
||||
## Checks whether ``s`` is upper case.
|
||||
##
|
||||
## This checks ASCII characters only.
|
||||
##
|
||||
## If ``skipNonAlpha`` is true, returns true if all alphabetical
|
||||
## characters in ``s`` are upper case. Returns false if none of the
|
||||
## characters in ``s`` are alphabetical.
|
||||
##
|
||||
## If ``skipNonAlpha`` is false, returns true only if all characters
|
||||
## in ``s`` are alphabetical and upper case.
|
||||
##
|
||||
## For either value of ``skipNonAlpha``, returns false if ``s`` is
|
||||
## an empty string.
|
||||
## Use `Unicode module<unicode.html>`_ for UTF-8 support.
|
||||
runnableExamples:
|
||||
doAssert isUpperAscii("1FOO", false) == false
|
||||
doAssert isUpperAscii("1FOO", true) == true
|
||||
doAssert isUpperAscii("1Foo", true) == false
|
||||
isCaseImpl(s, isUpperAscii, skipNonAlpha)
|
||||
|
||||
proc wordWrap*(s: string, maxLineWidth = 80,
|
||||
splitLongWords = true,
|
||||
seps: set[char] = Whitespace,
|
||||
newLine = "\n"): string {.
|
||||
noSideEffect, rtl, extern: "nsuWordWrap",
|
||||
deprecated: "use wrapWords in std/wordwrap instead".} =
|
||||
## Word wraps `s`.
|
||||
result = newStringOfCap(s.len + s.len shr 6)
|
||||
var spaceLeft = maxLineWidth
|
||||
var lastSep = ""
|
||||
for word, isSep in tokenize(s, seps):
|
||||
if isSep:
|
||||
lastSep = word
|
||||
spaceLeft = spaceLeft - len(word)
|
||||
continue
|
||||
if len(word) > spaceLeft:
|
||||
if splitLongWords and len(word) > maxLineWidth:
|
||||
result.add(substr(word, 0, spaceLeft-1))
|
||||
var w = spaceLeft
|
||||
var wordLeft = len(word) - spaceLeft
|
||||
while wordLeft > 0:
|
||||
result.add(newLine)
|
||||
var L = min(maxLineWidth, wordLeft)
|
||||
spaceLeft = maxLineWidth - L
|
||||
result.add(substr(word, w, w+L-1))
|
||||
inc(w, L)
|
||||
dec(wordLeft, L)
|
||||
else:
|
||||
spaceLeft = maxLineWidth - len(word)
|
||||
result.add(newLine)
|
||||
result.add(word)
|
||||
else:
|
||||
spaceLeft = spaceLeft - len(word)
|
||||
result.add(lastSep & word)
|
||||
lastSep.setLen(0)
|
||||
|
||||
|
||||
|
||||
when isMainModule:
|
||||
proc nonStaticTests =
|
||||
doAssert formatBiggestFloat(1234.567, ffDecimal, -1) == "1234.567000"
|
||||
|
|
|
|||
|
|
@ -293,3 +293,13 @@ when isMainModule:
|
|||
doAssert editDistanceAscii("", "") == 0
|
||||
doAssert editDistanceAscii("kitten", "sitting") == 3 # from Wikipedia
|
||||
doAssert editDistanceAscii("flaw", "lawn") == 2 # from Wikipedia
|
||||
|
||||
|
||||
assert(editDistance("prefix__hallo_suffix", "prefix__hallo_suffix") == 0)
|
||||
assert(editDistance("prefix__hallo_suffix", "prefix__hallo_suffi1") == 1)
|
||||
assert(editDistance("prefix__hallo_suffix", "prefix__HALLO_suffix") == 5)
|
||||
assert(editDistance("prefix__hallo_suffix", "prefix__ha_suffix") == 3)
|
||||
assert(editDistance("prefix__hallo_suffix", "prefix") == 14)
|
||||
assert(editDistance("prefix__hallo_suffix", "suffix") == 14)
|
||||
assert(editDistance("prefix__hallo_suffix", "prefix__hao_suffix") == 2)
|
||||
assert(editDistance("main", "malign") == 2)
|
||||
|
|
|
|||
|
|
@ -164,9 +164,6 @@ proc declared*(x: untyped): bool {.magic: "Defined", noSideEffect, compileTime.}
|
|||
## # provide our own toUpper proc here, because strutils is
|
||||
## # missing it.
|
||||
|
||||
when defined(useNimRtl):
|
||||
{.deadCodeElim: on.} # dce option deprecated
|
||||
|
||||
proc declaredInScope*(x: untyped): bool {.
|
||||
magic: "DefinedInScope", noSideEffect, compileTime.}
|
||||
## Special compile-time procedure that checks whether `x` is
|
||||
|
|
@ -899,17 +896,6 @@ when defined(nimHasalignOf):
|
|||
when defined(nimtypedescfixed):
|
||||
proc sizeof*(x: typedesc): int {.magic: "SizeOf", noSideEffect.}
|
||||
|
||||
proc `<`*[T](x: Ordinal[T]): T {.magic: "UnaryLt", noSideEffect, deprecated.}
|
||||
## **Deprecated since version 0.18.0**. For the common excluding range
|
||||
## write ``0 ..< 10`` instead of ``0 .. < 10`` (look at the spacing).
|
||||
## For ``<x`` write ``pred(x)``.
|
||||
##
|
||||
## Unary ``<`` that can be used for excluding ranges.
|
||||
## Semantically this is the same as `pred <#pred,T,int>`_.
|
||||
##
|
||||
## .. code-block:: Nim
|
||||
## for i in 0 .. <10: echo i # => 0 1 2 3 4 5 6 7 8 9
|
||||
##
|
||||
|
||||
proc succ*[T: Ordinal](x: T, y = 1): T {.magic: "Succ", noSideEffect.}
|
||||
## Returns the ``y``-th successor (default: 1) of the value ``x``.
|
||||
|
|
@ -2597,19 +2583,6 @@ when not defined(js) and not defined(booting) and defined(nimTrMacros):
|
|||
# unnecessary slow down in this case.
|
||||
swap(cast[ptr pointer](addr arr[a])[], cast[ptr pointer](addr arr[b])[])
|
||||
|
||||
|
||||
# undocumented:
|
||||
proc getRefcount*[T](x: ref T): int {.importc: "getRefcount", noSideEffect,
|
||||
deprecated: "the refcount was never reliable, the GC does not use traditional refcounting".}
|
||||
proc getRefcount*(x: string): int {.importc: "getRefcount", noSideEffect,
|
||||
deprecated: "the refcount was never reliable, the GC does not use traditional refcounting".}
|
||||
proc getRefcount*[T](x: seq[T]): int {.importc: "getRefcount", noSideEffect,
|
||||
deprecated: "the refcount was never reliable, the GC does not use traditional refcounting".}
|
||||
##
|
||||
## Retrieves the reference count of an heap-allocated object. The
|
||||
## value is implementation-dependent.
|
||||
|
||||
|
||||
const
|
||||
Inf* = 0x7FF0000000000000'f64
|
||||
## Contains the IEEE floating point value of positive infinity.
|
||||
|
|
@ -3337,16 +3310,6 @@ when not defined(nimscript) and hasAlloc:
|
|||
{.warning: "GC_getStatistics is a no-op in JavaScript".}
|
||||
""
|
||||
|
||||
template accumulateResult*(iter: untyped) {.deprecated: "use `sequtils.toSeq` instead (more hygienic, sometimes more efficient)".} =
|
||||
## **Deprecated since v0.19.2:** use `sequtils.toSeq
|
||||
## <sequtils.html#toSeq.t,untyped>`_ instead.
|
||||
##
|
||||
## Helps to convert an iterator to a proc.
|
||||
## `sequtils.toSeq <sequtils.html#toSeq.t,untyped>`_ is more hygienic and efficient.
|
||||
##
|
||||
result = @[]
|
||||
for x in iter: add(result, x)
|
||||
|
||||
# we have to compute this here before turning it off in except.nim anyway ...
|
||||
const NimStackTrace = compileOption("stacktrace")
|
||||
|
||||
|
|
@ -3815,19 +3778,6 @@ when not defined(JS): #and not defined(nimscript):
|
|||
var e = getCurrentException()
|
||||
return if e == nil: "" else: e.msg
|
||||
|
||||
proc onRaise*(action: proc(e: ref Exception): bool{.closure.}) {.deprecated.} =
|
||||
## **Deprecated since version 0.18.1**: No good usages of this
|
||||
## feature are known.
|
||||
##
|
||||
## Can be used in a ``try`` statement to setup a Lisp-like
|
||||
## `condition system`:idx:\: This prevents the 'raise' statement to
|
||||
## raise an exception but instead calls ``action``.
|
||||
## If ``action`` returns false, the exception has been handled and
|
||||
## does not propagate further through the call stack.
|
||||
if not isNil(excHandler):
|
||||
excHandler.hasRaiseAction = true
|
||||
excHandler.raiseAction = action
|
||||
|
||||
proc setCurrentException*(exc: ref Exception) {.inline, benign.} =
|
||||
## Sets the current exception.
|
||||
##
|
||||
|
|
@ -4357,34 +4307,6 @@ proc addQuoted*[T](s: var string, x: T) =
|
|||
else:
|
||||
s.add($x)
|
||||
|
||||
when hasAlloc:
|
||||
# XXX: make these the default (or implement the NilObject optimization)
|
||||
proc safeAdd*[T](x: var seq[T], y: T) {.noSideEffect, deprecated.} =
|
||||
## Adds ``y`` to ``x`` unless ``x`` is not yet initialized; in that case,
|
||||
## ``x`` becomes ``@[y]``.
|
||||
when defined(nimNoNilSeqs):
|
||||
x.add(y)
|
||||
else:
|
||||
if x == nil: x = @[y]
|
||||
else: x.add(y)
|
||||
|
||||
proc safeAdd*(x: var string, y: char) {.noSideEffect, deprecated.} =
|
||||
## Adds ``y`` to ``x``. If ``x`` is ``nil`` it is initialized to ``""``.
|
||||
when defined(nimNoNilSeqs):
|
||||
x.add(y)
|
||||
else:
|
||||
if x == nil: x = ""
|
||||
x.add(y)
|
||||
|
||||
proc safeAdd*(x: var string, y: string) {.noSideEffect, deprecated.} =
|
||||
## Adds ``y`` to ``x`` unless ``x`` is not yet initialized; in that
|
||||
## case, ``x`` becomes ``y``.
|
||||
when defined(nimNoNilSeqs):
|
||||
x.add(y)
|
||||
else:
|
||||
if x == nil: x = y
|
||||
else: x.add(y)
|
||||
|
||||
proc locals*(): RootObj {.magic: "Plugin", noSideEffect.} =
|
||||
## Generates a tuple constructor expression listing all the local variables
|
||||
## in the current scope.
|
||||
|
|
@ -4436,18 +4358,6 @@ proc procCall*(x: untyped) {.magic: "ProcCall", compileTime.} =
|
|||
## procCall someMethod(a, b)
|
||||
discard
|
||||
|
||||
proc xlen*(x: string): int {.magic: "XLenStr", noSideEffect,
|
||||
deprecated: "use len() instead".} =
|
||||
## **Deprecated since version 0.18.1**. Use `len()` instead.
|
||||
discard
|
||||
proc xlen*[T](x: seq[T]): int {.magic: "XLenSeq", noSideEffect,
|
||||
deprecated: "use len() instead".} =
|
||||
## **Deprecated since version 0.18.1**. Use `len()` instead.
|
||||
##
|
||||
## Returns the length of a sequence or a string without testing for 'nil'.
|
||||
## This is an optimization that rarely makes sense.
|
||||
discard
|
||||
|
||||
|
||||
proc `==`*(x, y: cstring): bool {.magic: "EqCString", noSideEffect,
|
||||
inline.} =
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue