ic/to_packed_ast

    Dark Mode
Search:
Group by:
  Source   Edit

Types

PackedConfig = object
  backend: TBackend
  selectedGC: TGCMode
  cCompiler: TSystemCC
  options: TOptions
  globalOptions: TGlobalOptions
  Source   Edit
PackedModule = object
  definedSymbols: string
  includes: seq[(LitId, string)]
  imports: seq[LitId]
  toReplay: PackedTree
  topLevel*: PackedTree
  bodies*: PackedTree
  exports*: seq[(LitId, int32)]
  reexports*: seq[(LitId, PackedItemId)]
  compilerProcs*, trmacros*, converters*, pureEnums*: seq[(LitId, int32)]
  methods*: seq[int32]
  macroUsages*: seq[(PackedItemId, PackedLineInfo)]
  typeInstCache*: seq[(PackedItemId, PackedItemId)]
  procInstCache*: seq[PackedInstantiation]
  attachedOps*: seq[(TTypeAttachedOp, PackedItemId, PackedItemId)]
  methodsPerType*: seq[(PackedItemId, int, PackedItemId)]
  enumToStringProcs*: seq[(PackedItemId, PackedItemId)]
  sh*: Shared
  cfg: PackedConfig
the parts of a PackedEncoder that are part of the .rod file   Source   Edit
PackedEncoder = object
  thisModule*: int32
  lastFile*: FileIndex
  lastLit*: LitId
  filenames*: Table[FileIndex, LitId]
  pendingTypes*: seq[PType]
  pendingSyms*: seq[PSym]
  typeMarker*: IntSet
  symMarker*: IntSet
  config*: ConfigRef
  Source   Edit
PackedDecoder = object
  lastModule: int
  lastLit: LitId
  lastFile: FileIndex
  config*: ConfigRef
  cache*: IdentCache
  Source   Edit
ModuleStatus = enum
  undefined, storing, loading, loaded, outdated
  Source   Edit
LoadedModule = object
  status*: ModuleStatus
  symsInit, typesInit: bool
  fromDisk*: PackedModule
  syms: seq[PSym]
  types: seq[PType]
  module*: PSym
  iface: Table[PIdent, seq[PackedItemId]]
  Source   Edit
PackedModuleGraph = seq[LoadedModule]
  Source   Edit
RodIter = object
  decoder: PackedDecoder
  values: seq[PackedItemId]
  i, module: int
  Source   Edit

Procs

proc rememberStartupConfig(dest: var PackedConfig; config: ConfigRef) {...}{.
    raises: [], tags: [].}
  Source   Edit
proc toFileIndex(x: LitId; m: PackedModule; config: ConfigRef): FileIndex {...}{.
    raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}
  Source   Edit
proc initEncoder(c: var PackedEncoder; m: var PackedModule; moduleSym: PSym;
                 config: ConfigRef; pc: PackedConfig) {...}{.raises: [IOError],
    tags: [ReadIOEffect].}
setup a context for serializing to packed ast   Source   Edit
proc addIncludeFileDep(c: var PackedEncoder; m: var PackedModule; f: FileIndex) {...}{.
    raises: [IOError], tags: [ReadIOEffect].}
  Source   Edit
proc addImportFileDep(c: var PackedEncoder; m: var PackedModule; f: FileIndex) {...}{.
    raises: [], tags: [].}
  Source   Edit
proc addExported(c: var PackedEncoder; m: var PackedModule; s: PSym) {...}{.
    raises: [], tags: [].}
  Source   Edit
proc addConverter(c: var PackedEncoder; m: var PackedModule; s: PSym) {...}{.
    raises: [], tags: [].}
  Source   Edit
proc addTrmacro(c: var PackedEncoder; m: var PackedModule; s: PSym) {...}{.
    raises: [], tags: [].}
  Source   Edit
proc addPureEnum(c: var PackedEncoder; m: var PackedModule; s: PSym) {...}{.
    raises: [], tags: [].}
  Source   Edit
proc addMethod(c: var PackedEncoder; m: var PackedModule; s: PSym) {...}{.raises: [],
    tags: [].}
  Source   Edit
proc addReexport(c: var PackedEncoder; m: var PackedModule; s: PSym) {...}{.
    raises: [], tags: [].}
  Source   Edit
proc addCompilerProc(c: var PackedEncoder; m: var PackedModule; s: PSym) {...}{.
    raises: [], tags: [].}
  Source   Edit
