summary refs log tree commit diff stats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--compiler/main.nim1
-rw-r--r--compiler/msgs.nim5
-rw-r--r--doc/sets_fragment.txt14
-rw-r--r--lib/pure/asyncdispatch.nim6
-rw-r--r--lib/pure/math.nim68
-rw-r--r--lib/pure/selectors.nim3
-rw-r--r--lib/pure/unicode.nim59
-rw-r--r--lib/system.nim6
-rw-r--r--lib/wrappers/linenoise/clinenoise.c (renamed from lib/wrappers/linenoise/linenoise.c)2
-rw-r--r--lib/wrappers/linenoise/clinenoise.h (renamed from lib/wrappers/linenoise/linenoise.h)0
-rw-r--r--lib/wrappers/linenoise/linenoise.nim2
11 files changed, 110 insertions, 56 deletions
diff --git a/compiler/main.nim b/compiler/main.nim
index ee4a34fbb..47fae7fa7 100644
--- a/compiler/main.nim
+++ b/compiler/main.nim
@@ -378,3 +378,4 @@ proc mainCommand* =
   when SimulateCaasMemReset:
     resetMemory()
 
+  resetAttributes()
diff --git a/compiler/msgs.nim b/compiler/msgs.nim
index f1d1029e4..e6bc45da6 100644
--- a/compiler/msgs.nim
+++ b/compiler/msgs.nim
@@ -865,6 +865,11 @@ proc rawMessage*(msg: TMsgKind, args: openArray[string]) =
 proc rawMessage*(msg: TMsgKind, arg: string) =
   rawMessage(msg, [arg])
 
+proc resetAttributes* =
+  if optUseColors in gGlobalOptions:
+    terminal.resetAttributes()
+    stdout.flushFile()
+
 proc writeSurroundingSrc(info: TLineInfo) =
   const indent = "  "
   msgWriteln(indent & $info.sourceLine)
diff --git a/doc/sets_fragment.txt b/doc/sets_fragment.txt
index 84b13e672..15f0962ef 100644
--- a/doc/sets_fragment.txt
+++ b/doc/sets_fragment.txt
@@ -1,6 +1,16 @@
 The set type models the mathematical notion of a set. The set's
-basetype can only be an ordinal type. The reason is that sets are implemented
-as high performance bit vectors.
+basetype can only be an ordinal type of a certain size, namely:
+  * ``int8``-``int16``
+  * ``uint8``/``byte``-``uint16``
+  * ``char``
+  * ``enum``
+or equivalent. The reason is that sets are implemented as high 
+performance bit vectors. Attempting to declare a set with a larger type will
+result in an error:
+
+.. code-block:: nim
+
+  var s: set[int64] # Error: set is too large
 
 Sets can be constructed via the set constructor: ``{}`` is the empty set. The
 empty set is type compatible with any concrete set type. The constructor
diff --git a/lib/pure/asyncdispatch.nim b/lib/pure/asyncdispatch.nim
index 0b312d4d4..2ce31b4e8 100644
--- a/lib/pure/asyncdispatch.nim
+++ b/lib/pure/asyncdispatch.nim
@@ -333,7 +333,7 @@ when defined(windows) or defined(nimdoc):
       ioPort: Handle
       handles: HashSet[AsyncFD]
 
-    CustomOverlapped = object of TOVERLAPPED
+    CustomOverlapped = object of OVERLAPPED
       data*: CompletionData
 
     PCustomOverlapped* = ref CustomOverlapped
@@ -420,12 +420,12 @@ when defined(windows) or defined(nimdoc):
   var acceptExPtr: pointer = nil
   var getAcceptExSockAddrsPtr: pointer = nil
 
-  proc initPointer(s: SocketHandle, fun: var pointer, guid: var TGUID): bool =
+  proc initPointer(s: SocketHandle, fun: var pointer, guid: var GUID): bool =
     # Ref: https://github.com/powdahound/twisted/blob/master/twisted/internet/iocpreactor/iocpsupport/winsock_pointers.c
     var bytesRet: Dword
     fun = nil
     result = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, addr guid,
