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

remove deprecated procs (#12535)

Browse source
This commit is contained in:
Andreas Rumpf 2019-11-05 11:05:46 +01:00 • committed by Miran
commit 3ba3307d61
39 changed files with 111 additions and 567 deletions
Download patch file Download diff file Expand all files Collapse all files

6
lib/impure/nre.nim
View file

@ -357,11 +357,13 @@ iterator items*(pattern: Captures,
proc toSeq*(pattern: CaptureBounds, proc toSeq*(pattern: CaptureBounds,
default = none(HSlice[int, int])): seq[Option[HSlice[int, int]]] = 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, proc toSeq*(pattern: Captures,
default: Option[string] = none(string)): seq[Option[string]] = 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 = proc `$`*(pattern: RegexMatch): string =
return pattern.captures[-1] return pattern.captures[-1]

16
lib/pure/json.nim
View file

@ -234,10 +234,6 @@ proc getBiggestInt*(n: JsonNode, default: BiggestInt = 0): BiggestInt =
if n.isNil or n.kind != JInt: return default if n.isNil or n.kind != JInt: return default
else: return n.num 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 = proc getFloat*(n: JsonNode, default: float = 0.0): float =
## Retrieves the float value of a `JFloat JsonNode`. ## 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) of JInt: return float(n.num)
else: return default 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 = proc getBool*(n: JsonNode, default: bool = false): bool =
## Retrieves the bool value of a `JBool JsonNode`. ## 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 if n.isNil or n.kind != JBool: return default
else: return n.bval 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, proc getFields*(n: JsonNode,
default = initOrderedTable[string, JsonNode](4)): default = initOrderedTable[string, JsonNode](4)):
OrderedTable[string, JsonNode] = OrderedTable[string, JsonNode] =
@ -502,10 +490,6 @@ proc contains*(node: JsonNode, val: JsonNode): bool =
assert(node.kind == JArray) assert(node.kind == JArray)
find(node.elems, val) >= 0 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 = proc `{}`*(node: JsonNode, keys: varargs[string]): JsonNode =
## Traverses the node and gets the given value. If any of the ## 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 ## keys do not exist, returns ``nil``. Also returns ``nil`` if one of the

7
lib/pure/os.nim
View file

@ -41,11 +41,6 @@
## * `dynlib module <dynlib.html>`_ ## * `dynlib module <dynlib.html>`_
## * `streams module <streams.html>`_ ## * `streams module <streams.html>`_
{.deadCodeElim: on.} # dce option deprecated
{.push debugger: off.}
include "system/inclrtl" include "system/inclrtl"
import import
@ -3131,8 +3126,6 @@ proc getCurrentProcessId*(): int {.noNimScript.} =
else: else:
result = getpid() result = getpid()
{.pop.}
proc setLastModificationTime*(file: string, t: times.Time) {.noNimScript.} = proc setLastModificationTime*(file: string, t: times.Time) {.noNimScript.} =
## Sets the `file`'s last modification time. `OSError` is raised in case of ## Sets the `file`'s last modification time. `OSError` is raised in case of
## an error. ## an error.

6
lib/pure/pegs.nim
View file

@ -1154,7 +1154,8 @@ proc findAll*(s: string, pattern: Peg, start = 0): seq[string] {.
noSideEffect, rtl, extern: "npegs$1".} = noSideEffect, rtl, extern: "npegs$1".} =
## returns all matching *substrings* of `s` that match `pattern`. ## returns all matching *substrings* of `s` that match `pattern`.
## If it does not match, @[] is returned. ## 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): when not defined(nimhygiene):
{.pragma: inject.} {.pragma: inject.}
@ -1372,7 +1373,8 @@ iterator split*(s: string, sep: Peg): string =
proc split*(s: string, sep: Peg): seq[string] {. proc split*(s: string, sep: Peg): seq[string] {.
noSideEffect, rtl, extern: "npegs$1".} = noSideEffect, rtl, extern: "npegs$1".} =
## Splits the string `s` into substrings. ## Splits the string `s` into substrings.
accumulateResult(split(s, sep)) result = @[]
for it in split(s, sep): result.add it
# ------------------- scanner ------------------------------------------------- # ------------------- scanner -------------------------------------------------

278
lib/pure/strutils.nim
View file

@ -80,21 +80,8 @@ when defined(nimVmExportFixed):
from unicode import toLower, toUpper from unicode import toLower, toUpper
export 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" include "system/inclrtl"
{.pop.}
# Support old split with set[char]
when defined(nimOldSplit):
{.pragma: deprecatedSplit, deprecated.}
else:
{.pragma: deprecatedSplit.}
const const
Whitespace* = {' ', '\t', '\v', '\r', '\l', '\f'} Whitespace* = {' ', '\t', '\v', '\r', '\l', '\f'}
## All the characters that count as whitespace (space, tab, vertical tab, ## 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 break
i = j 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, proc isNilOrWhitespace*(s: string): bool {.noSideEffect, procvar, rtl,
extern: "nsuIsNilOrWhitespace".} = extern: "nsuIsNilOrWhitespace".} =
## Checks if `s` is nil or consists entirely of whitespace characters. ## 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(): if not c.isSpaceAscii():
return false 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: when isMainModule:
proc nonStaticTests = proc nonStaticTests =
doAssert formatBiggestFloat(1234.567, ffDecimal, -1) == "1234.567000" doAssert formatBiggestFloat(1234.567, ffDecimal, -1) == "1234.567000"

