949 lines
33 KiB
Nim
949 lines
33 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, strutils, sets, tables]
|
|
|
|
# Cannot use std/macros, must uss compiler 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 and
|
|
## must take an parameter
|
|
recursive
|
|
## type is recursive and therefore must be a ref
|
|
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) =
|
|
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]
|
|
|
|
proc hasEmbeddedType(scm: Schema): bool =
|
|
case scm.field0.embeddedType.orKind
|
|
of EmbeddedtypenameKind.false: false
|
|
of EmbeddedtypenameKind.Ref: true
|
|
|
|
proc embeddedIdentString(scm: Schema): string =
|
|
case scm.field0.embeddedType.orKind
|
|
of EmbeddedtypenameKind.false:
|
|
"E"
|
|
of EmbeddedtypenameKind.Ref:
|
|
doAssert $scm.field0.embeddedType.ref.name != ""
|
|
$scm.field0.embeddedType.ref.name
|
|
|
|
proc embeddedIdent(scm: Schema): PNode =
|
|
ident(embeddedIdentString(scm))
|
|
|
|
proc preserveIdent(scm: Schema): Pnode =
|
|
if scm.hasEmbeddedType:
|
|
nkBracketExpr.newTree(ident"Preserve", embeddedIdent(scm))
|
|
else:
|
|
nkBracketExpr.newTree(ident"Preserve", ident"void")
|
|
|
|
proc parameterize(scm: Schema; node: PNode; embeddable: bool): PNode =
|
|
if embeddable and node.kind notin {nkBracketExpr}:
|
|
nkBracketExpr.newTree(node, scm.embeddedIdent)
|
|
else: node
|
|
|
|
proc parameterize(scm: Schema; spec: TypeSpec): PNode =
|
|
parameterize(scm, spec.node, spec.isEmbedded)
|
|
|
|
proc hash(r: Ref): Hash = r.toPreserve.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: {}
|
|
of SimplepatternKind.any, SimplepatternKind.embedded:
|
|
if loc.schema.hasEmbeddedType: {embedded}
|
|
else: {}
|
|
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: {recursive}
|
|
elif 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; orDef: DefinitionOr; seen: RefSet): Attributes =
|
|
result = attrs(loc, orDef.field0.pattern0, seen) + attrs(loc, orDef.field0.pattern1, seen)
|
|
for p in orDef.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.field0.pattern0, seen) +
|
|
attrs(loc, def.and.field0.pattern1, seen)
|
|
for p in def.and.field0.patternN:
|
|
result = result + attrs(loc, p, seen)
|
|
of DefinitionKind.Pattern:
|
|
result = attrs(loc, def.pattern, seen)
|
|
|
|
proc attrs(loc: Location; p: Definition|DefinitionOr|Pattern|CompoundPattern|SimplePattern): Attributes =
|
|
var seen: RefSet
|
|
attrs(loc, p, seen)
|
|
|
|
proc isEmbedded(loc: Location; p: Definition|DefinitionOr|Pattern|CompoundPattern): bool =
|
|
embedded in attrs(loc, p)
|
|
|
|
proc isRecursive(loc: Location; p: Definition|DefinitionOr|Pattern|CompoundPattern): bool =
|
|
recursive in attrs(loc, p)
|
|
|
|
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
|
|
of SimplepatternKind.embedded:
|
|
result = isLiteral(loc, sp.embedded.interface)
|
|
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 isRef(pat: Pattern): bool =
|
|
pat.orKind == PatternKind.SimplePattern and
|
|
pat.simplePattern.isRef
|
|
|
|
proc isSimple(pat: Pattern): bool =
|
|
pat.orKind == PatternKind.SimplePattern
|
|
|
|
proc isLiteral(loc: Location; na: NamedAlternative): bool = isLiteral(loc, na.pattern)
|
|
|
|
proc isSymbolEnum(loc: Location; orDef: DefinitionOr): bool =
|
|
result = isLiteral(loc, orDef.field0.pattern0) and isLiteral(loc, orDef.field0.pattern1)
|
|
for na in orDef.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 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
|
|
of DefinitionKind.and:
|
|
# not actually "any" but it will be a Preserve[E] type
|
|
result = true
|
|
else: discard
|
|
|
|
proc typeIdent(atom: AtomKind): PNode =
|
|
case atom
|
|
of AtomKind.Boolean: ident"bool"
|
|
of AtomKind.Float: ident"float32"
|
|
of AtomKind.Double: ident"float64"
|
|
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 =
|
|
let scm = loc.schema
|
|
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(scm, result)
|
|
of SimplepatternKind.embedded:
|
|
case scm.field0.embeddedType.orKind
|
|
of EmbeddedtypenameKind.false:
|
|
result = typeIdent(loc, sp.embedded.interface)
|
|
of EmbeddedtypenameKind.Ref:
|
|
result = TypeSpec(node: scm.embeddedIdent())
|
|
incl(result.attrs, embedded)
|
|
of SimplepatternKind.any, SimplepatternKind.lit:
|
|
result = TypeSpec(node: preserveIdent(scm))
|
|
|
|
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:
|
|
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(scm: Schema; embeddable: bool): PNode =
|
|
if embeddable:
|
|
nkGenericParams.newTree(nkIdentDefs.newTree(embeddedIdent(scm), newEmpty(), newEmpty()))
|
|
else:
|
|
newEmpty()
|
|
|
|
proc identDef(scm: Schema; a, b: PNode; embeddable: bool): PNode =
|
|
if embeddable and scm.hasEmbeddedType and b.kind notin {nkBracketExpr, nkTupleTy} and
|
|
(b.kind != nkIdent or b.ident.s != scm.embeddedIdentString):
|
|
nkIdentDefs.newTree(a, nkBracketExpr.newTree(b, embeddedIdent(scm)), newEmpty())
|
|
else:
|
|
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; index: int): string =
|
|
case na.orKind
|
|
of NamedPatternKind.named:
|
|
string na.named.name
|
|
of NamedPatternKind.anonymous:
|
|
"field" & $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: Pattern; ty: PNode): PNode =
|
|
let
|
|
scm = loc.schema
|
|
embedParams = embeddingParams(scm, isEmbedded(loc, pat))
|
|
id = name.ident.toExport
|
|
case pat.orKind
|
|
of PatternKind.CompoundPattern:
|
|
let pragma = newNode(nkPragma)
|
|
if isRecursive(loc, pat): pragma.add(ident"acyclic")
|
|
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:
|
|
let pragma = newNode(nkPragma)
|
|
if isRecursive(loc, def): pragma.add(ident"acyclic")
|
|
pragma.add(ident"preservesOr")
|
|
if isSymbolEnum(loc, def):
|
|
pragma.add ident"pure"
|
|
nkTypeDef.newTree(
|
|
nkPragmaExpr.newTree(
|
|
name.ident.accQuote.toExport,
|
|
pragma),
|
|
embeddingParams(loc.schema, isEmbedded(loc, def)),
|
|
ty)
|
|
of DefinitionKind.and:
|
|
nkTypeDef.newTree(
|
|
name.ident.toExport,
|
|
embeddingParams(loc.schema, isEmbedded(loc, def)),
|
|
preserveIdent(loc.schema))
|
|
of DefinitionKind.Pattern:
|
|
typeDef(loc, name, def.pattern, ty)
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; nsp: NamedSimplePattern; name = ""): TypeSpec
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; pat: Pattern; name = ""): TypeSpec
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; cp: CompoundPattern; name = ""): TypeSpec
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; sp: SimplePattern; name = ""): 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 and not scm.hasEmbeddedType:
|
|
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 addFields(recList: PNode; loc: Location; known: var TypeTable; cp: CompoundPattern; parentName: string): PNode {.discardable.} =
|
|
let scm = loc.schema
|
|
template addField(np: NamedPattern; index: int) =
|
|
let
|
|
label = label(np, index)
|
|
id = label.toFieldIdent
|
|
pattern = np.pattern
|
|
if pattern.isRef or pattern.isSimple:
|
|
addField(recList, loc, known, pattern.simplePattern, label)
|
|
else:
|
|
var
|
|
typeName = parentName & capitalizeAscii(label)
|
|
typePath = loc.schemaPath & @[Symbol typeName]
|
|
fieldSpec = nimTypeOf(loc, known, pattern, label)
|
|
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(scm, variableType),
|
|
variableType.isEmbedded)
|
|
else: raiseAssert "not adding fields for " #& $cp
|
|
reclist
|
|
|
|
proc addFields(recList: PNode; loc: Location; known: var TypeTable; pat: Pattern; parentName: string): PNode {.discardable.} =
|
|
case pat.orKind
|
|
of PatternKind.SimplePattern:
|
|
addField(recList, loc, known, pat.simplePattern, "field0")
|
|
of PatternKind.CompoundPattern:
|
|
discard addFields(recList, loc, known, pat.compoundPattern, parentName)
|
|
reclist
|
|
|
|
proc addFields(recList: PNode; loc: Location; known: var TypeTable; entries: DictionaryEntries; parentName: string): PNode {.discardable.} =
|
|
var sortedEntries =
|
|
initOrderedTable[Preserve[void], NamedSimplePattern](entries.len)
|
|
for key, val in entries.pairs:
|
|
sortedEntries[key] = val
|
|
sort(sortedEntries) do (x, y: (Preserve[void], 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; nsp: NamedSimplePattern; name: string): TypeSpec =
|
|
case nsp.orKind
|
|
of NamedsimplepatternKind.named:
|
|
nimTypeOf(loc, known, nsp.named.pattern, string nsp.named.name)
|
|
of NamedsimplepatternKind.anonymous:
|
|
nimTypeOf(loc, known, nsp.anonymous, name)
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; rec: CompoundPatternRec; name: string): TypeSpec =
|
|
if isLiteral(loc, rec.label):
|
|
result.node = nkObjectTy.newTree(
|
|
newEmpty(), newEmpty(),
|
|
newNode(nkRecList).addFields(loc, known, rec.fields.pattern, name))
|
|
else:
|
|
result.node = preserveIdent(loc.schema)
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; cp: CompoundPattern; name: string): TypeSpec =
|
|
case cp.orKind
|
|
of CompoundPatternKind.`rec`:
|
|
result = nimTypeOf(loc, known, cp.rec, name)
|
|
of CompoundPatternKind.`tuple`, CompoundPatternKind.`tupleprefix`:
|
|
result.node = nkObjectTy.newTree(
|
|
newEmpty(), newEmpty(),
|
|
newNode(nkRecList).addFields(loc, known, cp, name))
|
|
of CompoundPatternKind.`dict`:
|
|
result.node = nkObjectTy.newTree(newEmpty(), newEmpty(),
|
|
newNode(nkRecList).addFields(loc, known, cp.dict.entries, name))
|
|
if result.node.kind == nkObjectTy and isRecursive(loc, cp):
|
|
result.node = nkRefTy.newTree(result.node)
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; pat: Pattern; name: string): TypeSpec =
|
|
case pat.orKind
|
|
of PatternKind.SimplePattern:
|
|
nimTypeOf(loc, known, pat.simplePattern, name)
|
|
of PatternKind.CompoundPattern:
|
|
nimTypeOf(loc, known, pat.compoundPattern, name)
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; orDef: DefinitionOr; name: string): TypeSpec =
|
|
let scm = loc.schema
|
|
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.isRef:
|
|
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, na.pattern, memberTypeName)
|
|
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(
|
|
scm, memberType.node, isEmbedded(loc, na.pattern))
|
|
branchRecList.add nkIdentDefs.newTree(
|
|
toFieldIdent(loc, na.variantLabel.normalize, na.pattern),
|
|
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))
|
|
# result.attrs = attrs(loc, orDef)
|
|
if result.node.kind == nkObjectTy and (recursive in attrs(loc, orDef)):
|
|
result.node = nkRefTy.newTree(result.node)
|
|
|
|
proc nimTypeOf(loc: Location; known: var TypeTable; def: Definition; name: string): TypeSpec =
|
|
case def.orKind
|
|
of DefinitionKind.or:
|
|
nimTypeOf(loc, known, def.or, name)
|
|
of DefinitionKind.and:
|
|
TypeSpec(node: preserveIdent(loc.schema))
|
|
of DefinitionKind.Pattern:
|
|
nimTypeOf(loc, known, def.pattern, name)
|
|
|
|
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.setof:
|
|
incl(imports, "std/sets")
|
|
of SimplePatternKind.dictof:
|
|
incl(imports, "std/tables")
|
|
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:
|
|
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, embeddableType: 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(scm, ident(name), isEmbedded(loc, def))
|
|
if not isSymbolEnum(loc, def) and not isAny(loc, def):
|
|
if isEmbedded(loc, def):
|
|
mergeType(embeddableType, defIdent)
|
|
else:
|
|
mergeType(unembeddableType, defIdent)
|
|
let typeSpec = nimTypeOf(loc, typeDefs, def, name)
|
|
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 embeddableType.isNil:
|
|
let genericParams =
|
|
nkGenericParams.newTree(nkIdentDefs.newTree(embeddedIdent(scm), newEmpty(), newEmpty()))
|
|
procs.add nkProcDef.newTree(
|
|
"$".toFieldIdent,
|
|
newEmpty(),
|
|
genericParams,
|
|
nkFormalParams.newTree(
|
|
ident"string",
|
|
nkIdentDefs.newTree(
|
|
ident"x",
|
|
embeddableType,
|
|
newEmpty())),
|
|
newEmpty(),
|
|
newEmpty(),
|
|
nkStmtList.newTree(
|
|
nkCall.newTree(ident"$",
|
|
nkCall.newTree(ident"toPreserve", ident"x", embeddedIdent(scm)))))
|
|
procs.add nkProcDef.newTree(
|
|
"encode".ident.toExport,
|
|
newEmpty(),
|
|
genericParams,
|
|
nkFormalParams.newTree(
|
|
nkBracketExpr.newTree(ident"seq", ident"byte"),
|
|
nkIdentDefs.newTree(
|
|
ident"x",
|
|
embeddableType,
|
|
newEmpty())),
|
|
newEmpty(),
|
|
newEmpty(),
|
|
nkStmtList.newTree(
|
|
nkCall.newTree(ident"encode",
|
|
nkCall.newTree(ident"toPreserve", ident"x", embeddedIdent(scm)))))
|
|
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"toPreserve", 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"toPreserve", 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/[options, 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:
|
|
new bundle
|
|
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 fromPreserve(bundle, pr):
|
|
var schema: Schema
|
|
if fromPreserve(schema, pr):
|
|
bundle.modules[@[Symbol fileName]] = schema
|
|
else:
|
|
new bundle
|
|
var scm = parsePreservesSchema(readFile(inputPath), dirPath)
|
|
bundle.modules[@[Symbol fileName]] = scm
|
|
if bundle.isNil or bundle.modules.len == 0:
|
|
quit "Failed to recognize " & inputPath
|
|
else:
|
|
writeModules(bundle)
|