Index

Modules: genny, genny/common, genny/internal, genny/languages/c, genny/languages/cpp, genny/languages/nim, genny/languages/node, genny/languages/python, genny/languages/zig.

API symbols

basicTypes:

• common: const basicTypes

convertExportFromNim:

• nim: proc convertExportFromNim(sym: NimNode): string

convertExportFromNode:

• node: proc convertExportFromNode(sym: NimNode): string

convertExportFromPy:

• python: proc convertExportFromPy(sym: NimNode): string

convertExportFromZig:

• zig: proc convertExportFromZig(inner: string; sym: string): string

convertImportToNim:

• nim: proc convertImportToNim(sym: NimNode): string

convertImportToNode:

• node: proc convertImportToNode(sym: NimNode): string

convertImportToPy:

• python: proc convertImportToPy(sym: NimNode): string

convertImportToZig:

• zig: proc convertImportToZig(inner: string; sym: string): string

dllProc:

• c: proc dllProc(procName: string; args: openArray[(NimNode, NimNode)]; restype: string)
• c: proc dllProc(procName: string; args: openArray[string]; restype: string)
• c: proc dllProc(procName: string; restype: string)
• cpp: proc dllProc(procName: string; args: openArray[(NimNode, NimNode)]; restype: string)
• cpp: proc dllProc(procName: string; args: openArray[string]; restype: string)
• cpp: proc dllProc(procName: string; restype: string)
• python: proc dllProc(procName: string; args: openArray[string]; restype: string)
• zig: proc dllProc(procName: string; args: openArray[string]; resType: string)

exportCloseObjectCpp:

• cpp: proc exportCloseObjectCpp()

exportCloseObjectZig:

• zig: proc exportCloseObjectZig()

exportConstC:

• c: proc exportConstC(sym: NimNode)

exportConstCpp:

• cpp: proc exportConstCpp(sym: NimNode)

exportConstInternal:

• internal: proc exportConstInternal(sym: NimNode)

exportConstNim:

• nim: proc exportConstNim(sym: NimNode)

exportConstNode:

• node: proc exportConstNode(sym: NimNode)

exportConstPy:

• python: proc exportConstPy(sym: NimNode)

exportConsts:

• genny: template exportConsts(body: untyped)

exportConstZig:

• zig: proc exportConstZig(sym: NimNode)

exportEnumC:

• c: proc exportEnumC(sym: NimNode)

exportEnumCpp:

• cpp: proc exportEnumCpp(sym: NimNode)

exportEnumInternal:

• internal: proc exportEnumInternal(sym: NimNode)

exportEnumNim:

• nim: proc exportEnumNim(sym: NimNode)

exportEnumNode:

• node: proc exportEnumNode(sym: NimNode)

exportEnumPy:

• python: proc exportEnumPy(sym: NimNode)

exportEnums:

• genny: template exportEnums(body: untyped)

exportEnumZig:

• zig: proc exportEnumZig(sym: NimNode)

exportObject:

• genny: template exportObject(sym, body: untyped)

exportObjectC:

• c: proc exportObjectC(sym: NimNode; constructor: NimNode)

exportObjectCpp:

• cpp: proc exportObjectCpp(sym: NimNode; constructor: NimNode)

exportObjectInternal:

• internal: proc exportObjectInternal(sym: NimNode; constructor: NimNode)

exportObjectNim:

• nim: proc exportObjectNim(sym: NimNode; constructor: NimNode)

exportObjectNode:

• node: proc exportObjectNode(sym: NimNode; constructor: NimNode)

exportObjectPy:

• python: proc exportObjectPy(sym: NimNode; constructor: NimNode)

exportObjectZig:

• zig: proc exportObjectZig(sym: NimNode; constructor: NimNode)

exportProcC:

• c: proc exportProcC(sym: NimNode; owner: NimNode = nil; prefixes: openArray[NimNode] = [])

exportProcCpp:

• cpp: proc exportProcCpp(sym: NimNode; owner: NimNode = nil; prefixes: openArray[NimNode] = [])

exportProcInternal:

• internal: proc exportProcInternal(sym: NimNode; owner: NimNode = nil; prefixes: openArray[NimNode] = [])

exportProcNim:

• nim: proc exportProcNim(sym: NimNode; owner: NimNode = nil; prefixes: openArray[NimNode] = [])

exportProcNode:

• node: proc exportProcNode(sym: NimNode; owner: NimNode = nil; prefixes: openArray[NimNode] = [])

exportProcPy:

• python: proc exportProcPy(sym: NimNode; owner: NimNode = nil; prefixes: openArray[NimNode] = [])

exportProcs:

• genny: template exportProcs(body: untyped)

exportProcZig:

• zig: proc exportProcZig(sym: NimNode; owner: NimNode = nil; prefixes: openArray[NimNode] = []; indent = false; rename = "")

exportRefObject:

• genny: template exportRefObject(sym, body: untyped)

exportRefObjectC:

• c: proc exportRefObjectC(sym: NimNode; fields: seq[(string, NimNode)]; constructor: NimNode)

exportRefObjectCpp:

• cpp: proc exportRefObjectCpp(sym: NimNode; fields: seq[(string, NimNode)]; constructor: NimNode)

exportRefObjectInternal:

• internal: proc exportRefObjectInternal(sym: NimNode; fields: seq[(string, NimNode)]; constructor: NimNode)

exportRefObjectNim:

• nim: proc exportRefObjectNim(sym: NimNode; fields: seq[(string, NimNode)]; constructor: NimNode)

exportRefObjectNode:

• node: proc exportRefObjectNode(sym: NimNode; fields: seq[(string, NimNode)]; constructor: NimNode)

exportRefObjectPy:

• python: proc exportRefObjectPy(sym: NimNode; fields: seq[(string, NimNode)]; constructor: NimNode)

exportRefObjectZig:

• zig: proc exportRefObjectZig(sym: NimNode; fields: seq[(string, NimNode)]; constructor: NimNode)

exportSeq:

• genny: template exportSeq(sym, body: untyped)

exportSeqC:

• c: proc exportSeqC(sym: NimNode)

exportSeqCpp:

• cpp: proc exportSeqCpp(sym: NimNode)

exportSeqInternal:

• internal: proc exportSeqInternal(sym: NimNode)

exportSeqNim:

• nim: proc exportSeqNim(sym: NimNode)

exportSeqNode:

• node: proc exportSeqNode(sym: NimNode)

exportSeqPy:

• python: proc exportSeqPy(sym: NimNode)

exportSeqZig:

• zig: proc exportSeqZig(sym: NimNode)

exportTypeNim:

• nim: proc exportTypeNim(sym: NimNode): string

getName:

• common: proc getName(sym: NimNode): string

getSeqName:

• common: proc getSeqName(sym: NimNode): string

raises:

• common: proc raises(procSym: NimNode): bool

toCamelCase:

• common: proc toCamelCase(s: string): string

toCapSnakeCase:

• common: proc toCapSnakeCase(s: string): string

toSnakeCase:

• common: proc toSnakeCase(s: string): string

toVarCase:

• common: proc toVarCase(s: string): string

writeC:

• c: proc writeC(dir, lib: string)

writeCpp:

• cpp: proc writeCpp(dir, lib: string)

writeFiles:

• genny: macro writeFiles(dir, lib: static[string])

writeInternal:

• internal: proc writeInternal(dir, lib: string)

writeNim:

• nim: proc writeNim(dir, lib: string)

writeNode:

• node: proc writeNode(dir, lib: string)

writePy:

• python: proc writePy(dir, lib: string)

writeZig:

• zig: proc writeZig(dir, lib: string)