10
lib/std/editdistance.nim
View file

@ -293,3 +293,13 @@ when isMainModule:
doAssert editDistanceAscii("", "") == 0 doAssert editDistanceAscii("", "") == 0
doAssert editDistanceAscii("kitten", "sitting") == 3 # from Wikipedia doAssert editDistanceAscii("kitten", "sitting") == 3 # from Wikipedia
doAssert editDistanceAscii("flaw", "lawn") == 2 # 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)

90
lib/system.nim
View file

@ -164,9 +164,6 @@ proc declared*(x: untyped): bool {.magic: "Defined", noSideEffect, compileTime.}
## # provide our own toUpper proc here, because strutils is ## # provide our own toUpper proc here, because strutils is
## # missing it. ## # missing it.
when defined(useNimRtl):
{.deadCodeElim: on.} # dce option deprecated
proc declaredInScope*(x: untyped): bool {. proc declaredInScope*(x: untyped): bool {.
magic: "DefinedInScope", noSideEffect, compileTime.} magic: "DefinedInScope", noSideEffect, compileTime.}
## Special compile-time procedure that checks whether `x` is ## Special compile-time procedure that checks whether `x` is
@ -899,17 +896,6 @@ when defined(nimHasalignOf):
when defined(nimtypedescfixed): when defined(nimtypedescfixed):
proc sizeof*(x: typedesc): int {.magic: "SizeOf", noSideEffect.} 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.} proc succ*[T: Ordinal](x: T, y = 1): T {.magic: "Succ", noSideEffect.}
## Returns the ``y``-th successor (default: 1) of the value ``x``. ## 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. # unnecessary slow down in this case.
swap(cast[ptr pointer](addr arr[a])[], cast[ptr pointer](addr arr[b])[]) 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 const
Inf* = 0x7FF0000000000000'f64 Inf* = 0x7FF0000000000000'f64
## Contains the IEEE floating point value of positive infinity. ## 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".} {.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 ... # we have to compute this here before turning it off in except.nim anyway ...
const NimStackTrace = compileOption("stacktrace") const NimStackTrace = compileOption("stacktrace")
@ -3815,19 +3778,6 @@ when not defined(JS): #and not defined(nimscript):
var e = getCurrentException() var e = getCurrentException()
return if e == nil: "" else: e.msg 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.} = proc setCurrentException*(exc: ref Exception) {.inline, benign.} =
## Sets the current exception. ## Sets the current exception.
## ##
@ -4357,34 +4307,6 @@ proc addQuoted*[T](s: var string, x: T) =
else: else:
s.add($x) 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.} = proc locals*(): RootObj {.magic: "Plugin", noSideEffect.} =
## Generates a tuple constructor expression listing all the local variables ## Generates a tuple constructor expression listing all the local variables
## in the current scope. ## in the current scope.
@ -4436,18 +4358,6 @@ proc procCall*(x: untyped) {.magic: "ProcCall", compileTime.} =
## procCall someMethod(a, b) ## procCall someMethod(a, b)
discard 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, proc `==`*(x, y: cstring): bool {.magic: "EqCString", noSideEffect,
inline.} = inline.} =

6
testament/categories.nim
View file

