899 lines
21 KiB
Nim
899 lines
21 KiB
Nim
import jsony/objvar, std/json, std/options, std/parseutils, std/sets,
|
|
std/strutils, std/tables, std/typetraits, std/unicode
|
|
|
|
type JsonError* = object of ValueError
|
|
|
|
const whiteSpace = {' ', '\n', '\t', '\r'}
|
|
|
|
when defined(release):
|
|
{.push checks: off, inline.}
|
|
|
|
type
|
|
SomeTable*[K, V] = Table[K, V] | OrderedTable[K, V] |
|
|
TableRef[K, V] | OrderedTableRef[K, V]
|
|
RawJson* = distinct string
|
|
|
|
proc parseHook*[T](s: string, i: var int, v: var seq[T])
|
|
proc parseHook*[T: enum](s: string, i: var int, v: var T)
|
|
proc parseHook*[T: object|ref object](s: string, i: var int, v: var T)
|
|
proc parseHook*[T](s: string, i: var int, v: var SomeTable[string, T])
|
|
proc parseHook*[T](s: string, i: var int, v: var (SomeSet[T]|set[T]))
|
|
proc parseHook*[T: tuple](s: string, i: var int, v: var T)
|
|
proc parseHook*[T: array](s: string, i: var int, v: var T)
|
|
proc parseHook*[T: not object](s: string, i: var int, v: var ref T)
|
|
proc parseHook*(s: string, i: var int, v: var JsonNode)
|
|
proc parseHook*(s: string, i: var int, v: var char)
|
|
proc parseHook*[T: distinct](s: string, i: var int, v: var T)
|
|
|
|
template error(msg: string, i: int) =
|
|
## Shortcut to raise an exception.
|
|
raise newException(JsonError, msg & " At offset: " & $i)
|
|
|
|
template eatSpace*(s: string, i: var int) =
|
|
## Will consume whitespace.
|
|
while i < s.len:
|
|
let c = s[i]
|
|
if c notin whiteSpace:
|
|
break
|
|
inc i
|
|
|
|
template eatChar*(s: string, i: var int, c: char) =
|
|
## Will consume space before and then the character `c`.
|
|
## Will raise an exception if `c` is not found.
|
|
eatSpace(s, i)
|
|
if i >= s.len:
|
|
error("Expected " & c & " but end reached.", i)
|
|
if s[i] == c:
|
|
inc i
|
|
else:
|
|
error("Expected " & c & " but got " & s[i] & " instead.", i)
|
|
|
|
proc parseSymbol*(s: string, i: var int): string =
|
|
## Will read a symbol and return it.
|
|
## Used for numbers and booleans.
|
|
eatSpace(s, i)
|
|
var j = i
|
|
while i < s.len:
|
|
case s[i]
|
|
of ',', '}', ']', whiteSpace:
|
|
break
|
|
else:
|
|
discard
|
|
inc i
|
|
return s[j ..< i]
|
|
|
|
proc parseHook*(s: string, i: var int, v: var bool) =
|
|
## Will parse boolean true or false.
|
|
when nimvm:
|
|
case parseSymbol(s, i)
|
|
of "true":
|
|
v = true
|
|
of "false":
|
|
v = false
|
|
else:
|
|
error("Boolean true or false expected.", i)
|
|
else:
|
|
# Its faster to do char by char scan:
|
|
eatSpace(s, i)
|
|
if i + 3 < s.len and
|
|
s[i+0] == 't' and
|
|
s[i+1] == 'r' and
|
|
s[i+2] == 'u' and
|
|
s[i+3] == 'e':
|
|
i += 4
|
|
v = true
|
|
elif i + 4 < s.len and
|
|
s[i+0] == 'f' and
|
|
s[i+1] == 'a' and
|
|
s[i+2] == 'l' and
|
|
s[i+3] == 's' and
|
|
s[i+4] == 'e':
|
|
i += 5
|
|
v = false
|
|
else:
|
|
error("Boolean true or false expected.", i)
|
|
|
|
proc parseHook*(s: string, i: var int, v: var SomeUnsignedInt) =
|
|
## Will parse unsigned integers.
|
|
when nimvm:
|
|
v = type(v)(parseInt(parseSymbol(s, i)))
|
|
else:
|
|
eatSpace(s, i)
|
|
var
|
|
v2: uint64 = 0
|
|
startI = i
|
|
while i < s.len and s[i] in {'0'..'9'}:
|
|
v2 = v2 * 10 + (s[i].ord - '0'.ord).uint64
|
|
inc i
|
|
if startI == i:
|
|
error("Number expected.", i)
|
|
v = type(v)(v2)
|
|
|
|
proc parseHook*(s: string, i: var int, v: var SomeSignedInt) =
|
|
## Will parse signed integers.
|
|
when nimvm:
|
|
v = type(v)(parseInt(parseSymbol(s, i)))
|
|
else:
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == '+':
|
|
inc i
|
|
if i < s.len and s[i] == '-':
|
|
var v2: uint64
|
|
inc i
|
|
parseHook(s, i, v2)
|
|
v = -type(v)(v2)
|
|
else:
|
|
var v2: uint64
|
|
parseHook(s, i, v2)
|
|
try:
|
|
v = type(v)(v2)
|
|
except:
|
|
error("Number type to small to contain the number.", i)
|
|
|
|
proc parseHook*(s: string, i: var int, v: var SomeFloat) =
|
|
## Will parse float32 and float64.
|
|
var f: float
|
|
eatSpace(s, i)
|
|
let chars = parseutils.parseFloat(s, f, i)
|
|
if chars == 0:
|
|
error("Failed to parse a float.", i)
|
|
i += chars
|
|
v = f
|
|
|
|
proc parseUnicodeEscape(s: string, i: var int): int =
|
|
inc i
|
|
result = parseHexInt(s[i ..< i + 4])
|
|
i += 3
|
|
# Deal with UTF-16 surrogates. Most of the time strings are encoded as utf8
|
|
# but some APIs will reply with UTF-16 surrogate pairs which needs to be dealt
|
|
# with.
|
|
if (result and 0xfc00) == 0xd800:
|
|
inc i
|
|
if s[i] != '\\':
|
|
error("Found an Orphan Surrogate.", i)
|
|
inc i
|
|
if s[i] != 'u':
|
|
error("Found an Orphan Surrogate.", i)
|
|
inc i
|
|
let nextRune = parseHexInt(s[i ..< i + 4])
|
|
i += 3
|
|
if (nextRune and 0xfc00) == 0xdc00:
|
|
result = 0x10000 + (((result - 0xd800) shl 10) or (nextRune - 0xdc00))
|
|
|
|
proc parseStringSlow(s: string, i: var int, v: var string) =
|
|
while i < s.len:
|
|
let c = s[i]
|
|
case c
|
|
of '"':
|
|
break
|
|
of '\\':
|
|
inc i
|
|
let c = s[i]
|
|
case c
|
|
of '"', '\\', '/': v.add(c)
|
|
of 'b': v.add '\b'
|
|
of 'f': v.add '\f'
|
|
of 'n': v.add '\n'
|
|
of 'r': v.add '\r'
|
|
of 't': v.add '\t'
|
|
of 'u':
|
|
v.add(Rune(parseUnicodeEscape(s, i)).toUTF8())
|
|
else:
|
|
v.add(c)
|
|
else:
|
|
v.add(c)
|
|
inc i
|
|
eatChar(s, i, '"')
|
|
|
|
proc parseStringFast(s: string, i: var int, v: var string) =
|
|
# It appears to be faster to scan the string once, then allocate exact chars,
|
|
# and then scan the string again populating it.
|
|
var
|
|
j = i
|
|
ll = 0
|
|
while j < s.len:
|
|
let c = s[j]
|
|
case c
|
|
of '"':
|
|
break
|
|
of '\\':
|
|
inc j
|
|
let c = s[j]
|
|
case c
|
|
of 'u':
|
|
ll += Rune(parseUnicodeEscape(s, j)).toUTF8().len
|
|
else:
|
|
inc ll
|
|
else:
|
|
inc ll
|
|
inc j
|
|
|
|
if ll > 0:
|
|
v = newString(ll)
|
|
var
|
|
at = 0
|
|
ss = cast[ptr UncheckedArray[char]](v[0].addr)
|
|
template add(ss: ptr UncheckedArray[char], c: char) =
|
|
ss[at] = c
|
|
inc at
|
|
while i < s.len:
|
|
let c = s[i]
|
|
case c
|
|
of '"':
|
|
break
|
|
of '\\':
|
|
inc i
|
|
let c = s[i]
|
|
case c
|
|
of '"', '\\', '/': ss.add(c)
|
|
of 'b': ss.add '\b'
|
|
of 'f': ss.add '\f'
|
|
of 'n': ss.add '\n'
|
|
of 'r': ss.add '\r'
|
|
of 't': ss.add '\t'
|
|
of 'u':
|
|
for c in Rune(parseUnicodeEscape(s, i)).toUTF8():
|
|
ss.add(c)
|
|
else:
|
|
ss.add(c)
|
|
else:
|
|
ss.add(c)
|
|
inc i
|
|
|
|
eatChar(s, i, '"')
|
|
|
|
proc parseHook*(s: string, i: var int, v: var string) =
|
|
## Parse string.
|
|
eatSpace(s, i)
|
|
if i + 3 < s.len and
|
|
s[i+0] == 'n' and
|
|
s[i+1] == 'u' and
|
|
s[i+2] == 'l' and
|
|
s[i+3] == 'l':
|
|
i += 4
|
|
return
|
|
eatChar(s, i, '"')
|
|
|
|
when nimvm:
|
|
parseStringSlow(s, i, v)
|
|
else:
|
|
when defined(js):
|
|
parseStringSlow(s, i, v)
|
|
else:
|
|
parseStringFast(s, i, v)
|
|
|
|
proc parseHook*(s: string, i: var int, v: var char) =
|
|
var str: string
|
|
s.parseHook(i, str)
|
|
if str.len != 1:
|
|
error("String can't fit into a char.", i)
|
|
v = str[0]
|
|
|
|
proc parseHook*[T](s: string, i: var int, v: var seq[T]) =
|
|
## Parse seq.
|
|
eatChar(s, i, '[')
|
|
while i < s.len:
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == ']':
|
|
break
|
|
var element: T
|
|
parseHook(s, i, element)
|
|
v.add(element)
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == ',':
|
|
inc i
|
|
else:
|
|
break
|
|
eatChar(s, i, ']')
|
|
|
|
proc parseHook*[T: array](s: string, i: var int, v: var T) =
|
|
eatSpace(s, i)
|
|
eatChar(s, i, '[')
|
|
for value in v.mitems:
|
|
eatSpace(s, i)
|
|
parseHook(s, i, value)
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == ',':
|
|
inc i
|
|
eatChar(s, i, ']')
|
|
|
|
proc parseHook*[T: not object](s: string, i: var int, v: var ref T) =
|
|
eatSpace(s, i)
|
|
if i + 3 < s.len and
|
|
s[i+0] == 'n' and
|
|
s[i+1] == 'u' and
|
|
s[i+2] == 'l' and
|
|
s[i+3] == 'l':
|
|
i += 4
|
|
return
|
|
new(v)
|
|
parseHook(s, i, v[])
|
|
|
|
proc skipValue*(s: string, i: var int) =
|
|
## Used to skip values of extra fields.
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == '{':
|
|
eatChar(s, i, '{')
|
|
while i < s.len:
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == '}':
|
|
break
|
|
skipValue(s, i)
|
|
eatChar(s, i, ':')
|
|
skipValue(s, i)
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == ',':
|
|
inc i
|
|
eatChar(s, i, '}')
|
|
elif i < s.len and s[i] == '[':
|
|
eatChar(s, i, '[')
|
|
while i < s.len:
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == ']':
|
|
break
|
|
skipValue(s, i)
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == ',':
|
|
inc i
|
|
eatChar(s, i, ']')
|
|
elif i < s.len and s[i] == '"':
|
|
var str: string
|
|
parseHook(s, i, str)
|
|
else:
|
|
discard parseSymbol(s, i)
|
|
|
|
proc snakeCaseDynamic(s: string): string =
|
|
if s.len == 0:
|
|
return
|
|
var prevCap = false
|
|
for i, c in s:
|
|
if c in {'A'..'Z'}:
|
|
if result.len > 0 and result[result.len-1] != '_' and not prevCap:
|
|
result.add '_'
|
|
prevCap = true
|
|
result.add c.toLowerAscii()
|
|
else:
|
|
prevCap = false
|
|
result.add c
|
|
|
|
template snakeCase(s: string): string =
|
|
const k = snakeCaseDynamic(s)
|
|
k
|
|
|
|
proc parseObjectInner[T](s: string, i: var int, v: var T) =
|
|
while i < s.len:
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == '}':
|
|
break
|
|
var key: string
|
|
parseHook(s, i, key)
|
|
eatChar(s, i, ':')
|
|
when compiles(renameHook(v, key)):
|
|
renameHook(v, key)
|
|
block all:
|
|
for k, v in v.fieldPairs:
|
|
if k == key or snakeCase(k) == key:
|
|
var v2: type(v)
|
|
parseHook(s, i, v2)
|
|
v = v2
|
|
break all
|
|
skipValue(s, i)
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == ',':
|
|
inc i
|
|
else:
|
|
break
|
|
when compiles(postHook(v)):
|
|
postHook(v)
|
|
|
|
proc parseHook*[T: tuple](s: string, i: var int, v: var T) =
|
|
eatSpace(s, i)
|
|
when T.isNamedTuple():
|
|
if i < s.len and s[i] == '{':
|
|
eatChar(s, i, '{')
|
|
parseObjectInner(s, i, v)
|
|
eatChar(s, i, '}')
|
|
return
|
|
eatChar(s, i, '[')
|
|
for name, value in v.fieldPairs:
|
|
eatSpace(s, i)
|
|
parseHook(s, i, value)
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == ',':
|
|
inc i
|
|
eatChar(s, i, ']')
|
|
|
|
proc parseHook*[T: enum](s: string, i: var int, v: var T) =
|
|
eatSpace(s, i)
|
|
var strV: string
|
|
if i < s.len and s[i] == '"':
|
|
parseHook(s, i, strV)
|
|
when compiles(enumHook(strV, v)):
|
|
enumHook(strV, v)
|
|
else:
|
|
try:
|
|
v = parseEnum[T](strV)
|
|
except:
|
|
error("Can't parse enum.", i)
|
|
else:
|
|
try:
|
|
strV = parseSymbol(s, i)
|
|
v = T(parseInt(strV))
|
|
except:
|
|
error("Can't parse enum.", i)
|
|
|
|
proc parseHook*[T: object|ref object](s: string, i: var int, v: var T) =
|
|
## Parse an object or ref object.
|
|
eatSpace(s, i)
|
|
if i + 3 < s.len and
|
|
s[i+0] == 'n' and
|
|
s[i+1] == 'u' and
|
|
s[i+2] == 'l' and
|
|
s[i+3] == 'l':
|
|
i += 4
|
|
return
|
|
eatChar(s, i, '{')
|
|
when not v.isObjectVariant:
|
|
when compiles(newHook(v)):
|
|
newHook(v)
|
|
elif compiles(new(v)):
|
|
new(v)
|
|
else:
|
|
# Try looking for the discriminatorFieldName, then parse as normal object.
|
|
eatSpace(s, i)
|
|
var saveI = i
|
|
while i < s.len:
|
|
var key: string
|
|
parseHook(s, i, key)
|
|
eatChar(s, i, ':')
|
|
when compiles(renameHook(v, key)):
|
|
renameHook(v, key)
|
|
if key == v.discriminatorFieldName:
|
|
var discriminator: type(v.discriminatorField)
|
|
parseHook(s, i, discriminator)
|
|
new(v, discriminator)
|
|
when compiles(newHook(v)):
|
|
newHook(v)
|
|
break
|
|
skipValue(s, i)
|
|
if i < s.len and s[i] != '}':
|
|
eatChar(s, i, ',')
|
|
else:
|
|
when compiles(newHook(v)):
|
|
newHook(v)
|
|
elif compiles(new(v)):
|
|
new(v)
|
|
break
|
|
i = saveI
|
|
parseObjectInner(s, i, v)
|
|
eatChar(s, i, '}')
|
|
|
|
proc parseHook*[T](s: string, i: var int, v: var Option[T]) =
|
|
## Parse an Option.
|
|
eatSpace(s, i)
|
|
if i + 3 < s.len and
|
|
s[i+0] == 'n' and
|
|
s[i+1] == 'u' and
|
|
s[i+2] == 'l' and
|
|
s[i+3] == 'l':
|
|
i += 4
|
|
return
|
|
var e: T
|
|
parseHook(s, i, e)
|
|
v = some(e)
|
|
|
|
proc parseHook*[T](s: string, i: var int, v: var SomeTable[string, T]) =
|
|
## Parse an object.
|
|
when compiles(new(v)):
|
|
new(v)
|
|
eatChar(s, i, '{')
|
|
while i < s.len:
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == '}':
|
|
break
|
|
var key: string
|
|
parseHook(s, i, key)
|
|
eatChar(s, i, ':')
|
|
var element: T
|
|
parseHook(s, i, element)
|
|
v[key] = element
|
|
if i < s.len and s[i] == ',':
|
|
inc i
|
|
else:
|
|
break
|
|
eatChar(s, i, '}')
|
|
|
|
proc parseHook*[T](s: string, i: var int, v: var (SomeSet[T]|set[T])) =
|
|
## Parses `HashSet`, `OrderedSet`, or a built-in `set` type.
|
|
eatSpace(s, i)
|
|
eatChar(s, i, '[')
|
|
while true:
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == ']':
|
|
break
|
|
var e: T
|
|
parseHook(s, i, e)
|
|
v.incl(e)
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == ',':
|
|
inc i
|
|
eatChar(s, i, ']')
|
|
|
|
proc parseHook*(s: string, i: var int, v: var JsonNode) =
|
|
## Parses a regular json node.
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == '{':
|
|
v = newJObject()
|
|
eatChar(s, i, '{')
|
|
while i < s.len:
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == '}':
|
|
break
|
|
var k: string
|
|
parseHook(s, i, k)
|
|
eatChar(s, i, ':')
|
|
var e: JsonNode
|
|
parseHook(s, i, e)
|
|
v[k] = e
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == ',':
|
|
inc i
|
|
eatChar(s, i, '}')
|
|
elif i < s.len and s[i] == '[':
|
|
v = newJArray()
|
|
eatChar(s, i, '[')
|
|
while i < s.len:
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == ']':
|
|
break
|
|
var e: JsonNode
|
|
parseHook(s, i, e)
|
|
v.add(e)
|
|
eatSpace(s, i)
|
|
if i < s.len and s[i] == ',':
|
|
inc i
|
|
eatChar(s, i, ']')
|
|
elif i < s.len and s[i] == '"':
|
|
var str: string
|
|
parseHook(s, i, str)
|
|
v = newJString(str)
|
|
else:
|
|
var data = parseSymbol(s, i)
|
|
if data == "null":
|
|
v = newJNull()
|
|
elif data == "true":
|
|
v = newJBool(true)
|
|
elif data == "false":
|
|
v = newJBool(false)
|
|
elif data.len > 0 and data[0] in {'0'..'9', '-', '+'}:
|
|
try:
|
|
v = newJInt(parseInt(data))
|
|
except ValueError:
|
|
try:
|
|
v = newJFloat(parseFloat(data))
|
|
except ValueError:
|
|
error("Invalid number.", i)
|
|
else:
|
|
error("Unexpected.", i)
|
|
|
|
proc parseHook*[T: distinct](s: string, i: var int, v: var T) =
|
|
var x: T.distinctBase
|
|
parseHook(s, i, x)
|
|
v = cast[T](x)
|
|
|
|
proc fromJson*[T](s: string, x: typedesc[T]): T =
|
|
## Takes json and outputs the object it represents.
|
|
## * Extra json fields are ignored.
|
|
## * Missing json fields keep their default values.
|
|
## * `proc newHook(foo: var ...)` Can be used to populate default values.
|
|
var i = 0
|
|
s.parseHook(i, result)
|
|
|
|
proc fromJson*(s: string): JsonNode =
|
|
## Takes json parses it into `JsonNode`s.
|
|
var i = 0
|
|
s.parseHook(i, result)
|
|
|
|
proc dumpHook*(s: var string, v: bool)
|
|
proc dumpHook*(s: var string, v: uint|uint8|uint16|uint32|uint64)
|
|
proc dumpHook*(s: var string, v: int|int8|int16|int32|int64)
|
|
proc dumpHook*(s: var string, v: SomeFloat)
|
|
proc dumpHook*(s: var string, v: string)
|
|
proc dumpHook*(s: var string, v: char)
|
|
proc dumpHook*(s: var string, v: tuple)
|
|
proc dumpHook*(s: var string, v: enum)
|
|
type t[T] = tuple[a: string, b: T]
|
|
proc dumpHook*[N, T](s: var string, v: array[N, t[T]])
|
|
proc dumpHook*[N, T](s: var string, v: array[N, T])
|
|
proc dumpHook*[T](s: var string, v: seq[T])
|
|
proc dumpHook*(s: var string, v: object)
|
|
proc dumpHook*(s: var string, v: ref)
|
|
proc dumpHook*[T: distinct](s: var string, v: T)
|
|
|
|
proc dumpHook*[T: distinct](s: var string, v: T) =
|
|
var x = cast[T.distinctBase](v)
|
|
s.dumpHook(x)
|
|
|
|
proc dumpHook*(s: var string, v: bool) =
|
|
if v:
|
|
s.add "true"
|
|
else:
|
|
s.add "false"
|
|
|
|
const lookup = block:
|
|
## Generate 00, 01, 02 ... 99 pairs.
|
|
var s = ""
|
|
for i in 0 ..< 100:
|
|
if ($i).len == 1:
|
|
s.add("0")
|
|
s.add($i)
|
|
s
|
|
|
|
proc dumpNumberSlow(s: var string, v: uint|uint8|uint16|uint32|uint64) =
|
|
s.add $v.uint64
|
|
|
|
proc dumpNumberFast(s: var string, v: uint|uint8|uint16|uint32|uint64) =
|
|
# Its faster to not allocate a string for a number,
|
|
# but to write it out the digits directly.
|
|
if v == 0:
|
|
s.add '0'
|
|
return
|
|
# Max size of a uin64 number is 20 digits.
|
|
var digits: array[20, char]
|
|
var v = v
|
|
var p = 0
|
|
while v != 0:
|
|
# Its faster to look up 2 digits at a time, less int divisions.
|
|
let idx = v mod 100
|
|
digits[p] = lookup[idx*2+1]
|
|
inc p
|
|
digits[p] = lookup[idx*2]
|
|
inc p
|
|
v = v div 100
|
|
var at = s.len
|
|
if digits[p-1] == '0':
|
|
dec p
|
|
s.setLen(s.len + p)
|
|
dec p
|
|
while p >= 0:
|
|
s[at] = digits[p]
|
|
dec p
|
|
inc at
|
|
|
|
proc dumpHook*(s: var string, v: uint|uint8|uint16|uint32|uint64) =
|
|
when nimvm:
|
|
s.dumpNumberSlow(v)
|
|
else:
|
|
when defined(js):
|
|
s.dumpNumberSlow(v)
|
|
else:
|
|
s.dumpNumberFast(v)
|
|
|
|
proc dumpHook*(s: var string, v: int|int8|int16|int32|int64) =
|
|
if v < 0:
|
|
s.add '-'
|
|
dumpHook(s, 0.uint64 - v.uint64)
|
|
else:
|
|
dumpHook(s, v.uint64)
|
|
|
|
proc dumpHook*(s: var string, v: SomeFloat) =
|
|
s.add $v
|
|
|
|
proc dumpStrSlow(s: var string, v: string) =
|
|
s.add '"'
|
|
for c in v:
|
|
case c:
|
|
of '\\': s.add r"\\"
|
|
of '\b': s.add r"\b"
|
|
of '\f': s.add r"\f"
|
|
of '\n': s.add r"\n"
|
|
of '\r': s.add r"\r"
|
|
of '\t': s.add r"\t"
|
|
of '"': s.add r"\"""
|
|
else:
|
|
s.add c
|
|
s.add '"'
|
|
|
|
proc dumpStrFast(s: var string, v: string) =
|
|
# Its faster to grow the string only once.
|
|
# Then fill the string with pointers.
|
|
# Then cap it off to right length.
|
|
var at = s.len
|
|
s.setLen(s.len + v.len*2+2)
|
|
|
|
var ss = cast[ptr UncheckedArray[char]](s[0].addr)
|
|
template add(ss: ptr UncheckedArray[char], c: char) =
|
|
ss[at] = c
|
|
inc at
|
|
template add(ss: ptr UncheckedArray[char], c1, c2: char) =
|
|
ss[at] = c1
|
|
inc at
|
|
ss[at] = c2
|
|
inc at
|
|
|
|
ss.add '"'
|
|
for c in v:
|
|
case c:
|
|
of '\\': ss.add '\\', '\\'
|
|
of '\b': ss.add '\\', 'b'
|
|
of '\f': ss.add '\\', 'f'
|
|
of '\n': ss.add '\\', 'n'
|
|
of '\r': ss.add '\\', 'r'
|
|
of '\t': ss.add '\\', 't'
|
|
of '"': ss.add '\\', '"'
|
|
else:
|
|
ss.add c
|
|
ss.add '"'
|
|
s.setLen(at)
|
|
|
|
proc dumpHook*(s: var string, v: string) =
|
|
when nimvm:
|
|
s.dumpStrSlow(v)
|
|
else:
|
|
when defined(js):
|
|
s.dumpStrSlow(v)
|
|
else:
|
|
s.dumpStrFast(v)
|
|
|
|
template dumpKey(s: var string, v: string) =
|
|
const v2 = v.toJson() & ":"
|
|
s.add v2
|
|
|
|
proc dumpHook*(s: var string, v: char) =
|
|
s.add '"'
|
|
s.add v
|
|
s.add '"'
|
|
|
|
proc dumpHook*(s: var string, v: tuple) =
|
|
s.add '['
|
|
var i = 0
|
|
for _, e in v.fieldPairs:
|
|
if i > 0:
|
|
s.add ','
|
|
s.dumpHook(e)
|
|
inc i
|
|
s.add ']'
|
|
|
|
proc dumpHook*(s: var string, v: enum) =
|
|
s.dumpHook($v)
|
|
|
|
proc dumpHook*[N, T](s: var string, v: array[N, T]) =
|
|
s.add '['
|
|
var i = 0
|
|
for e in v:
|
|
if i != 0:
|
|
s.add ','
|
|
s.dumpHook(e)
|
|
inc i
|
|
s.add ']'
|
|
|
|
proc dumpHook*[T](s: var string, v: seq[T]) =
|
|
s.add '['
|
|
for i, e in v:
|
|
if i != 0:
|
|
s.add ','
|
|
s.dumpHook(e)
|
|
s.add ']'
|
|
|
|
proc dumpHook*[T](s: var string, v: Option[T]) =
|
|
if v.isNone:
|
|
s.add "null"
|
|
else:
|
|
s.dumpHook(v.get())
|
|
|
|
proc dumpHook*(s: var string, v: object) =
|
|
s.add '{'
|
|
var i = 0
|
|
when compiles(for k, e in v.pairs: discard):
|
|
# Tables and table like objects.
|
|
for k, e in v.pairs:
|
|
if i > 0:
|
|
s.add ','
|
|
s.dumpHook(k)
|
|
s.add ':'
|
|
s.dumpHook(e)
|
|
inc i
|
|
else:
|
|
# Normal objects.
|
|
for k, e in v.fieldPairs:
|
|
if i > 0:
|
|
s.add ','
|
|
s.dumpKey(k)
|
|
s.dumpHook(e)
|
|
inc i
|
|
s.add '}'
|
|
|
|
proc dumpHook*[N, T](s: var string, v: array[N, t[T]]) =
|
|
s.add '{'
|
|
var i = 0
|
|
# Normal objects.
|
|
for (k, e) in v:
|
|
if i > 0:
|
|
s.add ','
|
|
s.dumpHook(k)
|
|
s.add ':'
|
|
s.dumpHook(e)
|
|
inc i
|
|
s.add '}'
|
|
|
|
proc dumpHook*(s: var string, v: ref) =
|
|
if v == nil:
|
|
s.add "null"
|
|
else:
|
|
s.dumpHook(v[])
|
|
|
|
proc dumpHook*[T](s: var string, v: SomeSet[T]|set[T]) =
|
|
s.add '['
|
|
var i = 0
|
|
for e in v:
|
|
if i != 0:
|
|
s.add ','
|
|
s.dumpHook(e)
|
|
inc i
|
|
s.add ']'
|
|
|
|
proc dumpHook*(s: var string, v: JsonNode) =
|
|
## Dumps a regular json node.
|
|
if v == nil:
|
|
s.add "null"
|
|
else:
|
|
case v.kind:
|
|
of JObject:
|
|
s.add '{'
|
|
var i = 0
|
|
for k, e in v.pairs:
|
|
if i != 0:
|
|
s.add ","
|
|
s.dumpHook(k)
|
|
s.add ':'
|
|
s.dumpHook(e)
|
|
inc i
|
|
s.add '}'
|
|
of JArray:
|
|
s.add '['
|
|
var i = 0
|
|
for e in v:
|
|
if i != 0:
|
|
s.add ","
|
|
s.dumpHook(e)
|
|
inc i
|
|
s.add ']'
|
|
of JNull:
|
|
s.add "null"
|
|
of JInt:
|
|
s.dumpHook(v.getInt)
|
|
of JFloat:
|
|
s.dumpHook(v.getFloat)
|
|
of JString:
|
|
s.dumpHook(v.getStr)
|
|
of JBool:
|
|
s.dumpHook(v.getBool)
|
|
|
|
proc parseHook*(s: string, i: var int, v: var RawJson) =
|
|
let oldI = i
|
|
skipValue(s, i)
|
|
v = s[oldI ..< i].RawJson
|
|
|
|
proc dumpHook*(s: var string, v: RawJson) =
|
|
s.add v.string
|
|
|
|
proc toJson*[T](v: T): string =
|
|
dumpHook(result, v)
|
|
|
|
template toStaticJson*(v: untyped): static[string] =
|
|
## This will turn v into json at compile time and return the json string.
|
|
const s = v.toJson()
|
|
s
|
|
|
|
# A compiler bug prevents this from working. Otherwise toStaticJson and toJson
|
|
# can be same thing.
|
|
# TODO: Figure out the compiler bug.
|
|
# proc toJsonDynamic*[T](v: T): string =
|
|
# dumpHook(result, v)
|
|
# template toJson*[T](v: static[T]): string =
|
|
# ## This will turn v into json at compile time and return the json string.
|
|
# const s = v.toJsonDynamic()
|
|
# s
|
|
|
|
when defined(release):
|
|
{.pop.}
|