summary refs log tree commit diff stats
diff options
context:
space:
mode:
Diffstat
-rwxr-xr-xlib/pure/strutils.nim106
1 files changed, 53 insertions, 53 deletions
diff --git a/lib/pure/strutils.nim b/lib/pure/strutils.nim
index 9b4b09fae..9f7e01693 100755
--- a/lib/pure/strutils.nim
+++ b/lib/pure/strutils.nim
@@ -26,19 +26,19 @@ type
 const

   Whitespace* = {' ', '\t', '\v', '\r', '\l', '\f'}

     ## All the characters that count as whitespace.

-    

+

   Letters* = {'A'..'Z', 'a'..'z'}

     ## the set of letters

-  

+

   Digits* = {'0'..'9'}

     ## the set of digits

-  

+

   HexDigits* = {'0'..'9', 'A'..'F', 'a'..'f'}

     ## the set of hexadecimal digits

 

   IdentChars* = {'a'..'z', 'A'..'Z', '0'..'9', '_'}

     ## the set of characters an identifier can consist of

-  

+

   IdentStartChars* = {'a'..'z', 'A'..'Z', '_'}

     ## the set of characters an identifier can start with

 

@@ -192,7 +192,7 @@ proc addf*(s: var string, formatstr: string, a: openarray[string]) {.
       inc(i)

 

 proc `%` *(formatstr: string, a: openarray[string]): string {.noSideEffect,

-  rtl, extern: "nsuFormatOpenArray".} = 

+  rtl, extern: "nsuFormatOpenArray".} =

   ## The `substitution`:idx: operator performs string substitutions in

   ## `formatstr` and returns a modified `formatstr`. This is often called

   ## `string interpolation`:idx:.