@ -322,10 +322,14 @@ proc testNimInAction(r: var TResults, cat: Category, options: string) =
"niminaction/Chapter8/sdl/sdl_test" "niminaction/Chapter8/sdl/sdl_test"
] ]
when false:
# Verify that the files have not been modified. Death shall fall upon # Verify that the files have not been modified. Death shall fall upon
# whoever edits these hashes without dom96's permission, j/k. But please only # whoever edits these hashes without dom96's permission, j/k. But please only
# edit when making a conscious breaking change, also please try to make your # edit when making a conscious breaking change, also please try to make your
# commit message clear and notify me so I can easily compile an errata later. # commit message clear and notify me so I can easily compile an errata later.
# ---------------------------------------------------------
# Hash-checks are disabled for Nim 1.1 and beyond
# since we needed to fix the deprecated unary '<' operator.
const refHashes = @[ const refHashes = @[
"51afdfa84b3ca3d810809d6c4e5037ba", "51afdfa84b3ca3d810809d6c4e5037ba",
"30f07e4cd5eaec981f67868d4e91cfcf", "30f07e4cd5eaec981f67868d4e91cfcf",
@ -350,12 +354,12 @@ proc testNimInAction(r: var TResults, cat: Category, options: string) =
"1a2b3fba1187c68d6a9bfa66854f3318", "1a2b3fba1187c68d6a9bfa66854f3318",
"391ff57b38d9ea6f3eeb3fe69ab539d3" "391ff57b38d9ea6f3eeb3fe69ab539d3"
] ]
for i, test in tests: for i, test in tests:
let filename = testsDir / test.addFileExt("nim") let filename = testsDir / test.addFileExt("nim")
let testHash = getMD5(readFile(filename).string) let testHash = getMD5(readFile(filename).string)
doAssert testHash == refHashes[i], "Nim in Action test " & filename & doAssert testHash == refHashes[i], "Nim in Action test " & filename &
" was changed: " & $(i: i, testHash: testHash, refHash: refHashes[i]) " was changed: " & $(i: i, testHash: testHash, refHash: refHashes[i])
# Run the tests. # Run the tests.
for testfile in tests: for testfile in tests:
test "tests/" & testfile & ".nim" test "tests/" & testfile & ".nim"

2
tests/ccgbugs/taddhigh.nim
View file

@ -14,6 +14,6 @@ s.add x
s.add s[s.high] s.add s[s.high]
s.add s[s.len-1] s.add s[s.len-1]
s.add s[s.xlen-1] s.add s[s.len-1]
echo s # @[5, 5, 0] echo s # @[5, 5, 0]

20
tests/concepts/t3330.nim
View file

@ -9,23 +9,27 @@ proc test(foo: Foo[int])
required type for foo: Foo[int] required type for foo: Foo[int]
but expression 'bar' is of type: Bar[system.int] but expression 'bar' is of type: Bar[system.int]
t3330.nim(63, 8) Hint: Non-matching candidates for add(k, string, T) t3330.nim(63, 8) Hint: Non-matching candidates for add(k, string, T)
proc add[T](x: var seq[T]; y: T)
first type mismatch at position: 1
required type for x: var seq[T]
but expression 'k' is of type: Alias
proc add(x: var string; y: string) proc add(x: var string; y: string)
first type mismatch at position: 1 first type mismatch at position: 1
required type for x: var string required type for x: var string
but expression 'k' is of type: Alias but expression 'k' is of type: Alias
proc add[T](x: var seq[T]; y: openArray[T])
first type mismatch at position: 1
required type for x: var seq[T]
but expression 'k' is of type: Alias
proc add(result: var string; x: float) proc add(result: var string; x: float)
first type mismatch at position: 1 first type mismatch at position: 1
required type for result: var string required type for result: var string
but expression 'k' is of type: Alias but expression 'k' is of type: Alias
proc add(x: var string; y: char) proc add[T](x: var seq[T]; y: T)
first type mismatch at position: 1
required type for x: var seq[T]
but expression 'k' is of type: Alias
proc add(x: var string; y: cstring)
first type mismatch at position: 1 first type mismatch at position: 1
required type for x: var string required type for x: var string
but expression 'k' is of type: Alias but expression 'k' is of type: Alias
proc add(x: var string; y: cstring) proc add(x: var string; y: char)
first type mismatch at position: 1 first type mismatch at position: 1
required type for x: var string required type for x: var string
but expression 'k' is of type: Alias but expression 'k' is of type: Alias
@ -33,10 +37,6 @@ proc add(result: var string; x: int64)
first type mismatch at position: 1 first type mismatch at position: 1
required type for result: var string required type for result: var string
but expression 'k' is of type: Alias but expression 'k' is of type: Alias
proc add[T](x: var seq[T]; y: openArray[T])
first type mismatch at position: 1
required type for x: var seq[T]
but expression 'k' is of type: Alias
t3330.nim(63, 8) template/generic instantiation of `add` from here t3330.nim(63, 8) template/generic instantiation of `add` from here
t3330.nim(70, 6) Foo: 'bar.value' cannot be assigned to t3330.nim(70, 6) Foo: 'bar.value' cannot be assigned to

8
tests/destructor/tnewruntime_strutils.nim
View file

