1125 lines
40 KiB
Nim
1125 lines
40 KiB
Nim
# SPDX-FileCopyrightText: ☭ Emery Hemingway
|
|
# SPDX-License-Identifier: Unlicense
|
|
|
|
## This module implements Nim code generation from Preserves schemas.
|
|
# This module imports code that it generates! After making any changes here
|
|
# the schema module must be regenerated!
|
|
# nim c --path:../../../nim --path:.. -r ./preserves_schema_nim ../../../preserves/schema/schema.bin
|
|
|
|
import std/[hashes, sets, strutils, tables]
|
|
|
|
# Cannot use std/macros, must use compiler modules because
|
|
# we are generating code at run-time.
|
|
import compiler/[ast, idents, renderer, lineinfos]
|
|
|
|
import ../preserves, ./schema
|
|
|
|
type
|
|
Attribute = enum
|
|
embedded
|
|
## type contains an embedded value
|
|
Attributes = set[Attribute]
|
|
TypeSpec = object
|
|
node: PNode
|
|
attrs: Attributes
|
|
TypeTable = OrderedTable[schema.ModulePath, PNode]
|
|
Location = tuple[bundle: Bundle, schemaPath: ModulePath]
|
|
StringSet = HashSet[string]
|
|
|
|
proc schema(loc: Location): Schema = loc.bundle.modules[loc.schemaPath]
|
|
|
|
proc add(parent, child: PNode): PNode {.discardable.} =
|
|
parent.sons.add child
|
|
parent
|
|
|
|
proc add(parent: PNode; children: varargs[PNode]): PNode {.discardable.} =
|
|
parent.sons.add children
|
|
parent
|
|
|
|
proc ident(s: string): PNode =
|
|
newIdentNode(PIdent(s: s), TLineInfo())
|
|
|
|
proc accQuote(n: PNode): Pnode =
|
|
nkAccQuoted.newNode.add(n)
|
|
|
|
proc pattern(np: NamedPattern): Pattern =
|
|
case np.orKind
|
|
of NamedPatternKind.named:
|
|
Pattern(orKind: PatternKind.SimplePattern, simplePattern: np.named.pattern)
|
|
of NamedPatternKind.anonymous:
|
|
np.anonymous
|
|
|
|
proc pattern(np: NamedSimplePattern): SimplePattern =
|
|
case np.orKind
|
|
of NamedSimplePatternKind.named:
|
|
np.named.pattern
|
|
of NamedSimplePatternKind.anonymous:
|
|
np.anonymous
|
|
|
|
proc ident(sp: SimplePattern): PNode =
|
|
raiseAssert "need ident from " #& $sp
|
|
|
|
proc ident(cp: CompoundPattern; fallback: string): PNode =
|
|
case cp.orKind
|
|
of CompoundPatternKind.rec:
|
|
ident($cp.rec.label)
|
|
of CompoundPatternKind.tuple,
|
|
CompoundPatternKind.tuplePrefix,
|
|
CompoundPatternKind.dict:
|
|
ident(fallback)
|
|
|
|
proc ident(pat: Pattern; fallback = string): PNode =
|
|
case pat.orKind
|
|
of PatternKind.simplePattern:
|
|
ident(pat.simplePattern, fallback)
|
|
of PatternKind.compoundPattern:
|
|
ident(pat.compoundPattern, fallback)
|
|
|
|
proc ident(np: NamedPattern; fallback: string): PNode =
|
|
case np.orKind
|
|
of NamedPatternKind.named:
|
|
ident(string np.named.name)
|
|
of NamedPatternKind.anonymous:
|
|
ident(fallback)
|
|
|
|
proc ident(np: NamedSimplePattern; fallback: string): PNode =
|
|
case np.orKind
|
|
of NamedSimplePatternKind.named:
|
|
ident(string np.named.name)
|
|
of NamedSimplePatternKind.anonymous:
|
|
ident(fallback)
|
|
|
|
proc isEmbedded(ts: TypeSpec): bool =
|
|
embedded in ts.attrs
|
|
|
|
func isAtomic(r: Ref): bool =
|
|
case r.name.string
|
|
of "bool", "float", "double", "int", "string", "bytes", "symbol": true
|
|
else: false
|
|
|
|
proc addAttrs(x: var TypeSpec; y: TypeSpec) =
|
|
x.attrs = x.attrs + y.attrs
|
|
|
|
proc dotExtend(result: var PNode; label: string) =
|
|
var id = ident(label)
|
|
if result.isNil: result = id
|
|
else: result = nkDotExpr.newTree(result, id)
|
|
|
|
proc ident(`ref`: Ref): PNode =
|
|
for m in `ref`.module: dotExtend(result, string m)
|
|
if `ref`.isAtomic:
|
|
dotExtend(result, `ref`.name.string)
|
|
else:
|
|
dotExtend(result, `ref`.name.string.capitalizeAscii)
|
|
|
|
proc deref(loc: Location; r: Ref): (Location, Definition) =
|
|
try:
|
|
result[0] = loc
|
|
if r.module == @[]:
|
|
result[1] = loc.bundle.modules[loc.schemaPath].field0.definitions[r.name]
|
|
else:
|
|
result[0].schemaPath = r.module
|
|
result[1] = loc.bundle.modules[r.module].field0.definitions[r.name]
|
|
except KeyError:
|
|
raise newException(KeyError, "reference not found in bundle: " & $r)
|
|
|
|
proc hasEmbeddedType(scm: Schema): bool =
|
|
case scm.field0.embeddedType.orKind
|
|
of EmbeddedtypenameKind.false: false
|
|
of EmbeddedtypenameKind.Ref: true
|
|
|
|
proc parameterize(loc: Location; node: PNode; embeddable: bool): PNode = node
|
|
|
|
proc parameterize(loc: Location; spec: TypeSpec): PNode =
|
|
parameterize(loc, spec.node, spec.isEmbedded)
|
|
|
|
proc hash(r: Ref): Hash = r.toPreserves.hash
|
|
type RefSet = HashSet[Ref]
|
|
|
|
proc attrs(loc: Location; pat: Pattern; seen: RefSet): Attributes {.gcsafe.}
|
|
proc attrs(loc: Location; def: Definition; seen: RefSet): Attributes {.gcsafe.}
|
|
|
|
proc attrs(loc: Location; n: NamedAlternative|NamedPattern; seen: RefSet): Attributes =
|
|
attrs(loc, n.pattern, seen)
|
|
|
|
proc attrs(loc: Location; sp: SimplePattern; seen: RefSet): Attributes =
|
|
case sp.orKind
|
|
of SimplepatternKind.atom, SimplepatternKind.lit, SimplepatternKind.any: {}
|
|
of SimplepatternKind.embedded: {embedded}
|
|
of SimplepatternKind.seqof:
|
|
attrs(loc, sp.seqof.pattern, seen)
|
|
of SimplepatternKind.setof:
|
|
attrs(loc, sp.setof.pattern, seen)
|
|
of SimplepatternKind.dictof:
|
|
attrs(loc, sp.dictof.key, seen) + attrs(loc, sp.dictof.value, seen)
|
|
of SimplepatternKind.Ref:
|
|
if (sp.ref in seen) or sp.ref.isAtomic: {}
|
|
else:
|
|
var
|
|
(loc, def) = deref(loc, sp.ref)
|
|
seen = seen
|
|
incl(seen, sp.ref)
|
|
attrs(loc, def, seen)
|
|
|
|
proc attrs(loc: Location; np: NamedSimplePattern; seen: RefSet): Attributes =
|
|
case np.orKind
|
|
of NamedSimplePatternKind.named:
|
|
attrs(loc, np.named.pattern, seen)
|
|
of NamedSimplePatternKind.anonymous:
|
|
attrs(loc, np.anonymous, seen)
|
|
|
|
proc attrs(loc: Location; cp: CompoundPattern; seen: RefSet): Attributes =
|
|
case cp.orKind
|
|
of CompoundPatternKind.rec:
|
|
result =
|
|
attrs(loc, cp.rec.label.pattern, seen) +
|
|
attrs(loc, cp.rec.fields.pattern, seen)
|
|
of CompoundPatternKind.tuple:
|
|
for np in cp.tuple.patterns:
|
|
result = result + attrs(loc, np.pattern, seen)
|
|
of CompoundPatternKind.tupleprefix:
|
|
result = attrs(loc, cp.tupleprefix.variable, seen)
|
|
for p in cp.tupleprefix.fixed:
|
|
result = result + attrs(loc, p, seen)
|
|
of CompoundPatternKind.dict:
|
|
for nsp in cp.dict.entries.values:
|
|
result = result + attrs(loc, nsp, seen)
|
|
|
|
proc attrs(loc: Location; pat: Pattern; seen: RefSet): Attributes =
|
|
case pat.orKind
|
|
of PatternKind.SimplePattern:
|
|
attrs(loc, pat.simplePattern, seen)
|
|
of PatternKind.CompoundPattern:
|
|
attrs(loc, pat.compoundPattern, seen)
|
|
|
|
proc attrs(loc: Location; def: DefinitionOr|DefinitionAnd; seen: RefSet): Attributes =
|
|
result = attrs(loc, def.field0.pattern0, seen) + attrs(loc, def.field0.pattern1, seen)
|
|
for p in def.field0.patternN:
|
|
result = result + attrs(loc, p, seen)
|
|
|
|
proc attrs(loc: Location; def: Definition; seen: RefSet): Attributes =
|
|
case def.orKind
|
|
of DefinitionKind.or: result = attrs(loc, def.or, seen)
|
|
of DefinitionKind.and: result = attrs(loc, def.and, seen)
|
|
of DefinitionKind.Pattern:
|
|
result = attrs(loc, def.pattern, seen)
|
|
|
|
proc attrs(loc: Location; p: Definition|DefinitionOr|DefinitionAnd|Pattern|CompoundPattern|SimplePattern): Attributes =
|
|
var seen: RefSet
|
|
attrs(loc, p, seen)
|
|
|
|
proc isEmbedded(loc: Location; p: Definition|DefinitionOr|DefinitionAnd|Pattern|CompoundPattern|SimplePattern): bool =
|
|
embedded in attrs(loc, p)
|
|
|
|
proc isRecursive(loc: Location; name: string; pat: Pattern; seen: RefSet): bool {.gcsafe.}
|
|
|
|
proc isRecursive(loc: Location; name: string; def: Definition; seen: RefSet): bool {.gcsafe.}
|
|
|
|
proc isRecursive(loc: Location; name: string; n: NamedAlternative|NamedPattern; seen: RefSet): bool =
|
|
isRecursive(loc, name, n.pattern, seen)
|
|
|
|
proc isRecursive(loc: Location; name: string; sp: SimplePattern; seen: RefSet): bool =
|
|
case sp.orKind
|
|
of SimplepatternKind.embedded:
|
|
isRecursive(loc, name, sp.embedded.interface, seen)
|
|
of SimplepatternKind.Ref:
|
|
if sp.ref.name.string == name: true
|
|
elif sp.ref in seen: false
|
|
else:
|
|
var
|
|
(loc, def) = deref(loc, sp.ref)
|
|
seen = seen
|
|
incl(seen, sp.ref)
|
|
isRecursive(loc, name, def, seen)
|
|
else:
|
|
false
|
|
# seqof, setof, and dictof are not processed
|
|
# because they imply pointer indirection
|
|
|
|
proc isRecursive(loc: Location; name: string; np: NamedSimplePattern; seen: RefSet): bool =
|
|
case np.orKind
|
|
of NamedSimplePatternKind.named:
|
|
isRecursive(loc, name, np.named.pattern, seen)
|
|
of NamedSimplePatternKind.anonymous:
|
|
isRecursive(loc, name, np.anonymous, seen)
|
|
|
|
proc isRecursive(loc: Location; name: string; cp: CompoundPattern; seen: RefSet): bool =
|
|
case cp.orKind
|
|
of CompoundPatternKind.rec:
|
|
result =
|
|
isRecursive(loc, name, cp.rec.label.pattern, seen) or
|
|
isRecursive(loc, name, cp.rec.fields.pattern, seen)
|
|
of CompoundPatternKind.tuple:
|
|
for np in cp.tuple.patterns:
|
|
if result: return
|
|
result = isRecursive(loc, name, np.pattern, seen)
|
|
of CompoundPatternKind.tupleprefix:
|
|
result = isRecursive(loc, name, cp.tupleprefix.variable, seen)
|
|
for p in cp.tupleprefix.fixed:
|
|
if result: return
|
|
result = isRecursive(loc, name, p, seen)
|
|
of CompoundPatternKind.dict:
|
|
for nsp in cp.dict.entries.values:
|
|
if result: return
|
|
result = isRecursive(loc, name, nsp, seen)
|
|
|
|
proc isRecursive(loc: Location; name: string; pat: Pattern; seen: RefSet): bool =
|
|
case pat.orKind
|
|
of PatternKind.SimplePattern:
|
|
isRecursive(loc, name, pat.simplePattern, seen)
|
|
of PatternKind.CompoundPattern:
|
|
isRecursive(loc, name, pat.compoundPattern, seen)
|
|
|
|
proc isRecursive(loc: Location; name: string; def: DefinitionOr|DefinitionAnd; seen: RefSet): bool =
|
|
result =
|
|
isRecursive(loc, name, def.field0.pattern0, seen) or
|
|
isRecursive(loc, name, def.field0.pattern1, seen)
|
|
for p in def.field0.patternN:
|
|
if result: return
|
|
result = isRecursive(loc, name, p, seen)
|
|
|
|
proc isRecursive(loc: Location; name: string; def: Definition; seen: RefSet): bool =
|
|
case def.orKind
|
|
of DefinitionKind.or:
|
|
isRecursive(loc, name, def.or, seen)
|
|
of DefinitionKind.and:
|
|
isRecursive(loc, name, def.and, seen)
|
|
of DefinitionKind.Pattern:
|
|
isRecursive(loc, name, def.pattern, seen)
|
|
|
|
proc isRecursive(loc: Location; name: string; def: Definition): bool =
|
|
var seen: RefSet
|
|
isRecursive(loc, name, def, seen)
|
|
|
|
proc isLiteral(loc: Location; def: Definition): bool {.gcsafe.}
|
|
proc isLiteral(loc: Location; pat: Pattern): bool {.gcsafe.}
|
|
|
|
proc isLiteral(loc: Location; sp: SimplePattern): bool =
|
|
case sp.orKind
|
|
of SimplepatternKind.Ref:
|
|
if sp.ref.module.len == 0 and not sp.ref.isAtomic:
|
|
var (loc, def) = deref(loc, sp.ref)
|
|
result = isLiteral(loc, def)
|
|
of SimplepatternKind.lit:
|
|
result = true
|
|
else: discard
|
|
|
|
proc isLiteral(loc: Location; np: NamedPattern): bool =
|
|
case np.orKind
|
|
of NamedPatternKind.named:
|
|
isLiteral(loc, np.named.pattern)
|
|
of NamedPatternKind.anonymous:
|
|
isLiteral(loc, np.anonymous)
|
|
|
|
proc isLiteral(loc: Location; pat: Pattern): bool =
|
|
case pat.orKind
|
|
of PatternKind.SimplePattern:
|
|
isLiteral(loc, pat.simplePattern)
|
|
of PatternKind.CompoundPattern:
|
|
false # TODO it could be a compound of all literals
|
|
|
|
proc isLiteral(loc: Location; def: Definition): bool =
|
|
if def.orKind == DefinitionKind.Pattern:
|
|
result = isLiteral(loc, def.pattern)
|
|
|
|
proc isRef(sp: SimplePattern): bool =
|
|
sp.orKind == SimplePatternKind.Ref
|
|
|
|
proc isSimple(pat: Pattern): bool =
|
|
pat.orKind == PatternKind.SimplePattern
|
|
|
|
proc isLiteral(loc: Location; na: NamedAlternative): bool = isLiteral(loc, na.pattern)
|
|
|
|
proc isSymbolEnum(loc: Location; def: DefinitionOr): bool =
|
|
result = isLiteral(loc, def.field0.pattern0) and isLiteral(loc, def.field0.pattern1)
|
|
for na in def.field0.patternN:
|
|
if not result: break
|
|
result = isLiteral(loc, na)
|
|
|
|
proc isSymbolEnum(loc: Location; def: Definition): bool =
|
|
case def.orKind
|
|
of DefinitionKind.Pattern:
|
|
if def.pattern.orKind == PatternKind.SimplePattern and
|
|
def.pattern.simplePattern.orKind == SimplepatternKind.Ref:
|
|
var (loc, def) = deref(loc, def.pattern.simplePattern.ref)
|
|
result = isSymbolEnum(loc, def)
|
|
of DefinitionKind.or:
|
|
result = isSymbolEnum(loc, def.or)
|
|
else: discard
|
|
|
|
proc isSymbolEnum(loc: Location; sp: SimplePattern): bool =
|
|
# HashSet
|
|
if sp.orKind == SimplepatternKind.Ref:
|
|
var (loc, def) = deref(loc, sp.ref)
|
|
result = isSymbolEnum(loc, def)
|
|
else: discard
|
|
|
|
proc isDictionary(loc: Location; def: Definition): bool {.gcsafe.}
|
|
|
|
proc isDictionary(loc: Location; pat: Pattern): bool =
|
|
case pat.orKind
|
|
of PatternKind.SimplePattern:
|
|
case pat.simplePattern.orKind
|
|
of SimplePatternKind.Ref:
|
|
var (loc, def) = deref(loc, pat.simplePattern.ref)
|
|
result = isDictionary(loc, def)
|
|
of SimplePatternKind.dictof:
|
|
result = true
|
|
else: discard
|
|
of PatternKind.CompoundPattern:
|
|
case pat.compoundpattern.orKind
|
|
of CompoundPatternKind.dict:
|
|
result = true
|
|
else: discard
|
|
|
|
proc isDictionary(loc: Location; def: Definition): bool =
|
|
case def.orKind
|
|
of DefinitionKind.Pattern:
|
|
result = isDictionary(loc, def.pattern)
|
|
of DefinitionKind.or:
|
|
result =
|
|
isDictionary(loc, def.or.field0.pattern0.pattern) and
|
|
isDictionary(loc, def.or.field0.pattern1.pattern)
|
|
for np in def.or.field0.patternN:
|
|
if result: result = isDictionary(loc, np.pattern)
|
|
of DefinitionKind.and:
|
|
result =
|
|
isDictionary(loc, def.and.field0.pattern0.pattern) and
|
|
isDictionary(loc, def.and.field0.pattern1.pattern)
|
|
for np in def.and.field0.patternN:
|
|
if result: result = isDictionary(loc, np.pattern)
|
|
|
|
proc isAny(loc: Location; def: Definition): bool =
|
|
case def.orKind
|
|
of DefinitionKind.Pattern:
|
|
case def.pattern.orKind
|
|
of PatternKind.SimplePattern:
|
|
case def.pattern.simplePattern.orKind
|
|
of SimplePatternKind.Ref:
|
|
var (loc, def) = deref(loc, def.pattern.simplePattern.ref)
|
|
result = isAny(loc, def)
|
|
of SimplePatternKind.any:
|
|
result = true
|
|
else: discard
|
|
of PatternKind.CompoundPattern:
|
|
case def.pattern.compoundpattern.orKind
|
|
of CompoundPatternKind.rec:
|
|
result = not isLiteral(loc, def.pattern.compoundpattern.rec.label)
|
|
else: discard
|
|
else: discard
|
|
|
|
proc typeIdent(atom: AtomKind): PNode =
|
|
case atom
|
|
of AtomKind.Boolean: ident"bool"
|
|
of AtomKind.Double: ident"float"
|
|
of AtomKind.Signedinteger: ident"BiggestInt"
|
|
of AtomKind.String: ident"string"
|
|
of AtomKind.Bytestring: nkBracketExpr.newTree(ident"seq", ident"byte")
|
|
of AtomKind.Symbol: ident"Symbol"
|
|
|
|
proc typeIdent(loc: Location; sp: SimplePattern): TypeSpec =
|
|
case sp.orKind
|
|
of SimplepatternKind.atom:
|
|
result = TypeSpec(node: typeIdent(sp.atom.atomKind))
|
|
of SimplepatternKind.seqof:
|
|
result = typeIdent(loc, sp.seqof.pattern)
|
|
result.node = nkBracketExpr.newTree(ident"seq", result.node)
|
|
of SimplepatternKind.setof:
|
|
result = typeIdent(loc, sp.setof.pattern)
|
|
result.node =
|
|
if isSymbolEnum(loc, sp.setof.pattern):
|
|
nkBracketExpr.newTree(ident"set", result.node)
|
|
else:
|
|
nkBracketExpr.newTree(ident"HashSet", result.node)
|
|
of SimplepatternKind.dictof:
|
|
let
|
|
key = typeIdent(loc, sp.dictof.key)
|
|
val = typeIdent(loc, sp.dictof.value)
|
|
result.node = nkBracketExpr.newTree(ident"Table", key.node, val.node)
|
|
result.attrs = key.attrs + val.attrs
|
|
of SimplepatternKind.Ref:
|
|
result = TypeSpec(node: ident(sp.ref), attrs: attrs(loc, sp))
|
|
result.node = parameterize(loc, result)
|
|
of SimplepatternKind.embedded:
|
|
if loc.schema.hasEmbeddedType:
|
|
result = TypeSpec(node: ident"EmbeddedRef")
|
|
else:
|
|
result = TypeSpec(node: ident"Value")
|
|
incl(result.attrs, embedded)
|
|
of SimplepatternKind.any, SimplepatternKind.lit:
|
|
result = TypeSpec(node: ident"Value")
|
|
|
|
proc typeIdent(loc: Location; pat: Pattern): TypeSpec =
|
|
case pat.orKind
|
|
of PatternKind.SimplePattern: typeIdent(loc, pat.simplePattern)
|
|
else: raiseAssert "no typeIdent for " & $pat
|
|
|
|
proc toExport(n: sink PNode): PNode =
|
|
nkPostFix.newNode.add(ident"*", n)
|
|
|
|
proc toStrLit(loc: Location; sp: SimplePattern): PNode {.gcsafe.}
|
|
|
|
proc toStrLit(loc: Location; def: Definition): PNode =
|
|
if def.orKind == DefinitionKind.Pattern:
|
|
if def.pattern.orKind == PatternKind.SimplePattern:
|
|
return toStrLit(loc, def.pattern.simplepattern)
|
|
raiseAssert "not a string literal"
|
|
|
|
proc toStrLit(loc: Location; sp: SimplePattern): PNode =
|
|
case sp.orKind
|
|
of SimplePatternKind.lit:
|
|
result = PNode(kind: nkStrLit, strVal: $sp.lit.value)
|
|
of SimplePatternKind.Ref:
|
|
var (loc, def) = deref(loc, sp.ref)
|
|
result = toStrLit(loc, def)
|
|
of SimplePatternKind.embedded:
|
|
doAssert not loc.schema.hasEmbeddedType
|
|
result = PNode(kind: nkStrLit, strVal: "#:" & toStrLit(loc, sp.embedded.interface).strVal)
|
|
else: raiseAssert $sp
|
|
|
|
proc toFieldIdent(s: string): PNode =
|
|
nkPostFix.newTree(ident("*"), nkAccQuoted.newTree(ident(s)))
|
|
|
|
proc toFieldIdent(loc: Location, label: string; pat: Pattern): PNode =
|
|
result = label.toFieldIdent
|
|
if isLiteral(loc, pat):
|
|
result = nkPragmaExpr.newTree(
|
|
result,
|
|
nkPragma.newTree(
|
|
nkExprColonExpr.newTree(
|
|
ident"preservesLiteral",
|
|
toStrLit(loc, pat.simplePattern))))
|
|
|
|
proc newEmpty(): PNode = newNode(nkEmpty)
|
|
|
|
proc embeddingParams(loc: Location; embeddable: bool): PNode =
|
|
newEmpty()
|
|
|
|
proc identDef(scm: Schema; a, b: PNode; embeddable: bool): PNode =
|
|
nkIdentDefs.newTree(a, b, newEmpty())
|
|
|
|
proc identDef(scm: Schema; l: PNode; ts: TypeSpec): PNode =
|
|
identDef(scm, l, ts.node, ts.isEmbedded)
|
|
|
|
proc label(pat: Pattern): string =
|
|
raiseAssert "need to derive record label for " & $pat
|
|
|
|
proc label(na: NamedPattern; parentLabel: string; index: int): string =
|
|
case na.orKind
|
|
of NamedPatternKind.named:
|
|
string na.named.name
|
|
of NamedPatternKind.anonymous:
|
|
"field" & $index
|
|
|
|
proc label(nsp: NamedSimplePattern; parentLabel: string; index: int): string =
|
|
case nsp.orKind
|
|
of NamedSimplePatternKind.named:
|
|
string nsp.named.name
|
|
of NamedSimplePatternKind.anonymous:
|
|
parentLabel & $index
|
|
|
|
proc idStr(sp: SimplePattern): string =
|
|
if sp.orKind == SimplepatternKind.lit:
|
|
case sp.lit.value.kind
|
|
of pkString:
|
|
result = sp.lit.value.string
|
|
of pkSymbol:
|
|
result = string sp.lit.value.symbol
|
|
else: discard
|
|
doAssert(result != "", "no idStr for " & $sp)
|
|
|
|
proc idStr(pat: Pattern): string =
|
|
doAssert(pat.orKind == PatternKind.SimplePattern)
|
|
pat.simplePattern.idStr
|
|
|
|
proc idStr(np: NamedPattern): string =
|
|
case np.orKind
|
|
of NamedPatternKind.named:
|
|
string np.named.name
|
|
of NamedPatternKind.anonymous:
|
|
np.anonymous.idStr
|
|
|
|
proc typeDef(loc: Location; name: string; pat: SimplePattern; ty: PNode): PNode =
|
|
let id = name.ident.toExport
|
|
nkTypeDef.newTree(id, newEmpty(), ty)
|
|
|
|
proc typeDef(loc: Location; name: string; pat: Pattern; ty: PNode): PNode =
|
|
let
|
|
embedParams = embeddingParams(loc, isEmbedded(loc, pat))
|
|
id = name.ident.toExport
|
|
case pat.orKind
|
|
of PatternKind.CompoundPattern:
|
|
let pragma = newNode(nkPragma)
|
|
case pat.compoundPattern.orKind
|
|
of CompoundPatternKind.rec:
|
|
if isLiteral(loc, pat.compoundPattern.rec.label):
|
|
pragma.add(
|
|
nkExprColonExpr.newTree(
|
|
ident"preservesRecord",
|
|
PNode(kind: nkStrLit, strVal: pat.compoundPattern.rec.label.idStr)))
|
|
nkTypeDef.newTree(nkPragmaExpr.newTree(id, pragma), embedParams, ty)
|
|
elif pragma.len > 0:
|
|
nkTypeDef.newTree(nkPragmaExpr.newTree(id, pragma), embedParams, ty)
|
|
else:
|
|
nkTypeDef.newTree(id, embedParams, ty)
|
|
of CompoundPatternKind.tuple, CompoundPatternKind.tuplePrefix:
|
|
pragma.add(ident"preservesTuple")
|
|
nkTypeDef.newTree(nkPragmaExpr.newTree(id, pragma), embedParams, ty)
|
|
of CompoundPatternKind.dict:
|
|
pragma.add(ident"preservesDictionary")
|
|
nkTypeDef.newTree(nkPragmaExpr.newTree(id, pragma), embedParams, ty)
|
|
else:
|
|
nkTypeDef.newTree(id, embedParams, ty)
|
|
|
|
proc typeDef(loc: Location; name: string; def: Definition; ty: PNode): PNode =
|
|
case def.orKind
|
|
of DefinitionKind.or:
|
|
var ty = ty
|
|
let pragma = newNode(nkPragma)
|
|
if isRecursive(loc, name, def):
|
|
doAssert ty.kind == nkObjectTy
|
|
pragma.add(ident"acyclic")
|
|
ty = nkRefTy.newTree(ty)
|
|
pragma.add(ident"preservesOr")
|
|
if isSymbolEnum(loc, def):
|
|
pragma.add ident"pure"
|
|
nkTypeDef.newTree(
|
|
nkPragmaExpr.newTree(
|
|
name.ident.accQuote.toExport,
|
|
pragma),
|
|
embeddingParams(loc, isEmbedded(loc, def)),
|
|
ty)
|
|
of DefinitionKind.and:
|
|
var pragma = nkPragma.newNode
|
|
if isDictionary(loc, def):
|
|
pragma.add(ident"preservesDictionary")
|
|
nkTypeDef.newTree(
|
|
nkPragmaExpr.newTree(
|
|
name.ident.accQuote.toExport,
|
|
pragma),
|
|
embeddingParams(loc, isEmbedded(loc, def)),
|
|
ty)
|
|
of DefinitionKind.Pattern:
|
|
typeDef(loc, name, def.pattern, ty)
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; name: string; nsp: NamedSimplePattern): TypeSpec
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; name: string; pat: Pattern): TypeSpec
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; name: string; cp: CompoundPattern): TypeSpec
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; name: string; sp: SimplePattern): TypeSpec =
|
|
typeIdent(loc, sp)
|
|
|
|
proc addField(recList: PNode; loc: Location; known: var TypeTable; sp: SimplePattern; label: string): PNode {.discardable.} =
|
|
let
|
|
scm = loc.schema
|
|
id = label.toFieldIdent
|
|
if isLiteral(loc, sp):
|
|
let id = nkPragmaExpr.newTree(
|
|
id,
|
|
nkPragma.newTree(
|
|
nkExprColonExpr.newTree(
|
|
ident"preservesLiteral",
|
|
toStrLit(loc, sp))))
|
|
recList.add identDef(scm, id, TypeSpec(node: ident"tuple[]"))
|
|
elif sp.orKind == SimplePatternKind.embedded:
|
|
let id = nkPragmaExpr.newTree(
|
|
id, nkPragma.newTree(ident"preservesEmbedded"))
|
|
recList.add identDef(scm, id, nimTypeOf(loc, known, "", sp))
|
|
else:
|
|
recList.add identDef(scm, id, nimTypeOf(loc, known, "", sp))
|
|
|
|
proc addField(recList: PNode; loc: Location; known: var TypeTable; parentName: string; np: NamedPattern; index = 0) =
|
|
let
|
|
label = label(np, parentName, index)
|
|
id = label.toFieldIdent
|
|
pattern = np.pattern
|
|
if pattern.isSimple:
|
|
addField(recList, loc, known, pattern.simplePattern, label)
|
|
else:
|
|
var
|
|
typeName = parentName & capitalizeAscii(label)
|
|
typePath = loc.schemaPath & @[Symbol typeName]
|
|
fieldSpec = nimTypeOf(loc, known, label, pattern)
|
|
known[typePath] = typeDef(loc, typeName, pattern, fieldSpec.node)
|
|
recList.add identDef(loc.schema, id, ident(typeName), isEmbedded(loc, pattern))
|
|
|
|
proc addField(recList: PNode; loc: Location; known: var TypeTable; parentName: string; nsp: NamedSimplePattern; index: int; optional: bool) =
|
|
let
|
|
label = label(nsp, parentName, index)
|
|
id = label.toFieldIdent
|
|
pattern = nsp.pattern
|
|
if pattern.isRef:
|
|
var node = typeIdent(loc, pattern).node
|
|
if optional:
|
|
node = nkBracketExpr.newTree(ident"Option", node)
|
|
recList.add identDef(loc.schema, id, node, false)
|
|
else:
|
|
var
|
|
typeName = parentName & capitalizeAscii(label)
|
|
typePath = loc.schemaPath & @[Symbol typeName]
|
|
fieldSpec = nimTypeOf(loc, known, label, pattern)
|
|
if optional:
|
|
fieldSpec.node = nkBracketExpr.newTree(ident"Option", fieldSpec.node)
|
|
known[typePath] = typeDef(loc, typeName, pattern, fieldSpec.node)
|
|
recList.add identDef(loc.schema, id, fieldSpec.node, false)
|
|
|
|
proc addFields(recList: PNode; loc: Location; known: var TypeTable; parentName: string; cp: CompoundPattern): PNode {.discardable.} =
|
|
let scm = loc.schema
|
|
template addField(np: NamedPattern; index: int) =
|
|
let
|
|
label = label(np, parentName, index)
|
|
id = label.toFieldIdent
|
|
pattern = np.pattern
|
|
if pattern.isSimple:
|
|
addField(recList, loc, known, pattern.simplePattern, label)
|
|
else:
|
|
var
|
|
typeName = parentName & capitalizeAscii(label)
|
|
typePath = loc.schemaPath & @[Symbol typeName]
|
|
fieldSpec = nimTypeOf(loc, known, label, pattern)
|
|
known[typePath] = typeDef(loc, typeName, pattern, fieldSpec.node)
|
|
recList.add identDef(scm, id, ident(typeName), isEmbedded(loc, pattern))
|
|
case cp.orKind
|
|
of CompoundPatternKind.rec:
|
|
# recList.add identDef(scm, ident(label), nimTypeOf(loc, known, "", cp))
|
|
raiseassert "unexpected record of fields " #& $cp.rec
|
|
of CompoundPatternKind.tuple:
|
|
for i, np in cp.tuple.patterns: addField(np, i)
|
|
of CompoundPatternKind.tuplePrefix:
|
|
for i, np in cp.tuplePrefix.fixed: addField(np, i)
|
|
let variableType = nimTypeOf(loc, known, "", cp.tuplePrefix.variable)
|
|
recList.add identDef(
|
|
scm,
|
|
nkPragmaExpr.newTree(
|
|
ident(cp.tuplePrefix.variable, parentName).accQuote.toExport,
|
|
nkPragma.newTree(ident"preservesTupleTail")),
|
|
parameterize(loc, variableType),
|
|
variableType.isEmbedded)
|
|
of CompoundPatternKind.dict:
|
|
for nameVal, nsp in cp.dict.entries:
|
|
recList.addField(loc, known, $nameVal, nsp, 0, false)
|
|
reclist
|
|
|
|
proc addFields(recList: PNode; loc: Location; known: var TypeTable; name: string; pat: SimplePattern): PNode {.discardable.} =
|
|
addField(recList, loc, known, pat, name)
|
|
|
|
proc addFields(recList: PNode; loc: Location; known: var TypeTable; parentName: string; pat: Pattern): PNode {.discardable.} =
|
|
case pat.orKind
|
|
of PatternKind.SimplePattern:
|
|
discard addFields(recList, loc, known, parentName, pat.simplePattern)
|
|
of PatternKind.CompoundPattern:
|
|
discard addFields(recList, loc, known, parentName, pat.compoundPattern)
|
|
reclist
|
|
|
|
proc addFields(recList: PNode; loc: Location; known: var TypeTable; parentName: string; entries: DictionaryEntries): PNode {.discardable.} =
|
|
var sortedEntries =
|
|
initOrderedTable[Value, NamedSimplePattern](entries.len)
|
|
for key, val in entries.pairs:
|
|
sortedEntries[key] = val
|
|
sort(sortedEntries) do (x, y: (Value, NamedSimplePattern)) -> int:
|
|
cmp(x[0], y[0])
|
|
for key, val in sortedEntries.pairs:
|
|
doAssert(key.isSymbol)
|
|
let label = string key.symbol
|
|
addField(recList, loc, known, val.pattern, label)
|
|
recList
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; name: string; nsp: NamedSimplePattern): TypeSpec =
|
|
case nsp.orKind
|
|
of NamedsimplepatternKind.named:
|
|
nimTypeOf(loc, known, string nsp.named.name, nsp.named.pattern)
|
|
of NamedsimplepatternKind.anonymous:
|
|
nimTypeOf(loc, known, name, nsp.anonymous)
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; name: string; rec: CompoundPatternRec): TypeSpec =
|
|
if isLiteral(loc, rec.label):
|
|
result.node = nkObjectTy.newTree(
|
|
newEmpty(), newEmpty(),
|
|
newNode(nkRecList).addFields(loc, known, name, rec.fields.pattern))
|
|
else:
|
|
result.node = ident"Value"
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; name: string; cp: CompoundPattern): TypeSpec =
|
|
case cp.orKind
|
|
of CompoundPatternKind.`rec`:
|
|
result = nimTypeOf(loc, known, name, cp.rec)
|
|
of CompoundPatternKind.`tuple`, CompoundPatternKind.`tupleprefix`:
|
|
result.node = nkObjectTy.newTree(
|
|
newEmpty(), newEmpty(),
|
|
newNode(nkRecList).addFields(loc, known, name, cp))
|
|
of CompoundPatternKind.`dict`:
|
|
result.node = nkObjectTy.newTree(newEmpty(), newEmpty(),
|
|
newNode(nkRecList).addFields(loc, known, name, cp.dict.entries))
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; name: string; pat: Pattern): TypeSpec =
|
|
case pat.orKind
|
|
of PatternKind.SimplePattern:
|
|
nimTypeOf(loc, known, name, pat.simplePattern)
|
|
of PatternKind.CompoundPattern:
|
|
nimTypeOf(loc, known, name, pat.compoundPattern)
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; name: string; orDef: DefinitionOr): TypeSpec =
|
|
proc toEnumTy(): PNode =
|
|
let ty = nkEnumTy.newNode.add newEmpty()
|
|
proc add (na: NamedAlternative) =
|
|
ty.add na.variantLabel.ident.accQuote
|
|
add(orDef.field0.pattern0)
|
|
add(orDef.field0.pattern1)
|
|
for na in orDef.field0.patternN:
|
|
add(na)
|
|
ty
|
|
if isSymbolEnum(loc, orDef):
|
|
result.node = toEnumTy()
|
|
else:
|
|
let
|
|
enumName = name & "Kind"
|
|
enumPath = loc.schemaPath & @[Symbol enumName]
|
|
enumIdent = ident(enumName)
|
|
if enumPath notin known:
|
|
known[enumPath] = nkTypeDef.newTree(
|
|
nkPragmaExpr.newTree(
|
|
enumName.ident.toExport,
|
|
nkPragma.newTree(ident"pure")),
|
|
newEmpty(),
|
|
toEnumTy())
|
|
let recCase = nkRecCase.newNode.add(
|
|
nkIdentDefs.newNode.add(
|
|
"orKind".ident.toExport,
|
|
enumName.ident,
|
|
newEmpty()))
|
|
template addCase(na: NamedAlternative) =
|
|
let branchRecList = newNode(nkRecList)
|
|
var memberType: TypeSpec
|
|
if isLiteral(loc, na.pattern):
|
|
memberType.node = ident"bool"
|
|
elif na.pattern.isSimple:
|
|
memberType = typeIdent(loc, na.pattern)
|
|
else:
|
|
let
|
|
memberTypeName = name & na.variantLabel.capitalizeAscii
|
|
memberPath = loc.schemaPath & @[Symbol memberTypeName]
|
|
memberType.node = ident memberTypeName
|
|
let ty = nimTypeOf(loc, known, memberTypeName, na.pattern)
|
|
addAttrs(memberType, ty)
|
|
if memberPath notin known and not isLiteral(loc, na.pattern):
|
|
known[memberPath] =
|
|
typeDef(loc, memberTypeName, na.pattern, ty.node)
|
|
addAttrs(result, memberType)
|
|
memberType.node = parameterize(
|
|
loc, memberType.node, isEmbedded(loc, na.pattern))
|
|
var memberId = toFieldIdent(loc, na.variantLabel.normalize, na.pattern)
|
|
if isEmbedded(loc, na.pattern):
|
|
memberId = nkPragmaExpr.newTree(
|
|
memberId, nkPragma.newTree(ident"preservesEmbedded"))
|
|
branchRecList.add nkIdentDefs.newTree(
|
|
memberId,
|
|
memberType.node, newEmpty())
|
|
recCase.add nkOfBranch.newTree(
|
|
nkDotExpr.newTree(
|
|
enumIdent, na.variantLabel.ident.accQuote),
|
|
branchRecList)
|
|
addCase(orDef.field0.pattern0)
|
|
addCase(orDef.field0.pattern1)
|
|
for na in orDef.field0.patternN: addCase(na)
|
|
result.node = nkObjectTy.newTree(
|
|
newEmpty(),
|
|
newEmpty(),
|
|
nkRecList.newTree(recCase))
|
|
|
|
proc isAny(sp: SimplePattern): bool =
|
|
sp.orKind == SimplePatternKind.any
|
|
|
|
proc initSimpleAny: SimplePattern =
|
|
SimplePattern(orKind: SimplePatternKind.any)
|
|
|
|
proc asAny(nsp: NamedSimplePattern): NamedSimplePattern =
|
|
result = nsp
|
|
case result.orKind
|
|
of NamedSimplePatternKind.named:
|
|
if not result.named.pattern.isAny:
|
|
result.named.pattern = initSimpleAny()
|
|
of NamedSimplePatternKind.anonymous:
|
|
if not result.anonymous.isAny:
|
|
result.anonymous = initSimpleAny()
|
|
|
|
type
|
|
AndEntry = tuple[pattern: NamedSimplePattern, optional: bool]
|
|
AndEntries = OrderedTable[Value, AndEntry]
|
|
|
|
proc collect(entries: var AndEntries; loc: Location; def: Definition; optional: bool) {.gcsafe.}
|
|
|
|
proc collect(entries: var AndEntries; loc: Location; pat: SimplePattern; optional: bool) =
|
|
case pat.orKind
|
|
of SimplePatternKind.Ref:
|
|
let (loc, def) = deref(loc, pat.ref)
|
|
collect(entries, loc, def, optional)
|
|
else:
|
|
raiseAssert "cannot collect dictionary entries from " & $pat
|
|
|
|
proc collect(entries: var AndEntries; loc: Location; comp: CompoundPattern; optional: bool) =
|
|
case comp.orKind
|
|
of CompoundPatternKind.dict:
|
|
for key, nsp in comp.dict.entries.pairs:
|
|
if entries.hasKey(key):
|
|
entries[key] = (asAny nsp, optional)
|
|
else:
|
|
entries[key] = (nsp, optional)
|
|
else:
|
|
raiseAssert "cannot collect dictionary entries from " & $comp
|
|
|
|
proc collect(entries: var AndEntries; loc: Location; pat: Pattern; optional: bool) =
|
|
case pat.orKind
|
|
of PatternKind.SimplePattern:
|
|
collect(entries, loc, pat.simplepattern, optional)
|
|
of PatternKind.CompoundPattern:
|
|
collect(entries, loc, pat.compoundpattern, optional)
|
|
|
|
proc collect(entries: var AndEntries; loc: Location; def: Definition; optional: bool) =
|
|
case def.orKind
|
|
of DefinitionKind.or:
|
|
collect(entries, loc, def.or.field0.pattern0.pattern, true)
|
|
collect(entries, loc, def.or.field0.pattern1.pattern, true)
|
|
for np in def.or.field0.patternN:
|
|
collect(entries, loc, np.pattern, true)
|
|
of DefinitionKind.and:
|
|
collect(entries, loc, def.and.field0.pattern0.pattern, optional)
|
|
collect(entries, loc, def.and.field0.pattern1.pattern, optional)
|
|
for np in def.and.field0.patternN:
|
|
collect(entries, loc, np.pattern, optional)
|
|
of DefinitionKind.Pattern:
|
|
collect(entries, loc, def.pattern, optional)
|
|
|
|
proc toDef(a: DefinitionAnd): Definition =
|
|
Definition(orKind: DefinitionKind.and, `and`: a)
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; name: string; andDef: DefinitionAnd): TypeSpec =
|
|
var def = andDef.toDef
|
|
if isDictionary(loc, def):
|
|
var
|
|
recList = nkRecList.newNode
|
|
entries: AndEntries
|
|
collect(entries, loc, def, false)
|
|
sort(entries) do (x, y: (Value, AndEntry)) -> int:
|
|
preserves.cmp(x[0], y[0])
|
|
# TODO: sort the entries
|
|
var i = 0
|
|
for key, (nsp, opt) in entries.pairs:
|
|
recList.addField(loc, known, name, nsp, i, opt)
|
|
inc(i)
|
|
result.node = nkObjectTy.newTree(
|
|
newEmpty(), newEmpty(), recList)
|
|
else:
|
|
result.node = ident"Value"
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; name: string; def: Definition): TypeSpec =
|
|
case def.orKind
|
|
of DefinitionKind.or:
|
|
nimTypeOf(loc, known, name, def.or)
|
|
of DefinitionKind.and:
|
|
nimTypeOf(loc, known, name, def.and)
|
|
of DefinitionKind.Pattern:
|
|
nimTypeOf(loc, known, name, def.pattern)
|
|
|
|
proc generateConstProcs(result: var seq[PNode]; scm: Schema, name: string; def: Definition) =
|
|
discard
|
|
|
|
proc generateProcs(result: var seq[PNode]; scm: Schema; name: string; def: Definition) =
|
|
discard
|
|
|
|
proc collectRefImports(imports: var StringSet; loc: Location; pat: Pattern)
|
|
|
|
proc collectRefImports(imports: var StringSet; loc: Location; sp: SimplePattern) =
|
|
case sp.orKind
|
|
of SimplePatternKind.seqof:
|
|
collectRefImports(imports, loc, sp.seqof.pattern)
|
|
of SimplePatternKind.setof:
|
|
incl(imports, "std/sets")
|
|
collectRefImports(imports, loc, sp.setof.pattern)
|
|
of SimplePatternKind.dictof:
|
|
incl(imports, "std/tables")
|
|
collectRefImports(imports, loc, sp.dictof.key)
|
|
collectRefImports(imports, loc, sp.dictof.value)
|
|
of SimplePatternKind.Ref:
|
|
if sp.ref.module != @[] and sp.ref.module != loc.schemaPath:
|
|
incl(imports, string sp.ref.module[0])
|
|
else: discard
|
|
|
|
proc collectRefImports(imports: var StringSet; loc: Location; cp: CompoundPattern) =
|
|
case cp.orKind
|
|
of CompoundPatternKind.rec:
|
|
collectRefImports(imports, loc, cp.rec.label.pattern)
|
|
collectRefImports(imports, loc, cp.rec.fields.pattern)
|
|
of CompoundPatternKind.tuple:
|
|
for p in cp.tuple.patterns: collectRefImports(imports, loc, p.pattern)
|
|
of CompoundPatternKind.tupleprefix:
|
|
for np in cp.tupleprefix.fixed: collectRefImports(imports, loc, np.pattern)
|
|
collectRefImports(imports, loc, cp.tupleprefix.variable.pattern)
|
|
of CompoundPatternKind.dict:
|
|
for nsp in cp.dict.entries.values:
|
|
collectRefImports(imports, loc, nsp.pattern)
|
|
|
|
proc collectRefImports(imports: var StringSet; loc: Location; pat: Pattern) =
|
|
case pat.orKind
|
|
of PatternKind.SimplePattern:
|
|
collectRefImports(imports, loc, pat.simplePattern)
|
|
of PatternKind.CompoundPattern:
|
|
collectRefImports(imports, loc, pat.compoundPattern)
|
|
|
|
proc collectRefImports(imports: var StringSet; loc: Location; def: Definition) =
|
|
case def.orKind
|
|
of DefinitionKind.or:
|
|
collectRefImports(imports, loc, def.or.field0.pattern0.pattern)
|
|
collectRefImports(imports, loc, def.or.field0.pattern1.pattern)
|
|
for na in def.or.field0.patternN:
|
|
collectRefImports(imports, loc, na.pattern)
|
|
of DefinitionKind.and:
|
|
if isDictionary(loc, def):
|
|
incl(imports, "std/options")
|
|
collectRefImports(imports, loc, def.and.field0.pattern0.pattern)
|
|
collectRefImports(imports, loc, def.and.field0.pattern1.pattern)
|
|
for np in def.and.field0.patternN:
|
|
collectRefImports(imports, loc, np.pattern)
|
|
of DefinitionKind.Pattern:
|
|
collectRefImports(imports, loc, def.pattern)
|
|
|
|
proc collectRefImports(imports: var StringSet; loc: Location; scm: Schema) =
|
|
for _, def in scm.field0.definitions:
|
|
collectRefImports(imports, loc, def)
|
|
|
|
proc mergeType(x: var PNode; y: PNode) =
|
|
if x.isNil: x = y
|
|
else: x = nkInfix.newTree(ident"|", x, y)
|
|
|
|
proc hasPrefix(a, b: ModulePath): bool =
|
|
for i, e in b:
|
|
if i > a.high or a[i] != e: return false
|
|
true
|
|
|
|
proc renderNimBundle*(bundle: Bundle): Table[string, string] =
|
|
## Render Nim modules from a `Bundle`.
|
|
result = initTable[string, string](bundle.modules.len)
|
|
var typeDefs: TypeTable
|
|
for scmPath, scm in bundle.modules:
|
|
let loc = (bundle, scmPath)
|
|
var
|
|
typeSection = newNode nkTypeSection
|
|
procs: seq[PNode]
|
|
unembeddableType: PNode
|
|
for name, def in scm.field0.definitions.pairs:
|
|
if isLiteral(loc, def):
|
|
generateConstProcs(procs, scm, string name, def)
|
|
else:
|
|
var name = string name
|
|
name[0] = name[0].toUpperAscii
|
|
var defIdent = parameterize(loc, ident(name), isEmbedded(loc, def))
|
|
if not isSymbolEnum(loc, def) and not isAny(loc, def):
|
|
mergeType(unembeddableType, defIdent)
|
|
let typeSpec = nimTypeOf(loc, typeDefs, name, def)
|
|
typeDefs[scmPath & @[Symbol name]] = typeDef(loc, name, def, typeSpec.node)
|
|
generateProcs(procs, scm, name, def)
|
|
|
|
for typePath, typeDef in typeDefs.pairs:
|
|
if typepath.hasPrefix(scmPath):
|
|
add(typeSection, typeDef)
|
|
|
|
let imports = nkImportStmt.newNode.add(ident"preserves")
|
|
block:
|
|
var importSet: HashSet[string]
|
|
collectRefImports(importSet, loc, scm)
|
|
for module in importSet:
|
|
add(imports, ident(module))
|
|
if not unembeddableType.isNil:
|
|
procs.add nkProcDef.newTree(
|
|
"$".toFieldIdent,
|
|
newEmpty(),
|
|
newEmpty(),
|
|
nkFormalParams.newTree(
|
|
ident"string",
|
|
nkIdentDefs.newTree(
|
|
ident"x",
|
|
unembeddableType,
|
|
newEmpty())),
|
|
newEmpty(),
|
|
newEmpty(),
|
|
nkStmtList.newTree(
|
|
nkCall.newTree(ident"$",
|
|
nkCall.newTree(ident"toPreserves", ident"x"))))
|
|
procs.add nkProcDef.newTree(
|
|
"encode".ident.toExport,
|
|
newEmpty(),
|
|
newEmpty(),
|
|
nkFormalParams.newTree(
|
|
nkBracketExpr.newTree(ident"seq", ident"byte"),
|
|
nkIdentDefs.newTree(
|
|
ident"x",
|
|
unembeddableType,
|
|
newEmpty())),
|
|
newEmpty(),
|
|
newEmpty(),
|
|
nkStmtList.newTree(
|
|
nkCall.newTree(ident"encode", nkCall.newTree(
|
|
ident"toPreserves", ident"x"))))
|
|
var module = newNode(nkStmtList).add(
|
|
imports,
|
|
typeSection
|
|
).add(procs)
|
|
var filePath = ""
|
|
for p in scmPath:
|
|
if filePath != "": add(filePath, '/')
|
|
add(filePath, string p)
|
|
add(filePath, ".nim")
|
|
result[filePath] = renderTree(module, {renderIds, renderSyms, renderIr, renderNonExportedFields, renderExpandUsing})
|
|
# not sure what all these flags do
|
|
|
|
when isMainModule:
|
|
import ./schemaparse
|
|
|
|
proc writeModules(bundle: Bundle) =
|
|
let modules = renderNimBundle(bundle)
|
|
for path, txt in modules.pairs:
|
|
writeFile(path, txt)
|
|
stdout.writeLine(path)
|
|
|
|
import std/[os, parseopt]
|
|
var inputs: seq[string]
|
|
for kind, key, val in getopt():
|
|
case kind
|
|
of cmdLongOption:
|
|
case key
|
|
else: quit("unhandled option " & key)
|
|
of cmdShortOption:
|
|
case key
|
|
else: quit("unhandled option " & key)
|
|
of cmdArgument:
|
|
inputs.add absolutePath(key)
|
|
of cmdEnd: discard
|
|
for inputPath in inputs:
|
|
var bundle: Bundle
|
|
if dirExists inputPath:
|
|
for filePath in walkDirRec(inputPath, relative = true):
|
|
var (dirPath, fileName, fileExt) = splitFile(filePath)
|
|
if fileExt == ".prs":
|
|
var
|
|
scm = parsePreservesSchema(readFile(inputPath / filePath), inputPath / dirPath)
|
|
path: ModulePath
|
|
for e in split(dirPath, '/'):
|
|
add(path, Symbol e)
|
|
add(path, Symbol fileName)
|
|
bundle.modules[path] = scm
|
|
elif fileExists inputPath:
|
|
var (dirPath, fileName, _) = splitFile inputPath
|
|
let raw = readFile inputPath
|
|
if raw[0] == 0xb4.char:
|
|
var pr = decodePreserves raw
|
|
if not fromPreserves(bundle, pr):
|
|
var schema: Schema
|
|
if fromPreserves(schema, pr):
|
|
bundle.modules[@[Symbol fileName]] = schema
|
|
else:
|
|
var scm = parsePreservesSchema(readFile(inputPath), dirPath)
|
|
bundle.modules[@[Symbol fileName]] = scm
|
|
if bundle.modules.len == 0:
|
|
quit "Failed to recognize " & inputPath
|
|
else:
|
|
writeModules(bundle)
|