@@ -233,7 +233,7 @@ proc `%` *(formatstr: string, a: openarray[string]): string {.noSideEffect,
   result = newStringOfCap(formatstr.len + a.len shl 4)

   addf(result, formatstr, a)

 

-proc `%` *(formatstr, a: string): string {.noSideEffect, 

+proc `%` *(formatstr, a: string): string {.noSideEffect,

   rtl, extern: "nsuFormatSingleElem".} =

   ## This is the same as ``formatstr % [a]``.

   result = newStringOfCap(formatstr.len + a.len)

@@ -249,7 +249,7 @@ proc strip*(s: string, leading = true, trailing = true): string {.noSideEffect,
   var

     first = 0

     last = len(s)-1

-  if leading: 

+  if leading:

     while s[first] in chars: inc(first)

   if trailing:

     while last >= 0 and s[last] in chars: dec(last)

@@ -337,7 +337,7 @@ iterator splitLines*(s: string): string =
   ## Example:

   ##

   ## .. code-block:: nimrod

-  ##   for line in lines("\nthis\nis\nan\n\nexample\n"):

+  ##   for line in splitLines("\nthis\nis\nan\n\nexample\n"):

   ##     writeln(stdout, line)

   ##

   ## Results in:

@@ -365,7 +365,7 @@ iterator splitLines*(s: string): string =
 

 proc splitLines*(s: string): seq[string] {.noSideEffect,

   rtl, extern: "nsuSplitLines".} =

-  ## The same as the `splitLines` iterator, but is a proc that returns a 

+  ## The same as the `splitLines` iterator, but is a proc that returns a

   ## sequence of substrings.

   accumulateResult(splitLines(s))

 

@@ -435,21 +435,21 @@ proc ParseHexInt*(s: string): int {.noSideEffect, procvar,
   rtl, extern: "nsuParseHexInt".} =

   ## Parses a hexadecimal integer value contained in `s`. If `s` is not

   ## a valid integer, `EInvalidValue` is raised. `s` can have one of the

-  ## following optional prefixes: ``0x``, ``0X``, ``#``. 

+  ## following optional prefixes: ``0x``, ``0X``, ``#``.

   ## Underscores within `s` are ignored.

   var i = 0

   if s[i] == '0' and (s[i+1] == 'x' or s[i+1] == 'X'): inc(i, 2)

   elif s[i] == '#': inc(i)

-  while true: 

+  while true:

     case s[i]

     of '_': inc(i)

-    of '0'..'9': 

+    of '0'..'9':

       result = result shl 4 or (ord(s[i]) - ord('0'))

       inc(i)

-    of 'a'..'f': 

+    of 'a'..'f':

       result = result shl 4 or (ord(s[i]) - ord('a') + 10)

       inc(i)

-    of 'A'..'F': 

+    of 'A'..'F':

       result = result shl 4 or (ord(s[i]) - ord('A') + 10)

       inc(i)

     of '\0': break

@@ -473,7 +473,7 @@ proc align*(s: string, count: int): string {.
   ## Aligns a string `s` with spaces, so that is of length `count`. Spaces are

   ## added before `s` resulting in right alignment. If ``s.len >= count``, no

   ## spaces are added and `s` is returned unchanged.

-  if s.len < count: 

+  if s.len < count:

     result = newString(count)

     var spaces = count - s.len

     for i in 0..spaces-1: result[i] = ' '

@@ -515,11 +515,11 @@ iterator tokenize*(s: string, seps: set[char] = Whitespace): tuple[
       break

     i = j

 

-proc wordWrap*(s: string, maxLineWidth = 80, 

+proc wordWrap*(s: string, maxLineWidth = 80,

                splitLongWords = true,

                seps: set[char] = whitespace,

                newLine = "\n"): string {.

-               noSideEffect, rtl, extern: "nsuWordWrap".} = 

+               noSideEffect, rtl, extern: "nsuWordWrap".} =

   ## word wraps `s`.

   result = newStringOfCap(s.len + s.len shr 6)

   var SpaceLeft = maxLineWidth

@@ -529,7 +529,7 @@ proc wordWrap*(s: string, maxLineWidth = 80,
         result.add(substr(word, 0, spaceLeft-1))

         var w = spaceLeft+1

         var wordLeft = len(word) - spaceLeft

-        while wordLeft > 0: 

+        while wordLeft > 0:

           result.add(newLine)

           var L = min(maxLineWidth, wordLeft)

           SpaceLeft = maxLineWidth - L

@@ -545,7 +545,7 @@ proc wordWrap*(s: string, maxLineWidth = 80,
       result.add(word)

 

 proc unindent*(s: string, eatAllIndent = false): string {.

-               noSideEffect, rtl, extern: "nsuUnindent".} = 

+               noSideEffect, rtl, extern: "nsuUnindent".} =

   ## unindents `s`.

   result = newStringOfCap(s.len)

   var i = 0

@@ -593,17 +593,17 @@ proc endsWith*(s, suffix: string): bool {.noSideEffect,
   if suffix[i] == '\0': return true

 

 proc addSep*(dest: var string, sep = ", ", startLen = 0) {.noSideEffect,

-                                                           inline.} = 

-  ## A shorthand for: 

-  ## 

+                                                           inline.} =

+  ## A shorthand for:

+  ##

   ## .. code-block:: nimrod

   ##   if dest.len > startLen: add(dest, sep)

-  ## 

+  ##

   ## This is often useful for generating some code where the items need to

   ## be *separated* by `sep`. `sep` is only added if `dest` is longer than

   ## `startLen`. The following example creates a string describing

-  ## an array of integers:  

-  ## 

+  ## an array of integers:

+  ##

   ## .. code-block:: nimrod

   ##   var arr = "["

   ##   for x in items([2, 3, 5, 7, 11]):

@@ -622,13 +622,13 @@ proc allCharsInSet*(s: string, theSet: TCharSet): bool =
 #    345

 

 when false:

-  proc abbrev(s: string, possibilities: openarray[string]): int = 

+  proc abbrev(s: string, possibilities: openarray[string]): int =

     ## returns the index of the first item in `possibilities` if not

     ## ambiguous; -1 if no item has been found; -2 if multiple items

     ## match.

     result = -1 # none found

-    for i in 0..possibilities.len-1: 

-      if possibilities[i].startsWith(s): 

+    for i in 0..possibilities.len-1:

+      if possibilities[i].startsWith(s):

         if result >= 0: return -2 # ambiguous

         result = i

 

@@ -648,7 +648,7 @@ proc join*(a: openArray[string], sep: string): string {.
       add(result, a[i])

   else:

     result = ""

-  

+

 proc join*(a: openArray[string]): string {.

   noSideEffect, rtl, extern: "nsuJoin".} =

   ## concatenates all strings in `a`.

@@ -706,7 +706,7 @@ proc find*(s: string, chars: set[char], start: int = 0): int {.noSideEffect,
   ## none of the characters in `chars`, -1 is returned.

   for i in start..s.len-1:

     if s[i] in chars: return i

-  return -1 

+  return -1

 

 proc quoteIfContainsWhite*(s: string): string =

   ## returns ``'"' & s & '"'`` if `s` contains a space and does not

@@ -775,10 +775,10 @@ proc ParseOctInt*(s: string): int {.noSideEffect,
   ## Underscores within `s` are ignored.

   var i = 0

   if s[i] == '0' and (s[i+1] == 'o' or s[i+1] == 'O'): inc(i, 2)

-  while true: 

+  while true:

     case s[i]

     of '_': inc(i)

-    of '0'..'7': 

+    of '0'..'7':

       result = result shl 3 or (ord(s[i]) - ord('0'))

       inc(i)

     of '\0': break

@@ -813,17 +813,17 @@ proc toBin*(x: BiggestInt, len: int): string {.noSideEffect,
     mask = mask shl 1

 

 proc insertSep*(s: string, sep = '_', digits = 3): string {.noSideEffect,

-  rtl, extern: "nsuInsertSep".} = 

+  rtl, extern: "nsuInsertSep".} =

   ## inserts the separator `sep` after `digits` digits from right to left.

-  ## Even though the algorithm works with any string `s`, it is only useful 

+  ## Even though the algorithm works with any string `s`, it is only useful

   ## if `s` contains a number.

-  ## Example: ``insertSep("1000000") == "1_000_000"`` 

+  ## Example: ``insertSep("1000000") == "1_000_000"``

   var L = (s.len-1) div digits + s.len

   result = newString(L)

   var j = 0

   dec(L)

-  for i in countdown(len(s)-1, 0): 

-    if j == digits: 

+  for i in countdown(len(s)-1, 0):

+    if j == digits:

       result[L] = sep

       dec(L)

       j = 0

@@ -854,9 +854,9 @@ proc escape*(s: string, prefix = "\"", suffix = "\""): string {.noSideEffect,
     of '\"': add(result, "\\\"")

     else: add(result, c)

   add(result, suffix)

-  

+

 proc validIdentifier*(s: string): bool {.noSideEffect,

-  rtl, extern: "nsuValidIdentifier".} = 

+  rtl, extern: "nsuValidIdentifier".} =

   ## returns true if `s` is a valid identifier. A valid identifier starts

   ## with a character of the set `IdentStartChars` and is followed by any

   ## number of characters of the set `IdentChars`.

@@ -864,7 +864,7 @@ proc validIdentifier*(s: string): bool {.noSideEffect,
     for i in 1..s.len-1:

       if s[i] notin IdentChars: return false

     return true

-  

+

 proc editDistance*(a, b: string): int {.noSideEffect,

   rtl, extern: "nsuEditDistance".} =

   ## returns the edit distance between `a` and `b`. This uses the Levenshtein

@@ -967,17 +967,17 @@ type
 

 proc formatBiggestFloat*(f: BiggestFloat, format: TFloatFormat = ffDefault,

                          precision = 16): string {.noSideEffect,

-                                                  rtl, extern: "nsu$1".} = 

-  ## converts a floating point value `f` to a string. 

+                                                  rtl, extern: "nsu$1".} =

+  ## converts a floating point value `f` to a string.

   ##

-  ## If ``format == ffDecimal`` then precision is the number of digits to 

+  ## If ``format == ffDecimal`` then precision is the number of digits to

   ## be printed after the decimal point.

-  ## If ``format == ffScientific`` then precision is the maximum number 

+  ## If ``format == ffScientific`` then precision is the maximum number

   ## of significant digits to be printed.

   ## `precision`'s default value is the maximum number of meaningful digits

-  ## after the decimal point for Nimrod's ``biggestFloat`` type. 

+  ## after the decimal point for Nimrod's ``biggestFloat`` type.

   const floatFormatToChar: array[TFloatFormat, char] = ['g', 'f', 'e']

-  var 

+  var

     frmtstr: array[0..5, char]

     buf: array[0..80, char]

   frmtstr[0] = '%'

@@ -988,7 +988,7 @@ proc formatBiggestFloat*(f: BiggestFloat, format: TFloatFormat = ffDefault,
     frmtstr[4] = floatFormatToChar[format]

     frmtstr[5] = '\0'

     c_sprintf(buf, frmtstr, precision, f)

-  else: 

+  else:

     frmtstr[2] = floatFormatToChar[format]

     frmtstr[3] = '\0'

     c_sprintf(buf, frmtstr, f)

@@ -996,15 +996,15 @@ proc formatBiggestFloat*(f: BiggestFloat, format: TFloatFormat = ffDefault,
 

 proc formatFloat*(f: float, format: TFloatFormat = ffDefault,

                   precision = 16): string {.noSideEffect,

-                                           rtl, extern: "nsu$1".} = 

-  ## converts a floating point value `f` to a string. 

+                                           rtl, extern: "nsu$1".} =

+  ## converts a floating point value `f` to a string.

   ##

-  ## If ``format == ffDecimal`` then precision is the number of digits to 

+  ## If ``format == ffDecimal`` then precision is the number of digits to

   ## be printed after the decimal point.

-  ## If ``format == ffScientific`` then precision is the maximum number 

+  ## If ``format == ffScientific`` then precision is the maximum number

   ## of significant digits to be printed.

   ## `precision`'s default value is the maximum number of meaningful digits

-  ## after the decimal point for Nimrod's ``float`` type. 

+  ## after the decimal point for Nimrod's ``float`` type.

   result = formatBiggestFloat(f, format, precision)

 

 {.pop.}

@@ -1017,6 +1017,6 @@ when isMainModule:
                    it goes""", 10, false)

   assert formatBiggestFloat(0.00000000001, ffDecimal, 11) == "0.00000000001"

   assert formatBiggestFloat(0.00000000001, ffScientific, 1) == "1.0e-11"

-  

+

   assert "$# $3 $# $#" % ["a", "b", "c"] == "a c b c"
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2025-03-06 17:31:19 +0000
lt'>
15
16
17
18
19
20
21
22

23

24
25

26
27
28

29
30
31

32

33

34

35

36

37

38
39

40
41
42

43

44

45
46

47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

71
72
73

74

75
76

77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

94

95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

110
111

112

113
114
115
116
117
118

119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

135
136

137
138
139
140
141
142
143
144
145
146

147

148
149
150
151
152
153
154
155
156
157

158

159
160
161
162
163
164
165
166
167
168

169

170
171

172
173
174