@ -1,9 +1,9 @@
discard """ discard """
cmd: '''nim c --newruntime $file''' cmd: '''nim c --newruntime $file'''
output: '''443 443''' output: '''422 422'''
""" """
import strutils, os import strutils, os, std / wordwrap
import core / allocators import core / allocators
import system / ansi_c import system / ansi_c
@ -76,12 +76,12 @@ proc staticTests =
inp = """ this is a long text -- muchlongerthan10chars and here inp = """ this is a long text -- muchlongerthan10chars and here
it goes""" it goes"""
outp = " this is a\nlong text\n--\nmuchlongerthan10chars\nand here\nit goes" outp = " this is a\nlong text\n--\nmuchlongerthan10chars\nand here\nit goes"
doAssert wordWrap(inp, 10, false) == outp doAssert wrapWords(inp, 10, false) == outp
let let
longInp = """ThisIsOneVeryLongStringWhichWeWillSplitIntoEightSeparatePartsNow""" longInp = """ThisIsOneVeryLongStringWhichWeWillSplitIntoEightSeparatePartsNow"""
longOutp = "ThisIsOn\neVeryLon\ngStringW\nhichWeWi\nllSplitI\nntoEight\nSeparate\nPartsNow" longOutp = "ThisIsOn\neVeryLon\ngStringW\nhichWeWi\nllSplitI\nntoEight\nSeparate\nPartsNow"
doAssert wordWrap(longInp, 8, true) == longOutp doAssert wrapWords(longInp, 8, true) == longOutp
doAssert "$animal eats $food." % ["animal", "The cat", "food", "fish"] == doAssert "$animal eats $food." % ["animal", "The cat", "food", "fish"] ==
"The cat eats fish." "The cat eats fish."

2
tests/niminaction/Chapter7/Tweeter/src/database.nim
View file

@ -81,7 +81,7 @@ proc findMessages*(database: Database, usernames: seq[string],
var whereClause = " WHERE " var whereClause = " WHERE "
for i in 0 ..< usernames.len: for i in 0 ..< usernames.len:
whereClause.add("username = ? ") whereClause.add("username = ? ")
if i != <usernames.len: if i != usernames.high:
whereClause.add("or ") whereClause.add("or ")
let messages = database.db.getAllRows( let messages = database.db.getAllRows(

56
tests/parallel/twrong_refcounts.nim
View file

@ -1,56 +0,0 @@
discard """
output: "Success"
target: "c"
"""
# Note: target: "cpp" fails because we can't yet have `extern "C"` mangling in
# `exportc` procs.
import math, random, threadPool
# ---
type
Person = object
age: int
friend: ref Person
var
people: seq[ref Person] = @[]
proc newPerson(age:int): ref Person =
result.new()
result.age = age
proc greet(p:Person) =
#echo p.age, ", ", p.friend.age
p.friend.age += 1
# ---
proc setup =
for i in 0 .. <20:
people.add newPerson(i + 1)
for i in 0 .. <20:
people[i].friend = people[random(20)]
proc update =
var countA: array[20, int]
var countB: array[20, int]
for i, p in people:
countA[i] = getRefCount(p)
parallel:
for i in 0 .. people.high:
spawn greet(people[i][])
for i, p in people:
countB[i] = getRefCount(p)
for i in 0 .. <20:
doAssert countA[i] == countB[i]
echo "Success"
# ---
when true:
setup()
update()

27
tests/stdlib/tstrutil.nim
View file

@ -155,24 +155,6 @@ proc testDelete =
delete(s, 0, 0) delete(s, 0, 0)
assert s == "1236789ABCDEFG" assert s == "1236789ABCDEFG"
proc testIsAlphaNumeric =
assert isAlphaNumeric("abcdABC1234") == true
assert isAlphaNumeric("a") == true
assert isAlphaNumeric("abcABC?1234") == false
assert isAlphaNumeric("abcABC 1234") == false
assert isAlphaNumeric(".") == false
testIsAlphaNumeric()
proc testIsDigit =
assert isDigit("1") == true
assert isDigit("1234") == true
assert isDigit("abcABC?1234") == false
assert isDigit(".") == false
assert isDigit(":") == false
testIsDigit()
proc testFind = proc testFind =
assert "0123456789ABCDEFGH".find('A') == 10 assert "0123456789ABCDEFGH".find('A') == 10
assert "0123456789ABCDEFGH".find('A', 5) == 10 assert "0123456789ABCDEFGH".find('A', 5) == 10
@ -273,15 +255,6 @@ assert(insertSep($232) == "232")
assert(insertSep($12345, ',') == "12,345") assert(insertSep($12345, ',') == "12,345")
assert(insertSep($0) == "0") assert(insertSep($0) == "0")
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)
assert "/1/2/3".rfind('/') == 4 assert "/1/2/3".rfind('/') == 4
assert "/1/2/3".rfind('/', last=1) == 0 assert "/1/2/3".rfind('/', last=1) == 0
assert "/1/2/3".rfind('0') == -1 assert "/1/2/3".rfind('0') == -1