-                      sizeof(TGUID).Dword, addr fun, sizeof(pointer).Dword,
+                      sizeof(GUID).Dword, addr fun, sizeof(pointer).Dword,
                       addr bytesRet, nil, nil) == 0
 
   proc initAll() =
diff --git a/lib/pure/math.nim b/lib/pure/math.nim
index d3f1f3814..821ab738b 100644
--- a/lib/pure/math.nim
+++ b/lib/pure/math.nim
@@ -56,7 +56,7 @@ type
     fcNegInf     ## value is negative infinity
 
 proc classify*(x: float): FloatClass =
-  ## classifies a floating point value. Returns `x`'s class as specified by
+  ## Classifies a floating point value. Returns `x`'s class as specified by
   ## `FloatClass`.
 
   # JavaScript and most C compilers have no classify:
@@ -74,7 +74,7 @@ proc classify*(x: float): FloatClass =
 
 
 proc binom*(n, k: int): int {.noSideEffect.} =
-  ## computes the binomial coefficient
+  ## Computes the binomial coefficient
   if k <= 0: return 1
   if 2*k > n: return binom(n, n-k)
   result = n
@@ -82,18 +82,18 @@ proc binom*(n, k: int): int {.noSideEffect.} =
     result = (result * (n + 1 - i)) div i
 
 proc fac*(n: int): int {.noSideEffect.} =
-  ## computes the faculty/factorial function.
+  ## Computes the faculty/factorial function.
   result = 1
   for i in countup(2, n):
     result = result * i
 
 proc isPowerOfTwo*(x: int): bool {.noSideEffect.} =
-  ## returns true, if `x` is a power of two, false otherwise.
+  ## Returns true, if `x` is a power of two, false otherwise.
   ## Zero and negative numbers are not a power of two.
   return (x > 0) and ((x and (x - 1)) == 0)
 
 proc nextPowerOfTwo*(x: int): int {.noSideEffect.} =
-  ## returns `x` rounded up to the nearest power of two.
+  ## Returns `x` rounded up to the nearest power of two.
   ## Zero and negative numbers get rounded up to 1.
   result = x - 1
   when defined(cpu64):
@@ -108,28 +108,28 @@ proc nextPowerOfTwo*(x: int): int {.noSideEffect.} =
   result += 1 + ord(x<=0)
 
 proc countBits32*(n: int32): int {.noSideEffect.} =
