import "../yaml" import macros, strutils, streams, tables, json, hashes, typetraits export yaml, streams, tables, json type TagStyle* = enum tsNone, tsRootOnly, tsAll AnchorStyle* = enum asNone, asTidy, asAlways RefNodeData* = object p: pointer count: int anchor: AnchorId ConstructionContext* = ref object refs: Table[AnchorId, pointer] SerializationContext* = ref object refsList: seq[RefNodeData] style: AnchorStyle const yTagNimInt8* = 100.TagId yTagNimInt16* = 101.TagId yTagNimInt32* = 102.TagId yTagNimInt64* = 103.TagId yTagNimUInt8* = 104.TagId yTagNimUInt16* = 105.TagId yTagNimUInt32* = 106.TagId yTagNimUInt64* = 107.TagId yTagNimFloat32* = 108.TagId yTagNimFloat64* = 109.TagId yTagNimChar* = 110.TagId proc initRefNodeData(p: pointer): RefNodeData = result.p = p result.count = 1 result.anchor = yAnchorNone proc newConstructionContext(): ConstructionContext = new(result) result.refs = initTable[AnchorId, pointer]() proc newSerializationContext(s: AnchorStyle): SerializationContext = new(result) result.refsList = newSeq[RefNodeData]() result.style = s proc initSerializationTagLibrary(): TagLibrary {.raises: [].} = result = initTagLibrary() result.tags["!"] = yTagExclamationMark result.tags["?"] = yTagQuestionMark result.tags["tag:yaml.org,2002:str"] = yTagString result.tags["tag:yaml.org,2002:null"] = yTagNull result.tags["tag:yaml.org,2002:bool"] = yTagBoolean result.tags["tag:yaml.org,2002:float"] = yTagFloat result.tags["tag:yaml.org,2002:timestamp"] = yTagTimestamp result.tags["tag:yaml.org,2002:value"] = yTagValue result.tags["tag:yaml.org,2002:binary"] = yTagBinary result.tags["!nim:system:int8"] = yTagNimInt8 result.tags["!nim:system:int16"] = yTagNimInt16 result.tags["!nim:system:int32"] = yTagNimInt32 result.tags["!nim:system:int64"] = yTagNimInt64 result.tags["!nim:system:uint8"] = yTagNimUInt8 result.tags["!nim:system:uint16"] = yTagNimUInt16 result.tags["!nim:system:uint32"] = yTagNimUInt32 result.tags["!nim:system:uint64"] = yTagNimUInt64 result.tags["!nim:system:float32"] = yTagNimFloat32 result.tags["!nim:system:float64"] = yTagNimFloat64 result.tags["!nim:system:char"] = yTagNimChar var serializationTagLibrary* = initSerializationTagLibrary() ## \ ## contains all local tags that are used for type serialization. Does ## not contain any of the specific default tags for sequences or maps, ## as those are not suited for Nim's static type system. ## ## Should not be modified manually. Will be extended by ## `serializable <#serializable,stmt,stmt>`_. static: iterator objectFields(n: NimNode): tuple[name: NimNode, t: NimNode] {.raises: [].} = assert n.kind in [nnkRecList, nnkTupleTy] for identDefs in n.children: let numFields = identDefs.len - 2 for i in 0..numFields - 1: yield (name: identDefs[i], t: identDefs[^2]) var existingTuples = newSeq[NimNode]() template presentTag(t: typedesc, ts: TagStyle): TagId = if ts == tsNone: yTagQuestionMark else: yamlTag(t) proc lazyLoadTag*(uri: string): TagId {.inline, raises: [].} = try: result = serializationTagLibrary.tags[uri] except KeyError: result = serializationTagLibrary.registerUri(uri) macro serializable*(types: stmt): stmt = assert types.kind == nnkTypeSection result = newStmtList(types) for typedef in types.children: assert typedef.kind == nnkTypeDef let tName = $typedef[0].symbol tIdent = newIdentNode(tName) var tUri: NimNode recList: NimNode assert typedef[1].kind == nnkEmpty let objectTy = typedef[2] case objectTy.kind of nnkObjectTy: assert objectTy[0].kind == nnkEmpty assert objectTy[1].kind == nnkEmpty tUri = newStrLitNode("!nim:custom:" & tName) recList = objectTy[2] of nnkTupleTy: if objectTy in existingTuples: continue existingTuples.add(objectTy) recList = objectTy tUri = newStmtList() var first = true curStrLit = "!nim:tuple(" curInfix = tUri for field in objectFields(recList): if first: first = false else: curStrLit &= "," curStrLit &= $field.name & "=" var tmp = newNimNode(nnkInfix).add(newIdentNode("&"), newStrLitNode(curStrLit)) curInfix.add(tmp) curInfix = tmp tmp = newNimNode(nnkInfix).add(newIdentNode("&"), newCall("safeTagUri", newCall("yamlTag", newCall("type", field.t)))) curInfix.add(tmp) curInfix = tmp curStrLit = "" curInfix.add(newStrLitNode(curStrLit & ")")) tUri = tUri[0] else: assert false # yamlTag() var yamlTagProc = newProc(newIdentNode("yamlTag"), [ newIdentNode("TagId"), newIdentDefs(newIdentNode("T"), newNimNode(nnkBracketExpr).add( newIdentNode("typedesc"), tIdent))]) var impl = newStmtList(newCall("lazyLoadTag", tUri)) yamlTagProc[6] = impl result.add(yamlTagProc) # constructObject() var constructProc = newProc(newIdentNode("constructObject"), [ newEmptyNode(), newIdentDefs(newIdentNode("s"), newIdentNode("YamlStream")), newIdentDefs(newIdentNode("c"), newIdentNode("ConstructionContext")), newIdentDefs(newIdentNode("result"), newNimNode(nnkVarTy).add(tIdent))]) constructProc[4] = newNimNode(nnkPragma).add( newNimNode(nnkExprColonExpr).add(newIdentNode("raises"), newNimNode(nnkBracket).add( newIdentNode("YamlConstructionError"), newIdentNode("YamlConstructionStreamError")))) impl = quote do: var event = s() if finished(s) or event.kind != yamlStartMap: raise newException(YamlConstructionError, "Expected map start") if event.mapTag != yTagQuestionMark and event.mapTag != yamlTag(type(`tIdent`)): raise newException(YamlConstructionError, "Wrong tag for " & `tName`) event = s() assert(not finished(s)) while event.kind != yamlEndMap: assert event.kind == yamlScalar assert event.scalarTag in [yTagQuestionMark, yTagString] case event.scalarContent else: raise newException(YamlConstructionError, "Unknown key for " & `tName` & ": " & event.scalarContent) event = s() assert(not finished(s)) var keyCase = impl[5][1][2] assert keyCase.kind == nnkCaseStmt for field in objectFields(recList): keyCase.insert(1, newNimNode(nnkOfBranch).add( newStrLitNode($field.name.ident)).add(newStmtList( newCall("constructObject", [newIdentNode("s"), newIdentNode("c"), newDotExpr(newIdentNode("result"), field.name)]) )) ) constructProc[6] = impl result.add(constructProc) # serializeObject() var serializeProc = newProc(newIdentNode("serializeObject"), [ newIdentNode("YamlStream"), newIdentDefs(newIdentNode("value"), tIdent), newIdentDefs(newIdentNode("ts"), newIdentNode("TagStyle")), newIdentDefs(newIdentNode("c"), newIdentNode("SerializationContext"))]) serializeProc[4] = newNimNode(nnkPragma).add( newNimNode(nnkExprColonExpr).add(newIdentNode("raises"), newNimNode(nnkBracket))) var iterBody = newStmtList( newLetStmt(newIdentNode("childTagStyle"), newNimNode(nnkIfExpr).add( newNimNode(nnkElifExpr).add( newNimNode(nnkInfix).add(newIdentNode("=="), newIdentNode("ts"), newIdentNode("tsRootOnly")), newIdentNode("tsNone") ), newNimNode(nnkElseExpr).add(newIdentNode("ts")))), newNimNode(nnkYieldStmt).add( newNimNode(nnkObjConstr).add(newIdentNode("YamlStreamEvent"), newNimNode(nnkExprColonExpr).add(newIdentNode("kind"), newIdentNode("yamlStartMap")), newNimNode(nnkExprColonExpr).add(newIdentNode("mapTag"), newNimNode(nnkIfExpr).add(newNimNode(nnkElifExpr).add( newNimNode(nnkInfix).add(newIdentNode("=="), newIdentNode("ts"), newIdentNode("tsNone")), newIdentNode("yTagQuestionMark") ), newNimNode(nnkElseExpr).add( newCall("yamlTag", newCall("type", tIdent)) ))), newNimNode(nnkExprColonExpr).add(newIdentNode("mapAnchor"), newIdentNode("yAnchorNone")) ) ), newNimNode(nnkYieldStmt).add(newNimNode(nnkObjConstr).add( newIdentNode("YamlStreamEvent"), newNimNode(nnkExprColonExpr).add( newIdentNode("kind"), newIdentNode("yamlEndMap") ) ))) var i = 2 for field in objectFields(recList): let fieldIterIdent = newIdentNode($field.name & "Events") fieldNameString = newStrLitNode($field.name) iterbody.insert(i, quote do: yield YamlStreamEvent(kind: yamlScalar, scalarTag: presentTag(string, childTagStyle), scalarAnchor: yAnchorNone, scalarContent: `fieldNameString`) ) iterbody.insert(i + 1, newVarStmt(fieldIterIdent, newCall("serializeObject", newDotExpr(newIdentNode("value"), field.name), newIdentNode("childTagStyle"), newIdentNode("c")))) iterbody.insert(i + 2, quote do: for event in `fieldIterIdent`(): yield event ) i += 3 impl = newStmtList(newAssignment(newIdentNode("result"), newProc( newEmptyNode(), [newIdentNode("YamlStreamEvent")], iterBody, nnkIteratorDef))) serializeProc[6] = impl result.add(serializeProc) proc prepend(event: YamlStreamEvent, s: YamlStream): YamlStream {.raises: [].} = result = iterator(): YamlStreamEvent = yield event for e in s(): yield e proc safeTagUri*(id: TagId): string {.raises: [].} = try: let uri = serializationTagLibrary.uri(id) if uri.len > 0 and uri[0] == '!': return uri[1..uri.len - 1] else: return uri except KeyError: # cannot happen (theoretically, you known) assert(false) template constructScalarItem(item: YamlStreamEvent, name: string, t: TagId, content: stmt) = try: item = s() except YamlConstructionStreamError, AssertionError: raise except Exception: var e = newException(YamlConstructionStreamError, "") e.parent = getCurrentException() raise e if finished(s) or item.kind != yamlScalar: raise newException(YamlConstructionError, "Expected scalar") if item.scalarTag notin [yTagQuestionMark, yTagExclamationMark, t]: raise newException(YamlConstructionError, "Wrong tag for " & name) try: content except YamlConstructionError: raise except Exception: var e = newException(YamlConstructionError, "Cannot construct to " & name & ": " & item.scalarContent) e.parent = getCurrentException() raise e template safeNextEvent(e: YamlStreamEvent, s: YamlStream) = try: e = s() except YamlConstructionStreamError, AssertionError: raise except Exception: var ex = newException(YamlConstructionStreamError, "") ex.parent = getCurrentException() raise ex proc yamlTag*(T: typedesc[string]): TagId {.inline, raises: [].} = yTagString proc constructObject*(s: YamlStream, c: ConstructionContext, result: var string) {.raises: [YamlConstructionError, YamlConstructionStreamError].} = var item: YamlStreamEvent constructScalarItem(item, "string", yTagString): result = item.scalarContent proc serializeObject*(value: string, ts: TagStyle = tsNone, c: SerializationContext): YamlStream {.raises: [].} = result = iterator(): YamlStreamEvent = yield scalarEvent(value, presentTag(string, ts), yAnchorNone) proc yamlTag*(T: typedesc[int8]): TagId {.inline, raises: [].} = yTagNimInt8 proc yamlTag*(T: typedesc[int16]): TagId {.inline, raises: [].} = yTagNimInt16 proc yamlTag*(T: typedesc[int32]): TagId {.inline, raises: [].} = yTagNimInt32 proc yamlTag*(T: typedesc[int64]): TagId {.inline, raises: [].} = yTagNimInt64 proc constructObject*[T: int8|int16|int32|int64]( s: YamlStream, c: ConstructionContext, result: var T) {.raises: [YamlConstructionError, YamlConstructionStreamError].} = var item: YamlStreamEvent constructScalarItem(item, name(T), yamlTag(T)): result = T(parseBiggestInt(item.scalarContent)) template constructObject*(s: YamlStream, c: ConstructionContext, result: var int) = {.fatal: "The length of `int` is platform dependent. Use int[8|16|32|64].".} discard proc serializeObject*[T: int8|int16|int32|int64]( value: T, ts: TagStyle = tsNone, c: SerializationContext): YamlStream {.raises: [].} = result = iterator(): YamlStreamEvent = yield scalarEvent($value, presentTag(T, ts), yAnchorNone) template serializeObject*(value: int, tagStyle: TagStyle, c: SerializationContext) = {.fatal: "The length of `int` is platform dependent. Use int[8|16|32|64].".} discard proc yamlTag*(T: typedesc[uint8]): TagId {.inline, raises: [].} = yTagNimUInt8 proc yamlTag*(T: typedesc[uint16]): TagId {.inline, raises: [].} = yTagNimUInt16 proc yamlTag*(T: typedesc[uint32]): TagId {.inline, raises: [].} = yTagNimUInt32 proc yamlTag*(T: typedesc[uint64]): TagId {.inline, raises: [].} = yTagNimUInt64 {.push overflowChecks: on.} proc parseBiggestUInt(s: string): uint64 = result = 0 for c in s: if c in {'0'..'9'}: result *= 10.uint64 + (uint64(c) - uint64('0')) elif c == '_': discard else: raise newException(ValueError, "Invalid char in uint: " & c) {.pop.} proc constructObject*[T: uint8|uint16|uint32|uint64]( s: YamlStream, c: ConstructionContext, result: var T) {.raises: [YamlConstructionError, YamlConstructionStreamError].} = var item: YamlStreamEvent constructScalarItem(item, name[T], yamlTag(T)): result = T(parseBiggestUInt(item.scalarContent)) template constructObject*(s: YamlStream, c: ConstructionContext, result: var uint) = {.fatal: "The length of `uint` is platform dependent. Use uint[8|16|32|64].".} discard proc serializeObject*[T: uint8|uint16|uint32|uint64]( value: T, ts: TagStyle, c: SerializationContext): YamlStream {.raises: [].} = result = iterator(): YamlStreamEvent = yield scalarEvent($value, presentTag(T, ts), yAnchorNone) template serializeObject*(value: uint, ts: TagStyle, c: SerializationContext) = {.fatal: "The length of `uint` is platform dependent. Use uint[8|16|32|64].".} discard proc yamlTag*(T: typedesc[float32]): TagId {.inline, raises: [].} = yTagNimFloat32 proc yamlTag*(T: typedesc[float64]): TagId {.inline, raises: [].} = yTagNimFloat64 proc constructObject*[T: float32|float64]( s: YamlStream, c: ConstructionContext, result: var T) {.raises: [YamlConstructionError, YamlConstructionStreamError].} = var item: YamlStreamEvent constructScalarItem(item, name(T), yamlTag(T)): let hint = guessType(item.scalarContent) case hint of yTypeFloat: result = T(parseBiggestFloat(item.scalarContent)) of yTypeFloatInf: if item.scalarContent[0] == '-': result = NegInf else: result = Inf of yTypeFloatNaN: result = NaN else: raise newException(YamlConstructionError, "Cannot construct to float: " & item.scalarContent) template constructObject*(s: YamlStream, c: ConstructionContext, result: var float) = {.fatal: "The length of `float` is platform dependent. Use float[32|64].".} proc serializeObject*[T: float32|float64](value: T, ts: TagStyle, c: SerializationContext): YamlStream {.raises: [].} = result = iterator(): YamlStreamEvent = var asString: string case value of Inf: asString = ".inf" of NegInf: asString = "-.inf" of NaN: asString = ".nan" else: asString = $value yield scalarEvent(asString, presentTag(T, ts), yAnchorNone) template serializeObject*(value: float, tagStyle: TagStyle, c: SerializationContext) = {.fatal: "The length of `float` is platform dependent. Use float[32|64].".} proc yamlTag*(T: typedesc[bool]): TagId {.inline, raises: [].} = yTagBoolean proc constructObject*(s: YamlStream, c: ConstructionContext, result: var bool) {.raises: [YamlConstructionError, YamlConstructionStreamError].} = var item: YamlStreamEvent constructScalarItem(item, "bool", yTagBoolean): case guessType(item.scalarContent) of yTypeBoolTrue: result = true of yTypeBoolFalse: result = false else: raise newException(YamlConstructionError, "Cannot construct to bool: " & item.scalarContent) proc serializeObject*(value: bool, ts: TagStyle, c: SerializationContext): YamlStream {.raises: [].} = result = iterator(): YamlStreamEvent = yield scalarEvent(if value: "y" else: "n", presentTag(bool, ts), yAnchorNone) proc yamlTag*(T: typedesc[char]): TagId {.inline, raises: [].} = yTagNimChar proc constructObject*(s: YamlStream, c: ConstructionContext, result: var char) {.raises: [YamlConstructionError, YamlConstructionStreamError].} = var item: YamlStreamEvent constructScalarItem(item, "char", yTagNimChar): if item.scalarContent.len != 1: raise newException(YamlConstructionError, "Cannot construct to char (length != 1): " & item.scalarContent) else: result = item.scalarContent[0] proc serializeObject*(value: char, ts: TagStyle, c: SerializationContext): YamlStream {.raises: [].} = result = iterator(): YamlStreamEvent = yield scalarEvent("" & value, presentTag(char, ts), yAnchorNone) proc yamlTag*[I](T: typedesc[seq[I]]): TagId {.inline, raises: [].} = let uri = "!nim:system:seq(" & safeTagUri(yamlTag(I)) & ")" result = lazyLoadTag(uri) proc constructObject*[T](s: YamlStream, c: ConstructionContext, result: var seq[T]) {.raises: [YamlConstructionError, YamlConstructionStreamError].} = var event: YamlStreamEvent safeNextEvent(event, s) if finished(s) or event.kind != yamlStartSequence: raise newException(YamlConstructionError, "Expected sequence start") if event.seqTag notin [yTagQuestionMark, yamlTag(seq[T])]: raise newException(YamlConstructionError, "Wrong tag for seq[T]") result = newSeq[T]() safeNextEvent(event, s) assert(not finished(s)) while event.kind != yamlEndSequence: var item: T events = prepend(event, s) try: constructObject(events, c, item) except AssertionError, YamlConstructionError, YamlConstructionStreamError: raise except: # compiler bug: https://github.com/nim-lang/Nim/issues/3772 assert(false) result.add(item) safeNextEvent(event, s) assert(not finished(s)) proc serializeObject*[T](value: seq[T], ts: TagStyle, c: SerializationContext): YamlStream {.raises: [].} = result = iterator(): YamlStreamEvent = let childTagStyle = if ts == tsRootOnly: tsNone else: ts yield YamlStreamEvent(kind: yamlStartSequence, seqTag: presentTag(seq[T], ts), seqAnchor: yAnchorNone) for item in value: var events = serializeObject(item, childTagStyle, c) for event in events(): yield event yield YamlStreamEvent(kind: yamlEndSequence) proc yamlTag*[K, V](T: typedesc[Table[K, V]]): TagId {.inline, raises: [].} = try: let keyUri = serializationTagLibrary.uri(yamlTag(K)) valueUri = serializationTagLibrary.uri(yamlTag(V)) keyIdent = if keyUri[0] == '!': keyUri[1..keyUri.len - 1] else: keyUri valueIdent = if valueUri[0] == '!': valueUri[1..valueUri.len - 1] else: valueUri uri = "!nim:tables:Table(" & keyUri & "," & valueUri & ")" result = lazyLoadTag(uri) except KeyError: # cannot happen (theoretically, you known) assert(false) proc constructObject*[K, V](s: YamlStream, c: ConstructionContext, result: var Table[K, V]) {.raises: [YamlConstructionError, YamlConstructionStreamError].} = var event: YamlStreamEvent safeNextEvent(event, s) assert(not finished(s)) if event.kind != yamlStartMap: raise newException(YamlConstructionError, "Expected map start, got " & $event.kind) if event.mapTag notin [yTagQuestionMark, yamlTag(Table[K, V])]: raise newException(YamlConstructionError, "Wrong tag for Table[K, V]") result = initTable[K, V]() safeNextEvent(event, s) assert(not finished(s)) while event.kind != yamlEndMap: var key: K value: V events = prepend(event, s) try: constructObject(events, c, key) constructObject(s, c, value) except AssertionError: raise except Exception: # compiler bug: https://github.com/nim-lang/Nim/issues/3772 assert(false) result[key] = value safeNextEvent(event, s) assert(not finished(s)) proc serializeObject*[K, V](value: Table[K, V], ts: TagStyle, c: SerializationContext): YamlStream {.raises:[].} = result = iterator(): YamlStreamEvent = let childTagStyle = if ts == tsRootOnly: tsNone else: ts yield YamlStreamEvent(kind: yamlStartMap, mapTag: presentTag(Table[K, V], ts), mapAnchor: yAnchorNone) for key, value in value.pairs: var events = serializeObject(key, childTagStyle, c) for event in events(): yield event events = serializeObject(value, childTagStyle, c) for event in events(): yield event yield YamlStreamEvent(kind: yamlEndMap) template yamlTag*(T: typedesc[object]): expr = var uri = when compiles(yamlTagId(T)): yamlTagId(T) else: "!nim:custom:" & T.name try: serializationTagLibrary.tags[uri] except KeyError: serializationTagLibrary.registerUri(uri) template yamlTag*(T: typedesc[tuple]): expr = var i: T uri = "!nim:tuple(" first = true for name, value in fieldPairs(i): if first: first = false else: uri.add(",") uri.add(safeTagUri(yamlTag(type(value)))) uri.add(")") try: serializationTagLibrary.tags[uri] except KeyError: serializationTagLibrary.registerUri(uri) proc constructObject*[O: object|tuple](s: YamlStream, c: ConstructionContext, result: var O) {.raises: [YamlConstructionError, YamlConstructionStreamError].} = var e = s() assert(not finished(s)) if e.kind != yamlStartMap: raise newException(YamlConstructionError, "Expected map start, got " & $e.kind) if e.mapAnchor != yAnchorNone: raise newException(YamlConstructionError, "Anchor on a non-ref type") e = s() assert(not finished(s)) while e.kind != yamlEndMap: if e.kind != yamlScalar: raise newException(YamlConstructionError, "Expected field name") let name = e.scalarContent for fname, value in fieldPairs(result): if fname == name: constructObject(s, c, value) break e = s() assert(not finished(s)) proc serializeObject*[O: object|tuple](value: O, ts: TagStyle, c: SerializationContext): YamlStream {.raises: [].} = result = iterator(): YamlStreamEvent = let childTagStyle = if ts == tsRootOnly: tsNone else: ts yield startMapEvent(presentTag(O, ts), yAnchorNone) for name, value in fieldPairs(value): yield scalarEvent(name, presentTag(string, childTagStyle), yAnchorNone) var events = serializeObject(value, childTagStyle, c) for event in events(): yield event yield endMapEvent() proc yamlTag*[O](T: typedesc[ref O]): TagId {.inline, raises: [].} = yamlTag(O) proc constructObject*[O](s: YamlStream, c: ConstructionContext, result: var ref O) {.raises: [YamlConstructionError, YamlConstructionStreamError].} = var e = s() assert(not finished(s)) if e.kind == yamlScalar: if e.scalarTag == yTagNull or ( e.scalarTag in [yTagQuestionMark, yTagExclamationMark] and guessType(e.scalarContent) == yTypeNull): result = nil return elif e.kind == yamlAlias: try: result = cast[ref O](c.refs[e.aliasTarget]) return except KeyError: assert(false) new(result) var a: ptr AnchorId case e.kind of yamlScalar: a = addr(e.scalarAnchor) of yamlStartMap: a = addr(e.mapAnchor) of yamlStartSequence: a = addr(e.seqAnchor) else: assert(false) if a[] != yAnchorNone: assert(not c.refs.hasKey(a[])) c.refs[a[]] = cast[pointer](result) a[] = yAnchorNone try: constructObject(prepend(e, s), c, result[]) except YamlConstructionError, YamlConstructionStreamError, AssertionError: raise except Exception: var e = newException(YamlConstructionStreamError, getCurrentExceptionMsg()) e.parent = getCurrentException() raise e proc serializeObject*[O](value: ref O, ts: TagStyle, c: SerializationContext): YamlStream {.raises: [].} = if value == nil: result = iterator(): YamlStreamEvent = yield scalarEvent("~", yTagNull) elif c.style == asNone: result = serializeObject(value[], ts, c) else: let p = cast[pointer](value) for i in countup(0, c.refsList.high): if p == c.refsList[i].p: c.refsList[i].count.inc() result = iterator(): YamlStreamEvent = yield aliasEvent(if c.style == asAlways: AnchorId(i) else: cast[AnchorId](p)) return c.refsList.add(initRefNodeData(p)) let a = if c.style == asAlways: AnchorId(c.refsList.high) else: cast[AnchorId](p) try: var objStream = serializeObject(value[], ts, c) first = objStream() assert(not finished(objStream)) case first.kind of yamlStartMap: first.mapAnchor = a of yamlStartSequence: first.seqAnchor = a of yamlScalar: first.scalarAnchor = a else: assert(false) result = prepend(first, objStream) except Exception: assert(false) proc construct*[T](s: YamlStream, target: var T) {.raises: [YamlConstructionError, YamlConstructionStreamError].} = var context = newConstructionContext() try: var e = s() assert((not finished(s)) and e.kind == yamlStartDocument) constructObject(s, context, target) e = s() assert((not finished(s)) and e.kind == yamlEndDocument) except YamlConstructionError, YamlConstructionStreamError, AssertionError: raise except Exception: # may occur while calling s() var ex = newException(YamlConstructionStreamError, "") ex.parent = getCurrentException() raise ex proc load*[K](input: Stream, target: var K) {.raises: [YamlConstructionError, IOError, YamlParserError].} = var parser = newYamlParser(serializationTagLibrary) events = parser.parse(input) try: construct(events, target) except YamlConstructionError, AssertionError: raise except YamlConstructionStreamError: let e = (ref YamlConstructionStreamError)(getCurrentException()) if e.parent of IOError: raise (ref IOError)(e.parent) elif e.parent of YamlParserError: raise (ref YamlParserError)(e.parent) else: echo e.parent.repr assert(false) except Exception: # compiler bug: https://github.com/nim-lang/Nim/issues/3772 assert(false) proc setAnchor(a: var AnchorId, q: var seq[RefNodeData], n: var AnchorId) {.inline.} = if a != yAnchorNone: let p = cast[pointer](a) for i in countup(0, q.len - 1): if p == q[i].p: if q[i].count > 1: assert(q[i].anchor == yAnchorNone) q[i].anchor = n a = n n = AnchorId(int(n) + 1) else: a = yAnchorNone break proc setAliasAnchor(a: var AnchorId, q: var seq[RefNodeData]) {.inline.} = let p = cast[pointer](a) for i in countup(0, q.len - 1): if p == q[i].p: assert q[i].count > 1 assert q[i].anchor != yAnchorNone a = q[i].anchor return assert(false) proc insideDoc(s: YamlStream): YamlStream {.raises: [].} = result = iterator(): YamlStreamEvent = yield YamlStreamEvent(kind: yamlStartDocument) while true: var event: YamlStreamEvent try: event = s() if finished(s): break except AssertionError: raise except Exception: # serializing object does not raise any errors, so we can # ignore this assert(false) yield event yield YamlStreamEvent(kind: yamlEndDocument) proc serialize*[T](value: T, ts: TagStyle = tsRootOnly, a: AnchorStyle = asTidy): YamlStream {.raises: [].} = var context = newSerializationContext(a) objStream: YamlStream try: objStream = insideDoc(serializeObject(value, ts, context)) except Exception: assert(false) if a == asTidy: var objQueue = newSeq[YamlStreamEvent]() try: for event in objStream(): objQueue.add(event) except Exception: assert(false) var next = 0.AnchorId result = iterator(): YamlStreamEvent = for i in countup(0, objQueue.len - 1): var event = objQueue[i] case event.kind of yamlStartMap: event.mapAnchor.setAnchor(context.refsList, next) of yamlStartSequence: event.seqAnchor.setAnchor(context.refsList, next) of yamlScalar: event.scalarAnchor.setAnchor(context.refsList, next) of yamlAlias: event.aliasTarget.setAliasAnchor(context.refsList) else: discard yield event else: result = objStream proc dump*[K](value: K, target: Stream, style: PresentationStyle = psDefault, tagStyle: TagStyle = tsRootOnly, anchorStyle: AnchorStyle = asTidy, indentationStep: int = 2) {.raises: [YamlPresenterJsonError, YamlPresenterOutputError].} = var events = serialize(value, if style == psCanonical: tsAll else: tagStyle, if style == psJson: asNone else: anchorStyle) try: present(events, target, serializationTagLibrary, style, indentationStep) except YamlPresenterStreamError: # serializing object does not raise any errors, so we can ignore this var e = getCurrentException() echo e.msg echo e.parent.repr assert(false) except YamlPresenterJsonError, YamlPresenterOutputError, AssertionError: raise except Exception: # cannot occur as serialize() doesn't raise any errors assert(false)