proc storeSym(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId {...}{.
    raises: [Exception], tags: [RootEffect].}
serialize a psym   Source   Edit
proc toPackedNode(n: PNode; ir: var PackedTree; c: var PackedEncoder;
                  m: var PackedModule) {...}{.raises: [], tags: [].}
serialize a node into the tree   Source   Edit
proc storeInstantiation(c: var PackedEncoder; m: var PackedModule; s: PSym;
                        i: PInstantiation) {...}{.raises: [], tags: [].}
  Source   Edit
proc storeTypeInst(c: var PackedEncoder; m: var PackedModule; s: PSym;
                   inst: PType) {...}{.raises: [], tags: [].}
  Source   Edit
proc addPragmaComputation(c: var PackedEncoder; m: var PackedModule; n: PNode) {...}{.
    raises: [], tags: [].}
  Source   Edit
proc toPackedNodeTopLevel(n: PNode; encoder: var PackedEncoder;
                          m: var PackedModule) {...}{.raises: [Exception],
    tags: [RootEffect].}
  Source   Edit
proc loadRodFile(filename: AbsoluteFile; m: var PackedModule; config: ConfigRef): RodFileError {...}{.
    raises: [IOError, KeyError, Exception],
    tags: [ReadIOEffect, ReadDirEffect, RootEffect].}
  Source   Edit
proc saveRodFile(filename: AbsoluteFile; encoder: var PackedEncoder;
                 m: var PackedModule) {...}{.raises: [IOError, OSError],
                                        tags: [WriteIOEffect, WriteDirEffect].}
  Source   Edit
proc toFileIndexCached(c: var PackedDecoder; g: PackedModuleGraph;
                       thisModule: int; f: LitId): FileIndex {...}{.
    raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}
  Source   Edit
proc loadNodes(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int;
               tree: PackedTree; n: NodePos): PNode {...}{.
    raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}
  Source   Edit
proc initPackedDecoder(config: ConfigRef; cache: IdentCache): PackedDecoder {...}{.
    raises: [], tags: [].}
  Source   Edit
proc moduleIndex(c: var PackedDecoder; g: var PackedModuleGraph;
                 thisModule: int; s: PackedItemId): int32 {...}{.inline,
    raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}
  Source   Edit
proc moduleFromRodFile(g: var PackedModuleGraph; conf: ConfigRef;
                       cache: IdentCache; fileIdx: FileIndex): PSym {...}{.
    raises: [OSError, IOError, KeyError, Exception], tags: [ReadEnvEffect,
    ReadIOEffect, WriteDirEffect, ReadDirEffect, WriteIOEffect, RootEffect].}
Returns 'nil' if the module needs to be recompiled.   Source   Edit
proc loadProcBody(config: ConfigRef; cache: IdentCache;
                  g: var PackedModuleGraph; s: PSym): PNode {...}{.
    raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}
  Source   Edit
proc loadTypeFromId(config: ConfigRef; cache: IdentCache;
                    g: var PackedModuleGraph; module: int; id: PackedItemId): PType {...}{.
    raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}
  Source   Edit
proc loadSymFromId(config: ConfigRef; cache: IdentCache;
                   g: var PackedModuleGraph; module: int; id: PackedItemId): PSym {...}{.
    raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}
  Source   Edit
proc translateId(id: PackedItemId; g: PackedModuleGraph; thisModule: int;
                 config: ConfigRef): ItemId {...}{.raises: [KeyError, Exception],
    tags: [ReadDirEffect, RootEffect].}
  Source   Edit
proc simulateLoadedModule(g: var PackedModuleGraph; conf: ConfigRef;
                          cache: IdentCache; moduleSym: PSym; m: PackedModule) {...}{.
    raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}
  Source   Edit
proc initRodIter(it: var RodIter; config: ConfigRef; cache: IdentCache;
                 g: var PackedModuleGraph; module: FileIndex; name: PIdent): PSym {...}{.
    raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}
  Source   Edit
proc initRodIterAllSyms(it: var RodIter; config: ConfigRef; cache: IdentCache;
                        g: var PackedModuleGraph; module: FileIndex): PSym {...}{.
    raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}
  Source   Edit
proc nextRodIter(it: var RodIter; g: var PackedModuleGraph): PSym {...}{.
    raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}
  Source   Edit
proc interfaceSymbol(config: ConfigRef; cache: IdentCache;
                     g: var PackedModuleGraph; module: FileIndex; name: PIdent): PSym {...}{.
    raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}
  Source   Edit
proc idgenFromLoadedModule(m: LoadedModule): IdGenerator {...}{.raises: [], tags: [].}
  Source   Edit
proc rodViewer(rodfile: AbsoluteFile; config: ConfigRef; cache: IdentCache) {...}{.
    raises: [IOError, KeyError, Exception],
    tags: [ReadIOEffect, ReadDirEffect, RootEffect].}
  Source   Edit

Iterators

iterator interfaceSymbols(config: ConfigRef; cache: IdentCache;
                          g: var PackedModuleGraph; module: FileIndex;
                          name: PIdent): PSym {...}{.raises: [KeyError, Exception],
    tags: [ReadDirEffect, RootEffect].}
  Source   Edit