-  ## counts the set bits in `n`.
+  ## Counts the set bits in `n`.
   var v = n
   v = v -% ((v shr 1'i32) and 0x55555555'i32)
   v = (v and 0x33333333'i32) +% ((v shr 2'i32) and 0x33333333'i32)
   result = ((v +% (v shr 4'i32) and 0xF0F0F0F'i32) *% 0x1010101'i32) shr 24'i32
 
 proc sum*[T](x: openArray[T]): T {.noSideEffect.} =
-  ## computes the sum of the elements in `x`.
+  ## Computes the sum of the elements in `x`.
   ## If `x` is empty, 0 is returned.
   for i in items(x): result = result + i
 
 template toFloat(f: float): float = f
 
 proc mean*[T](x: openArray[T]): float {.noSideEffect.} =
-  ## computes the mean of the elements in `x`, which are first converted to floats.
+  ## Computes the mean of the elements in `x`, which are first converted to floats.
   ## If `x` is empty, NaN is returned.
   ## ``toFloat(x: T): float`` must be defined.
   for i in items(x): result = result + toFloat(i)
   result = result / toFloat(len(x))
 
 proc variance*[T](x: openArray[T]): float {.noSideEffect.} =
-  ## computes the variance of the elements in `x`.
+  ## Computes the variance of the elements in `x`.
   ## If `x` is empty, NaN is returned.
   ## ``toFloat(x: T): float`` must be defined.
   result = 0.0
@@ -140,41 +140,43 @@ proc variance*[T](x: openArray[T]): float {.noSideEffect.} =
   result = result / toFloat(len(x))
 
 proc random*(max: int): int {.benign.}
-  ## returns a random number in the range 0..max-1. The sequence of
+  ## Returns a random number in the range 0..max-1. The sequence of
   ## random number is always the same, unless `randomize` is called
   ## which initializes the random number generator with a "random"
   ## number, i.e. a tickcount.
 
 proc random*(max: float): float {.benign.}
-  ## returns a random number in the range 0..<max. The sequence of
+  ## Returns a random number in the range 0..<max. The sequence of
   ## random number is always the same, unless `randomize` is called
   ## which initializes the random number generator with a "random"
   ## number, i.e. a tickcount. This has a 16-bit resolution on windows
   ## and a 48-bit resolution on other platforms.
 
 proc randomize*() {.benign.}
-  ## initializes the random number generator with a "random"
+  ## Initializes the random number generator with a "random"
   ## number, i.e. a tickcount. Note: Does nothing for the JavaScript target,
   ## as JavaScript does not support this.
 
 proc randomize*(seed: int) {.benign.}
-  ## initializes the random number generator with a specific seed.
+  ## Initializes the random number generator with a specific seed.
   ## Note: Does nothing for the JavaScript target,
   ## as JavaScript does not support this.
 
 {.push noSideEffect.}
 when not defined(JS):
   proc sqrt*(x: float): float {.importc: "sqrt", header: "<math.h>".}
-    ## computes the square root of `x`.
+    ## Computes the square root of `x`.
   proc cbrt*(x: float): float {.importc: "cbrt", header: "<math.h>".}
-    ## computes the cubic root of `x`
+    ## Computes the cubic root of `x`
 
   proc ln*(x: float): float {.importc: "log", header: "<math.h>".}
-    ## computes ln(x).
+    ## Computes the natural log of `x`
   proc log10*(x: float): float {.importc: "log10", header: "<math.h>".}
+    ## Computes the common logarithm (base 10) of `x`
   proc log2*(x: float): float = return ln(x) / ln(2.0)
+    ## Computes the binary logarithm (base 2) of `x`
   proc exp*(x: float): float {.importc: "exp", header: "<math.h>".}
-    ## computes e**x.
+    ## Computes the exponential function of `x` (pow(E, x))
 
   proc frexp*(x: float, exponent: var int): float {.
     importc: "frexp", header: "<math.h>".}
@@ -185,11 +187,14 @@ when not defined(JS):
     ## m.
 
   proc round*(x: float): int {.importc: "lrint", header: "<math.h>".}
-    ## converts a float to an int by rounding.
+    ## Converts a float to an int by rounding.
 
   proc arccos*(x: float): float {.importc: "acos", header: "<math.h>".}
+    ## Computes the arc cosine of `x`
   proc arcsin*(x: float): float {.importc: "asin", header: "<math.h>".}
+    ## Computes the arc sine of `x`
   proc arctan*(x: float): float {.importc: "atan", header: "<math.h>".}
+    ## Calculate the arc tangent of `y` / `x`
   proc arctan2*(y, x: float): float {.importc: "atan2", header: "<math.h>".}
     ## Calculate the arc tangent of `y` / `x`.
     ## `atan2` returns the arc tangent of `y` / `x`; it produces correct
@@ -197,16 +202,23 @@ when not defined(JS):
     ## (`x` near 0).
 
   proc cos*(x: float): float {.importc: "cos", header: "<math.h>".}
+    ## Computes the cosine of `x`
   proc cosh*(x: float): float {.importc: "cosh", header: "<math.h>".}
+    ## Computes the hyperbolic cosine of `x`
   proc hypot*(x, y: float): float {.importc: "hypot", header: "<math.h>".}
-    ## same as ``sqrt(x*x + y*y)``.
+    ## Computes the hypotenuse of a right-angle triangle with `x` and
+    ## `y` as its base and height. Equivalent to ``sqrt(x*x + y*y)``.
 
   proc sinh*(x: float): float {.importc: "sinh", header: "<math.h>".}
+    ## Computes the hyperbolic sine of `x`
   proc sin*(x: float): float {.importc: "sin", header: "<math.h>".}
+    ## Computes the sine of `x`
   proc tan*(x: float): float {.importc: "tan", header: "<math.h>".}
+    ## Computes the tangent of `x`
   proc tanh*(x: float): float {.importc: "tanh", header: "<math.h>".}
+    ## Computes the hyperbolic tangent of `x`
   proc pow*(x, y: float): float {.importc: "pow", header: "<math.h>".}
-    ## computes x to power raised of y.
+    ## Computes `x` to power of `y`.
 
   proc erf*(x: float): float {.importc: "erf", header: "<math.h>".}
     ## The error function
@@ -269,10 +281,26 @@ when not defined(JS):
     result = int(rand()) mod max
 
   proc trunc*(x: float): float {.importc: "trunc", header: "<math.h>".}
+    ## Truncates `x` to the decimal point
+    ##
+    ## .. code-block:: nim
+    ##  echo trunc(PI) # 3.0
   proc floor*(x: float): float {.importc: "floor", header: "<math.h>".}
+    ## Computes the floor function (i.e., the largest integer not greater than `x`)
+    ##
+    ## .. code-block:: nim
+    ##  echo floor(-3.5) ## -4.0
   proc ceil*(x: float): float {.importc: "ceil", header: "<math.h>".}
+    ## Computes the ceiling function (i.e., the smallest integer not less than `x`)
+    ##
+    ## .. code-block:: nim
+    ##  echo ceil(-2.1) ## -2.0
 
   proc fmod*(x, y: float): float {.importc: "fmod", header: "<math.h>".}
+    ## Computes the remainder of `x` divided by `y`
+    ##
+    ## .. code-block:: nim
+    ##  echo fmod(-2.5, 0.3) ## -0.1
 
 else:
   proc mathrandom(): float {.importc: "Math.random", nodecl.}
diff --git a/lib/pure/selectors.nim b/lib/pure/selectors.nim
index aa8ad39d1..bfc393a96 100644
--- a/lib/pure/selectors.nim
+++ b/lib/pure/selectors.nim
@@ -295,7 +295,8 @@ proc contains*(s: Selector, key: SelectorKey): bool =
   ## ensures that the keys are equal. File descriptors may not always be
   ## unique especially when an fd is closed and then a new one is opened,
   ## the new one may have the same value.
-  return key.fd in s and s.fds[key.fd] == key
+  when not defined(nimdoc):
+    return key.fd in s and s.fds[key.fd] == key
 
 {.deprecated: [TEvent: Event, PSelectorKey: SelectorKey,
    TReadyInfo: ReadyInfo, PSelector: Selector].}
diff --git a/lib/pure/unicode.nim b/lib/pure/unicode.nim
index 4446eaa0c..5e20db32b 100644
--- a/lib/pure/unicode.nim
+++ b/lib/pure/unicode.nim
@@ -27,7 +27,7 @@ proc `==`*(a, b: Rune): bool = return int(a) == int(b)
 template ones(n: expr): expr = ((1 shl n)-1)
 
 proc runeLen*(s: string): int {.rtl, extern: "nuc$1".} =
-  ## returns the number of Unicode characters of the string `s`.
+  ## Returns the number of Unicode characters of the string ``s``
   var i = 0
   while i < len(s):
     if ord(s[i]) <=% 127: inc(i)
@@ -40,7 +40,7 @@ proc runeLen*(s: string): int {.rtl, extern: "nuc$1".} =
     inc(result)
 
 proc runeLenAt*(s: string, i: Natural): int =
-  ## returns the number of bytes the rune starting at ``s[i]`` takes.
+  ## Returns the number of bytes the rune starting at ``s[i]`` takes
   if ord(s[i]) <=% 127: result = 1
   elif ord(s[i]) shr 5 == 0b110: result = 2
   elif ord(s[i]) shr 4 == 0b1110: result = 3
@@ -50,8 +50,8 @@ proc runeLenAt*(s: string, i: Natural): int =
   else: result = 1
 
 template fastRuneAt*(s: string, i: int, result: expr, doInc = true) =
-  ## Returns the unicode character ``s[i]`` in `result`. If ``doInc == true``
-  ## `i` is incremented by the number of bytes that have been processed.
+  ## Returns the Unicode character ``s[i]`` in ``result``. If ``doInc == true``
+  ## ``i`` is incremented by the number of bytes that have been processed.
   bind ones
   if ord(s[i]) <=% 127:
     result = Rune(ord(s[i]))
@@ -106,8 +106,8 @@ template fastRuneAt*(s: string, i: int, result: expr, doInc = true) =
     when doInc: inc(i)
 
 proc validateUtf8*(s: string): int =
-  ## returns the position of the invalid byte in ``s`` if the string ``s`` does
-  ## not hold valid UTF-8 data. Otherwise -1 is returned.
+  ## Returns the position of the invalid byte in ``s`` if the string ``s`` does
+  ## not hold valid UTF-8 data. Otherwise ``-1`` is returned.
   var i = 0
   let L = s.len
   while i < L:
@@ -131,11 +131,11 @@ proc validateUtf8*(s: string): int =
   return -1
 
 proc runeAt*(s: string, i: Natural): Rune =
-  ## returns the unicode character in `s` at byte index `i`
+  ## Returns the unicode character in ``s`` at byte index ``i``
   fastRuneAt(s, i, result, false)
 
 proc toUTF8*(c: Rune): string {.rtl, extern: "nuc$1".} =
-  ## converts a rune into its UTF8 representation
+  ## Converts a rune into its UTF-8 representation
   var i = RuneImpl(c)
   if i <=% 127:
     result = newString(1)
@@ -174,11 +174,11 @@ proc toUTF8*(c: Rune): string {.rtl, extern: "nuc$1".} =
     discard # error, exception?
 
 proc `$`*(rune: Rune): string =
-  ## converts a rune to a string
+  ## Converts a Rune to a string
   rune.toUTF8
 
 proc `$`*(runes: seq[Rune]): string =
-  ## converts a sequence of runes to a string
+  ## Converts a sequence of Runes to a string
   result = ""
   for rune in runes: result.add(rune.toUTF8)
 
@@ -1163,8 +1163,8 @@ proc binarySearch(c: RuneImpl, tab: openArray[RuneImpl], len, stride: int): int
   return -1
 
 proc toLower*(c: Rune): Rune {.rtl, extern: "nuc$1", procvar.} =
-  ## Converts `c` into lower case. This works for any Unicode character.
-  ## If possible, prefer `toLower` over `toUpper`.
+  ## Converts ``c`` into lower case. This works for any Unicode character.
+  ## If possible, prefer ``toLower`` over ``toUpper``.
   var c = RuneImpl(c)
   var p = binarySearch(c, tolowerRanges, len(tolowerRanges) div 3, 3)
   if p >= 0 and c >= tolowerRanges[p] and c <= tolowerRanges[p+1]:
@@ -1175,8 +1175,8 @@ proc toLower*(c: Rune): Rune {.rtl, extern: "nuc$1", procvar.} =
   return Rune(c)
 
 proc toUpper*(c: Rune): Rune {.rtl, extern: "nuc$1", procvar.} =
-  ## Converts `c` into upper case. This works for any Unicode character.
-  ## If possible, prefer `toLower` over `toUpper`.
+  ## Converts ``c`` into upper case. This works for any Unicode character.
+  ## If possible, prefer ``toLower`` over ``toUpper``.
   var c = RuneImpl(c)
   var p = binarySearch(c, toupperRanges, len(toupperRanges) div 3, 3)
   if p >= 0 and c >= toupperRanges[p] and c <= toupperRanges[p+1]:
@@ -1187,6 +1187,7 @@ proc toUpper*(c: Rune): Rune {.rtl, extern: "nuc$1", procvar.} =
   return Rune(c)
 
 proc toTitle*(c: Rune): Rune {.rtl, extern: "nuc$1", procvar.} =
+  ## Converts ``c`` to title case
   var c = RuneImpl(c)
   var p = binarySearch(c, toTitleSinglets, len(toTitleSinglets) div 2, 2)
   if p >= 0 and c == toTitleSinglets[p]:
@@ -1194,8 +1195,8 @@ proc toTitle*(c: Rune): Rune {.rtl, extern: "nuc$1", procvar.} =
   return Rune(c)
 
 proc isLower*(c: Rune): bool {.rtl, extern: "nuc$1", procvar.} =
-  ## returns true iff `c` is a lower case Unicode character
-  ## If possible, prefer `isLower` over `isUpper`.
+  ## Returns true iff ``c`` is a lower case Unicode character.
+  ## If possible, prefer ``isLower`` over ``isUpper``.
   var c = RuneImpl(c)
   # Note: toUpperRanges is correct here!
   var p = binarySearch(c, toupperRanges, len(toupperRanges) div 3, 3)
@@ -1206,8 +1207,8 @@ proc isLower*(c: Rune): bool {.rtl, extern: "nuc$1", procvar.} =
     return true
 
 proc isUpper*(c: Rune): bool {.rtl, extern: "nuc$1", procvar.} =
-  ## returns true iff `c` is a upper case Unicode character
-  ## If possible, prefer `isLower` over `isUpper`.
+  ## Returns true iff ``c`` is a upper case Unicode character.
+  ## If possible, prefer ``isLower`` over ``isUpper``.
   var c = RuneImpl(c)
   # Note: toLowerRanges is correct here!
   var p = binarySearch(c, tolowerRanges, len(tolowerRanges) div 3, 3)
@@ -1218,7 +1219,7 @@ proc isUpper*(c: Rune): bool {.rtl, extern: "nuc$1", procvar.} =
     return true
 
 proc isAlpha*(c: Rune): bool {.rtl, extern: "nuc$1", procvar.} =
-  ## returns true iff `c` is an *alpha* Unicode character (i.e. a letter)
+  ## Returns true iff ``c`` is an *alpha* Unicode character (i.e., a letter)
   if isUpper(c) or isLower(c):
     return true
   var c = RuneImpl(c)
@@ -1230,17 +1231,18 @@ proc isAlpha*(c: Rune): bool {.rtl, extern: "nuc$1", procvar.} =
     return true
 
 proc isTitle*(c: Rune): bool {.rtl, extern: "nuc$1", procvar.} =
+  ## Returns true iff ``c`` is a Unicode titlecase character
   return isUpper(c) and isLower(c)
 
 proc isWhiteSpace*(c: Rune): bool {.rtl, extern: "nuc$1", procvar.} =
-  ## returns true iff `c` is a Unicode whitespace character
+  ## Returns true iff ``c`` is a Unicode whitespace character
   var c = RuneImpl(c)
   var p = binarySearch(c, spaceRanges, len(spaceRanges) div 2, 2)
   if p >= 0 and c >= spaceRanges[p] and c <= spaceRanges[p+1]:
     return true
 
 proc isCombining*(c: Rune): bool {.rtl, extern: "nuc$1", procvar.} =
-  ## returns true iff `c` is a Unicode combining character
+  ## Returns true iff ``c`` is a Unicode combining character
   var c = RuneImpl(c)
 
   # Optimized to return false immediately for ASCII
@@ -1251,7 +1253,7 @@ proc isCombining*(c: Rune): bool {.rtl, extern: "nuc$1", procvar.} =
     (c >= 0xfe20 and c <= 0xfe2f))
 
 iterator runes*(s: string): Rune =
-  ## iterates over any unicode character of the string `s`.
+  ## Iterates over any unicode character of the string ``s``
   var
     i = 0
     result: Rune
@@ -1259,8 +1261,14 @@ iterator runes*(s: string): Rune =
     fastRuneAt(s, i, result, true)
     yield result
 
+proc toRunes*(s: string): seq[Rune] =
+  ## Obtains a sequence containing the Runes in ``s``
+  result = newSeq[Rune]()
+  for r in s.runes:
+    result.add(r)
+
 proc cmpRunesIgnoreCase*(a, b: string): int {.rtl, extern: "nuc$1", procvar.} =
-  ## compares two UTF8 strings and ignores the case. Returns:
+  ## Compares two UTF-8 strings and ignores the case. Returns:
   ##
   ## | 0 iff a == b
   ## | < 0 iff a < b
@@ -1277,8 +1285,8 @@ proc cmpRunesIgnoreCase*(a, b: string): int {.rtl, extern: "nuc$1", procvar.} =
   result = a.len - b.len
 
 proc reversed*(s: string): string =
-  ## returns the reverse of `s`, interpreting it as unicode characters. Unicode
-  ## combining characters are correctly interpreted as well:
+  ## Returns the reverse of ``s``, interpreting it as Unicode characters. 
+  ## Unicode combining characters are correctly interpreted as well:
   ##
   ## .. code-block:: nim
   ##
@@ -1322,3 +1330,4 @@ when isMainModule:
   assert reversed("先秦兩漢") == "漢兩秦先"
   assert reversed("as⃝df̅") == "f̅ds⃝a"
   assert reversed("a⃞b⃞c⃞") == "c⃞b⃞a⃞"
+  assert len(toRunes("as⃝df̅")) == runeLen("as⃝df̅")
diff --git a/lib/system.nim b/lib/system.nim
index 1977c2203..e2d214ef0 100644
--- a/lib/system.nim
+++ b/lib/system.nim
@@ -389,9 +389,9 @@ type
     ## Each exception has to inherit from `Exception`. See the full `exception
     ## hierarchy`_.
     parent*: ref Exception ## parent exception (can be used as a stack)
-    name: cstring ## The exception's name is its Nim identifier.
-                  ## This field is filled automatically in the
-                  ## ``raise`` statement.
+    name*: cstring ## The exception's name is its Nim identifier.
+                   ## This field is filled automatically in the
+                   ## ``raise`` statement.
     msg* {.exportc: "message".}: string ## the exception's message. Not
                                         ## providing an exception message
                                         ## is bad style.
diff --git a/lib/wrappers/linenoise/linenoise.c b/lib/wrappers/linenoise/clinenoise.c
index c10557d0e..b4ae32472 100644
--- a/lib/wrappers/linenoise/linenoise.c
+++ b/lib/wrappers/linenoise/clinenoise.c
@@ -116,7 +116,7 @@
 #include <sys/types.h>
 #include <sys/ioctl.h>
 #include <unistd.h>
-#include "linenoise.h"
+#include "clinenoise.h"
 
 #define LINENOISE_DEFAULT_HISTORY_MAX_LEN 100
 #define LINENOISE_MAX_LINE 4096
diff --git a/lib/wrappers/linenoise/linenoise.h b/lib/wrappers/linenoise/clinenoise.h
index fbb01cfaa..fbb01cfaa 100644
--- a/lib/wrappers/linenoise/linenoise.h
+++ b/lib/wrappers/linenoise/clinenoise.h
diff --git a/lib/wrappers/linenoise/linenoise.nim b/lib/wrappers/linenoise/linenoise.nim
index a6260eb12..b7004c6e2 100644
--- a/lib/wrappers/linenoise/linenoise.nim
+++ b/lib/wrappers/linenoise/linenoise.nim
@@ -14,7 +14,7 @@ type
 
   CompletionCallback* = proc (a2: cstring; a3: ptr Completions) {.cdecl.}
 
-{.compile: "linenoise.c".}
+{.compile: "clinenoise.c".}
 
 proc setCompletionCallback*(a2: ptr CompletionCallback) {.
     importc: "linenoiseSetCompletionCallback".}
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2025-06-30 01:31:19 +0000