Index
Modules:
aliases
,
ast
,
astalgo
,
astmsgs
,
bitsets
,
btrees
,
ccgutils
,
cgen
,
cgendata
,
cgmeth
,
closureiters
,
cmdlinehelper
,
commands
,
concepts
,
condsyms
,
depends
,
dfa
,
docgen
,
docgen2
,
enumtostr
,
errorhandling
,
evaltempl
,
extccomp
,
filter_tmpl
,
filters
,
gorgeimpl
,
guards
,
ic/bitabs
,
ic/cbackend
,
ic/dce
,
ic/ic
,
ic/integrity
,
ic/navigator
,
ic/packed_ast
,
ic/replayer
,
ic/rodfiles
,
idents
,
importer
,
index
,
injectdestructors
,
int128
,
isolation_check
,
jsgen
,
lambdalifting
,
lexer
,
liftdestructors
,
liftlocals
,
lineinfos
,
linter
,
llstream
,
lookups
,
lowerings
,
macrocacheimpl
,
magicsys
,
main
,
modulegraphs
,
modulepaths
,
modules
,
msgs
,
ndi
,
nilcheck
,
nimblecmd
,
nimconf
,
nimfix/prettybase
,
nimlexbase
,
nimpaths
,
nimsets
,
nodejs
,
nversion
,
optimizer
,
options
,
parampatterns
,
parser
,
passaux
,
passes
,
pathutils
,
patterns
,
platform
,
plugins/active
,
plugins/itersgen
,
plugins/locals
,
pluginsupport
,
pragmas
,
prefixmatches
,
procfind
,
renderer
,
renderverbatim
,
reorder
,
rodutils
,
ropes
,
saturate
,
scriptconfig
,
sem
,
semdata
,
semfold
,
semmacrosanity
,
semparallel
,
sempass2
,
semtypinst
,
sighashes
,
sigmatch
,
sourcemap
,
spawn
,
strutils2
,
syntaxes
,
transf
,
trees
,
treetab
,
typeallowed
,
types
,
typesrenderer
,
varpartitions
,
vm
,
vmconv
,
vmdef
,
vmdeps
,
vmgen
,
vmmarshal
,
vmprofiler
,
wordrecg
.
API symbols
`$`:
ast: `$`(s: PSym): string
ast: `$`(x: TLockLevel): string
bitabs: `$`(x: LitId): string
int128: `$`(a: Int128): string
lexer: `$`(tok: Token): string
modulegraphs: `$`(u: SigHash): string
msgs: `$`(conf: ConfigRef; info: TLineInfo): string
msgs: `$`(info: TLineInfo): string
nilcheck: `$`(a: ExprIndex): string
nilcheck: `$`(a: SetIndex): string
nimblecmd: `$`(ver: Version): string
options: `$`(c: IdeCmd): string
pathutils: `$`(x: AnyPath): string
renderer: `$`(n: PNode): string
ropes: `$`(r: Rope): string
sigmatch: `$`(suggest: Suggest): string
sourcemap: `$`(sourceNode: SourceNode): string
types: `$`(typ: PType): string
varpartitions: `$`(config: ConfigRef; g: MutationInfo): string
`%`:
ropes: `%`(frmt: static[FormatStr]; args: openArray[Rope]): Rope
`&`:
ropes: `&`(a: openArray[Rope]): Rope
ropes: `&`(a, b: Rope): Rope
ropes: `&`(a: Rope; b: string): Rope
ropes: `&`(a: string; b: Rope): Rope
`>=`:
nilcheck: `>=`(a: ExprIndex; b: ExprIndex): bool
`>`:
nilcheck: `>`(a: ExprIndex; b: ExprIndex): bool
`<=`:
bitabs: `<=`(x, y: LitId): bool
int128: `<=`(a: BiggestInt; b: Int128): bool
int128: `<=`(a: Int128; b: BiggestInt): bool
int128: `<=`(a, b: Int128): bool
nilcheck: `<=`(a: ExprIndex; b: ExprIndex): bool
`<`:
bitabs: `<`(x, y: LitId): bool
int128: `<`(a: BiggestInt; b: Int128): bool
int128: `<`(a: Int128; b: BiggestInt): bool
int128: `<`(a, b: Int128): bool
nilcheck: `<`(a: ExprIndex; b: ExprIndex): bool
nimblecmd: `<`(ver: Version; ver2: Version): bool
`*=`:
int128: `*=`(a: var Int128; b: Int128)
int128: `*=`(a: var Int128; b: int32): Int128
`*`:
int128: `*`(lhs, rhs: Int128): Int128
int128: `*`(a: Int128; b: int32): Int128
`+=`:
int128: `+=`(a: var Int128; b: Int128)
`+`:
int128: `+`(a: BiggestInt; b: Int128): Int128
int128: `+`(a: Int128; b: BiggestInt): Int128
int128: `+`(a, b: Int128): Int128
nilcheck: `+`(a: ExprIndex; b: ExprIndex): ExprIndex
nilcheck: `+`(a: SetIndex; b: SetIndex): SetIndex
`-=`:
int128: `-=`(a: var Int128; b: Int128)
`-`:
int128: `-`(a: BiggestInt; b: Int128): Int128
int128: `-`(a: Int128): Int128
int128: `-`(a: Int128; b: BiggestInt): Int128
int128: `-`(a, b: Int128): Int128
nilcheck: `-`(a: ExprIndex; b: ExprIndex): ExprIndex
nilcheck: `-`(a: SetIndex; b: SetIndex): SetIndex
`/`:
pathutils: `/`(base: AbsoluteDir; f: RelativeDir): AbsoluteDir
pathutils: `/`(base: AbsoluteDir; f: RelativeFile): AbsoluteFile
`==`:
ast: `==`(a, b: ItemId): bool
bitabs: `==`(x, y: LitId): bool
packed_ast: `==`(a, b: NodeId): bool
packed_ast: `==`(a, b: NodePos): bool
packed_ast: `==`(a, b: SymId): bool
idents: `==`(a, b: PIdent): bool
int128: `==`(a: BiggestInt; b: Int128): bool
int128: `==`(a: Int128; b: BiggestInt): bool
int128: `==`(a, b: Int128): bool
lineinfos: `==`(a, b: FileIndex): bool
modulegraphs: `==`(a, b: SigHash): bool
msgs: `==`(a, b: TLineInfo): bool
nilcheck: `==`(a: ExprIndex; b: ExprIndex): bool
nilcheck: `==`(a: SetIndex; b: SetIndex): bool
pathutils: `==`[T: AnyPath](x, y: T): bool
`??`:
msgs: `??`(conf: ConfigRef; info: TLineInfo; filename: string): bool
`[]=`:
ast: `[]=`(n: Indexable; i: BackwardsIndex; x: Indexable)
ast: `[]=`(n: Indexable; i: int; x: Indexable)
`[]`:
ast: `[]`(n: Indexable; i: BackwardsIndex): Indexable
ast: `[]`(n: Indexable; i: int): Indexable
bitabs: `[]`[T](t: var BiTable[T]; LitId: LitId): var T
bitabs: `[]`[T](t: BiTable[T]; LitId: LitId): lent T
packed_ast: `[]`(tree: PackedTree; i: int): lent PackedNode
`div`:
int128: `div`(a, b: Int128): Int128
`mod`:
int128: `mod`(a, b: Int128): Int128
`shl`:
int128: `shl`(a: Int128; b: int): Int128
`shr`:
int128: `shr`(a: Int128; b: int): Int128
`|*|`:
saturate: `|*|`(a, b: BiggestInt): BiggestInt
`|+|`:
saturate: `|+|`(a, b: BiggestInt): BiggestInt
`|-|`:
saturate: `|-|`(a, b: BiggestInt): BiggestInt
`|abs|`:
saturate: `|abs|`(a: BiggestInt): BiggestInt
`|div|`:
saturate: `|div|`(a, b: BiggestInt): BiggestInt
`|mod|`:
saturate: `|mod|`(a, b: BiggestInt): BiggestInt
`~`:
ropes: `~`(r: string): Rope
abs:
int128: abs(a: Int128): Int128
AbsoluteDir:
pathutils: AbsoluteDir
AbsoluteFile:
pathutils: AbsoluteFile
absOutFile:
options: absOutFile(conf: ConfigRef): AbsoluteFile
abstractInst:
ast: abstractInst
abstractInstOwned:
types: abstractInstOwned
abstractPtrs:
types: abstractPtrs
abstractRange:
types: abstractRange
abstractVar:
types: abstractVar
abstractVarRange:
ast: abstractVarRange
add:
ast: add(father, son: Indexable)
btrees: add[Key, Val](b: var BTree[Key, Val]; key: Key; val: Val)
nilcheck: add[T, U](a: var SeqOfDistinct[T, U]; value: U)
ropes: add(a: var Rope; b: Rope)
ropes: add(a: var Rope; b: string)
addAllowNil:
ast: addAllowNil(father, son: Indexable)
addAsgnFact:
guards: addAsgnFact(m: var TModel; key, value: PNode)
addCaseBranchFacts:
guards: addCaseBranchFacts(m: var TModel; n: PNode; i: int)
addCmdPrefix:
cmdlinehelper: addCmdPrefix(result: var string; kind: CmdLineKind)
addCompileOption:
extccomp: addCompileOption(conf: ConfigRef; option: string)
addCompileOptionCmd:
extccomp: addCompileOptionCmd(conf: ConfigRef; option: string)
addCompilerProc:
ic: addCompilerProc(c: var PackedEncoder; m: var PackedModule; s: PSym)
addConverter:
ic: addConverter(c: var PackedEncoder; m: var PackedModule; s: PSym)
semdata: addConverter(c: PContext; conv: LazySym)
addConverterDef:
semdata: addConverterDef(c: PContext; conv: LazySym)
addDecl:
lookups: addDecl(c: PContext; sym: PSym)
lookups: addDecl(c: PContext; sym: PSym; info: TLineInfo)
addDeclaredLoc:
astmsgs: addDeclaredLoc(result: var string; conf: ConfigRef; sym: PSym)
astmsgs: addDeclaredLoc(result: var string; conf: ConfigRef; typ: PType)
addDeclaredLocMaybe:
astmsgs: addDeclaredLocMaybe(result: var string; conf: ConfigRef; sym: PSym)
astmsgs: addDeclaredLocMaybe(result: var string; conf: ConfigRef; typ: PType)
addDeclAt:
lookups: addDeclAt(c: PContext; scope: PScope; sym: PSym)
lookups: addDeclAt(c: PContext; scope: PScope; sym: PSym; info: TLineInfo)
addDep:
modulegraphs: addDep(g: ModuleGraph; m: PSym; dep: FileIndex)
addDiscriminantFact:
guards: addDiscriminantFact(m: var TModel; n: PNode)
addExport:
semdata: addExport(c: PContext; s: PSym)
addExported:
ic: addExported(c: var PackedEncoder; m: var PackedModule; s: PSym)
addExternalFileToCompile:
extccomp: addExternalFileToCompile(conf: ConfigRef; filename: AbsoluteFile)
extccomp: addExternalFileToCompile(conf: ConfigRef; c: var Cfile)
addExternalFileToLink:
extccomp: addExternalFileToLink(conf: ConfigRef; filename: AbsoluteFile)
addf:
ropes: addf(c: var Rope; frmt: FormatStr; args: openArray[Rope])
addFact:
guards: addFact(m: var TModel; nn: PNode)
addFactLe:
guards: addFactLe(m: var TModel; a, b: PNode)
addFactLt:
guards: addFactLt(m: var TModel; a, b: PNode)
addFactNeg:
guards: addFactNeg(m: var TModel; n: PNode)
addField:
lowerings: addField(obj: PType; s: PSym; cache: IdentCache; idgen: IdGenerator)
addFileExt:
pathutils: addFileExt(x: AbsoluteFile; ext: string): AbsoluteFile
pathutils: addFileExt(x: RelativeFile; ext: string): RelativeFile
addFileToCompile:
extccomp: addFileToCompile(conf: ConfigRef; cf: Cfile)
addHidden:
ic: addHidden(c: var PackedEncoder; m: var PackedModule; s: PSym)
addIdent:
packed_ast: addIdent(tree: var PackedTree; s: LitId; info: PackedLineInfo)
addImportFileDep:
ic: addImportFileDep(c: var PackedEncoder; m: var PackedModule; f: FileIndex)
semdata: addImportFileDep(c: PContext; f: FileIndex)
addIncludeDep:
modulegraphs: addIncludeDep(g: ModuleGraph; module, includeFile: FileIndex)
addIncludeFileDep:
ic: addIncludeFileDep(c: var PackedEncoder; m: var PackedModule; f: FileIndex)
semdata: addIncludeFileDep(c: PContext; f: FileIndex)
addInt128:
int128: addInt128(result: var string; value: Int128)
addInterfaceDecl:
lookups: addInterfaceDecl(c: PContext; sym: PSym)
addInterfaceDeclAt:
lookups: addInterfaceDeclAt(c: PContext; scope: PScope; sym: PSym)
addInterfaceOverloadableSymAt:
lookups: addInterfaceOverloadableSymAt(c: PContext; scope: PScope; sym: PSym)
addLinkOption:
extccomp: addLinkOption(conf: ConfigRef; option: string)
addLinkOptionCmd:
extccomp: addLinkOptionCmd(conf: ConfigRef; option: string)
addLocalCompileOption:
extccomp: addLocalCompileOption(conf: ConfigRef; option: string; nimfile: AbsoluteFile)
addMapping:
sourcemap: addMapping(map: SourceMapGenerator; mapping: Mapping)
addMethod:
ic: addMethod(c: var PackedEncoder; m: var PackedModule; s: PSym)
addMethodToGeneric:
modulegraphs: addMethodToGeneric(g: ModuleGraph; module: int; t: PType; col: int; m: PSym)
addModuleId:
packed_ast: addModuleId(tree: var PackedTree; s: ModuleId; info: PackedLineInfo)
addOverloadableSymAt:
lookups: addOverloadableSymAt(c: PContext; scope: PScope; fn: PSym)
addPackage:
nimblecmd: addPackage(conf: ConfigRef; packages: var PackageInfo; p: string; info: TLineInfo)
addParam:
ast: addParam(procType: PType; param: PSym)
addPath:
nimblecmd: addPath(conf: ConfigRef; path: AbsoluteDir; info: TLineInfo)
addPattern:
semdata: addPattern(c: PContext; p: LazySym)
addPragmaAndCallConvMismatch:
types: addPragmaAndCallConvMismatch(message: var string; formal, actual: PType; conf: ConfigRef)
addPragmaComputation:
ic: addPragmaComputation(c: var PackedEncoder; m: var PackedModule; n: PNode)
semdata: addPragmaComputation(c: PContext; n: PNode)
addPrelimDecl:
lookups: addPrelimDecl(c: PContext; sym: PSym)
addPureEnum:
ic: addPureEnum(c: var PackedEncoder; m: var PackedModule; s: PSym)
semdata: addPureEnum(c: PContext; e: LazySym)
addReexport:
ic: addReexport(c: var PackedEncoder; m: var PackedModule; s: PSym)
addSonNilAllowed:
ast: addSonNilAllowed(father, son: PNode)
addSonSkipIntLit:
magicsys: addSonSkipIntLit(father, son: PType; id: IdGenerator)
addSym:
packed_ast: addSym(tree: var PackedTree; s: int32; info: PackedLineInfo)
lookups: addSym(scope: PScope; s: PSym)
addSymDef:
packed_ast: addSymDef(tree: var PackedTree; s: SymId; info: PackedLineInfo)
addToGenericCache:
semdata: addToGenericCache(c: PContext; s: PSym; inst: PType)
addToGenericProcCache:
semdata: addToGenericProcCache(c: PContext; s: PSym; inst: PInstantiation)
addToHex:
int128: addToHex(result: var string; arg: Int128)
addToLib:
semdata: addToLib(lib: PLib; sym: PSym)
addTrmacro:
ic: addTrmacro(c: var PackedEncoder; m: var PackedModule; s: PSym)
addTypeDeclVerboseMaybe:
types: addTypeDeclVerboseMaybe(result: var string; conf: ConfigRef; typ: PType)
addTypeHeader:
types: addTypeHeader(result: var string; conf: ConfigRef; typ: PType; prefer: TPreferedDesc = preferMixed; getDeclarationPath = true)
addUniqueField:
lowerings: addUniqueField(obj: PType; s: PSym; cache: IdentCache; idgen: IdGenerator): PSym
addUniqueSym:
lookups: addUniqueSym(scope: PScope; s: PSym): PSym
addVar:
lowerings: addVar(father, v: PNode)
lowerings: addVar(father, v, value: PNode)
aliases:
dfa: aliases(obj, field: PNode): AliasKind
AliasKind:
dfa: AliasKind
AliveContext:
dce: AliveContext
AliveSyms:
dce: AliveSyms
aliveSymsSection:
RodSection.aliveSymsSection
allNodes:
packed_ast: allNodes(tree: PackedTree): NodePos
allowCast:
TSandboxFlag.allowCast
AllowCommonBase:
TTypeCmpFlag.AllowCommonBase
allowInfiniteLoops:
TSandboxFlag.allowInfiniteLoops
allowSemcheckedAstModification:
LegacyFeature.allowSemcheckedAstModification
allRoutinePragmas:
pragmas: allRoutinePragmas
allScopes:
lookups: allScopes(scope: PScope): PScope
allSyms:
lookups: allSyms(c: PContext): (PSym, int, bool)
modulegraphs: allSyms(g: ModuleGraph; m: PSym): PSym
AmbiguousCall:
ErrorKind.AmbiguousCall
analyseObjectWithTypeField:
types: analyseObjectWithTypeField(t: PType): TTypeFieldResult
annotateType:
semmacrosanity: annotateType(n: PNode; t: PType; conf: ConfigRef)
AnyPath:
pathutils: AnyPath
Apo:
nimlexbase: Apo
appendToModule:
ast: appendToModule(m: PSym; n: PNode)
applyRule:
patterns: applyRule(c: PContext; s: PSym; n: PNode): PNode
aqNoAlias:
TAliasRequest.aqNoAlias
aqNone:
TAliasRequest.aqNone
aqShouldAlias:
TAliasRequest.aqShouldAlias
arDiscriminant:
TAssignableResult.arDiscriminant
argtypeMatches:
sigmatch: argtypeMatches(c: PContext; f, a: PType; fromHlo = false): bool
arLentValue:
TAssignableResult.arLentValue
arLocalLValue:
TAssignableResult.arLocalLValue
arLValue:
TAssignableResult.arLValue
arMaybe:
TAnalysisResult.arMaybe
arNo:
TAnalysisResult.arNo
arNone:
TAssignableResult.arNone
arStrange:
TAssignableResult.arStrange
arYes:
TAnalysisResult.arYes
asink:
liftdestructors: asink(t: PType): PSym
assignIfDefault:
options: assignIfDefault[T](result: var T; val: T; def = default(T))
assignment:
liftdestructors: assignment(t: PType): PSym
assignType:
ast: assignType(dest, src: PType)
astdef:
ast: astdef(s: PSym): PNode
attachedAsgn:
TTypeAttachedOp.attachedAsgn
attachedDeepCopy:
TTypeAttachedOp.attachedDeepCopy
attachedDestructor:
TTypeAttachedOp.attachedDestructor
attachedOpsSection:
RodSection.attachedOpsSection
AttachedOpToStr:
ast: AttachedOpToStr
attachedSink:
TTypeAttachedOp.attachedSink
attachedTrace:
TTypeAttachedOp.attachedTrace
backendC:
TBackend.backendC
backendCpp:
TBackend.backendCpp
backendFlagsSection:
RodSection.backendFlagsSection
backendInvalid:
TBackend.backendInvalid
backendJs:
TBackend.backendJs
backendObjc:
TBackend.backendObjc
BACKSPACE:
nimlexbase: BACKSPACE
base:
types: base(t: PType): PType
base10:
NumericalBase.base10
base16:
NumericalBase.base16
base2:
NumericalBase.base2
base8:
NumericalBase.base8
baseOfDistinct:
types: baseOfDistinct(t: PType; g: ModuleGraph; idgen: IdGenerator): PType
beforeRetNeeded:
TCProcFlag.beforeRetNeeded
BEL:
nimlexbase: BEL
bindConcreteTypeToUserTypeClass:
types: bindConcreteTypeToUserTypeClass(tc, concrete: PType)
BiTable:
bitabs: BiTable
bitand:
int128: bitand(a, b: Int128): Int128
bitnot:
int128: bitnot(a: Int128): Int128
bitor:
int128: bitor(a, b: Int128): Int128
bitSetCard:
bitsets: bitSetCard(x: TBitSet): BiggestInt
bitSetContains:
bitsets: bitSetContains(x, y: TBitSet): bool
bitSetDiff:
bitsets: bitSetDiff(x: var TBitSet; y: TBitSet)
bitSetEquals:
bitsets: bitSetEquals(x, y: TBitSet): bool
bitSetExcl:
bitsets: bitSetExcl(x: var TBitSet; elem: BiggestInt)
bitSetIn:
bitsets: bitSetIn(x: TBitSet; e: BiggestInt): bool
bitSetIncl:
bitsets: bitSetIncl(x: var TBitSet; elem: BiggestInt)
bitSetInit:
bitsets: bitSetInit(b: var TBitSet; length: int)
bitSetIntersect:
bitsets: bitSetIntersect(x: var TBitSet; y: TBitSet)
bitSetSymDiff:
bitsets: bitSetSymDiff(x: var TBitSet; y: TBitSet)
bitSetUnion:
bitsets: bitSetUnion(x: var TBitSet; y: TBitSet)
bitxor:
int128: bitxor(a, b: Int128): Int128
BModule:
cgendata: BModule
BModuleList:
cgendata: BModuleList
bodiesSection:
RodSection.bodiesSection
bodyPos:
ast: bodyPos
boolArg:
filters: boolArg(conf: ConfigRef; n: PNode; name: string; pos: int; default: bool): bool
boolLit:
liftdestructors: boolLit(g: ModuleGraph; info: TLineInfo; value: bool): PNode
borrowChecking:
Goal.borrowChecking
BProc:
cgendata: BProc
bracketKind:
renderer: bracketKind(g: TSrcGen; n: PNode): BracketKind
BTree:
btrees: BTree
buildAdd:
guards: buildAdd(a: PNode; b: BiggestInt; o: Operators): PNode
buildCall:
guards: buildCall(op: PSym; a: PNode): PNode
guards: buildCall(op: PSym; a, b: PNode): PNode
buildLe:
guards: buildLe(o: Operators; a, b: PNode): PNode
byteExcess:
vmdef: byteExcess
callableDefs:
ast: callableDefs
callCCompiler:
extccomp: callCCompiler(conf: ConfigRef)
callCodegenProc:
lowerings: callCodegenProc(g: ModuleGraph; name: string; info: TLineInfo = unknownLineInfo; arg1, arg2, arg3, optionalArgs: PNode = nil): PNode
callOperator:
Feature.callOperator
canAlias:
isolation_check: canAlias(arg, ret: PType): bool
CandidateError:
sigmatch: CandidateError
CandidateErrors:
sigmatch: CandidateErrors
canFormAcycle:
types: canFormAcycle(typ: PType): bool
cannotOpen:
RodFileError.cannotOpen
canon:
guards: canon(n: PNode; o: Operators): PNode
canonicalImport:
options: canonicalImport(conf: ConfigRef; file: AbsoluteFile): string
canonicalImportAux:
options: canonicalImportAux(conf: ConfigRef; file: AbsoluteFile): string
canonicalizePath:
options: canonicalizePath(conf: ConfigRef; path: AbsoluteFile): AbsoluteFile
canonValue:
vmgen: canonValue(n: PNode): PNode
canRaise:
ast: canRaise(fn: PNode): bool
canRaiseConservative:
ast: canRaiseConservative(fn: PNode): bool
cardSet:
nimsets: cardSet(conf: ConfigRef; a: PNode): BiggestInt
caseStmtMacros:
Feature.caseStmtMacros
castToInt64:
int128: castToInt64(arg: Int128): int64
castToUInt64:
int128: castToUInt64(arg: Int128): uint64
CC:
extccomp: CC
ccBcc:
TSystemCC.ccBcc
ccCDecl:
TCallingConvention.ccCDecl
ccCLang:
TSystemCC.ccCLang
ccClangCl:
TSystemCC.ccClangCl
ccClosure:
TCallingConvention.ccClosure
ccEnv:
TSystemCC.ccEnv
ccFastCall:
TCallingConvention.ccFastCall
ccGcc:
TSystemCC.ccGcc
ccgIntroducedPtr:
ccgutils: ccgIntroducedPtr(conf: ConfigRef; s: PSym; retType: PType): bool
ccgKeywordsHigh:
wordrecg: ccgKeywordsHigh
ccgKeywordsLow:
wordrecg: ccgKeywordsLow
ccHasSaneOverflow:
extccomp: ccHasSaneOverflow(conf: ConfigRef): bool
ccIcc:
TSystemCC.ccIcc
ccIcl:
TSystemCC.ccIcl
ccInline:
TCallingConvention.ccInline
ccLLVM_Gcc:
TSystemCC.ccLLVM_Gcc
ccNimCall:
TCallingConvention.ccNimCall
ccNintendoSwitch:
TSystemCC.ccNintendoSwitch
ccNoConvention:
TCallingConvention.ccNoConvention
ccNoInline:
TCallingConvention.ccNoInline
ccNone:
TSystemCC.ccNone
ccSafeCall:
TCallingConvention.ccSafeCall
ccStdCall:
TCallingConvention.ccStdCall
ccSysCall:
TCallingConvention.ccSysCall
ccTcc:
TSystemCC.ccTcc
ccThisCall:
TCallingConvention.ccThisCall
ccVcc:
TSystemCC.ccVcc
Cfile:
options: Cfile
CfileFlag:
options: CfileFlag
CfileList:
options: CfileList
cfsData:
TCFileSection.cfsData
cfsDatInitProc:
TCFileSection.cfsDatInitProc
cfsDebugInit:
TCFileSection.cfsDebugInit
cfsDynLibDeinit:
TCFileSection.cfsDynLibDeinit
cfsDynLibInit:
TCFileSection.cfsDynLibInit
cfsFieldInfo:
TCFileSection.cfsFieldInfo
cfsForwardTypes:
TCFileSection.cfsForwardTypes
cfsFrameDefines:
TCFileSection.cfsFrameDefines
cfsHeaders:
TCFileSection.cfsHeaders
cfsInitProc:
TCFileSection.cfsInitProc
cfsMergeInfo:
TCFileSection.cfsMergeInfo
cfsProcHeaders:
TCFileSection.cfsProcHeaders
cfsProcs:
TCFileSection.cfsProcs
cfsSeqTypes:
TCFileSection.cfsSeqTypes
cfsTypeInfo:
TCFileSection.cfsTypeInfo
cfsTypeInit1:
TCFileSection.cfsTypeInit1
cfsTypeInit2:
TCFileSection.cfsTypeInit2
cfsTypeInit3:
TCFileSection.cfsTypeInit3
cfsTypes:
TCFileSection.cfsTypes
cfsVars:
TCFileSection.cfsVars
cgDeclFrmt:
cgen: cgDeclFrmt(s: PSym): string
cgenModules:
cgendata: cgenModules(g: BModuleList): BModule
cgenPass:
cgen: cgenPass
cgenWriteModules:
cgen: cgenWriteModules(backend: RootRef; config: ConfigRef)
changeDetectedViaJsonBuildInstructions:
extccomp: changeDetectedViaJsonBuildInstructions(conf: ConfigRef; jsonFile: AbsoluteFile): bool
changeFileExt:
pathutils: changeFileExt(x: AbsoluteFile; ext: string): AbsoluteFile
pathutils: changeFileExt(x: RelativeFile; ext: string): RelativeFile
charArg:
filters: charArg(conf: ConfigRef; n: PNode; name: string; pos: int; default: char): char
checkAmbiguity:
TLookupFlag.checkAmbiguity
checkBorrowedLocations:
varpartitions: checkBorrowedLocations(par: var Partitions; body: PNode; config: ConfigRef)
checkConstructedType:
semtypinst: checkConstructedType(conf: ConfigRef; info: TLineInfo; typ: PType)
checkFieldAccess:
guards: checkFieldAccess(m: TModel; n: PNode; conf: ConfigRef)
checkForSideEffects:
parampatterns: checkForSideEffects(n: PNode): TSideEffectAnalysis
checkForSink:
sempass2: checkForSink(config: ConfigRef; idgen: IdGenerator; owner: PSym; arg: PNode)
checkIntegrity:
integrity: checkIntegrity(g: ModuleGraph)
checkIsolate:
isolation_check: checkIsolate(n: PNode): bool
checkMethodEffects:
sempass2: checkMethodEffects(g: ModuleGraph; disp, branch: PSym)
checkMinSonsLen:
semdata: checkMinSonsLen(n: PNode; length: int; conf: ConfigRef)
checkModule:
TLookupFlag.checkModule
checkModuleName:
modulepaths: checkModuleName(conf: ConfigRef; n: PNode; doLocalError = true): FileIndex
checkNil:
nilcheck: checkNil(s: PSym; body: PNode; conf: ConfigRef; idgen: IdGenerator)
checkPragmaUse:
linter: checkPragmaUse(conf: ConfigRef; info: TLineInfo; w: TSpecialWord; pragmaName: string)
checkPureEnumFields:
TLookupFlag.checkPureEnumFields
checkSonsLen:
semdata: checkSonsLen(n: PNode; length: int; conf: ConfigRef)
ChecksOptions:
options: ChecksOptions
checkSumsSection:
RodSection.checkSumsSection
checkUndeclared:
TLookupFlag.checkUndeclared
checkUnsignedConversions:
LegacyFeature.checkUnsignedConversions
Child:
sourcemap: Child
child:
sourcemap: child(node: SourceNode): Child
sourcemap: child(s: string): Child
classify:
types: classify(t: PType): OrdinalType
classifyViewType:
typeallowed: classifyViewType(t: PType): ViewTypeKind
clearNimblePath:
options: clearNimblePath(conf: ConfigRef)
clearPasses:
passes: clearPasses(g: ModuleGraph)
close:
rodfiles: close(f: var RodFile)
ndi: close(f: var NdiFile; conf: ConfigRef)
closeBaseLexer:
nimlexbase: closeBaseLexer(L: var TBaseLexer)
closeLexer:
lexer: closeLexer(lex: var Lexer)
closeParser:
parser: closeParser(p: var Parser)
closeRodFile:
modulegraphs: closeRodFile(g: ModuleGraph; m: PSym)
closeScope:
lookups: closeScope(c: PContext)
closeShadowScope:
lookups: closeShadowScope(c: PContext)
cmdBackends:
options: cmdBackends
cmdBuildindex:
Command.cmdBuildindex
cmdCheck:
Command.cmdCheck
cmdCompileToC:
Command.cmdCompileToC
cmdCompileToCpp:
Command.cmdCompileToCpp
cmdCompileToJS:
Command.cmdCompileToJS
cmdCompileToOC:
Command.cmdCompileToOC
cmdCrun:
Command.cmdCrun
cmdCtags:
Command.cmdCtags
cmdDoc:
Command.cmdDoc
cmdDoc0:
Command.cmdDoc0
cmdDoc2tex:
Command.cmdDoc2tex
cmdDocLike:
options: cmdDocLike
cmdDump:
Command.cmdDump
cmdGendepend:
Command.cmdGendepend
cmdIdeTools:
Command.cmdIdeTools
cmdInteractive:
Command.cmdInteractive
cmdJsondoc:
Command.cmdJsondoc
cmdJsondoc0:
Command.cmdJsondoc0
cmdJsonscript:
Command.cmdJsonscript
cmdNimfix:
Command.cmdNimfix
cmdNimscript:
Command.cmdNimscript
cmdNone:
Command.cmdNone
cmdNop:
Command.cmdNop
cmdParse:
Command.cmdParse
cmdRod:
Command.cmdRod
cmdRst2html:
Command.cmdRst2html
cmdRst2tex:
Command.cmdRst2tex
cmdTcc:
Command.cmdTcc
cmdUnknown:
Command.cmdUnknown
cmp:
int128: cmp(a, b: Int128): int
cmpCandidates:
sigmatch: cmpCandidates(a, b: TCandidate): int
cmpIgnoreStyle:
idents: cmpIgnoreStyle(a, b: cstring; blen: int): int
cmpPaths:
pathutils: cmpPaths(x, y: AbsoluteDir): int
cmpTypes:
sigmatch: cmpTypes(c: PContext; f, a: PType): TTypeRelation
CoConsiderOwned:
ConsiderFlag.CoConsiderOwned
CodegenFlag:
cgendata: CodegenFlag
codeReordering:
Feature.codeReordering
CoDistinct:
ConsiderFlag.CoDistinct
CoHashTypeInsideNode:
ConsiderFlag.CoHashTypeInsideNode
CoIgnoreRange:
ConsiderFlag.CoIgnoreRange
ColOffset:
msgs: ColOffset
Command:
options: Command
commandBuildIndex:
docgen: commandBuildIndex(conf: ConfigRef; dir: string; outFile = RelativeFile"")
commandDoc:
docgen: commandDoc(cache: IdentCache; conf: ConfigRef)
commandJson:
docgen: commandJson(cache: IdentCache; conf: ConfigRef)
commandLineDesc:
msgs: commandLineDesc
commandLineIdx:
lineinfos: commandLineIdx
commandRst2Html:
docgen: commandRst2Html(cache: IdentCache; conf: ConfigRef)
commandRst2TeX:
docgen: commandRst2TeX(cache: IdentCache; conf: ConfigRef)
commandTags:
docgen: commandTags(cache: IdentCache; conf: ConfigRef)
comment:
ast: comment(n: PNode): string
comment=:
ast: comment=(n: PNode; a: string)
commonOptimizations:
transf: commonOptimizations(g: ModuleGraph; idgen: IdGenerator; c: PSym; n: PNode): PNode
commonSuperclass:
types: commonSuperclass(a, b: PType): PType
commonType:
sem: commonType(c: PContext; x: PType; y: PNode): PType
sem: commonType(c: PContext; x, y: PType): PType
commonTypeBegin:
sem: commonTypeBegin(): PType
compareTypes:
types: compareTypes(x, y: PType; cmp: TDistinctCompare = dcEq; flags: TTypeCmpFlags = {}): bool
compatibleEffects:
types: compatibleEffects(formal, actual: PType): EffectsCompat
compilationCachePresent:
options: compilationCachePresent(conf: ConfigRef): untyped
compileModule:
modules: compileModule(graph: ModuleGraph; fileIdx: FileIndex; flags: TSymFlags; fromModule: PSym = nil): PSym
compileProject:
modules: compileProject(graph: ModuleGraph; projectFileIdx = InvalidFileIdx)
compilerProcsSection:
RodSection.compilerProcsSection
CompilesId:
ast: CompilesId
compileSystemModule:
modules: compileSystemModule(graph: ModuleGraph)
compiletimeFFI:
Feature.compiletimeFFI
complement:
nimsets: complement(conf: ConfigRef; a: PNode): PNode
completeCfilePath:
extccomp: completeCfilePath(conf: ConfigRef; cfile: AbsoluteFile; createSubDir: bool = true): AbsoluteFile
completeGeneratedFilePath:
options: completeGeneratedFilePath(conf: ConfigRef; f: AbsoluteFile; createSubDir: bool = true): AbsoluteFile
completePartialOp:
modulegraphs: completePartialOp(g: ModuleGraph; module: int; t: PType; op: TTypeAttachedOp; value: PSym)
computeAliveSyms:
dce: computeAliveSyms(g: PackedModuleGraph; conf: ConfigRef): AliveSyms
computeCursors:
varpartitions: computeCursors(s: PSym; n: PNode; g: ModuleGraph)
computeGraphPartitions:
varpartitions: computeGraphPartitions(s: PSym; n: PNode; g: ModuleGraph; goals: set[Goal]): Partitions
computeSize:
types: computeSize(conf: ConfigRef; typ: PType): BiggestInt
conceptMatch:
concepts: conceptMatch(c: PContext; concpt, arg: PType; bindings: var TIdTable; invocation: PType): bool
ConcreteTypes:
ast: ConcreteTypes
config:
cgendata: config(m: BModule): ConfigRef
cgendata: config(p: BProc): ConfigRef
jsgen: config(p: PProc): ConfigRef
semdata: config(c: PContext): ConfigRef
configComplete:
modulegraphs: configComplete(g: ModuleGraph)
configMismatch:
RodFileError.configMismatch
ConfigRef:
options: ConfigRef
configSection:
RodSection.configSection
connectCallbacks:
modules: connectCallbacks(graph: ModuleGraph)
ConsiderFlag:
sighashes: ConsiderFlag
considerGenSyms:
semdata: considerGenSyms(c: PContext; n: PNode)
considerQuotedIdent:
lookups: considerQuotedIdent(c: PContext; n: PNode; origin: PNode = nil): PIdent
ConstantDataTypes:
ast: ConstantDataTypes
constParameters:
Goal.constParameters
constPragmas:
pragmas: constPragmas
constructCfg:
dfa: constructCfg(s: PSym; body: PNode): ControlFlowGraph
contains:
btrees: contains[Key, Val](b: BTree[Key, Val]; key: Key): bool
containsCompileTimeOnly:
types: containsCompileTimeOnly(t: PType): bool
containsGarbageCollectedRef:
types: containsGarbageCollectedRef(typ: PType): bool
containsGenericType:
types: containsGenericType(t: PType): bool
containsHiddenPointer:
types: containsHiddenPointer(typ: PType): bool
containsManagedMemory:
types: containsManagedMemory(typ: PType): bool
containsNode:
ast: containsNode(n: PNode; kinds: TNodeKinds): bool
containsObject:
types: containsObject(t: PType): bool
containsSets:
nimsets: containsSets(conf: ConfigRef; a, b: PNode): bool
containsTyRef:
types: containsTyRef(typ: PType): bool
ControlFlowGraph:
dfa: ControlFlowGraph
converterPragmas:
pragmas: converterPragmas
convertersSection:
RodSection.convertersSection
CoOwnerSig:
ConsiderFlag.CoOwnerSig
CoProc:
ConsiderFlag.CoProc
copyFile:
pathutils: copyFile(source, dest: AbsoluteFile)
copyIdTable:
ast: copyIdTable(dest: var TIdTable; src: TIdTable)
copyInto:
packed_ast: copyInto(dest, n, body)
copyIntoKind:
packed_ast: copyIntoKind(dest, kind, info, body)
copyNode:
ast: copyNode(src: PNode): PNode
copyObjectSet:
ast: copyObjectSet(dest: var TObjectSet; src: TObjectSet)
copyrightYear:
options: copyrightYear
copyStrTable:
ast: copyStrTable(dest: var TStrTable; src: TStrTable)
copySym:
ast: copySym(s: PSym; id: ItemId): PSym
copyTree:
ast: copyTree(src: PNode): PNode
packed_ast: copyTree(dest: var PackedTree; tree: PackedTree; n: NodePos)
copyTreeWithoutNode:
ast: copyTreeWithoutNode(src, skippedNode: PNode): PNode
copyType:
ast: copyType(t: PType; id: ItemId; owner: PSym): PType
copyTypeProps:
modulegraphs: copyTypeProps(g: ModuleGraph; module: int; dest, src: PType)
CoType:
ConsiderFlag.CoType
countDefinedSymbols:
condsyms: countDefinedSymbols(symbols: StringTableRef): int
cpExact:
TCheckPointResult.cpExact
cpFuzzy:
TCheckPointResult.cpFuzzy
cpNone:
TCheckPointResult.cpNone
cppDefine:
options: cppDefine(c: ConfigRef; define: string)
cppNimSharedKeywords:
wordrecg: cppNimSharedKeywords
cpsInit:
TCProcSection.cpsInit
cpsLocals:
TCProcSection.cpsLocals
cpsStmts:
TCProcSection.cpsStmts
CPU:
platform: CPU
cpuAlpha:
TSystemCPU.cpuAlpha
cpuAmd64:
TSystemCPU.cpuAmd64
cpuArm:
TSystemCPU.cpuArm
cpuArm64:
TSystemCPU.cpuArm64
cpuAVR:
TSystemCPU.cpuAVR
cpuEsp:
TSystemCPU.cpuEsp
cpuHppa:
TSystemCPU.cpuHppa
cpuI386:
TSystemCPU.cpuI386
cpuIa64:
TSystemCPU.cpuIa64
cpuJS:
TSystemCPU.cpuJS
cpuM68k:
TSystemCPU.cpuM68k
cpuMips:
TSystemCPU.cpuMips
cpuMips64:
TSystemCPU.cpuMips64
cpuMips64el:
TSystemCPU.cpuMips64el
cpuMipsel:
TSystemCPU.cpuMipsel
cpuMSP430:
TSystemCPU.cpuMSP430
cpuNimVM:
TSystemCPU.cpuNimVM
cpuNone:
TSystemCPU.cpuNone
cpuPowerpc:
TSystemCPU.cpuPowerpc
cpuPowerpc64:
TSystemCPU.cpuPowerpc64
cpuPowerpc64el:
TSystemCPU.cpuPowerpc64el
cpuRiscV32:
TSystemCPU.cpuRiscV32
cpuRiscV64:
TSystemCPU.cpuRiscV64
cpuSparc:
TSystemCPU.cpuSparc
cpuSparc64:
TSystemCPU.cpuSparc64
cpuVm:
TSystemCPU.cpuVm
cpuWasm32:
TSystemCPU.cpuWasm32
CR:
nimlexbase: CR
create:
rodfiles: create(filename: string): RodFile
createClosureIterStateType:
lambdalifting: createClosureIterStateType(g: ModuleGraph; iter: PSym; idgen: IdGenerator): PType
createDir:
pathutils: createDir(x: AbsoluteDir)
createDocLink:
lineinfos: createDocLink(urlSuffix: string): string
createMagic:
modulegraphs: createMagic(g: ModuleGraph; idgen: IdGenerator; name: string; m: TMagic): PSym
createModuleAlias:
ast: createModuleAlias(s: PSym; id: ItemId; newIdent: PIdent; info: TLineInfo; options: TOptions): PSym
createObj:
lowerings: createObj(g: ModuleGraph; idgen: IdGenerator; owner: PSym; info: TLineInfo; final = true): PType
createTypeBoundOps:
liftdestructors: createTypeBoundOps(g: ModuleGraph; c: PContext; orig: PType; info: TLineInfo; idgen: IdGenerator)
csEmpty:
TCandidateState.csEmpty
csMatch:
TCandidateState.csMatch
csNoMatch:
TCandidateState.csNoMatch
ctArray:
TCTypeKind.ctArray
ctBool:
TCTypeKind.ctBool
ctChar:
TCTypeKind.ctChar
ctCString:
TCTypeKind.ctCString
ctfeWhitelist:
ast: ctfeWhitelist
ctFloat:
TCTypeKind.ctFloat
ctFloat128:
TCTypeKind.ctFloat128
ctFloat32:
TCTypeKind.ctFloat32
ctFloat64:
TCTypeKind.ctFloat64
ctInt:
TCTypeKind.ctInt
ctInt16:
TCTypeKind.ctInt16
ctInt32:
TCTypeKind.ctInt32
ctInt64:
TCTypeKind.ctInt64
ctInt8:
TCTypeKind.ctInt8
ctNimSeq:
TCTypeKind.ctNimSeq
ctNimStr:
TCTypeKind.ctNimStr
ctProc:
TCTypeKind.ctProc
ctPtr:
TCTypeKind.ctPtr
ctPtrToArray:
TCTypeKind.ctPtrToArray
ctStruct:
TCTypeKind.ctStruct
ctUInt:
TCTypeKind.ctUInt
ctUInt16:
TCTypeKind.ctUInt16
ctUInt32:
TCTypeKind.ctUInt32
ctUInt64:
TCTypeKind.ctUInt64
ctUInt8:
TCTypeKind.ctUInt8
ctVoid:
TCTypeKind.ctVoid
cursorInference:
Goal.cursorInference
CustomError:
ErrorKind.CustomError
cyclicTree:
trees: cyclicTree(n: PNode): bool
cyclicType:
liftdestructors: cyclicType(t: PType): bool
dataPointer:
strutils2: dataPointer[T](a: T): pointer
dcEq:
TDistinctCompare.dcEq
dcEqIgnoreDistinct:
TDistinctCompare.dcEqIgnoreDistinct
dcEqOrDistinctOf:
TDistinctCompare.dcEqOrDistinctOf
debug:
astalgo: debug(n: PNode; conf: ConfigRef = nil)
astalgo: debug(n: PSym; conf: ConfigRef = nil)
astalgo: debug(n: PType; conf: ConfigRef = nil)
astalgo: debug(x: PSym | PType | PNode)
astalgo: debug(x: auto)
ic: debug(tree: PackedTree; m: PackedModule)
debugEchoCode:
vmgen: debugEchoCode
debugScopes:
lookups: debugScopes(c: PContext; limit = 0; max = int.high)
declarativeDefs:
ast: declarativeDefs
declarePureEnumField:
importer: declarePureEnumField(c: PContext; s: PSym)
decodeStr:
rodutils: decodeStr(s: cstring; pos: var int): string
decodeStrArray:
rodutils: decodeStrArray(s: cstring): string
decodeVBiggestInt:
rodutils: decodeVBiggestInt(s: cstring; pos: var int): BiggestInt
decodeVInt:
rodutils: decodeVInt(s: cstring; pos: var int): int
decodeVIntArray:
rodutils: decodeVIntArray(s: cstring): int
deduplicate:
nimsets: deduplicate(conf: ConfigRef; a: PNode): PNode
def:
InstrKind.def
DefaultConfig:
options: DefaultConfig
DefaultConfigNims:
options: DefaultConfigNims
DefaultGlobalOptions:
options: DefaultGlobalOptions
defaultOffset:
ast: defaultOffset
DefaultOptions:
options: DefaultOptions
defaultParamSeparator:
typesrenderer: defaultParamSeparator
definedSymbolNames:
condsyms: definedSymbolNames(symbols: StringTableRef): string
defineSymbol:
condsyms: defineSymbol(symbols: StringTableRef; symbol: string; value: string = "true")
delSon:
ast: delSon(father: PNode; idx: int)
demanglePackageName:
options: demanglePackageName(path: string): string
depsSection:
RodSection.depsSection
describeArgs:
sigmatch: describeArgs(c: PContext; n: PNode; startIdx = 1; prefer = preferName): string
destructor:
liftdestructors: destructor(t: PType): PSym
Feature.destructor
detailedInfo:
ast: detailedInfo(sym: PSym): string
differ:
linter: differ(line: string; a, b: int; x: string): string
diffSets:
nimsets: diffSets(conf: ConfigRef; a, b: PNode): PNode
directIntLit:
packed_ast: directIntLit
directViewType:
typeallowed: directViewType(t: PType): ViewTypeKind
dirExists:
pathutils: dirExists(x: AbsoluteDir): bool
disabledSf:
SymbolFilesOption.disabledSf
disableNimblePath:
options: disableNimblePath(conf: ConfigRef)
discardSons:
ast: discardSons(father: PNode)
dispatcherPos:
ast: dispatcherPos
divMod:
int128: divMod(dividend, divisor: Int128): tuple[quotient, remainder: Int128]
doAbort:
TErrorHandling.doAbort
DocConfig:
options: DocConfig
docCss:
nimpaths: docCss
docgen2JsonPass:
docgen2: docgen2JsonPass
docgen2Pass:
docgen2: docgen2Pass
docgen2TexPass:
docgen2: docgen2TexPass
docHackJs:
nimpaths: docHackJs
docHackJsFname:
nimpaths: docHackJsFname
docHackNim:
nimpaths: docHackNim
docRootDefault:
options: docRootDefault
DocTexConfig:
options: DocTexConfig
documentRaises:
docgen: documentRaises(cache: IdentCache; n: PNode)
doesImply:
guards: doesImply(facts: TModel; prop: PNode): TImplication
doNothing:
TErrorHandling.doNothing
dontInlineConstant:
trees: dontInlineConstant(orig, cnst: PNode): bool
doRaise:
TErrorHandling.doRaise
dotdotMangle:
nimpaths: dotdotMangle
dotOperators:
Feature.dotOperators
dump:
vmprofiler: dump(conf: ConfigRef; pd: ProfileData): string
dynamicBindSym:
Feature.dynamicBindSym
eat:
parser: eat(p: var Parser; tokType: TokType)
echoCfg:
dfa: echoCfg(c: ControlFlowGraph; start = 0; last = -1)
echoCode:
vmgen: echoCode(c: PCtx; start = 0; last = -1)
efAllowStmt:
TExprFlag.efAllowStmt
efCompat:
EffectsCompat.efCompat
efDetermineType:
TExprFlag.efDetermineType
efEffectsDelayed:
EffectsCompat.efEffectsDelayed
efExplain:
TExprFlag.efExplain
effectListLen:
ast: effectListLen
EffectsCompat:
types: EffectsCompat
effectSpec:
trees: effectSpec(n: PNode; effectType: TSpecialWord): PNode
efFromHlo:
TExprFlag.efFromHlo
efInCall:
TExprFlag.efInCall
efInTypeof:
TExprFlag.efInTypeof
efLockLevelsDiffer:
EffectsCompat.efLockLevelsDiffer
efLValue:
TExprFlag.efLValue
efNeedStatic:
TExprFlag.efNeedStatic
efNoEvaluateGeneric:
TExprFlag.efNoEvaluateGeneric
efNoSem2Check:
TExprFlag.efNoSem2Check
efNoSemCheck:
TExprFlag.efNoSemCheck
efNoUndeclared:
TExprFlag.efNoUndeclared
efOperand:
TExprFlag.efOperand
efPreferNilResult:
TExprFlag.efPreferNilResult
efPreferStatic:
TExprFlag.efPreferStatic
efRaisesDiffer:
EffectsCompat.efRaisesDiffer
efRaisesUnknown:
EffectsCompat.efRaisesUnknown
efTagsDiffer:
EffectsCompat.efTagsDiffer
efTagsUnknown:
EffectsCompat.efTagsUnknown
efWantIterable:
TExprFlag.efWantIterable
efWantIterator:
TExprFlag.efWantIterator
efWantStmt:
TExprFlag.efWantStmt
efWantValue:
TExprFlag.efWantValue
elementType:
vmconv: elementType(T: typedesc): typedesc
ElemSize:
bitsets: ElemSize
elemType:
types: elemType(t: PType): PType
emConst:
TEvalMode.emConst
emOptimize:
TEvalMode.emOptimize
emptyNodeId:
packed_ast: emptyNodeId
emptyRange:
nimsets: emptyRange(a, b: PNode): bool
emRepl:
TEvalMode.emRepl
emStaticExpr:
TEvalMode.emStaticExpr
emStaticStmt:
TEvalMode.emStaticStmt
encode:
sourcemap: encode(i: int): string
encoder:
semdata: encoder(c): untyped
encodeStr:
rodutils: encodeStr(s: string; result: var string)
encodeVBiggestInt:
rodutils: encodeVBiggestInt(x: BiggestInt; result: var string)
encodeVInt:
rodutils: encodeVInt(x: int; result: var string)
EndianToStr:
platform: EndianToStr
EndOfFile:
nimlexbase: EndOfFile
endsWith:
llstream: endsWith(x: string; s: set[char]): bool
endsWithOpr:
llstream: endsWithOpr(x: string): bool
ensuresEffects:
ast: ensuresEffects
enter:
vmprofiler: enter(prof: var Profiler; c: PCtx; tos: PStackFrame)
enumFieldPragmas:
pragmas: enumFieldPragmas
enumHasHoles:
types: enumHasHoles(t: PType): bool
enumToStringProcsSection:
RodSection.enumToStringProcsSection
envName:
lambdalifting: envName
eqTypeFlags:
ast: eqTypeFlags
equalParams:
types: equalParams(a, b: PNode): TParamsEquality
equalSets:
nimsets: equalSets(conf: ConfigRef; a, b: PNode): bool
equalsFile:
ropes: equalsFile(r: Rope; filename: AbsoluteFile): bool
ropes: equalsFile(r: Rope; f: File): bool
eraseVoidParams:
semtypinst: eraseVoidParams(t: PType)
ERecoverableError:
lineinfos: ERecoverableError
errArgsNeedRunOption:
lineinfos: errArgsNeedRunOption
errCannotOpenFile:
TMsgKind.errCannotOpenFile
errFatal:
TMsgKind.errFatal
errGenerated:
TMsgKind.errGenerated
errIllFormedAstX:
TMsgKind.errIllFormedAstX
errInternal:
TMsgKind.errInternal
errMax:
lineinfos: errMax
errMin:
lineinfos: errMin
ErrorHandler:
lexer: ErrorHandler
ErrorKind:
errorhandling: ErrorKind
errorNode:
semdata: errorNode(c: PContext; n: PNode): PNode
errorSubNode:
errorhandling: errorSubNode(n: PNode): PNode
errorSym:
lookups: errorSym(c: PContext; n: PNode): PSym
errorToString:
errorhandling: errorToString(config: ConfigRef; n: PNode): string
errorType:
semdata: errorType(c: PContext): PType
semfold: errorType(g: ModuleGraph): PType
errorUndeclaredIdentifier:
lookups: errorUndeclaredIdentifier(c: PContext; info: TLineInfo; name: string; extra = "")
errorUndeclaredIdentifierHint:
lookups: errorUndeclaredIdentifierHint(c: PContext; n: PNode; ident: PIdent): PSym
errorUseQualifier:
lookups: errorUseQualifier(c: PContext; info: TLineInfo; s: PSym)
errProveInit:
TMsgKind.errProveInit
errRstFootnoteMismatch:
TMsgKind.errRstFootnoteMismatch
errRstGeneralParseError:
TMsgKind.errRstGeneralParseError
errRstGridTableNotImplemented:
TMsgKind.errRstGridTableNotImplemented
errRstInvalidDirectiveX:
TMsgKind.errRstInvalidDirectiveX
errRstInvalidField:
TMsgKind.errRstInvalidField
errRstMarkdownIllformedTable:
TMsgKind.errRstMarkdownIllformedTable
errRstNewSectionExpected:
TMsgKind.errRstNewSectionExpected
errUnknown:
TMsgKind.errUnknown
errUser:
TMsgKind.errUser
errXExpected:
TMsgKind.errXExpected
errXMustBeCompileTime:
lineinfos: errXMustBeCompileTime
ESC:
nimlexbase: ESC
eStdErr:
TErrorOutput.eStdErr
eStdOut:
TErrorOutput.eStdOut
ESuggestDone:
lineinfos: ESuggestDone
evalConstExpr:
vm: evalConstExpr(module: PSym; idgen: IdGenerator; g: ModuleGraph; e: PNode): PNode
evalExpr:
vm: evalExpr(c: PCtx; n: PNode): PNode
evalFrom:
importer: evalFrom(c: PContext; n: PNode): PNode
evalImport:
importer: evalImport(c: PContext; n: PNode): PNode
evalImportExcept:
importer: evalImportExcept(c: PContext; n: PNode): PNode
evalMacroCall:
vm: evalMacroCall(module: PSym; idgen: IdGenerator; g: ModuleGraph; templInstCounter: ref int; n, nOrig: PNode; sym: PSym): PNode
evalOnce:
lowerings: evalOnce(g: ModuleGraph; value: PNode; idgen: IdGenerator; owner: PSym): PNode
evalOp:
semfold: evalOp(m: TMagic; n, a, b, c: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
evalPass:
vm: evalPass
evalStaticExpr:
vm: evalStaticExpr(module: PSym; idgen: IdGenerator; g: ModuleGraph; e: PNode; prc: PSym): PNode
evalStaticStmt:
vm: evalStaticStmt(module: PSym; idgen: IdGenerator; g: ModuleGraph; e: PNode; prc: PSym)
evalStmt:
vm: evalStmt(c: PCtx; n: PNode)
evalTemplate:
evaltempl: evalTemplate(n: PNode; tmpl, genSymOwner: PSym; conf: ConfigRef; ic: IdentCache; instID: ref int; idgen: IdGenerator; fromHlo = false): PNode
evalTemplateLimit:
evaltempl: evalTemplateLimit
ExactConstraints:
TTypeCmpFlag.ExactConstraints
exactEquals:
msgs: exactEquals(a, b: TLineInfo): bool
ExactGcSafety:
TTypeCmpFlag.ExactGcSafety
ExactGenericParams:
TTypeCmpFlag.ExactGenericParams
exactReplica:
ast: exactReplica(t: PType): PType
ExactTypeDescValues:
TTypeCmpFlag.ExactTypeDescValues
excCpp:
ExceptionSystem.excCpp
exceptionEffects:
ast: exceptionEffects
ExceptionSystem:
options: ExceptionSystem
excGoto:
ExceptionSystem.excGoto
excNone:
ExceptionSystem.excNone
excQuirky:
ExceptionSystem.excQuirky
excSetjmp:
ExceptionSystem.excSetjmp
execExternalProgram:
extccomp: execExternalProgram(conf: ConfigRef; cmd: string; msg = hintExecuting)
execProc:
vm: execProc(c: PCtx; sym: PSym; args: openArray[PNode]): PNode
existsConfigVar:
options: existsConfigVar(conf: ConfigRef; key: string): bool
expectIdent:
parser: expectIdent(p: Parser)
expectIdentOrKeyw:
parser: expectIdentOrKeyw(p: Parser)
explanationsBaseUrl:
lineinfos: explanationsBaseUrl
ExportableSymKinds:
ast: ExportableSymKinds
exportsSection:
RodSection.exportsSection
exportSym:
semdata: exportSym(c: PContext; s: PSym)
ExpressionCannotBeCalled:
ErrorKind.ExpressionCannotBeCalled
exprPragmas:
pragmas: exprPragmas
exprRoot:
parampatterns: exprRoot(n: PNode): PSym
exprStructuralEquivalent:
trees: exprStructuralEquivalent(a, b: PNode; strictSymEquality = false): bool
externIntLit:
packed_ast: externIntLit
externSIntLit:
packed_ast: externSIntLit
externUIntLit:
packed_ast: externUIntLit
extractFilename:
pathutils: extractFilename(x: AbsoluteFile): string
extractRange:
trees: extractRange(k: TNodeKind; n: PNode; a, b: int): PNode
extractRunnableExamplesSource:
renderverbatim: extractRunnableExamplesSource(conf: ConfigRef; n: PNode; indent = 0): string
fakePackageName:
options: fakePackageName(conf: ConfigRef; path: AbsoluteFile): string
fastLog2:
int128: fastLog2(a: Int128): int
fatal:
msgs: fatal(conf: ConfigRef; info: TLineInfo; arg = ""; msg = errFatal)
fatalMsgs:
lineinfos: fatalMsgs
Feature:
options: Feature
FF:
nimlexbase: FF
fieldPragmas:
pragmas: fieldPragmas
fieldVisible:
sigmatch: fieldVisible(c: PContext; f: PSym): bool
fileExists:
pathutils: fileExists(x: AbsoluteFile): bool
fileIdx:
ast: fileIdx(c: PSym): FileIndex
FileIndex:
lineinfos: FileIndex
fileInfoIdx:
msgs: fileInfoIdx(conf: ConfigRef; filename: AbsoluteFile): FileIndex
msgs: fileInfoIdx(conf: ConfigRef; filename: AbsoluteFile; isKnownFile: var bool): FileIndex
fileInfoKnown:
msgs: fileInfoKnown(conf: ConfigRef; filename: AbsoluteFile): bool
filename:
ast: filename(c: PSym): string
semdata: filename(c: PContext): string
FilenameOption:
options: FilenameOption
fillObjectFields:
cgen: fillObjectFields(m: BModule; typ: PType)
fillTypeS:
semdata: fillTypeS(dest: PType; kind: TTypeKind; c: PContext)
filterReplace:
filters: filterReplace(conf: ConfigRef; stdin: PLLStream; filename: AbsoluteFile; call: PNode): PLLStream
filterStrip:
filters: filterStrip(conf: ConfigRef; stdin: PLLStream; filename: AbsoluteFile; call: PNode): PLLStream
filterTmpl:
filter_tmpl: filterTmpl(conf: ConfigRef; stdin: PLLStream; filename: AbsoluteFile; call: PNode): PLLStream
finalCodegenActions:
cgen: finalCodegenActions(graph: ModuleGraph; m: BModule; n: PNode)
findFile:
options: findFile(conf: ConfigRef; f: string; suppressStdlib = false): AbsoluteFile
findModule:
options: findModule(conf: ConfigRef; modulename, currentModule: string): AbsoluteFile
findNodeJs:
nodejs: findNodeJs(): string
findPragma:
trees: findPragma(n: PNode; which: TSpecialWord): PNode
findProjectNimFile:
options: findProjectNimFile(conf: ConfigRef; pkg: string): string
findStr:
wordrecg: findStr[T: enum](a, b: static[T]; s: string; default: T): T
findUnresolvedStatic:
ast: findUnresolvedStatic(n: PNode): PNode
finishDoc2Pass:
docgen2: finishDoc2Pass(project: string)
finishGenerateDoc:
docgen: finishGenerateDoc(d: var PDoc)
firstABxInstr:
vmdef: firstABxInstr
FirstCallConv:
pragmas: FirstCallConv
firstFloat:
types: firstFloat(t: PType): BiggestFloat
firstIdentExcluding:
astalgo: firstIdentExcluding(ti: var TIdentIter; tab: TStrTable; s: PIdent; excluding: IntSet): PSym
firstOrd:
types: firstOrd(conf: ConfigRef; t: PType): Int128
firstSon:
packed_ast: firstSon(n: NodePos): NodePos
packed_ast: firstSon(tree: PackedTree; n: NodePos): NodePos
fitsRegister:
vmgen: fitsRegister(t: PType): bool
flags:
packed_ast: flags(n: NodePos): TNodeFlags
flattenStmts:
trees: flattenStmts(n: PNode): PNode
floatInt64Align:
options: floatInt64Align(conf: ConfigRef): int16
FloatLike:
OrdinalType.FloatLike
floatRangeCheck:
types: floatRangeCheck(x: BiggestFloat; t: PType): bool
flushDot:
msgs: flushDot(conf: ConfigRef)
foAbs:
FilenameOption.foAbs
foCanonical:
FilenameOption.foCanonical
foldAlignOf:
types: foldAlignOf(conf: ConfigRef; n: PNode; fallback: PNode): PNode
foldOffsetOf:
types: foldOffsetOf(conf: ConfigRef; n: PNode; fallback: PNode): PNode
foldSizeOf:
types: foldSizeOf(conf: ConfigRef; n: PNode; fallback: PNode): PNode
foLegacyRelProj:
FilenameOption.foLegacyRelProj
foName:
FilenameOption.foName
forceCopy:
strutils2: forceCopy(result: var string; a: string)
foreignPackageNotesDefault:
options: foreignPackageNotesDefault
foRelProject:
FilenameOption.foRelProject
fork:
InstrKind.fork
forLoopMacros:
Feature.forLoopMacros
formatMsg:
msgs: formatMsg(conf: ConfigRef; info: TLineInfo; msg: TMsgKind; arg: string): string
FormatStr:
ropes: FormatStr
forVarPragmas:
pragmas: forVarPragmas
foStacktrace:
FilenameOption.foStacktrace
frameDeclared:
CodegenFlag.frameDeclared
frEmbedded:
TTypeFieldResult.frEmbedded
freshVarForClosureIter:
lambdalifting: freshVarForClosureIter(g: ModuleGraph; s: PSym; idgen: IdGenerator; owner: PSym): PNode
frHeader:
TTypeFieldResult.frHeader
frNone:
TTypeFieldResult.frNone
fromLit:
vmconv: fromLit(a: PNode; T: typedesc): auto
fromSystem:
astalgo: fromSystem(op: PSym): bool
FullId:
modulegraphs: FullId
gCacheIntTries:
ropes: gCacheIntTries
gCacheMisses:
ropes: gCacheMisses
gCacheTries:
ropes: gCacheTries
gcArc:
TGCMode.gcArc
gcBoehm:
TGCMode.gcBoehm
gcGo:
TGCMode.gcGo
gcHooks:
TGCMode.gcHooks
gcMarkAndSweep:
TGCMode.gcMarkAndSweep
gCmdLineInfo:
msgs: gCmdLineInfo
gcNone:
TGCMode.gcNone
gcOrc:
TGCMode.gcOrc
gcRefc:
TGCMode.gcRefc
gcRegions:
TGCMode.gcRegions
GcTypeKinds:
ast: GcTypeKinds
gcUnselected:
TGCMode.gcUnselected
gcV2:
TGCMode.gcV2
gen:
sourcemap: gen(map: SourceMapGenerator): SourceMap
genAddrOf:
lowerings: genAddrOf(n: PNode; idgen: IdGenerator; typeKind = tyPtr): PNode
genBuiltin:
liftdestructors: genBuiltin(g: ModuleGraph; idgen: IdGenerator; magic: TMagic; name: string; i: PNode): PNode
genCaseObjDiscMapping:
enumtostr: genCaseObjDiscMapping(t: PType; field: PSym; info: TLineInfo; g: ModuleGraph; idgen: IdGenerator): PSym
gendependPass:
depends: gendependPass
genDeref:
lowerings: genDeref(n: PNode; k = nkHiddenDeref): PNode
genEnumToStrProc:
enumtostr: genEnumToStrProc(t: PType; info: TLineInfo; g: ModuleGraph; idgen: IdGenerator): PSym
generateCode:
cbackend: generateCode(g: ModuleGraph)
generateDoc:
docgen: generateDoc(d: PDoc; n, orig: PNode; docFlags: DocFlags = kDefault)
generateDot:
depends: generateDot(graph: ModuleGraph; project: AbsoluteFile)
generateIndex:
docgen: generateIndex(d: PDoc)
generateJson:
docgen: generateJson(d: PDoc; n: PNode; includeComments: bool = true)
generateMethodDispatchers:
cgmeth: generateMethodDispatchers(g: ModuleGraph): PNode
generateTags:
docgen: generateTags(d: PDoc; n: PNode; r: var string)
generateTypeInstance:
semtypinst: generateTypeInstance(p: PContext; pt: TIdTable; info: TLineInfo; t: PType): PType
semtypinst: generateTypeInstance(p: PContext; pt: TIdTable; arg: PNode; t: PType): untyped
genericParamsInMacroCall:
vm: genericParamsInMacroCall(macroSym: PSym; call: PNode): (PSym, PNode)
genericParamsPos:
ast: genericParamsPos
GenericTypes:
ast: GenericTypes
genExpr:
vmgen: genExpr(c: PCtx; n: PNode; requiresValue = true): int
genFieldDefect:
astmsgs: genFieldDefect(conf: ConfigRef; field: string; disc: PSym): string
genHigh:
lowerings: genHigh(g: ModuleGraph; n: PNode): PNode
genLen:
lowerings: genLen(g: ModuleGraph; n: PNode): PNode
genPrefix:
lowerings: genPrefix
genProc:
vmgen: genProc(c: PCtx; s: PSym): int
genSourceMap:
sourcemap: genSourceMap(source: string; outFile: string): (Rope, SourceMap)
genStmt:
vmgen: genStmt(c: PCtx; n: PNode): int
genSubDir:
options: genSubDir
genSuccessX:
msgs: genSuccessX(conf: ConfigRef)
genTopLevelStmt:
cgen: genTopLevelStmt(m: BModule; n: PNode)
genTypeInfo:
cgen: genTypeInfo(config: ConfigRef; m: BModule; t: PType; info: TLineInfo): Rope
get:
semdata: get(p: PProcCon; key: PSym): PSym
getAlign:
types: getAlign(conf: ConfigRef; typ: PType): BiggestInt
getAttachedOp:
modulegraphs: getAttachedOp(g: ModuleGraph; t: PType; op: TTypeAttachedOp): PSym
getBody:
modulegraphs: getBody(g: ModuleGraph; s: PSym): PNode
getBool:
vm: getBool(a: VmArgs; i: Natural): bool
getClockStr:
options: getClockStr(): string
getClosureIterResult:
lambdalifting: getClosureIterResult(g: ModuleGraph; iter: PSym; idgen: IdGenerator): PSym
getColNumber:
nimlexbase: getColNumber(L: TBaseLexer; pos: int): int
getCompileCFileCmd:
extccomp: getCompileCFileCmd(conf: ConfigRef; cfile: Cfile; isMainFile = false; produceOutput = false): string
getCompilerProc:
magicsys: getCompilerProc(g: ModuleGraph; name: string): PSym
getConfigVar:
options: getConfigVar(conf: ConfigRef; key: string; default = ""): string
getConstExpr:
semfold: getConstExpr(m: PSym; n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
getCurrentLine:
nimlexbase: getCurrentLine(L: TBaseLexer; marker: bool = true): string
getCurrOwner:
semdata: getCurrOwner(c: PContext): PSym
getDateStr:
options: getDateStr(): string
getDeclPragma:
ast: getDeclPragma(n: PNode): PNode
getDispatcher:
cgmeth: getDispatcher(s: PSym): PSym
getDocHacksJs:
nimpaths: getDocHacksJs(nimr: string; nim = getCurrentCompilerExe(); forceRebuild = false): string
getEnvParam:
lambdalifting: getEnvParam(routine: PSym): PSym
getFieldFromObj:
lowerings: getFieldFromObj(t: PType; v: PSym): PSym
getFloat:
ast: getFloat(a: PNode): BiggestFloat
vm: getFloat(a: VmArgs; i: Natural): BiggestFloat
getFloatLitType:
magicsys: getFloatLitType(g: ModuleGraph; literal: PNode): PType
getFloatValue:
types: getFloatValue(n: PNode): BiggestFloat
getGenSym:
semdata: getGenSym(c: PContext; s: PSym): PSym
getGlobalValue:
vm: getGlobalValue(c: PCtx; s: PSym): PNode
getHash:
msgs: getHash(conf: ConfigRef; fileIdx: FileIndex): string
getIdent:
idents: getIdent(ic: IdentCache; identifier: cstring; length: int; h: Hash): PIdent
idents: getIdent(ic: IdentCache; identifier: string): PIdent
idents: getIdent(ic: IdentCache; identifier: string; h: Hash): PIdent
getIndentWidth:
lexer: getIndentWidth(fileIdx: FileIndex; inputstream: PLLStream; cache: IdentCache; config: ConfigRef): int
getInfoContext:
msgs: getInfoContext(conf: ConfigRef; index: int): TLineInfo
getInfoContextLen:
msgs: getInfoContextLen(conf: ConfigRef): int
getInt:
ast: getInt(a: PNode): Int128
vm: getInt(a: VmArgs; i: Natural): BiggestInt
getInt64:
ast: getInt64(a: PNode): int64
getIntLitType:
semdata: getIntLitType(c: PContext; literal: PNode): PType
getKeyId:
bitabs: getKeyId[T](t: BiTable[T]; v: T): LitId
getLineInfo:
lexer: getLineInfo(L: Lexer; tok: Token): TLineInfo
getMagic:
trees: getMagic(op: PNode): TMagic
getMagicEqSymForType:
magicsys: getMagicEqSymForType(g: ModuleGraph; t: PType; info: TLineInfo): PSym
getModule:
astalgo: getModule(s: PSym): PSym
modulegraphs: getModule(g: ModuleGraph; fileIdx: FileIndex): PSym
getModuleName:
modulepaths: getModuleName(conf: ConfigRef; n: PNode): string
getNamedParamFromList:
astalgo: getNamedParamFromList(list: PNode; ident: PIdent): PSym
getNextTok:
renderer: getNextTok(r: var TSrcGen; kind: var TokType; literal: var string)
getNimbleFile:
options: getNimbleFile(conf: ConfigRef; path: string): string
getnimblePkg:
ast: getnimblePkg(a: PSym): PSym
getnimblePkgId:
ast: getnimblePkgId(a: PSym): int
getNimcacheDir:
options: getNimcacheDir(conf: ConfigRef): AbsoluteDir
getNimScriptSymbol:
magicsys: getNimScriptSymbol(g: ModuleGraph; name: string): PSym
getNode:
vm: getNode(a: VmArgs; i: Natural): PNode
getNodeAddr:
vm: getNodeAddr(a: VmArgs; i: Natural): PNode
getNodeId:
packed_ast: getNodeId(tree: PackedTree): NodeId
getNullValue:
vmgen: getNullValue(typ: PType; info: TLineInfo; conf: ConfigRef): PNode
getOrDefault:
btrees: getOrDefault[Key, Val](b: BTree[Key, Val]; key: Key): Val
getOrdValue:
types: getOrdValue(n: PNode; onError = high(Int128)): Int128
getOrIncl:
bitabs: getOrIncl[T](t: var BiTable[T]; v: T): LitId
getOutFile:
options: getOutFile(conf: ConfigRef; filename: RelativeFile; ext: string): AbsoluteFile
getPackageName:
options: getPackageName(conf: ConfigRef; path: string): string
getPathVersionChecksum:
nimblecmd: getPathVersionChecksum(p: string): tuple[name, version, checksum: string]
getPIdent:
ast: getPIdent(a: PNode): PIdent
getPlugin:
active: getPlugin(ic: IdentCache; fn: PSym): Transformation
getPragmaStmt:
ccgutils: getPragmaStmt(n: PNode; w: TSpecialWord): PNode
getPragmaVal:
pragmas: getPragmaVal(procAst: PNode; name: TSpecialWord): PNode
getPrecedence:
lexer: getPrecedence(ident: PIdent): int
lexer: getPrecedence(tok: Token): int
getPrefixDir:
options: getPrefixDir(conf: ConfigRef): AbsoluteDir
getProcConvMismatch:
types: getProcConvMismatch(c: ConfigRef; f, a: PType; rel = isNone): ( set[ProcConvMismatch], TTypeRelation)
getProcHeader:
types: getProcHeader(conf: ConfigRef; sym: PSym; prefer: TPreferedDesc = preferName; getDeclarationPath = true): string
getRelativePathFromConfigPath:
options: getRelativePathFromConfigPath(conf: ConfigRef; f: AbsoluteFile; isTitle = false): RelativeFile
getReturnType:
types: getReturnType(s: PSym): PType
getRoot:
trees: getRoot(n: PNode): PSym
getSize:
types: getSize(conf: ConfigRef; typ: PType): BiggestInt
getStateField:
lambdalifting: getStateField(g: ModuleGraph; owner: PSym): PSym
getStdlibVersion:
options: getStdlibVersion(conf: ConfigRef): NimVer
getStr:
ast: getStr(a: PNode): string
getString:
vm: getString(a: VmArgs; i: Natural): string
getStrOrChar:
ast: getStrOrChar(a: PNode): string
getSymFromList:
astalgo: getSymFromList(list: PNode; ident: PIdent; start: int = 0): PSym
getSymRepr:
lookups: getSymRepr(conf: ConfigRef; s: PSym; getDeclarationPath = true): string
getSysMagic:
magicsys: getSysMagic(g: ModuleGraph; info: TLineInfo; name: string; m: TMagic): PSym
getSysSym:
magicsys: getSysSym(g: ModuleGraph; info: TLineInfo; name: string): PSym
getSystemConfigPath:
nimconf: getSystemConfigPath(conf: ConfigRef; filename: RelativeFile): AbsoluteFile
getSysType:
magicsys: getSysType(g: ModuleGraph; info: TLineInfo; kind: TTypeKind): PType
getTok:
parser: getTok(p: var Parser)
getTokSym:
renderer: getTokSym(r: TSrcGen): PSym
getToStringProc:
modulegraphs: getToStringProc(g: ModuleGraph; t: PType): PSym
getUniqueType:
ccgutils: getUniqueType(key: PType): PType
getUserConfigPath:
nimconf: getUserConfigPath(filename: RelativeFile): AbsoluteFile
getVar:
vm: getVar(a: VmArgs; i: Natural): PNode
ggDebug:
ast: ggDebug
globalAssert:
msgs: globalAssert(conf: ConfigRef; cond: untyped; info: TLineInfo = unknownLineInfo; arg = "")
globalError:
msgs: globalError(conf: ConfigRef; info: TLineInfo; arg: string)
msgs: globalError(conf: ConfigRef; info: TLineInfo; msg: TMsgKind; arg = "")
gloptNone:
TGlobalOption.gloptNone
Goal:
varpartitions: Goal
goto:
InstrKind.goto
GrowthFactor:
ast: GrowthFactor
handleCmdInput:
commands: handleCmdInput(conf: ConfigRef)
handleCR:
nimlexbase: handleCR(L: var TBaseLexer; pos: int): int
handleDocOutputOptions:
docgen: handleDocOutputOptions(conf: ConfigRef)
handleLF:
nimlexbase: handleLF(L: var TBaseLexer; pos: int): int
handleStdinInput:
commands: handleStdinInput(conf: ConfigRef)
harmlessOptions:
options: harmlessOptions
hasAssume:
TInfoCCProp.hasAssume
hasAtLeastXsons:
packed_ast: hasAtLeastXsons(tree: PackedTree; n: NodePos; x: int): bool
hasAttribute:
TInfoCCProp.hasAttribute
hasComputedGoto:
TInfoCCProp.hasComputedGoto
hasCpp:
TInfoCCProp.hasCpp
hasCurFramePointer:
TCProcFlag.hasCurFramePointer
HasDatInitProc:
ModuleBackendFlag.HasDatInitProc
hasDeclspec:
TInfoCCProp.hasDeclspec
hasDestructor:
ast: hasDestructor(t: PType): bool
hasDisabledAsgn:
modulegraphs: hasDisabledAsgn(g: ModuleGraph; t: PType): bool
hasFauxMatch:
sigmatch: hasFauxMatch(c: TCandidate): bool
hasFFI:
options: hasFFI
hasGcGuard:
TInfoCCProp.hasGcGuard
hasGnuAsm:
TInfoCCProp.hasGnuAsm
hash:
ast: hash(x: ItemId): Hash
bitabs: hash[T](t: BiTable[T]): Hash
bitabs: hash(x: LitId): Hash
packed_ast: hash(a: SymId): Hash
idents: hash(x: PIdent): Hash
lineinfos: hash(i: TLineInfo): Hash
modulegraphs: hash(x: FileIndex): Hash
modulegraphs: hash(u: SigHash): Hash
hasHint:
options: hasHint(conf: ConfigRef; note: TNoteKind): bool
hashMainCompilationParams:
main: hashMainCompilationParams(conf: ConfigRef): string
hashNode:
astalgo: hashNode(p: RootRef): Hash
hashNonProc:
sighashes: hashNonProc(s: PSym): SigHash
hashOwner:
sighashes: hashOwner(s: PSym): SigHash
hashProc:
sighashes: hashProc(s: PSym): SigHash
hashString:
ccgutils: hashString(conf: ConfigRef; s: string): BiggestInt
hashTree:
treetab: hashTree(n: PNode): Hash
hashType:
sighashes: hashType(t: PType; flags: set[ConsiderFlag] = {CoType}): SigHash
hasLitId:
bitabs: hasLitId[T](t: BiTable[T]; x: LitId): bool
HasModuleInitProc:
ModuleBackendFlag.HasModuleInitProc
hasNext:
btrees: hasNext[Key, Val](b: BTree[Key, Val]; index: int): bool
hasNilSon:
ast: hasNilSon(n: PNode): bool
hasPattern:
ast: hasPattern(s: PSym): bool
hasPragma:
pragmas: hasPragma(n: PNode; pragma: TSpecialWord): bool
hasSideEffect:
varpartitions: hasSideEffect(c: var Partitions; info: var MutationInfo): bool
hasSonWith:
ast: hasSonWith(n: PNode; kind: TNodeKind): bool
hasSubnodeWith:
ast: hasSubnodeWith(n: PNode; kind: TNodeKind): bool
hasSwitchRange:
TInfoCCProp.hasSwitchRange
hasTinyCBackend:
options: hasTinyCBackend
hasWarn:
options: hasWarn(conf: ConfigRef; note: TNoteKind): bool
hasXsons:
packed_ast: hasXsons(tree: PackedTree; n: NodePos; x: int): bool
hcrOn:
options: hcrOn(conf: ConfigRef): bool
hExt:
extccomp: hExt
hiddenSection:
RodSection.hiddenSection
high:
int128: high(t: typedesc[Int128]): Int128
highBound:
guards: highBound(conf: ConfigRef; x: PNode; o: Operators): PNode
hintCC:
TMsgKind.hintCC
hintCodeBegin:
TMsgKind.hintCodeBegin
hintCodeEnd:
TMsgKind.hintCodeEnd
hintConditionAlwaysFalse:
TMsgKind.hintConditionAlwaysFalse
hintConditionAlwaysTrue:
TMsgKind.hintConditionAlwaysTrue
hintConf:
TMsgKind.hintConf
hintConvFromXtoItselfNotNeeded:
TMsgKind.hintConvFromXtoItselfNotNeeded
hintConvToBaseNotNeeded:
TMsgKind.hintConvToBaseNotNeeded
hintDeclaredLoc:
TMsgKind.hintDeclaredLoc
hintDependency:
TMsgKind.hintDependency
hintDuplicateModuleImport:
TMsgKind.hintDuplicateModuleImport
hintExecuting:
TMsgKind.hintExecuting
hintExpandMacro:
TMsgKind.hintExpandMacro
hintExprAlwaysX:
TMsgKind.hintExprAlwaysX
hintExtendedContext:
TMsgKind.hintExtendedContext
hintGCStats:
TMsgKind.hintGCStats
hintGlobalVar:
TMsgKind.hintGlobalVar
hintLineTooLong:
TMsgKind.hintLineTooLong
hintLinking:
TMsgKind.hintLinking
hintMax:
lineinfos: hintMax
hintMin:
lineinfos: hintMin
hintMsgOrigin:
TMsgKind.hintMsgOrigin
hintName:
TMsgKind.hintName
hintPath:
TMsgKind.hintPath
hintPattern:
TMsgKind.hintPattern
hintPerformance:
TMsgKind.hintPerformance
hintProcessing:
TMsgKind.hintProcessing
hintProcessingStmt:
TMsgKind.hintProcessingStmt
hintQuitCalled:
TMsgKind.hintQuitCalled
hintSource:
TMsgKind.hintSource
hintStackTrace:
TMsgKind.hintStackTrace
hintSuccess:
TMsgKind.hintSuccess
hintSuccessX:
TMsgKind.hintSuccessX
hintUser:
TMsgKind.hintUser
hintUserRaw:
TMsgKind.hintUserRaw
hintXCannotRaiseY:
TMsgKind.hintXCannotRaiseY
hintXDeclaredButNotUsed:
TMsgKind.hintXDeclaredButNotUsed
htmldocsDir:
options: htmldocsDir
htmldocsDirname:
nimpaths: htmldocsDirname
HtmlExt:
options: HtmlExt
id:
ast: id(a: PIdObj): int
ideChk:
IdeCmd.ideChk
IdeCmd:
options: IdeCmd
ideCon:
IdeCmd.ideCon
ideDef:
IdeCmd.ideDef
ideDus:
IdeCmd.ideDus
ideHighlight:
IdeCmd.ideHighlight
ideKnown:
IdeCmd.ideKnown
ideMod:
IdeCmd.ideMod
ideMsg:
IdeCmd.ideMsg
ideNone:
IdeCmd.ideNone
IdentCache:
idents: IdentCache
identLen:
linter: identLen(line: string; start: int): int
ideOutline:
IdeCmd.ideOutline
ideProject:
IdeCmd.ideProject
ideSug:
IdeCmd.ideSug
ideUse:
IdeCmd.ideUse
IdGenerator:
ast: IdGenerator
idGeneratorFromModule:
ast: idGeneratorFromModule(m: PSym): IdGenerator
idgenFromLoadedModule:
ic: idgenFromLoadedModule(m: LoadedModule): IdGenerator
idNodeTableGet:
astalgo: idNodeTableGet(t: TIdNodeTable; key: PIdObj): PNode
idNodeTablePut:
astalgo: idNodeTablePut(t: var TIdNodeTable; key: PIdObj; val: PNode)
idOrSig:
sighashes: idOrSig(s: PSym; currentModule: string; sigCollisions: var CountTable[SigHash]): Rope
idTableGet:
astalgo: idTableGet(t: TIdTable; key: int): RootRef
astalgo: idTableGet(t: TIdTable; key: PIdObj): RootRef
idTableHasObjectAsKey:
astalgo: idTableHasObjectAsKey(t: TIdTable; key: PIdObj): bool
idTablePairs:
astalgo: idTablePairs(t: TIdTable): tuple[key: PIdObj, val: RootRef]
idTablePut:
astalgo: idTablePut(t: var TIdTable; key: PIdObj; val: RootRef)
Iface:
modulegraphs: Iface
IgnoreCC:
TTypeCmpFlag.IgnoreCC
IgnoreTupleFields:
TTypeCmpFlag.IgnoreTupleFields
iiTableGet:
astalgo: iiTableGet(t: TIITable; key: int): int
iiTablePut:
astalgo: iiTablePut(t: var TIITable; key, val: int)
illegalCustomPragma:
pragmas: illegalCustomPragma(c: PContext; n: PNode; s: PSym)
illFormedAst:
semdata: illFormedAst(n: PNode; conf: ConfigRef)
illFormedAstLocal:
semdata: illFormedAstLocal(n: PNode; conf: ConfigRef)
immutableView:
ViewTypeKind.immutableView
implicitDeref:
Feature.implicitDeref
implicitPragmas:
pragmas: implicitPragmas(c: PContext; sym: PSym; info: TLineInfo; validPragmas: TSpecialWords)
impliesNotNil:
guards: impliesNotNil(m: TModel; arg: PNode): TImplication
impNo:
TImplication.impNo
importAll:
ImportMode.importAll
importAllSymbols:
importer: importAllSymbols(c: PContext; fromMod: PSym)
importantComments:
options: importantComments(conf: ConfigRef): bool
importcCond:
vmgen: importcCond(c: PCtx; s: PSym): bool
importcCondVar:
vmgen: importcCondVar(s: PSym): bool
importedItems:
lookups: importedItems(c: PContext; name: PIdent): PSym
ImportedModule:
semdata: ImportedModule
importExcept:
ImportMode.importExcept
ImportMode:
semdata: ImportMode
importModule:
modules: importModule(graph: ModuleGraph; s: PSym; fileIdx: FileIndex): PSym
importSet:
ImportMode.importSet
impUnknown:
TImplication.impUnknown
impYes:
TImplication.impYes
inc:
int128: inc(a: var Int128; y: uint32 = 1)
inCheckpoint:
sigmatch: inCheckpoint(current, trackPos: TLineInfo): TCheckPointResult
inclDynlibOverride:
options: inclDynlibOverride(conf: ConfigRef; lib: string)
includeFileChanged:
RodFileError.includeFileChanged
includeHeader:
cgendata: includeHeader(this: BModule; header: string)
includeModule:
modules: includeModule(graph: ModuleGraph; s: PSym; fileIdx: FileIndex): PNode
reorder: includeModule(graph: ModuleGraph; s: PSym; fileIdx: FileIndex): PNode
includesStringh:
CodegenFlag.includesStringh
incompleteType:
ast: incompleteType(t: PType): bool
indAndComment:
parser: indAndComment(p: var Parser; n: PNode; maybeMissEquals = false)
index:
sourcemap: index[T](elements: seq[T]; element: T): int
indirectAccess:
lowerings: indirectAccess(a: PNode; b: ItemId; info: TLineInfo): PNode
lowerings: indirectAccess(a: PNode; b: PSym; info: TLineInfo): PNode
lowerings: indirectAccess(a: PNode; b: string; info: TLineInfo; cache: IdentCache): PNode
lowerings: indirectAccess(a, b: PSym; info: TLineInfo): PNode
inferStaticParam:
sigmatch: inferStaticParam(c: var TCandidate; lhs: PNode; rhs: BiggestInt): bool
info:
packed_ast: info(tree: PackedTree; n: NodePos): PackedLineInfo
packed_ast: info(n: NodePos): PackedLineInfo
inheritanceDiff:
types: inheritanceDiff(a, b: PType): int
IniExt:
options: IniExt
initBTree:
btrees: initBTree[Key, Val](): BTree[Key, Val]
initCandidate:
sigmatch: initCandidate(ctx: PContext; c: var TCandidate; callee: PSym; binding: PNode; calleeScope = -1; diagnosticsEnabled = false)
sigmatch: initCandidate(ctx: PContext; c: var TCandidate; callee: PType)
initDefines:
condsyms: initDefines(symbols: StringTableRef)
initDefinesProg:
cmdlinehelper: initDefinesProg(self: NimProg; conf: ConfigRef; name: string)
initEncoder:
ic: initEncoder(c: var PackedEncoder; m: var PackedModule; moduleSym: PSym; config: ConfigRef; pc: PackedConfig)
modulegraphs: initEncoder(g: ModuleGraph; module: PSym)
initIdentIter:
astalgo: initIdentIter(ti: var TIdentIter; tab: TStrTable; s: PIdent): PSym
initIdNodeTable:
ast: initIdNodeTable(x: var TIdNodeTable)
initIdTable:
ast: initIdTable(x: var TIdTable)
initIiTable:
astalgo: initIiTable(x: var TIITable)
initLayeredTypeMap:
semtypinst: initLayeredTypeMap(pt: TIdTable): LayeredIdTable
initModuleIter:
modulegraphs: initModuleIter(mi: var ModuleIter; g: ModuleGraph; m: PSym; name: PIdent): PSym
initMsgConfig:
lineinfos: initMsgConfig(): MsgConfig
initNodeTable:
ast: initNodeTable(x: var TNodeTable)
initObjectSet:
ast: initObjectSet(x: var TObjectSet)
initOperators:
modulegraphs: initOperators(g: ModuleGraph): Operators
initOverloadIter:
lookups: initOverloadIter(o: var TOverloadIter; c: PContext; n: PNode): PSym
initPackedDecoder:
ic: initPackedDecoder(config: ConfigRef; cache: IdentCache): PackedDecoder
initRodIter:
ic: initRodIter(it: var RodIter; config: ConfigRef; cache: IdentCache; g: var PackedModuleGraph; module: FileIndex; name: PIdent; importHidden: bool): PSym
initRodIterAllSyms:
ic: initRodIterAllSyms(it: var RodIter; config: ConfigRef; cache: IdentCache; g: var PackedModuleGraph; module: FileIndex; importHidden: bool): PSym
initStrTable:
ast: initStrTable(x: var TStrTable)
initStrTables:
modulegraphs: initStrTables(g: ModuleGraph; m: PSym)
initTabIter:
astalgo: initTabIter(ti: var TTabIter; tab: TStrTable): PSym
initToken:
lexer: initToken(L: var Token)
initTokRender:
renderer: initTokRender(r: var TSrcGen; n: PNode; renderFlags: TRenderFlags = {})
initTypeVars:
semtypinst: initTypeVars(p: PContext; typeMap: LayeredIdTable; info: TLineInfo; owner: PSym): TReplTypeVars
initVars:
extccomp: initVars(conf: ConfigRef)
injectDestructorCalls:
injectdestructors: injectDestructorCalls(g: ModuleGraph; idgen: IdGenerator; owner: PSym; n: PNode): PNode
inSet:
nimsets: inSet(s: PNode; elem: PNode): bool
InstantiationInfo:
msgs: InstantiationInfo
instCopyType:
semtypinst: instCopyType(cl: var TReplTypeVars; t: PType): PType
instGenericConvertersArg:
sem: instGenericConvertersArg(c: PContext; a: PNode; x: TCandidate)
instGenericConvertersSons:
sem: instGenericConvertersSons(c: PContext; n: PNode; x: TCandidate)
instLoc:
msgs: instLoc(): InstantiationInfo
Instr:
dfa: Instr
InstrKind:
dfa: InstrKind
instTypeBoundOp:
sigmatch: instTypeBoundOp(c: PContext; dc: PSym; t: PType; info: TLineInfo; op: TTypeAttachedOp; col: int): PSym
Int128:
int128: Int128
IntegralTypes:
ast: IntegralTypes
interestingCaseExpr:
guards: interestingCaseExpr(m: PNode): bool
interfaceSymbol:
ic: interfaceSymbol(config: ConfigRef; cache: IdentCache; g: var PackedModuleGraph; module: FileIndex; name: PIdent; importHidden: bool): PSym
interfaceSymbols:
ic: interfaceSymbols(config: ConfigRef; cache: IdentCache; g: var PackedModuleGraph; module: FileIndex; name: PIdent; importHidden: bool): PSym
internalAssert:
msgs: internalAssert(conf: ConfigRef; e: bool)
internalError:
msgs: internalError(conf: ConfigRef; errMsg: string)
msgs: internalError(conf: ConfigRef; info: TLineInfo; errMsg: string)
interp:
nimpaths: interp(path: string; nimr: string): string
intersectSets:
nimsets: intersectSets(conf: ConfigRef; a, b: PNode): PNode
IntLike:
OrdinalType.IntLike
invalidateFacts:
guards: invalidateFacts(s: var seq[PNode]; n: PNode)
guards: invalidateFacts(m: var TModel; n: PNode)
InvalidFileIdx:
lineinfos: InvalidFileIdx
invalidGenericInst:
types: invalidGenericInst(f: PType): bool
InvalidKey:
astalgo: InvalidKey
invalidPragma:
pragmas: invalidPragma(c: PContext; n: PNode)
ioFailure:
RodFileError.ioFailure
isActive:
ic: isActive(e: PackedEncoder): bool
isAddrNode:
astalgo: isAddrNode(n: PNode): bool
isAlive:
dce: isAlive(a: AliveSyms; module: int; item: int32): bool
isAnalysableFieldAccess:
dfa: isAnalysableFieldAccess(orig: PNode; owner: PSym): bool
isAssignable:
parampatterns: isAssignable(owner: PSym; n: PNode; isUnsafeAddr = false): TAssignableResult
isAtom:
ast: isAtom(n: PNode): bool
packed_ast: isAtom(tree: PackedTree; pos: int): bool
isBothMetaConvertible:
TTypeRelation.isBothMetaConvertible
isCallExpr:
ast: isCallExpr(n: PNode): bool
isCaseObj:
trees: isCaseObj(n: PNode): bool
isCharArrayPtr:
types: isCharArrayPtr(t: PType; allowPointerToChar: bool): bool
isClosure:
ast: isClosure(typ: PType): bool
isClosureIterator:
ast: isClosureIterator(typ: PType): bool
isCompileTimeOnly:
types: isCompileTimeOnly(t: PType): bool
isCompileTimeProc:
ast: isCompileTimeProc(s: PSym): bool
isConstExpr:
trees: isConstExpr(n: PNode): bool
isConvertible:
TTypeRelation.isConvertible
isDeepConstExpr:
trees: isDeepConstExpr(n: PNode; preventInheritance = false): bool
isDefectException:
types: isDefectException(t: PType): bool
isDefined:
options: isDefined(conf: ConfigRef; symbol: string): bool
isDirty:
modulegraphs: isDirty(g: ModuleGraph; m: PSym): bool
isDiscriminantField:
astalgo: isDiscriminantField(n: PNode): bool
isDynlibOverride:
options: isDynlibOverride(conf: ConfigRef; lib: string): bool
isEmpty:
pathutils: isEmpty(x: AnyPath): bool
isEmptyContainer:
types: isEmptyContainer(t: PType): bool
isEmptyType:
ast: isEmptyType(t: PType): bool
isEqual:
TTypeRelation.isEqual
isException:
types: isException(t: PType): bool
isFinal:
types: isFinal(t: PType): bool
isFloatLit:
types: isFloatLit(t: PType): bool
isFromIntLit:
TTypeRelation.isFromIntLit
isGCedMem:
ast: isGCedMem(t: PType): bool
isGeneric:
TTypeRelation.isGeneric
isGenericAlias:
types: isGenericAlias(t: PType): bool
isGenericParams:
ast: isGenericParams(n: PNode): bool
isGenericRoutine:
ast: isGenericRoutine(n: PNode): bool
ast: isGenericRoutine(s: PSym): bool
isGenericRoutineStrict:
ast: isGenericRoutineStrict(s: PSym): bool
isHeaderFile:
CodegenFlag.isHeaderFile
isImportedException:
ast: isImportedException(t: PType; conf: ConfigRef): bool
isInferred:
TTypeRelation.isInferred
isInferredConvertible:
TTypeRelation.isInferredConvertible
isInfixAs:
ast: isInfixAs(n: PNode): bool
isInlineIterator:
ast: isInlineIterator(typ: PType): bool
isIntConv:
TTypeRelation.isIntConv
isIntLit:
types: isIntLit(t: PType): bool
isIterator:
lambdalifting: isIterator(owner: PSym): bool
isKeyword:
lexer: isKeyword(kind: TokType): bool
renderer: isKeyword(i: PIdent): bool
isLValue:
parampatterns: isLValue(n: PNode): bool
isMetaType:
ast: isMetaType(t: PType): bool
isNewStyleConcept:
ast: isNewStyleConcept(n: PNode): bool
isNimIdentifier:
lexer: isNimIdentifier(s: string): bool
isNone:
TTypeRelation.isNone
isNoSideEffectPragma:
trees: isNoSideEffectPragma(n: PNode): bool
isons:
packed_ast: isons(dest: var PackedTree; tree: PackedTree; n: NodePos): (int, NodePos)
isOperator:
parser: isOperator(tok: Token): bool
isOrdinalType:
types: isOrdinalType(t: PType; allowEnumWithHoles: bool = false): bool
isPartOf:
aliases: isPartOf(a, b: PNode): TAnalysisResult
isPureObject:
types: isPureObject(typ: PType): bool
isRange:
trees: isRange(n: PNode): bool
isResolvedUserTypeClass:
types: isResolvedUserTypeClass(t: PType): bool
isRoutine:
ast: isRoutine(s: PSym): bool
isRunnableExamples:
ast: isRunnableExamples(n: PNode): bool
isSelf:
concepts: isSelf(t: PType): bool
isShadowScope:
lookups: isShadowScope(s: PScope): bool
isSinkParam:
ast: isSinkParam(s: PSym): bool
isSinkType:
ast: isSinkType(t: PType): bool
isSinkTypeForParam:
types: isSinkTypeForParam(t: PType): bool
isSubrange:
TTypeRelation.isSubrange
isSubtype:
TTypeRelation.isSubtype
isTopLevel:
semdata: isTopLevel(c: PContext): bool
isTopLevelInsideDeclaration:
semdata: isTopLevelInsideDeclaration(c: PContext; sym: PSym): bool
isTracked:
sigmatch: isTracked(current, trackPos: TLineInfo; tokenLen: int): bool
isTrue:
trees: isTrue(n: PNode): bool
isTupleRecursive:
types: isTupleRecursive(t: PType): bool
isUnresolvedStatic:
ast: isUnresolvedStatic(t: PType): bool
isUnsigned:
types: isUnsigned(t: PType): bool
isVSCompatible:
extccomp: isVSCompatible(conf: ConfigRef): bool
ItemId:
ast: ItemId
items:
ast: items(n: PNode): PNode
astalgo: items(tab: TStrTable): PSym
ropes: items(r: Rope): char
iteratorPragmas:
pragmas: iteratorPragmas
iterOverType:
types: iterOverType(t: PType; iter: TTypeIter; closure: RootRef): bool
iterToProcImpl:
itersgen: iterToProcImpl(c: PContext; n: PNode): PNode
ithSon:
packed_ast: ithSon(tree: PackedTree; n: NodePos; i: int): NodePos
jmpDiff:
vmdef: jmpDiff(x: TInstr): int
JSgenPass:
jsgen: JSgenPass
jsonBuildInstructionsFile:
extccomp: jsonBuildInstructionsFile(conf: ConfigRef): AbsoluteFile
JsonExt:
options: JsonExt
kAlreadyGiven:
MismatchKind.kAlreadyGiven
kExtraArg:
MismatchKind.kExtraArg
kind:
packed_ast: kind(tree: PackedTree; n: NodePos): TNodeKind
packed_ast: kind(n: NodePos): TNodeKind
kMissingParam:
MismatchKind.kMissingParam
kPositionalAlreadyGiven:
MismatchKind.kPositionalAlreadyGiven
kTypeMismatch:
MismatchKind.kTypeMismatch
kUnknown:
MismatchKind.kUnknown
kUnknownNamedParam:
MismatchKind.kUnknownNamedParam
kVarNeeded:
MismatchKind.kVarNeeded
lambdaPragmas:
pragmas: lambdaPragmas
largeInstrs:
vmdef: largeInstrs
LastCallConv:
pragmas: LastCallConv
lastFloat:
types: lastFloat(t: PType): BiggestFloat
lastOptionEntry:
semdata: lastOptionEntry(c: PContext): POptionEntry
lastOrd:
types: lastOrd(conf: ConfigRef; t: PType): Int128
lastOverloadScope:
lookups: lastOverloadScope(o: TOverloadIter): int
lastSon:
ast: lastSon(n: Indexable): Indexable
LayeredIdTable:
semtypinst: LayeredIdTable
LazyInstantiation:
modulegraphs: LazyInstantiation
LazySym:
modulegraphs: LazySym
LazyType:
modulegraphs: LazyType
leave:
vmprofiler: leave(prof: var Profiler; c: PCtx)
leaves:
ropes: leaves(r: Rope): string
LegacyFeature:
options: LegacyFeature
len:
ast: len(n: Indexable): int
btrees: len[Key, Val](b: BTree[Key, Val]): int
bitabs: len[T](t: BiTable[T]): int
packed_ast: len(tree: PackedTree): int
ropes: len(a: Rope): int
lengthOrd:
types: lengthOrd(conf: ConfigRef; t: PType): Int128
letPragmas:
pragmas: letPragmas
Letters:
linter: Letters
leValue:
astalgo: leValue(a, b: PNode): bool
leValueConv:
semfold: leValueConv(a, b: PNode): bool
Lexer:
lexer: Lexer
lexMessage:
lexer: lexMessage(L: Lexer; msg: TMsgKind; arg = "")
lexMessageTok:
lexer: lexMessageTok(L: Lexer; msg: TMsgKind; tok: Token; arg = "")
LF:
nimlexbase: LF
lfDynamicLib:
TLocFlag.lfDynamicLib
lfEnforceDeref:
TLocFlag.lfEnforceDeref
lfExportLib:
TLocFlag.lfExportLib
lfFullExternalName:
TLocFlag.lfFullExternalName
lfHeader:
TLocFlag.lfHeader
lfImportCompilerProc:
TLocFlag.lfImportCompilerProc
lfIndirect:
TLocFlag.lfIndirect
lfNoDecl:
TLocFlag.lfNoDecl
lfNoDeepCopy:
TLocFlag.lfNoDeepCopy
lfPrepareForMutation:
TLocFlag.lfPrepareForMutation
lfSingleUse:
TLocFlag.lfSingleUse
libDynamic:
TLibKind.libDynamic
libHeader:
TLibKind.libHeader
liftForLoop:
lambdalifting: liftForLoop(g: ModuleGraph; body: PNode; idgen: IdGenerator; owner: PSym): PNode
liftIterSym:
lambdalifting: liftIterSym(g: ModuleGraph; n: PNode; idgen: IdGenerator; owner: PSym): PNode
liftIterToProc:
lambdalifting: liftIterToProc(g: ModuleGraph; fn: PSym; body: PNode; ptrType: PType; idgen: IdGenerator): PNode
liftLambdas:
lambdalifting: liftLambdas(g: ModuleGraph; fn: PSym; body: PNode; tooEarly: var bool; idgen: IdGenerator): PNode
liftLambdasForTopLevel:
lambdalifting: liftLambdasForTopLevel(module: PSym; body: PNode): PNode
liftLocalsIfRequested:
liftlocals: liftLocalsIfRequested(prc: PSym; n: PNode; cache: IdentCache; conf: ConfigRef; idgen: IdGenerator): PNode
liftParallel:
semparallel: liftParallel(g: ModuleGraph; idgen: IdGenerator; owner: PSym; n: PNode): PNode
liftTypeBoundOps:
liftdestructors: liftTypeBoundOps(c: PContext; typ: PType; info: TLineInfo)
liMessage:
msgs: liMessage(conf: ConfigRef; info: TLineInfo; msg: TMsgKind; arg: string; eh: TErrorHandling; info2: InstantiationInfo; isRaw = false)
lineInfoToStr:
astalgo: lineInfoToStr(conf: ConfigRef; info: TLineInfo): Rope
linkTo:
ast: linkTo(s: PSym; t: PType): PSym
ast: linkTo(t: PType; s: PSym): PType
lintReport:
msgs: lintReport(conf: ConfigRef; info: TLineInfo; beau, got: string; forceHint = false; extraMsg = "")
listCPUnames:
platform: listCPUnames(): seq[string]
listHints:
msgs: listHints(conf: ConfigRef)
listOSnames:
platform: listOSnames(): seq[string]
listSymbolNames:
astalgo: listSymbolNames(symbols: openArray[PSym]): string
listWarnings:
msgs: listWarnings(conf: ConfigRef)
LitId:
bitabs: LitId
litId:
packed_ast: litId(tree: PackedTree; n: NodePos): LitId
packed_ast: litId(n: NodePos): LitId
llsFile:
TLLStreamKind.llsFile
llsNone:
TLLStreamKind.llsNone
llsStdIn:
TLLStreamKind.llsStdIn
llsString:
TLLStreamKind.llsString
llStreamClose:
llstream: llStreamClose(s: PLLStream)
llStreamOpen:
llstream: llStreamOpen(): PLLStream
llstream: llStreamOpen(filename: AbsoluteFile; mode: FileMode): PLLStream
llstream: llStreamOpen(f: File): PLLStream
llstream: llStreamOpen(data: string): PLLStream
llStreamOpenStdIn:
llstream: llStreamOpenStdIn(r: TLLRepl = llReadFromStdin; onPrompt: OnPrompt = nil): PLLStream
llStreamRead:
llstream: llStreamRead(s: PLLStream; buf: pointer; bufLen: int): int
llStreamReadAll:
llstream: llStreamReadAll(s: PLLStream): string
llStreamReadLine:
llstream: llStreamReadLine(s: PLLStream; line: var string): bool
llStreamWrite:
llstream: llStreamWrite(s: PLLStream; data: char)
llstream: llStreamWrite(s: PLLStream; buf: pointer; buflen: int)
llstream: llStreamWrite(s: PLLStream; data: string)
llStreamWriteln:
llstream: llStreamWriteln(s: PLLStream; data: string)
load:
bitabs: load[T](f: var RodFile; t: var BiTable[T])
loadAny:
vmmarshal: loadAny(s: string; t: PType; cache: IdentCache; conf: ConfigRef; idgen: IdGenerator): PNode
loadCompilerProc:
modulegraphs: loadCompilerProc(g: ModuleGraph; name: string): PSym
loadConfigs:
nimconf: loadConfigs(cfg: RelativeFile; cache: IdentCache; conf: ConfigRef; idgen: IdGenerator)
loadConfigsAndProcessCmdLine:
cmdlinehelper: loadConfigsAndProcessCmdLine(self: NimProg; cache: IdentCache; conf: ConfigRef; graph: ModuleGraph): bool
loadConfigsAndRunMainCommand:
cmdlinehelper: loadConfigsAndRunMainCommand(self: NimProg; cache: IdentCache; conf: ConfigRef; graph: ModuleGraph): bool
loaded:
ModuleStatus.loaded
LoadedModule:
ic: LoadedModule
loadHeader:
rodfiles: loadHeader(f: var RodFile)
loading:
ModuleStatus.loading
loadNodes:
ic: loadNodes(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int; tree: PackedTree; n: NodePos): PNode
loadPackedSym:
modulegraphs: loadPackedSym(g: ModuleGraph; s: var LazySym)
loadPrim:
rodfiles: loadPrim(f: var RodFile; s: var string)
rodfiles: loadPrim[T](f: var RodFile; x: var T)
loadProcBody:
ic: loadProcBody(config: ConfigRef; cache: IdentCache; g: var PackedModuleGraph; s: PSym): PNode
loadRodFile:
ic: loadRodFile(filename: AbsoluteFile; m: var PackedModule; config: ConfigRef; ignoreConfig = false): RodFileError
loadSection:
rodfiles: loadSection(f: var RodFile; expected: RodSection)
loadSeq:
rodfiles: loadSeq[T](f: var RodFile; s: var seq[T])
loadSymFromId:
ic: loadSymFromId(config: ConfigRef; cache: IdentCache; g: var PackedModuleGraph; module: int; id: PackedItemId): PSym
loadTypeFromId:
ic: loadTypeFromId(config: ConfigRef; cache: IdentCache; g: var PackedModuleGraph; module: int; id: PackedItemId): PType
localError:
msgs: localError(conf: ConfigRef; info: TLineInfo; arg: string)
msgs: localError(conf: ConfigRef; info: TLineInfo; msg: TMsgKind; arg = "")
localErrorNode:
semdata: localErrorNode(c: PContext; n: PNode; arg: string): PNode
semdata: localErrorNode(c: PContext; n: PNode; info: TLineInfo; arg: string): PNode
semdata: localErrorNode(c: PContext; n: PNode; info: TLineInfo; msg: TMsgKind; arg: string): PNode
semdata: localErrorNode(c: PContext; n: PNode; msg: TMsgKind; arg: string): PNode
localScopesFrom:
lookups: localScopesFrom(c: PContext; scope: PScope): PScope
localSearchInScope:
lookups: localSearchInScope(c: PContext; s: PIdent): PSym
locCall:
TLocKind.locCall
locData:
TLocKind.locData
locExpr:
TLocKind.locExpr
locField:
TLocKind.locField
locGlobalVar:
TLocKind.locGlobalVar
locLocalVar:
TLocKind.locLocalVar
locNone:
TLocKind.locNone
locOther:
TLocKind.locOther
locParam:
TLocKind.locParam
locProc:
TLocKind.locProc
locTemp:
TLocKind.locTemp
log:
msgs: log(s: string)
lookUp:
lookups: lookUp(c: PContext; n: PNode): PSym
lookupFieldAgain:
types: lookupFieldAgain(ty: PType; field: PSym): PSym
lookupInRecord:
astalgo: lookupInRecord(n: PNode; field: PIdent): PSym
low:
int128: low(t: typedesc[Int128]): Int128
lowBound:
guards: lowBound(conf: ConfigRef; x: PNode): PNode
lowerSwap:
lowerings: lowerSwap(g: ModuleGraph; n: PNode; idgen: IdGenerator; owner: PSym): PNode
lowerTupleUnpacking:
lowerings: lowerTupleUnpacking(g: ModuleGraph; n: PNode; idgen: IdGenerator; owner: PSym): PNode
lowerTupleUnpackingForAsgn:
lowerings: lowerTupleUnpackingForAsgn(g: ModuleGraph; n: PNode; idgen: IdGenerator; owner: PSym): PNode
Lrz:
nimlexbase: Lrz
mAbsI:
TMagic.mAbsI
mAccessEnv:
TMagic.mAccessEnv
macroPragmas:
pragmas: macroPragmas
macroUsagesSection:
RodSection.macroUsagesSection
mAddF64:
TMagic.mAddF64
mAddI:
TMagic.mAddI
mAddr:
TMagic.mAddr
mAddU:
TMagic.mAddU
mainCommand:
main: mainCommand(graph: ModuleGraph)
mainCommandArg:
options: mainCommandArg(conf: ConfigRef): string
makeAndType:
semdata: makeAndType(c: PContext; t1, t2: PType): PType
makeClosure:
lambdalifting: makeClosure(g: ModuleGraph; idgen: IdGenerator; prc: PSym; env: PNode; info: TLineInfo): PNode
makeCString:
msgs: makeCString(s: string): Rope
makeInstPair:
semdata: makeInstPair(s: PSym; inst: PInstantiation): TInstantiationPair
makeModule:
modules: makeModule(graph: ModuleGraph; filename: AbsoluteFile): PSym
modules: makeModule(graph: ModuleGraph; filename: string): PSym
makeNotType:
semdata: makeNotType(c: PContext; t1: PType): PType
makeOrType:
semdata: makeOrType(c: PContext; t1, t2: PType): PType
makePass:
passes: makePass(open: TPassOpen = nil; process: TPassProcess = nil; close: TPassClose = nil; isFrontend = false): TPass
makePtrType:
semdata: makePtrType(c: PContext; baseType: PType): PType
semdata: makePtrType(owner: PSym; baseType: PType; idgen: IdGenerator): PType
makeRangeType:
semdata: makeRangeType(c: PContext; first, last: BiggestInt; info: TLineInfo; intType: PType = nil): PType
makeRangeWithStaticExpr:
semdata: makeRangeWithStaticExpr(c: PContext; n: PNode): PType
makeSingleLineCString:
ccgutils: makeSingleLineCString(s: string): string
makeStaticExpr:
semdata: makeStaticExpr(c: PContext; n: PNode): PNode
makeStdinModule:
modules: makeStdinModule(graph: ModuleGraph): PSym
makeStmtList:
ast: makeStmtList(n: PNode): PNode
makeTypeDesc:
concepts: makeTypeDesc(c: PContext; typ: PType): PType
makeTypeFromExpr:
semdata: makeTypeFromExpr(c: PContext; n: PNode): PType
makeTypeSymNode:
semdata: makeTypeSymNode(c: PContext; typ: PType; info: TLineInfo): PNode
makeTypeWithModifier:
semdata: makeTypeWithModifier(c: PContext; modifier: TTypeKind; baseType: PType): PType
makeVarType:
semdata: makeVarType(c: PContext; baseType: PType; kind = tyVar): PType
semdata: makeVarType(owner: PSym; baseType: PType; idgen: IdGenerator; kind = tyVar): PType
makeYamlString:
astalgo: makeYamlString(s: string): Rope
mAlignOf:
TMagic.mAlignOf
mAnd:
TMagic.mAnd
mangle:
ccgutils: mangle(name: string): string
mAppendSeqElem:
TMagic.mAppendSeqElem
mAppendStrCh:
TMagic.mAppendStrCh
mAppendStrStr:
TMagic.mAppendStrStr
Mapping:
sourcemap: Mapping
mAppType:
TMagic.mAppType
markClientsDirty:
modulegraphs: markClientsDirty(g: ModuleGraph; fileIdx: FileIndex)
markDirty:
modulegraphs: markDirty(g: ModuleGraph; fileIdx: FileIndex)
markIndirect:
semdata: markIndirect(c: PContext; s: PSym)
markOwnerModuleAsUsed:
sigmatch: markOwnerModuleAsUsed(c: PContext; s: PSym)
markUsed:
sigmatch: markUsed(c: PContext; info: TLineInfo; s: PSym)
mArray:
TMagic.mArray
mArrGet:
TMagic.mArrGet
mArrPut:
TMagic.mArrPut
mArrToSeq:
TMagic.mArrToSeq
mAsgn:
TMagic.mAsgn
mAshrI:
TMagic.mAshrI
maskBytes:
int128: maskBytes(arg: Int128; numbytes: int): Int128
maskUInt16:
int128: maskUInt16(arg: Int128): Int128
maskUInt32:
int128: maskUInt32(arg: Int128): Int128
maskUInt64:
int128: maskUInt64(arg: Int128): Int128
maskUInt8:
int128: maskUInt8(arg: Int128): Int128
mAstToStr:
TMagic.mAstToStr
matches:
sigmatch: matches(c: PContext; n, nOrig: PNode; m: var TCandidate)
matchNodeKinds:
parampatterns: matchNodeKinds(p, n: PNode): bool
matchType:
types: matchType(a: PType; pattern: openArray[tuple[k: TTypeKind, i: int]]; last: TTypeKind): bool
matchUserTypeClass:
sigmatch: matchUserTypeClass(m: var TCandidate; ff, a: PType): PType
MaxLineLength:
lexer: MaxLineLength
MaxLockLevel:
ast: MaxLockLevel
MaxSetElements:
nversion: MaxSetElements
MaxStackSize:
parampatterns: MaxStackSize
maybe:
AliasKind.maybe
MaybeNil:
Nilability.MaybeNil
mBitandI:
TMagic.mBitandI
mBitnotI:
TMagic.mBitnotI
mBitorI:
TMagic.mBitorI
mBitxorI:
TMagic.mBitxorI
mBool:
TMagic.mBool
mBoolDefine:
TMagic.mBoolDefine
mBoolToStr:
TMagic.mBoolToStr
mBuildCPU:
TMagic.mBuildCPU
mBuildOS:
TMagic.mBuildOS
mBuiltinType:
TMagic.mBuiltinType
mCard:
TMagic.mCard
mChar:
TMagic.mChar
mCharToStr:
TMagic.mCharToStr
mChr:
TMagic.mChr
mCompileDate:
TMagic.mCompileDate
mCompileOption:
TMagic.mCompileOption
mCompileOptionArg:
TMagic.mCompileOptionArg
mCompiles:
TMagic.mCompiles
mCompileTime:
TMagic.mCompileTime
mConStrStr:
TMagic.mConStrStr
mCpuEndian:
TMagic.mCpuEndian
mCstring:
TMagic.mCstring
mCStrToStr:
TMagic.mCStrToStr
mdbg:
astalgo: mdbg(): bool
mDec:
TMagic.mDec
mDeclared:
TMagic.mDeclared
mDeclaredInScope:
TMagic.mDeclaredInScope
mDeepCopy:
TMagic.mDeepCopy
mDefault:
TMagic.mDefault
mDefined:
TMagic.mDefined
mDestroy:
TMagic.mDestroy
mDistinct:
TMagic.mDistinct
mDivF64:
TMagic.mDivF64
mDivI:
TMagic.mDivI
mDivU:
TMagic.mDivU
mDotDot:
TMagic.mDotDot
mEcho:
TMagic.mEcho
mEnumToStr:
TMagic.mEnumToStr
mEqB:
TMagic.mEqB
mEqCh:
TMagic.mEqCh
mEqCString:
TMagic.mEqCString
mEqEnum:
TMagic.mEqEnum
mEqF64:
TMagic.mEqF64
mEqI:
TMagic.mEqI
mEqIdent:
TMagic.mEqIdent
mEqNimrodNode:
TMagic.mEqNimrodNode
mEqProc:
TMagic.mEqProc
mEqRef:
TMagic.mEqRef
mEqSet:
TMagic.mEqSet
mEqStr:
TMagic.mEqStr
mergeShadowScope:
lookups: mergeShadowScope(c: PContext)
message:
msgs: message(conf: ConfigRef; info: TLineInfo; msg: TMsgKind; arg = "")
methodCall:
cgmeth: methodCall(n: PNode; conf: ConfigRef): PNode
methodDef:
cgmeth: methodDef(g: ModuleGraph; idgen: IdGenerator; s: PSym)
methodPragmas:
pragmas: methodPragmas
methodsForGeneric:
modulegraphs: methodsForGeneric(g: ModuleGraph; t: PType): (int, PSym)
methodsPerTypeSection:
RodSection.methodsPerTypeSection
methodsSection:
RodSection.methodsSection
mException:
TMagic.mException
mExcl:
TMagic.mExcl
mExists:
TMagic.mExists
mExit:
TMagic.mExit
mExpandToAst:
TMagic.mExpandToAst
mExpr:
TMagic.mExpr
mFieldPairs:
TMagic.mFieldPairs
mFields:
TMagic.mFields
mFinished:
TMagic.mFinished
mFloat:
TMagic.mFloat
mFloat128:
TMagic.mFloat128
mFloat32:
TMagic.mFloat32
mFloat64:
TMagic.mFloat64
mFloatToStr:
TMagic.mFloatToStr
mForall:
TMagic.mForall
mGCref:
TMagic.mGCref
mGCunref:
TMagic.mGCunref
mGetImpl:
TMagic.mGetImpl
mGetImplTransf:
TMagic.mGetImplTransf
mGetTypeInfo:
TMagic.mGetTypeInfo
mGetTypeInfoV2:
TMagic.mGetTypeInfoV2
mHigh:
TMagic.mHigh
mHostCPU:
TMagic.mHostCPU
mHostOS:
TMagic.mHostOS
mIff:
TMagic.mIff
mImplies:
TMagic.mImplies
mInc:
TMagic.mInc
mIncl:
TMagic.mIncl
mInSet:
TMagic.mInSet
mInstantiationInfo:
TMagic.mInstantiationInfo
mInt:
TMagic.mInt
mInt16:
TMagic.mInt16
mInt32:
TMagic.mInt32
mInt64:
TMagic.mInt64
mInt64ToStr:
TMagic.mInt64ToStr
mInt8:
TMagic.mInt8
mIntDefine:
TMagic.mIntDefine
mIntToStr:
TMagic.mIntToStr
mIs:
TMagic.mIs
miscPos:
ast: miscPos
mIsMainModule:
TMagic.mIsMainModule
MismatchInfo:
sigmatch: MismatchInfo
MismatchKind:
sigmatch: MismatchKind
mIsNil:
TMagic.mIsNil
mIsolate:
TMagic.mIsolate
mIsPartOf:
TMagic.mIsPartOf
mIterableType:
TMagic.mIterableType
mLeB:
TMagic.mLeB
mLeCh:
TMagic.mLeCh
mLeEnum:
TMagic.mLeEnum
mLeF64:
TMagic.mLeF64
mLeI:
TMagic.mLeI
mLengthArray:
TMagic.mLengthArray
mLengthOpenArray:
TMagic.mLengthOpenArray
mLengthSeq:
TMagic.mLengthSeq
mLengthStr:
TMagic.mLengthStr
mLePtr:
TMagic.mLePtr
mLeSet:
TMagic.mLeSet
mLeStr:
TMagic.mLeStr
mLeU:
TMagic.mLeU
mLow:
TMagic.mLow
mLtB:
TMagic.mLtB
mLtCh:
TMagic.mLtCh
mLtEnum:
TMagic.mLtEnum
mLtF64:
TMagic.mLtF64
mLtI:
TMagic.mLtI
mLtPtr:
TMagic.mLtPtr
mLtSet:
TMagic.mLtSet
mLtStr:
TMagic.mLtStr
mLtU:
TMagic.mLtU
mMaxI:
TMagic.mMaxI
mMinI:
TMagic.mMinI
mMinusSet:
TMagic.mMinusSet
mModI:
TMagic.mModI
mModU:
TMagic.mModU
mMove:
TMagic.mMove
mMulF64:
TMagic.mMulF64
mMulI:
TMagic.mMulI
mMulSet:
TMagic.mMulSet
mMulU:
TMagic.mMulU
mNAdd:
TMagic.mNAdd
mNAddMultiple:
TMagic.mNAddMultiple
mNBindSym:
TMagic.mNBindSym
mNCallSite:
TMagic.mNCallSite
mNccInc:
TMagic.mNccInc
mNccValue:
TMagic.mNccValue
mNChild:
TMagic.mNChild
mNCopyNimNode:
TMagic.mNCopyNimNode
mNCopyNimTree:
TMagic.mNCopyNimTree
mNcsAdd:
TMagic.mNcsAdd
mNcsAt:
TMagic.mNcsAt
mNcsIncl:
TMagic.mNcsIncl
mNcsLen:
TMagic.mNcsLen
mNctGet:
TMagic.mNctGet
mNctHasNext:
TMagic.mNctHasNext
mNctLen:
TMagic.mNctLen
mNctNext:
TMagic.mNctNext
mNctPut:
TMagic.mNctPut
mNDel:
TMagic.mNDel
mNError:
TMagic.mNError
mNew:
TMagic.mNew
mNewFinalize:
TMagic.mNewFinalize
mNewSeq:
TMagic.mNewSeq
mNewSeqOfCap:
TMagic.mNewSeqOfCap
mNewString:
TMagic.mNewString
mNewStringOfCap:
TMagic.mNewStringOfCap
mNFloatVal:
TMagic.mNFloatVal
mNGenSym:
TMagic.mNGenSym
mNGetType:
TMagic.mNGetType
mNHint:
TMagic.mNHint
mNIdent:
TMagic.mNIdent
mNil:
TMagic.mNil
mNimvm:
TMagic.mNimvm
mNIntVal:
TMagic.mNIntVal
mNKind:
TMagic.mNKind
mNLen:
TMagic.mNLen
mNLineInfo:
TMagic.mNLineInfo
mNNewNimNode:
TMagic.mNNewNimNode
mNodeId:
TMagic.mNodeId
mNone:
TMagic.mNone
mNot:
TMagic.mNot
mNSetChild:
TMagic.mNSetChild
mNSetFloatVal:
TMagic.mNSetFloatVal
mNSetIdent:
TMagic.mNSetIdent
mNSetIntVal:
TMagic.mNSetIntVal
mNSetStrVal:
TMagic.mNSetStrVal
mNSetSymbol:
TMagic.mNSetSymbol
mNSetType:
TMagic.mNSetType
mNSigHash:
TMagic.mNSigHash
mNSizeOf:
TMagic.mNSizeOf
mNStrVal:
TMagic.mNStrVal
mNSymbol:
TMagic.mNSymbol
mNSymKind:
TMagic.mNSymKind
mNWarning:
TMagic.mNWarning
ModuleBackendFlag:
ic: ModuleBackendFlag
moduleFromRodFile:
ic: moduleFromRodFile(g: var PackedModuleGraph; conf: ConfigRef; cache: IdentCache; fileIdx: FileIndex; cachedModules: var seq[FileIndex]): PSym
modulegraphs: moduleFromRodFile(g: ModuleGraph; fileIdx: FileIndex; cachedModules: var seq[FileIndex]): PSym
ModuleGraph:
modulegraphs: ModuleGraph
moduleHasChanged:
passes: moduleHasChanged(graph: ModuleGraph; module: PSym): bool
ModuleId:
packed_ast: ModuleId
moduleIndex:
ic: moduleIndex(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int; s: PackedItemId): int32
ModuleIter:
modulegraphs: ModuleIter
moduleOpenForCodegen:
modulegraphs: moduleOpenForCodegen(g: ModuleGraph; m: FileIndex): bool
ModuleStatus:
ic: ModuleStatus
mOf:
TMagic.mOf
mOffsetOf:
TMagic.mOffsetOf
mOld:
TMagic.mOld
mOmpParFor:
TMagic.mOmpParFor
mOpenArray:
TMagic.mOpenArray
mOr:
TMagic.mOr
mOrd:
TMagic.mOrd
mOrdinal:
TMagic.mOrdinal
mParallel:
TMagic.mParallel
mParseBiggestFloat:
TMagic.mParseBiggestFloat
mParseExprToAst:
TMagic.mParseExprToAst
mParseStmtToAst:
TMagic.mParseStmtToAst
mPlugin:
TMagic.mPlugin
mPlusSet:
TMagic.mPlusSet
mPNimrodNode:
TMagic.mPNimrodNode
mPointer:
TMagic.mPointer
mPred:
TMagic.mPred
mPrivateAccess:
TMagic.mPrivateAccess
mProcCall:
TMagic.mProcCall
mPtr:
TMagic.mPtr
mQuoteAst:
TMagic.mQuoteAst
mRange:
TMagic.mRange
mRef:
TMagic.mRef
mRepr:
TMagic.mRepr
mReset:
TMagic.mReset
mRunnableExamples:
TMagic.mRunnableExamples
mSameNodeType:
TMagic.mSameNodeType
mSeq:
TMagic.mSeq
mSet:
TMagic.mSet
mSetLengthSeq:
TMagic.mSetLengthSeq
mSetLengthStr:
TMagic.mSetLengthStr
MsgConfig:
lineinfos: MsgConfig
MsgFlag:
msgs: MsgFlag
MsgFlags:
msgs: MsgFlags
MsgKindToStr:
lineinfos: MsgKindToStr
msgKindToString:
msgs: msgKindToString(kind: TMsgKind): string
msgNoUnitSep:
MsgFlag.msgNoUnitSep
msgQuit:
msgs: msgQuit(x: int8)
msgs: msgQuit(x: string)
msgSkipHook:
MsgFlag.msgSkipHook
msgStdout:
MsgFlag.msgStdout
msgWriteln:
msgs: msgWriteln(conf: ConfigRef; s: string; flags: MsgFlags = {})
mShallowCopy:
TMagic.mShallowCopy
mShlI:
TMagic.mShlI
mShrI:
TMagic.mShrI
mSizeOf:
TMagic.mSizeOf
mSlice:
TMagic.mSlice
mSlurp:
TMagic.mSlurp
mSpawn:
TMagic.mSpawn
mStatic:
TMagic.mStatic
mStaticExec:
TMagic.mStaticExec
mStmt:
TMagic.mStmt
mStrDefine:
TMagic.mStrDefine
mString:
TMagic.mString
mStrToIdent:
TMagic.mStrToIdent
mStrToStr:
TMagic.mStrToStr
mSubF64:
TMagic.mSubF64
mSubI:
TMagic.mSubI
mSubU:
TMagic.mSubU
mSucc:
TMagic.mSucc
mSwap:
TMagic.mSwap
mSymIsInstantiationOf:
TMagic.mSymIsInstantiationOf
mSymOwner:
TMagic.mSymOwner
mTrace:
TMagic.mTrace
mTuple:
TMagic.mTuple
mType:
TMagic.mType
mTypeDesc:
TMagic.mTypeDesc
mTypeOf:
TMagic.mTypeOf
mTypeTrait:
TMagic.mTypeTrait
mUInt:
TMagic.mUInt
mUInt16:
TMagic.mUInt16
mUInt32:
TMagic.mUInt32
mUInt64:
TMagic.mUInt64
mUInt8:
TMagic.mUInt8
mUnaryMinusF64:
TMagic.mUnaryMinusF64
mUnaryMinusI:
TMagic.mUnaryMinusI
mUnaryMinusI64:
TMagic.mUnaryMinusI64
mUnaryPlusF64:
TMagic.mUnaryPlusF64
mUnaryPlusI:
TMagic.mUnaryPlusI
mUncheckedArray:
TMagic.mUncheckedArray
mUnown:
TMagic.mUnown
mustRehash:
astalgo: mustRehash(length, counter: int): bool
mutableView:
ViewTypeKind.mutableView
mutateType:
types: mutateType(t: PType; iter: TTypeMutator; closure: RootRef): PType
MutationInfo:
varpartitions: MutationInfo
mVar:
TMagic.mVar
mVarargs:
TMagic.mVarargs
mVoid:
TMagic.mVoid
mVoidType:
TMagic.mVoidType
mWasMoved:
TMagic.mWasMoved
mXor:
TMagic.mXor
namePos:
ast: namePos
nameToCC:
extccomp: nameToCC(name: string): TSystemCC
nameToCPU:
platform: nameToCPU(name: string): TSystemCPU
nameToOS:
platform: nameToOS(name: string): TSystemOS
navDefinition:
navigator: navDefinition(g: ModuleGraph)
navDefusages:
navigator: navDefusages(g: ModuleGraph)
navUsages:
navigator: navUsages(g: ModuleGraph)
NdiFile:
ndi: NdiFile
NegOne:
int128: NegOne
newAsgnStmt:
lowerings: newAsgnStmt(le, ri: PNode): PNode
newCandidate:
sigmatch: newCandidate(ctx: PContext; callee: PSym; binding: PNode; calleeScope = -1): TCandidate
sigmatch: newCandidate(ctx: PContext; callee: PType): TCandidate
newConfigRef:
options: newConfigRef(): ConfigRef
newContext:
semdata: newContext(graph: ModuleGraph; module: PSym): PContext
newCtx:
vmdef: newCtx(module: PSym; cache: IdentCache; g: ModuleGraph; idgen: IdGenerator): PCtx
newDeref:
lowerings: newDeref(n: PNode): PNode
newDocumentor:
docgen: newDocumentor(filename: AbsoluteFile; cache: IdentCache; conf: ConfigRef; outExt: string = HtmlExt; module: PSym = nil; isPureRst = false): PDoc
newDotExpr:
lowerings: newDotExpr(obj, b: PSym): PNode
newError:
errorhandling: newError(wrongNode: PNode; k: ErrorKind; args: varargs[PNode]): PNode
errorhandling: newError(wrongNode: PNode; msg: string): PNode
newFastAsgnStmt:
lowerings: newFastAsgnStmt(le, ri: PNode): PNode
newFastMoveStmt:
lowerings: newFastMoveStmt(g: ModuleGraph; le, ri: PNode): PNode
newFloatNode:
ast: newFloatNode(kind: TNodeKind; floatVal: BiggestFloat): PNode
newFloatNodeP:
parser: newFloatNodeP(kind: TNodeKind; floatVal: BiggestFloat; p: Parser): PNode
newFloatNodeT:
semfold: newFloatNodeT(floatVal: BiggestFloat; n: PNode; g: ModuleGraph): PNode
newIdentCache:
idents: newIdentCache(): IdentCache
newIdentNode:
ast: newIdentNode(ident: PIdent; info: TLineInfo): PNode
newIdentNodeP:
parser: newIdentNodeP(ident: PIdent; p: Parser): PNode
newIdTable:
ast: newIdTable(): TIdTable
newIntLit:
lowerings: newIntLit(g: ModuleGraph; info: TLineInfo; value: BiggestInt): PNode
newIntNode:
ast: newIntNode(kind: TNodeKind; intVal: BiggestInt): PNode
ast: newIntNode(kind: TNodeKind; intVal: Int128): PNode
newIntNodeP:
parser: newIntNodeP(kind: TNodeKind; intVal: BiggestInt; p: Parser): PNode
newIntNodeT:
semfold: newIntNodeT(intVal: Int128; n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
newIntTypeNode:
ast: newIntTypeNode(intVal: BiggestInt; typ: PType): PNode
ast: newIntTypeNode(intVal: Int128; typ: PType): PNode
newLib:
semdata: newLib(kind: TLibKind): PLib
newlineFollows:
lexer: newlineFollows(L: Lexer): bool
newLineInfo:
msgs: newLineInfo(conf: ConfigRef; filename: AbsoluteFile; line, col: int): TLineInfo
msgs: newLineInfo(fileInfoIdx: FileIndex; line, col: int): TLineInfo
NewLines:
nimlexbase: NewLines
newModule:
cgen: newModule(g: BModuleList; module: PSym; conf: ConfigRef): BModule
newModuleGraph:
modulegraphs: newModuleGraph(cache: IdentCache; config: ConfigRef): ModuleGraph
newModuleList:
cgendata: newModuleList(g: ModuleGraph): BModuleList
newNode:
ast: newNode(kind: TNodeKind): PNode
newNodeI:
ast: newNodeI(kind: TNodeKind; info: TLineInfo): PNode
ast: newNodeI(kind: TNodeKind; info: TLineInfo; children: int): PNode
newNodeIT:
ast: newNodeIT(kind: TNodeKind; info: TLineInfo; typ: PType): PNode
newNodeP:
parser: newNodeP(kind: TNodeKind; p: Parser): PNode
newOptionEntry:
semdata: newOptionEntry(conf: ConfigRef): POptionEntry
newPackageCache:
options: newPackageCache(): untyped
newPartialConfigRef:
options: newPartialConfigRef(): ConfigRef
newProc:
cgendata: newProc(prc: PSym; module: BModule): BProc
newProcNode:
ast: newProcNode(kind: TNodeKind; info: TLineInfo; body: PNode; params, name, pattern, genericParams, pragmas, exceptions: PNode): PNode
newProcType:
ast: newProcType(info: TLineInfo; id: ItemId; owner: PSym): PType
newSons:
ast: newSons(father: Indexable; length: int)
newStrNode:
ast: newStrNode(strVal: string; info: TLineInfo): PNode
ast: newStrNode(kind: TNodeKind; strVal: string): PNode
newStrNodeP:
parser: newStrNodeP(kind: TNodeKind; strVal: string; p: Parser): PNode
newStrNodeT:
semfold: newStrNodeT(strVal: string; n: PNode; g: ModuleGraph): PNode
newStrTable:
ast: newStrTable(): TStrTable
newSym:
ast: newSym(symKind: TSymKind; name: PIdent; id: ItemId; owner: PSym; info: TLineInfo; options: TOptions = {}): PSym
newSymG:
sem: newSymG(kind: TSymKind; n: PNode; c: PContext): PSym
newSymNode:
ast: newSymNode(sym: PSym): PNode
ast: newSymNode(sym: PSym; info: TLineInfo): PNode
newSymNodeTypeDesc:
semfold: newSymNodeTypeDesc(s: PSym; idgen: IdGenerator; info: TLineInfo): PNode
newTree:
ast: newTree(kind: TNodeKind; children: varargs[PNode]): PNode
newTreeFrom:
packed_ast: newTreeFrom(old: PackedTree): PackedTree
newTreeI:
ast: newTreeI(kind: TNodeKind; info: TLineInfo; children: varargs[PNode]): PNode
newTreeIT:
ast: newTreeIT(kind: TNodeKind; info: TLineInfo; typ: PType; children: varargs[PNode]): PNode
newTryFinally:
lowerings: newTryFinally(body, final: PNode): PNode
newTupleAccess:
lowerings: newTupleAccess(g: ModuleGraph; tup: PNode; i: int): PNode
newTupleAccessRaw:
lowerings: newTupleAccessRaw(tup: PNode; i: int): PNode
newType:
ast: newType(kind: TTypeKind; id: ItemId; owner: PSym): PType
newTypeMapLayer:
semtypinst: newTypeMapLayer(cl: var TReplTypeVars): LayeredIdTable
newTypeS:
semdata: newTypeS(kind: TTypeKind; c: PContext): PType
newTypeWithSons:
semdata: newTypeWithSons(c: PContext; kind: TTypeKind; sons: seq[PType]): PType
semdata: newTypeWithSons(owner: PSym; kind: TTypeKind; sons: seq[PType]; idgen: IdGenerator): PType
newVersion:
nimblecmd: newVersion(ver: string): Version
next:
btrees: next[Key, Val](b: BTree[Key, Val]; index: int): (Key, Val, int)
nextIdentExcluding:
astalgo: nextIdentExcluding(ti: var TIdentIter; tab: TStrTable; excluding: IntSet): PSym
nextIdentIter:
astalgo: nextIdentIter(ti: var TIdentIter; tab: TStrTable): PSym
nextIter:
astalgo: nextIter(ti: var TTabIter; tab: TStrTable): PSym
nextModuleIter:
modulegraphs: nextModuleIter(mi: var ModuleIter; g: ModuleGraph): PSym
nextOverloadIter:
lookups: nextOverloadIter(o: var TOverloadIter; c: PContext; n: PNode): PSym
nextRodIter:
ic: nextRodIter(it: var RodIter; g: var PackedModuleGraph): PSym
nextSymId:
ast: nextSymId(x: IdGenerator): ItemId
nextTry:
astalgo: nextTry(h, maxHash: Hash): Hash
nextTypeId:
ast: nextTypeId(x: IdGenerator): ItemId
nfAllConst:
TNodeFlag.nfAllConst
nfAllFieldsSet:
ast: nfAllFieldsSet
nfBase16:
TNodeFlag.nfBase16
nfBase2:
TNodeFlag.nfBase2
nfBase8:
TNodeFlag.nfBase8
nfBlockArg:
TNodeFlag.nfBlockArg
nfDefaultParam:
TNodeFlag.nfDefaultParam
nfDefaultRefsParam:
TNodeFlag.nfDefaultRefsParam
nfDotField:
TNodeFlag.nfDotField
nfDotSetter:
TNodeFlag.nfDotSetter
nfExecuteOnReload:
TNodeFlag.nfExecuteOnReload
nfExplicitCall:
TNodeFlag.nfExplicitCall
nfExprCall:
TNodeFlag.nfExprCall
nfFirstWrite:
TNodeFlag.nfFirstWrite
nfFromTemplate:
TNodeFlag.nfFromTemplate
nfHasComment:
TNodeFlag.nfHasComment
nfIsPtr:
TNodeFlag.nfIsPtr
nfIsRef:
TNodeFlag.nfIsRef
nfLastRead:
TNodeFlag.nfLastRead
nfLL:
TNodeFlag.nfLL
nfNone:
TNodeFlag.nfNone
nfNoRewrite:
TNodeFlag.nfNoRewrite
nfPreventCg:
TNodeFlag.nfPreventCg
nfSem:
TNodeFlag.nfSem
nfTransf:
TNodeFlag.nfTransf
Nil:
Nilability.Nil
Nilability:
nilcheck: Nilability
NilableTypes:
ast: NilableTypes
nilItemId:
packed_ast: nilItemId
nilOrSysInt:
magicsys: nilOrSysInt(g: ModuleGraph): PType
nimblePath:
nimblecmd: nimblePath(conf: ConfigRef; path: AbsoluteDir; info: TLineInfo)
nimbleSubs:
options: nimbleSubs(conf: ConfigRef; p: string): string
NimCompilerApiVersion:
nversion: NimCompilerApiVersion
nimdocOutCss:
nimpaths: nimdocOutCss
nimEnableCovariance:
options: nimEnableCovariance
nimErrorFlagAccessed:
TCProcFlag.nimErrorFlagAccessed
nimErrorFlagDeclared:
TCProcFlag.nimErrorFlagDeclared
nimErrorFlagDisabled:
TCProcFlag.nimErrorFlagDisabled
NimExt:
options: NimExt
nimKeywordsHigh:
wordrecg: nimKeywordsHigh
nimKeywordsLow:
wordrecg: nimKeywordsLow
nimNodeFlag:
vmdef: nimNodeFlag
NimProg:
cmdlinehelper: NimProg
NimVer:
options: NimVer
nkAccQuoted:
TNodeKind.nkAccQuoted
nkAddr:
TNodeKind.nkAddr
nkArgList:
TNodeKind.nkArgList
nkAsgn:
TNodeKind.nkAsgn
nkAsmStmt:
TNodeKind.nkAsmStmt
nkBind:
TNodeKind.nkBind
nkBindStmt:
TNodeKind.nkBindStmt
nkBlockExpr:
TNodeKind.nkBlockExpr
nkBlockStmt:
TNodeKind.nkBlockStmt
nkBlockType:
TNodeKind.nkBlockType
nkBracket:
TNodeKind.nkBracket
nkBracketExpr:
TNodeKind.nkBracketExpr
nkBreakState:
TNodeKind.nkBreakState
nkBreakStmt:
TNodeKind.nkBreakStmt
nkCall:
TNodeKind.nkCall
nkCallKinds:
ast: nkCallKinds
nkCallStrLit:
TNodeKind.nkCallStrLit
nkCaseStmt:
TNodeKind.nkCaseStmt
nkCast:
TNodeKind.nkCast
nkCharLit:
TNodeKind.nkCharLit
nkChckRange:
TNodeKind.nkChckRange
nkChckRange64:
TNodeKind.nkChckRange64
nkChckRangeF:
TNodeKind.nkChckRangeF
nkCheckedFieldExpr:
TNodeKind.nkCheckedFieldExpr
nkClosedSymChoice:
TNodeKind.nkClosedSymChoice
nkClosure:
TNodeKind.nkClosure
nkComesFrom:
TNodeKind.nkComesFrom
nkCommand:
TNodeKind.nkCommand
nkCommentStmt:
TNodeKind.nkCommentStmt
nkConstDef:
TNodeKind.nkConstDef
nkConstSection:
TNodeKind.nkConstSection
nkConstTy:
TNodeKind.nkConstTy
nkContinueStmt:
TNodeKind.nkContinueStmt
nkConv:
TNodeKind.nkConv
nkConverterDef:
TNodeKind.nkConverterDef
nkCStringToString:
TNodeKind.nkCStringToString
nkCurly:
TNodeKind.nkCurly
nkCurlyExpr:
TNodeKind.nkCurlyExpr
nkDefer:
TNodeKind.nkDefer
nkDerefExpr:
TNodeKind.nkDerefExpr
nkDiscardStmt:
TNodeKind.nkDiscardStmt
nkDistinctTy:
TNodeKind.nkDistinctTy
nkDo:
TNodeKind.nkDo
nkDotCall:
TNodeKind.nkDotCall
nkDotExpr:
TNodeKind.nkDotExpr
nkEffectList:
ast: nkEffectList
nkElifBranch:
TNodeKind.nkElifBranch
nkElifExpr:
TNodeKind.nkElifExpr
nkElse:
TNodeKind.nkElse
nkElseExpr:
TNodeKind.nkElseExpr
nkEmpty:
TNodeKind.nkEmpty
nkEnumFieldDef:
TNodeKind.nkEnumFieldDef
nkEnumTy:
TNodeKind.nkEnumTy
nkError:
TNodeKind.nkError
nkExceptBranch:
TNodeKind.nkExceptBranch
nkExportExceptStmt:
TNodeKind.nkExportExceptStmt
nkExportStmt:
TNodeKind.nkExportStmt
nkExprColonExpr:
TNodeKind.nkExprColonExpr
nkExprEqExpr:
TNodeKind.nkExprEqExpr
nkFastAsgn:
TNodeKind.nkFastAsgn
nkFinally:
TNodeKind.nkFinally
nkFloat128Lit:
TNodeKind.nkFloat128Lit
nkFloat32Lit:
TNodeKind.nkFloat32Lit
nkFloat64Lit:
TNodeKind.nkFloat64Lit
nkFloatLit:
TNodeKind.nkFloatLit
nkFloatLiterals:
ast: nkFloatLiterals
nkFormalParams:
TNodeKind.nkFormalParams
nkForStmt:
TNodeKind.nkForStmt
nkFromStmt:
TNodeKind.nkFromStmt
nkFuncDef:
TNodeKind.nkFuncDef
nkGenericParams:
TNodeKind.nkGenericParams
nkGotoState:
TNodeKind.nkGotoState
nkHiddenAddr:
TNodeKind.nkHiddenAddr
nkHiddenCallConv:
TNodeKind.nkHiddenCallConv
nkHiddenDeref:
TNodeKind.nkHiddenDeref
nkHiddenStdConv:
TNodeKind.nkHiddenStdConv
nkHiddenSubConv:
TNodeKind.nkHiddenSubConv
nkHiddenTryStmt:
TNodeKind.nkHiddenTryStmt
nkIdent:
TNodeKind.nkIdent
nkIdentDefs:
TNodeKind.nkIdentDefs
nkIdentKinds:
ast: nkIdentKinds
nkIfExpr:
TNodeKind.nkIfExpr
nkIfStmt:
TNodeKind.nkIfStmt
nkImportAs:
TNodeKind.nkImportAs
nkImportExceptStmt:
TNodeKind.nkImportExceptStmt
nkImportStmt:
TNodeKind.nkImportStmt
nkIncludeStmt:
TNodeKind.nkIncludeStmt
nkInfix:
TNodeKind.nkInfix
nkInt16Lit:
TNodeKind.nkInt16Lit
nkInt32Lit:
TNodeKind.nkInt32Lit
nkInt64Lit:
TNodeKind.nkInt64Lit
nkInt8Lit:
TNodeKind.nkInt8Lit
nkIntLit:
TNodeKind.nkIntLit
nkIteratorDef:
TNodeKind.nkIteratorDef
nkIteratorTy:
TNodeKind.nkIteratorTy
nkLambda:
TNodeKind.nkLambda
nkLambdaKinds:
ast: nkLambdaKinds
nkLastBlockStmts:
ast: nkLastBlockStmts
nkLetSection:
TNodeKind.nkLetSection
nkLiterals:
ast: nkLiterals
nkMacroDef:
TNodeKind.nkMacroDef
nkMethodDef:
TNodeKind.nkMethodDef
nkMixinStmt:
TNodeKind.nkMixinStmt
nkModuleRef:
TNodeKind.nkModuleRef
nkMutableTy:
TNodeKind.nkMutableTy
nkNilLit:
TNodeKind.nkNilLit
nkNilRodNode:
TNodeKind.nkNilRodNode
nkNone:
TNodeKind.nkNone
nkObjConstr:
TNodeKind.nkObjConstr
nkObjDownConv:
TNodeKind.nkObjDownConv
nkObjectTy:
TNodeKind.nkObjectTy
nkObjUpConv:
TNodeKind.nkObjUpConv
nkOfBranch:
TNodeKind.nkOfBranch
nkOfInherit:
TNodeKind.nkOfInherit
nkOpenSymChoice:
TNodeKind.nkOpenSymChoice
nkPar:
TNodeKind.nkPar
nkParForStmt:
TNodeKind.nkParForStmt
nkPattern:
TNodeKind.nkPattern
nkPostfix:
TNodeKind.nkPostfix
nkPragma:
TNodeKind.nkPragma
nkPragmaBlock:
TNodeKind.nkPragmaBlock
nkPragmaCallKinds:
ast: nkPragmaCallKinds
nkPragmaExpr:
TNodeKind.nkPragmaExpr
nkPrefix:
TNodeKind.nkPrefix
nkProcDef:
TNodeKind.nkProcDef
nkProcTy:
TNodeKind.nkProcTy
nkPtrTy:
TNodeKind.nkPtrTy
nkRaiseStmt:
TNodeKind.nkRaiseStmt
nkRange:
TNodeKind.nkRange
nkRecCase:
TNodeKind.nkRecCase
nkRecList:
TNodeKind.nkRecList
nkRecWhen:
TNodeKind.nkRecWhen
nkRefTy:
TNodeKind.nkRefTy
nkReplayAction:
TNodeKind.nkReplayAction
nkReturnStmt:
TNodeKind.nkReturnStmt
nkRStrLit:
TNodeKind.nkRStrLit
nkSharedTy:
TNodeKind.nkSharedTy
nkState:
TNodeKind.nkState
nkStaticExpr:
TNodeKind.nkStaticExpr
nkStaticStmt:
TNodeKind.nkStaticStmt
nkStaticTy:
TNodeKind.nkStaticTy
nkStmtList:
TNodeKind.nkStmtList
nkStmtListExpr:
TNodeKind.nkStmtListExpr
nkStmtListType:
TNodeKind.nkStmtListType
nkStringToCString:
TNodeKind.nkStringToCString
nkStrKinds:
ast: nkStrKinds
nkStrLit:
TNodeKind.nkStrLit
nkSym:
TNodeKind.nkSym
nkSymChoices:
ast: nkSymChoices
nkTableConstr:
TNodeKind.nkTableConstr
nkTemplateDef:
TNodeKind.nkTemplateDef
nkTripleStrLit:
TNodeKind.nkTripleStrLit
nkTryStmt:
TNodeKind.nkTryStmt
nkTupleClassTy:
TNodeKind.nkTupleClassTy
nkTupleConstr:
TNodeKind.nkTupleConstr
nkTupleTy:
TNodeKind.nkTupleTy
nkType:
TNodeKind.nkType
nkTypeClassTy:
TNodeKind.nkTypeClassTy
nkTypeDef:
TNodeKind.nkTypeDef
nkTypeOfExpr:
TNodeKind.nkTypeOfExpr
nkTypeSection:
TNodeKind.nkTypeSection
nkUInt16Lit:
TNodeKind.nkUInt16Lit
nkUInt32Lit:
TNodeKind.nkUInt32Lit
nkUInt64Lit:
TNodeKind.nkUInt64Lit
nkUInt8Lit:
TNodeKind.nkUInt8Lit
nkUIntLit:
TNodeKind.nkUIntLit
nkUsingStmt:
TNodeKind.nkUsingStmt
nkVarSection:
TNodeKind.nkVarSection
nkVarTuple:
TNodeKind.nkVarTuple
nkVarTy:
TNodeKind.nkVarTy
nkWhen:
ast: nkWhen
nkWhenExpr:
ast: nkWhenExpr
nkWhenStmt:
TNodeKind.nkWhenStmt
nkWhileStmt:
TNodeKind.nkWhileStmt
nkWith:
TNodeKind.nkWith
nkWithout:
TNodeKind.nkWithout
nkYieldStmt:
TNodeKind.nkYieldStmt
no:
AliasKind.no
NodeId:
packed_ast: NodeId
NodePos:
packed_ast: NodePos
nodeTableGet:
treetab: nodeTableGet(t: TNodeTable; key: PNode): int
nodeTablePut:
treetab: nodeTablePut(t: var TNodeTable; key: PNode; val: int)
nodeTableTestOrSet:
treetab: nodeTableTestOrSet(t: var TNodeTable; key: PNode; val: int): int
NoneLike:
OrdinalType.NoneLike
noSafePoints:
TCProcFlag.noSafePoints
NotesVerbosity:
lineinfos: NotesVerbosity
notFoundError:
sem: notFoundError(c: PContext; n: PNode; errors: CandidateErrors)
notnil:
Feature.notnil
noView:
ViewTypeKind.noView
numArgs:
vm: numArgs(a: VmArgs): int
numbersSection:
RodSection.numbersSection
numChars:
lexer: numChars
NumericalBase:
lexer: NumericalBase
numLines:
msgs: numLines(conf: ConfigRef; fileIdx: FileIndex): int
objectSetContains:
astalgo: objectSetContains(t: TObjectSet; obj: RootRef): bool
objectSetContainsOrIncl:
astalgo: objectSetContainsOrIncl(t: var TObjectSet; obj: RootRef): bool
objectSetIncl:
astalgo: objectSetIncl(t: var TObjectSet; obj: RootRef)
objHasKidsValid:
CodegenFlag.objHasKidsValid
oimDone:
TOverloadIterMode.oimDone
oimNoQualifier:
TOverloadIterMode.oimNoQualifier
oimOtherModule:
TOverloadIterMode.oimOtherModule
oimSelfModule:
TOverloadIterMode.oimSelfModule
oimSymChoice:
TOverloadIterMode.oimSymChoice
oimSymChoiceLocalLookup:
TOverloadIterMode.oimSymChoiceLocalLookup
ok:
RodFileError.ok
oKeepVariableNames:
options: oKeepVariableNames
oldExperimentalFeatures:
options: oldExperimentalFeatures
onDef:
modulegraphs: onDef(info: TLineInfo; s: PSym)
onDefResolveForward:
modulegraphs: onDefResolveForward(info: TLineInfo; s: PSym)
One:
int128: One
OnHeap:
TStorageLoc.OnHeap
onProcessing:
modulegraphs: onProcessing(graph: ModuleGraph; fileIdx: FileIndex; moduleStatus: string; fromModule: PSym)
OnPrompt:
llstream: OnPrompt
OnStack:
TStorageLoc.OnStack
OnStatic:
TStorageLoc.OnStatic
OnUnknown:
TStorageLoc.OnUnknown
onUse:
modulegraphs: onUse(info: TLineInfo; s: PSym)
opcAddFloat:
TOpcode.opcAddFloat
opcAddImmInt:
TOpcode.opcAddImmInt
opcAddInt:
TOpcode.opcAddInt
opcAddrNode:
TOpcode.opcAddrNode
opcAddrReg:
TOpcode.opcAddrReg
opcAddSeqElem:
TOpcode.opcAddSeqElem
opcAddStrCh:
TOpcode.opcAddStrCh
opcAddStrStr:
TOpcode.opcAddStrStr
opcAddu:
TOpcode.opcAddu
opcAsgnComplex:
TOpcode.opcAsgnComplex
opcAsgnConst:
TOpcode.opcAsgnConst
opcAsgnFloat:
TOpcode.opcAsgnFloat
opcAsgnInt:
TOpcode.opcAsgnInt
opcAsgnRef:
TOpcode.opcAsgnRef
opcAshrInt:
TOpcode.opcAshrInt
opcBitandInt:
TOpcode.opcBitandInt
opcBitnotInt:
TOpcode.opcBitnotInt
opcBitorInt:
TOpcode.opcBitorInt
opcBitxorInt:
TOpcode.opcBitxorInt
opcBranch:
TOpcode.opcBranch
opcCallSite:
TOpcode.opcCallSite
opcCard:
TOpcode.opcCard
opcCast:
TOpcode.opcCast
opcCastFloatToInt32:
TOpcode.opcCastFloatToInt32
opcCastFloatToInt64:
TOpcode.opcCastFloatToInt64
opcCastIntToFloat32:
TOpcode.opcCastIntToFloat32
opcCastIntToFloat64:
TOpcode.opcCastIntToFloat64
opcCastIntToPtr:
TOpcode.opcCastIntToPtr
opcCastPtrToInt:
TOpcode.opcCastPtrToInt
opcConcatStr:
TOpcode.opcConcatStr
opcContainsSet:
TOpcode.opcContainsSet
opcConv:
TOpcode.opcConv
opcDivFloat:
TOpcode.opcDivFloat
opcDivInt:
TOpcode.opcDivInt
opcDivu:
TOpcode.opcDivu
opcEcho:
TOpcode.opcEcho
opcEof:
TOpcode.opcEof
opcEqFloat:
TOpcode.opcEqFloat
opcEqIdent:
TOpcode.opcEqIdent
opcEqInt:
TOpcode.opcEqInt
opcEqNimNode:
TOpcode.opcEqNimNode
opcEqRef:
TOpcode.opcEqRef
opcEqSet:
TOpcode.opcEqSet
opcEqStr:
TOpcode.opcEqStr
opcExcept:
TOpcode.opcExcept
opcExcl:
TOpcode.opcExcl
opcFastAsgnComplex:
TOpcode.opcFastAsgnComplex
opcFinally:
TOpcode.opcFinally
opcFinallyEnd:
TOpcode.opcFinallyEnd
opcFJmp:
TOpcode.opcFJmp
opcGenSym:
TOpcode.opcGenSym
opcGetImpl:
TOpcode.opcGetImpl
opcGetImplTransf:
TOpcode.opcGetImplTransf
opcGorge:
TOpcode.opcGorge
OpChars:
lexer: OpChars
opcIncl:
TOpcode.opcIncl
opcInclRange:
TOpcode.opcInclRange
opcIndCall:
TOpcode.opcIndCall
opcIndCallAsgn:
TOpcode.opcIndCallAsgn
opcInvalidField:
TOpcode.opcInvalidField
opcIs:
TOpcode.opcIs
opcIsNil:
TOpcode.opcIsNil
opcJmp:
TOpcode.opcJmp
opcJmpBack:
TOpcode.opcJmpBack
opcLdArr:
TOpcode.opcLdArr
opcLdArrAddr:
TOpcode.opcLdArrAddr
opcLdConst:
TOpcode.opcLdConst
opcLdDeref:
TOpcode.opcLdDeref
opcLdGlobal:
TOpcode.opcLdGlobal
opcLdGlobalAddr:
TOpcode.opcLdGlobalAddr
opcLdGlobalAddrDerefFFI:
TOpcode.opcLdGlobalAddrDerefFFI
opcLdGlobalDerefFFI:
TOpcode.opcLdGlobalDerefFFI
opcLdImmInt:
TOpcode.opcLdImmInt
opcLdNull:
TOpcode.opcLdNull
opcLdNullReg:
TOpcode.opcLdNullReg
opcLdObj:
TOpcode.opcLdObj
opcLdObjAddr:
TOpcode.opcLdObjAddr
opcLdStrIdx:
TOpcode.opcLdStrIdx
opcLdStrIdxAddr:
TOpcode.opcLdStrIdxAddr
opcLeFloat:
TOpcode.opcLeFloat
opcLeInt:
TOpcode.opcLeInt
opcLenCstring:
TOpcode.opcLenCstring
opcLenSeq:
TOpcode.opcLenSeq
opcLenStr:
TOpcode.opcLenStr
opcLeSet:
TOpcode.opcLeSet
opcLeStr:
TOpcode.opcLeStr
opcLeu:
TOpcode.opcLeu
opcLtFloat:
TOpcode.opcLtFloat
opcLtInt:
TOpcode.opcLtInt
opcLtSet:
TOpcode.opcLtSet
opcLtStr:
TOpcode.opcLtStr
opcLtu:
TOpcode.opcLtu
opcMarshalLoad:
TOpcode.opcMarshalLoad
opcMarshalStore:
TOpcode.opcMarshalStore
opcMinusSet:
TOpcode.opcMinusSet
opcModInt:
TOpcode.opcModInt
opcModu:
TOpcode.opcModu
opcMulFloat:
TOpcode.opcMulFloat
opcMulInt:
TOpcode.opcMulInt
opcMulSet:
TOpcode.opcMulSet
opcMulu:
TOpcode.opcMulu
opcNAdd:
TOpcode.opcNAdd
opcNAddMultiple:
TOpcode.opcNAddMultiple
opcNarrowS:
TOpcode.opcNarrowS
opcNarrowU:
TOpcode.opcNarrowU
opcNBindSym:
TOpcode.opcNBindSym
opcNccInc:
TOpcode.opcNccInc
opcNccValue:
TOpcode.opcNccValue
opcNChild:
TOpcode.opcNChild
opcNCopyNimNode:
TOpcode.opcNCopyNimNode
opcNCopyNimTree:
TOpcode.opcNCopyNimTree
opcNcsAdd:
TOpcode.opcNcsAdd
opcNcsAt:
TOpcode.opcNcsAt
opcNcsIncl:
TOpcode.opcNcsIncl
opcNcsLen:
TOpcode.opcNcsLen
opcNctGet:
TOpcode.opcNctGet
opcNctHasNext:
TOpcode.opcNctHasNext
opcNctLen:
TOpcode.opcNctLen
opcNctNext:
TOpcode.opcNctNext
opcNctPut:
TOpcode.opcNctPut
opcNDel:
TOpcode.opcNDel
opcNDynBindSym:
TOpcode.opcNDynBindSym
opcNError:
TOpcode.opcNError
opcNew:
TOpcode.opcNew
opcNewSeq:
TOpcode.opcNewSeq
opcNewStr:
TOpcode.opcNewStr
opcNFloatVal:
TOpcode.opcNFloatVal
opcNGetLineInfo:
TOpcode.opcNGetLineInfo
opcNGetSize:
TOpcode.opcNGetSize
opcNGetType:
TOpcode.opcNGetType
opcNHint:
TOpcode.opcNHint
opcNIdent:
TOpcode.opcNIdent
opcNIntVal:
TOpcode.opcNIntVal
opcNKind:
TOpcode.opcNKind
opcNNewNimNode:
TOpcode.opcNNewNimNode
opcNodeId:
TOpcode.opcNodeId
opcNodeToReg:
TOpcode.opcNodeToReg
opcNot:
TOpcode.opcNot
opcNSetChild:
TOpcode.opcNSetChild
opcNSetFloatVal:
TOpcode.opcNSetFloatVal
opcNSetIdent:
TOpcode.opcNSetIdent
opcNSetIntVal:
TOpcode.opcNSetIntVal
opcNSetLineInfo:
TOpcode.opcNSetLineInfo
opcNSetStrVal:
TOpcode.opcNSetStrVal
opcNSetSymbol:
TOpcode.opcNSetSymbol
opcNSetType:
TOpcode.opcNSetType
opcNSigHash:
TOpcode.opcNSigHash
opcNStrVal:
TOpcode.opcNStrVal
opcNSymbol:
TOpcode.opcNSymbol
opcNSymKind:
TOpcode.opcNSymKind
opcNWarning:
TOpcode.opcNWarning
opcode:
vmdef: opcode(x: TInstr): TOpcode
opcOf:
TOpcode.opcOf
opcParseExprToAst:
TOpcode.opcParseExprToAst
opcParseFloat:
TOpcode.opcParseFloat
opcParseStmtToAst:
TOpcode.opcParseStmtToAst
opcPlusSet:
TOpcode.opcPlusSet
opcQueryErrorFlag:
TOpcode.opcQueryErrorFlag
opcQuit:
TOpcode.opcQuit
opcRaise:
TOpcode.opcRaise
opcRangeChck:
TOpcode.opcRangeChck
opcRepr:
TOpcode.opcRepr
opcRet:
TOpcode.opcRet
opcSameNodeType:
TOpcode.opcSameNodeType
opcSetLenSeq:
TOpcode.opcSetLenSeq
opcSetLenStr:
TOpcode.opcSetLenStr
opcSetType:
TOpcode.opcSetType
opcShlInt:
TOpcode.opcShlInt
opcShrInt:
TOpcode.opcShrInt
opcSignExtend:
TOpcode.opcSignExtend
opcSlurp:
TOpcode.opcSlurp
opcStrToIdent:
TOpcode.opcStrToIdent
opcSubFloat:
TOpcode.opcSubFloat
opcSubImmInt:
TOpcode.opcSubImmInt
opcSubInt:
TOpcode.opcSubInt
opcSubStr:
TOpcode.opcSubStr
opcSubu:
TOpcode.opcSubu
opcSymIsInstantiationOf:
TOpcode.opcSymIsInstantiationOf
opcSymOwner:
TOpcode.opcSymOwner
opcTJmp:
TOpcode.opcTJmp
opcTry:
TOpcode.opcTry
opcTypeTrait:
TOpcode.opcTypeTrait
opcUnaryMinusFloat:
TOpcode.opcUnaryMinusFloat
opcUnaryMinusInt:
TOpcode.opcUnaryMinusInt
opcWrArr:
TOpcode.opcWrArr
opcWrDeref:
TOpcode.opcWrDeref
opcWrObj:
TOpcode.opcWrObj
opcWrStrIdx:
TOpcode.opcWrStrIdx
opcXor:
TOpcode.opcXor
opcYldVal:
TOpcode.opcYldVal
opcYldYoid:
TOpcode.opcYldYoid
open:
rodfiles: open(filename: string): RodFile
ndi: open(f: var NdiFile; filename: AbsoluteFile; conf: ConfigRef)
openBaseLexer:
nimlexbase: openBaseLexer(L: var TBaseLexer; inputstream: PLLStream; bufLen: int = 8192)
openLexer:
lexer: openLexer(lex: var Lexer; filename: AbsoluteFile; inputstream: PLLStream; cache: IdentCache; config: ConfigRef)
lexer: openLexer(lex: var Lexer; fileIdx: FileIndex; inputstream: PLLStream; cache: IdentCache; config: ConfigRef)
openParser:
parser: openParser(p: var Parser; filename: AbsoluteFile; inputStream: PLLStream; cache: IdentCache; config: ConfigRef)
parser: openParser(p: var Parser; fileIdx: FileIndex; inputStream: PLLStream; cache: IdentCache; config: ConfigRef)
syntaxes: openParser(p: var Parser; fileIdx: FileIndex; inputstream: PLLStream; cache: IdentCache; config: ConfigRef)
openScope:
lookups: openScope(c: PContext): PScope
openShadowScope:
lookups: openShadowScope(c: PContext)
operand:
packed_ast: operand(n: NodePos): int32
Operators:
modulegraphs: Operators
opGorge:
gorgeimpl: opGorge(cmd, input, cache: string; info: TLineInfo; conf: ConfigRef): (string, int)
opMapTypeImplToAst:
vmdeps: opMapTypeImplToAst(cache: IdentCache; t: PType; info: TLineInfo; idgen: IdGenerator): PNode
opMapTypeInstToAst:
vmdeps: opMapTypeInstToAst(cache: IdentCache; t: PType; info: TLineInfo; idgen: IdGenerator): PNode
opMapTypeToAst:
vmdeps: opMapTypeToAst(cache: IdentCache; t: PType; info: TLineInfo; idgen: IdGenerator): PNode
oprHigh:
wordrecg: oprHigh
oprLow:
wordrecg: oprLow
opSlurp:
vmdeps: opSlurp(file: string; info: TLineInfo; module: PSym; conf: ConfigRef): string
optAssert:
TOption.optAssert
optBenchmarkVM:
TGlobalOption.optBenchmarkVM
optBoundsCheck:
TOption.optBoundsCheck
optByRef:
TOption.optByRef
optCDebug:
TGlobalOption.optCDebug
optCompileOnly:
TGlobalOption.optCompileOnly
optCursorInference:
TOption.optCursorInference
optDeclaredLocs:
TGlobalOption.optDeclaredLocs
optDocInternal:
TGlobalOption.optDocInternal
optDynlibOverrideAll:
TGlobalOption.optDynlibOverrideAll
optEmbedOrigSrc:
TGlobalOption.optEmbedOrigSrc
optEnableDeepCopy:
TGlobalOption.optEnableDeepCopy
optExcessiveStackTrace:
TGlobalOption.optExcessiveStackTrace
optFieldCheck:
TOption.optFieldCheck
optForceFullMake:
TGlobalOption.optForceFullMake
optGenDynLib:
TGlobalOption.optGenDynLib
optGenGuiApp:
TGlobalOption.optGenGuiApp
optGenIndex:
TGlobalOption.optGenIndex
optGenMapping:
TGlobalOption.optGenMapping
optGenScript:
TGlobalOption.optGenScript
optGenStaticLib:
TGlobalOption.optGenStaticLib
optHints:
TOption.optHints
optHotCodeReloading:
TGlobalOption.optHotCodeReloading
optIdeDebug:
TGlobalOption.optIdeDebug
optIdeTerse:
TGlobalOption.optIdeTerse
optimize:
optimizer: optimize(n: PNode): PNode
optImplicitStatic:
TOption.optImplicitStatic
optImportHidden:
TOption.optImportHidden
optInd:
parser: optInd(p: var Parser; n: PNode)
optInfCheck:
TOption.optInfCheck
optLineDir:
TOption.optLineDir
optLineTrace:
TOption.optLineTrace
optListCmd:
TGlobalOption.optListCmd
optMemTracker:
TOption.optMemTracker
optMixedMode:
TGlobalOption.optMixedMode
optMultiMethods:
TGlobalOption.optMultiMethods
optNaNCheck:
TOption.optNaNCheck
optNimV12Emulation:
TGlobalOption.optNimV12Emulation
optNimV1Emulation:
TGlobalOption.optNimV1Emulation
optNoLinking:
TGlobalOption.optNoLinking
optNoMain:
TGlobalOption.optNoMain
optNone:
TOption.optNone
optNoNimblePath:
TGlobalOption.optNoNimblePath
optObjCheck:
TOption.optObjCheck
optOptimizeSize:
TOption.optOptimizeSize
optOptimizeSpeed:
TOption.optOptimizeSpeed
optOverflowCheck:
TOption.optOverflowCheck
optOwnedRefs:
TGlobalOption.optOwnedRefs
optPanics:
TGlobalOption.optPanics
optPar:
parser: optPar(p: var Parser)
optPreserveOrigSource:
options: optPreserveOrigSource(conf: ConfigRef): untyped
optProduceAsm:
TGlobalOption.optProduceAsm
optProfiler:
TOption.optProfiler
optProfileVM:
TGlobalOption.optProfileVM
optRangeCheck:
TOption.optRangeCheck
optRefCheck:
TOption.optRefCheck
optRun:
TGlobalOption.optRun
optSeqDestructors:
TGlobalOption.optSeqDestructors
optShowAllMismatches:
TGlobalOption.optShowAllMismatches
optSinkInference:
TOption.optSinkInference
optSkipParentConfigFiles:
TGlobalOption.optSkipParentConfigFiles
optSkipProjConfigFile:
TGlobalOption.optSkipProjConfigFile
optSkipSystemConfigFile:
TGlobalOption.optSkipSystemConfigFile
optSkipUserConfigFile:
TGlobalOption.optSkipUserConfigFile
optSourcemap:
TGlobalOption.optSourcemap
optStackTrace:
TOption.optStackTrace
optStackTraceMsgs:
TOption.optStackTraceMsgs
optStaticBoundsCheck:
TOption.optStaticBoundsCheck
optStdout:
TGlobalOption.optStdout
optStyleCheck:
TOption.optStyleCheck
optStyleError:
TGlobalOption.optStyleError
optStyleHint:
TGlobalOption.optStyleHint
optStyleUsages:
TGlobalOption.optStyleUsages
optThreadAnalysis:
TGlobalOption.optThreadAnalysis
optThreads:
TGlobalOption.optThreads
optTinyRtti:
TGlobalOption.optTinyRtti
optTlsEmulation:
TGlobalOption.optTlsEmulation
optTrMacros:
TOption.optTrMacros
optUseColors:
TGlobalOption.optUseColors
optUseNimcache:
TGlobalOption.optUseNimcache
optWarns:
TOption.optWarns
optWasNimscript:
TGlobalOption.optWasNimscript
optWholeProject:
TGlobalOption.optWholeProject
OrdinalType:
types: OrdinalType
ordinalValToString:
semfold: ordinalValToString(a: PNode; g: ModuleGraph): string
originatingModule:
ast: originatingModule(s: PSym): PSym
OS:
platform: OS
osAix:
TSystemOS.osAix
osAmiga:
TSystemOS.osAmiga
osAndroid:
TSystemOS.osAndroid
osAny:
TSystemOS.osAny
osAtari:
TSystemOS.osAtari
osCrossos:
TSystemOS.osCrossos
osDos:
TSystemOS.osDos
osDragonfly:
TSystemOS.osDragonfly
osFreebsd:
TSystemOS.osFreebsd
osFreeRTOS:
TSystemOS.osFreeRTOS
osGenode:
TSystemOS.osGenode
osHaiku:
TSystemOS.osHaiku
osIos:
TSystemOS.osIos
osIrix:
TSystemOS.osIrix
osJS:
TSystemOS.osJS
osLinux:
TSystemOS.osLinux
osMacos:
TSystemOS.osMacos
osMacosx:
TSystemOS.osMacosx
osMorphos:
TSystemOS.osMorphos
osNetbsd:
TSystemOS.osNetbsd
osNetware:
TSystemOS.osNetware
osNimVM:
TSystemOS.osNimVM
osNintendoSwitch:
TSystemOS.osNintendoSwitch
osNone:
TSystemOS.osNone
osOpenbsd:
TSystemOS.osOpenbsd
osOs2:
TSystemOS.osOs2
osPalmos:
TSystemOS.osPalmos
ospCaseInsensitive:
TInfoOSProp.ospCaseInsensitive
ospLacksThreadVars:
TInfoOSProp.ospLacksThreadVars
ospNeedsPIC:
TInfoOSProp.ospNeedsPIC
ospPosix:
TInfoOSProp.ospPosix
osQnx:
TSystemOS.osQnx
osSkyos:
TSystemOS.osSkyos
osSolaris:
TSystemOS.osSolaris
osStandalone:
TSystemOS.osStandalone
osVxWorks:
TSystemOS.osVxWorks
osWindows:
TSystemOS.osWindows
outdated:
ModuleStatus.outdated
overlap:
nimsets: overlap(a, b: PNode): bool
overloadableEnums:
Feature.overloadableEnums
OverloadableSyms:
ast: OverloadableSyms
PackageModuleId:
ast: PackageModuleId
PackedConfig:
ic: PackedConfig
PackedDecoder:
ic: PackedDecoder
PackedEncoder:
ic: PackedEncoder
PackedInstantiation:
packed_ast: PackedInstantiation
PackedItemId:
packed_ast: PackedItemId
PackedLib:
packed_ast: PackedLib
PackedLineInfo:
packed_ast: PackedLineInfo
PackedModule:
ic: PackedModule
PackedModuleGraph:
ic: PackedModuleGraph
PackedNode:
packed_ast: PackedNode
packedRepr:
semdata: packedRepr(c): untyped
PackedSym:
packed_ast: PackedSym
PackedTree:
packed_ast: PackedTree
PackedType:
packed_ast: PackedType
pairs:
ast: pairs(n: PNode): tuple[i: int, n: PNode]
astalgo: pairs(t: TIdNodeTable): tuple[key: PIdObj, val: PNode]
astalgo: pairs(t: TIdTable): tuple[key: int, value: RootRef]
btrees: pairs[Key, Val](b: BTree[Key, Val]): (Key, Val)
parallel:
Feature.parallel
paramName:
lambdalifting: paramName
paramPragmas:
pragmas: paramPragmas
paramsEqual:
TParamsEquality.paramsEqual
paramsIncompatible:
TParamsEquality.paramsIncompatible
paramsNotEqual:
TParamsEquality.paramsNotEqual
paramsPos:
ast: paramsPos
paramTypesMatch:
sigmatch: paramTypesMatch(m: var TCandidate; f, a: PType; arg, argOrig: PNode): PNode
parent:
packed_ast: parent(n: NodePos): NodePos
Parent:
Nilability.Parent
parentModule:
modulegraphs: parentModule(g: ModuleGraph; fileIdx: FileIndex): FileIndex
parLineInfo:
parser: parLineInfo(p: Parser): TLineInfo
parMessage:
parser: parMessage(p: Parser; msg: TMsgKind; arg: string = "")
parse:
sourcemap: parse(source: string; path: string): SourceNode
parseAll:
parser: parseAll(p: var Parser): PNode
parseCommand:
commands: parseCommand(command: string): Command
parseDecimalInt128:
int128: parseDecimalInt128(arg: string; pos: int = 0): Int128
parseFile:
syntaxes: parseFile(fileIdx: FileIndex; cache: IdentCache; config: ConfigRef): PNode
parseIdeCmd:
options: parseIdeCmd(s: string): IdeCmd
parseNimVersion:
options: parseNimVersion(a: string): NimVer
Parser:
parser: Parser
parseString:
parser: parseString(s: string; cache: IdentCache; config: ConfigRef; filename: string = ""; line: int = 0; errorHandler: ErrorHandler = nil): PNode
parseSymbol:
parser: parseSymbol(p: var Parser; mode = smNormal): PNode
parseTopLevelStmt:
parser: parseTopLevelStmt(p: var Parser): PNode
partialMatch:
sigmatch: partialMatch(c: PContext; n, nOrig: PNode; m: var TCandidate)
Partitions:
varpartitions: Partitions
passCmd1:
TCmdLinePass.passCmd1
passCmd2:
TCmdLinePass.passCmd2
passPP:
TCmdLinePass.passPP
patch:
packed_ast: patch(tree: var PackedTree; pos: PatchPos)
pathSubs:
options: pathSubs(conf: ConfigRef; p, config: string): string
patternPos:
ast: patternPos
pcmDifferentCallConv:
ProcConvMismatch.pcmDifferentCallConv
pcmLockDifference:
ProcConvMismatch.pcmLockDifference
pcmNoSideEffect:
ProcConvMismatch.pcmNoSideEffect
pcmNotGcSafe:
ProcConvMismatch.pcmNotGcSafe
pcmNotIterator:
ProcConvMismatch.pcmNotIterator
PContext:
semdata: PContext
PCtx:
vmdef: PCtx
PDoc:
docgen: PDoc
PersistentNodeFlags:
ast: PersistentNodeFlags
PEvalContext:
vmdef: PEvalContext
pickSym:
lookups: pickSym(c: PContext; n: PNode; kinds: set[TSymKind]; flags: TSymFlags = {}): PSym
PickyCAliases:
TTypeCmpFlag.PickyCAliases
PIdent:
idents: PIdent
PIdObj:
ast: PIdObj
PInstantiation:
ast: PInstantiation
PLib:
ast: PLib
PLLStream:
llstream: PLLStream
Plugin:
pluginsupport: Plugin
pluginMatches:
pluginsupport: pluginMatches(ic: IdentCache; p: Plugin; s: PSym): bool
PNode:
ast: PNode
popCaseContext:
semdata: popCaseContext(c: PContext)
popInfoContext:
msgs: popInfoContext(conf: ConfigRef)
popOptionEntry:
semdata: popOptionEntry(c: PContext)
popOwner:
semdata: popOwner(c: PContext)
popProcCon:
semdata: popProcCon(c: PContext)
POptionEntry:
semdata: POptionEntry
PPassContext:
modulegraphs: PPassContext
PProc:
vmdef: PProc
PProcCon:
semdata: PProcCon
pragma:
pragmas: pragma(c: PContext; sym: PSym; n: PNode; validPragmas: TSpecialWords; isStatement: bool = false)
pragmaAsm:
pragmas: pragmaAsm(c: PContext; n: PNode): char
pragmaCallable:
pragmas: pragmaCallable(c: PContext; sym: PSym; n: PNode; validPragmas: TSpecialWords; isStatement: bool = false)
pragmasEffects:
ast: pragmasEffects
pragmasPos:
ast: pragmasPos
preferDesc:
TPreferedDesc.preferDesc
preferExported:
TPreferedDesc.preferExported
preferGenericArg:
TPreferedDesc.preferGenericArg
preferMixed:
TPreferedDesc.preferMixed
preferModuleInfo:
TPreferedDesc.preferModuleInfo
preferName:
TPreferedDesc.preferName
preferResolved:
TPreferedDesc.preferResolved
preferTypeName:
TPreferedDesc.preferTypeName
PrefixMatch:
prefixmatches: PrefixMatch
prefixMatch:
prefixmatches: prefixMatch(p, s: string): PrefixMatch
prepare:
packed_ast: prepare(dest: var PackedTree; source: PackedTree; sourcePos: NodePos): PatchPos
packed_ast: prepare(tree: var PackedTree; kind: TNodeKind; flags: TNodeFlags; typeId: PackedItemId; info: PackedLineInfo): PatchPos
prepareMetatypeForSigmatch:
semtypinst: prepareMetatypeForSigmatch(p: PContext; pt: TIdTable; info: TLineInfo; t: PType): PType
prepareToWriteOutput:
options: prepareToWriteOutput(conf: ConfigRef): AbsoluteFile
prepend:
ropes: prepend(a: var Rope; b: Rope)
ropes: prepend(a: var Rope; b: string)
prependCurDir:
cmdlinehelper: prependCurDir(f: AbsoluteFile): AbsoluteFile
presentationPath:
docgen: presentationPath(conf: ConfigRef; file: AbsoluteFile): RelativeFile
prettyTok:
lexer: prettyTok(tok: Token): string
preventStackTrace:
CodegenFlag.preventStackTrace
previouslyInferred:
ast: previouslyInferred(t: PType): PType
printTok:
lexer: printTok(conf: ConfigRef; tok: Token)
ProcConvMismatch:
types: ProcConvMismatch
procDefs:
ast: procDefs
processArgument:
commands: processArgument(pass: TCmdLinePass; p: OptParser; argsCount: var int; config: ConfigRef): bool
processCmdLineAndProjectPath:
cmdlinehelper: processCmdLineAndProjectPath(self: NimProg; conf: ConfigRef)
processCommand:
commands: processCommand(switch: string; pass: TCmdLinePass; config: ConfigRef)
processModule:
passes: processModule(graph: ModuleGraph; module: PSym; idgen: IdGenerator; stream: PLLStream): bool
processSpecificNote:
commands: processSpecificNote(arg: string; state: TSpecialWord; pass: TCmdLinePass; info: TLineInfo; orig: string; conf: ConfigRef)
processSwitch:
commands: processSwitch(switch, arg: string; pass: TCmdLinePass; info: TLineInfo; conf: ConfigRef)
commands: processSwitch(pass: TCmdLinePass; p: OptParser; config: ConfigRef)
procInstCacheItems:
modulegraphs: procInstCacheItems(g: ModuleGraph; s: PSym): PInstantiation
procInstCacheSection:
RodSection.procInstCacheSection
procPragmas:
pragmas: procPragmas
procSec:
cgendata: procSec(p: BProc; s: TCProcSection): var Rope
procTypePragmas:
pragmas: procTypePragmas
produceDestructorForDiscriminator:
liftdestructors: produceDestructorForDiscriminator(g: ModuleGraph; typ: PType; field: PSym; info: TLineInfo; idgen: IdGenerator): PSym
ProfileData:
options: ProfileData
ProfileInfo:
options: ProfileInfo
Profiler:
vmdef: Profiler
propagateToOwner:
ast: propagateToOwner(owner, elem: PType; propagateHasAsgn = true)
propSpec:
trees: propSpec(n: PNode; effectType: TSpecialWord): PNode
proveLe:
guards: proveLe(m: TModel; a, b: PNode): TImplication
PScope:
ast: PScope
PStackFrame:
vmdef: PStackFrame
PSym:
ast: PSym
PtrLikeKinds:
ast: PtrLikeKinds
PType:
ast: PType
pureEnumsSection:
RodSection.pureEnumsSection
pushCaseContext:
semdata: pushCaseContext(c: PContext; caseNode: PNode)
pushInfoContext:
msgs: pushInfoContext(conf: ConfigRef; info: TLineInfo; detail: string = "")
pushOptionEntry:
semdata: pushOptionEntry(c: PContext): POptionEntry
pushOwner:
semdata: pushOwner(c: PContext; owner: PSym)
pushProcCon:
sem: pushProcCon(c: PContext; owner: PSym)
put:
semdata: put(p: PProcCon; key, val: PSym)
qualifiedLookUp:
lookups: qualifiedLookUp(c: PContext; n: PNode; flags: set[TLookupFlag]): PSym
quitOrRaise:
options: quitOrRaise(conf: ConfigRef; msg = "")
quotedFilename:
msgs: quotedFilename(conf: ConfigRef; i: TLineInfo): Rope
quoteExpr:
astmsgs: quoteExpr(a: string): untyped
quoteShell:
pathutils: quoteShell(x: AbsoluteDir): string
pathutils: quoteShell(x: AbsoluteFile): string
raiseRecoverableError:
lineinfos: raiseRecoverableError(msg: string)
rangeHasUnresolvedStatic:
semdata: rangeHasUnresolvedStatic(t: PType): bool
rawAddField:
lowerings: rawAddField(obj: PType; field: PSym)
rawAddSon:
ast: rawAddSon(father, son: PType; propagateHasAsgn = true)
rawAddSonNoPropagationOfTypeFlags:
ast: rawAddSonNoPropagationOfTypeFlags(father, son: PType)
rawCloseScope:
lookups: rawCloseScope(c: PContext)
rawDirectAccess:
lowerings: rawDirectAccess(obj, field: PSym): PNode
rawGetTok:
lexer: rawGetTok(L: var Lexer; tok: var Token)
rawIndirectAccess:
lowerings: rawIndirectAccess(a: PNode; field: PSym; info: TLineInfo): PNode
rawMessage:
msgs: rawMessage(conf: ConfigRef; msg: TMsgKind; args: openArray[string])
msgs: rawMessage(conf: ConfigRef; msg: TMsgKind; arg: string)
RawTypeMismatchError:
ErrorKind.RawTypeMismatchError
readConfigFile:
nimconf: readConfigFile(filename: AbsoluteFile; cache: IdentCache; config: ConfigRef): bool
readExceptSet:
importer: readExceptSet(c: PContext; n: PNode): IntSet
readOnlySf:
SymbolFilesOption.readOnlySf
recomputeFieldPositions:
semtypinst: recomputeFieldPositions(t: PType; obj: PNode; currPosition: var int)
recordAdd:
macrocacheimpl: recordAdd(c: PCtx; info: TLineInfo; key: string; val: PNode)
recordInc:
macrocacheimpl: recordInc(c: PCtx; info: TLineInfo; key: string; by: BiggestInt)
recordIncl:
macrocacheimpl: recordIncl(c: PCtx; info: TLineInfo; key: string; val: PNode)
recordPut:
macrocacheimpl: recordPut(c: PCtx; info: TLineInfo; key: string; k: string; val: PNode)
reexportsSection:
RodSection.reexportsSection
reexportSym:
semdata: reexportSym(c: PContext; s: PSym)
refresh:
vmdef: refresh(c: PCtx; module: PSym; idgen: IdGenerator)
regA:
vmdef: regA(x: TInstr): TRegister
regAMask:
vmdef: regAMask
regAShift:
vmdef: regAShift
regB:
vmdef: regB(x: TInstr): TRegister
regBMask:
vmdef: regBMask
regBShift:
vmdef: regBShift
regBx:
vmdef: regBx(x: TInstr): int
regBxMask:
vmdef: regBxMask
regBxMax:
vmdef: regBxMax
regBxMin:
vmdef: regBxMin
regBxShift:
vmdef: regBxShift
regC:
vmdef: regC(x: TInstr): TRegister
regCMask:
vmdef: regCMask
regCShift:
vmdef: regCShift
registerAdditionalOps:
vm: registerAdditionalOps(c: PCtx)
registerCallback:
vmdef: registerCallback(c: PCtx; name: string; callback: VmCallback): int
registerCompilerProc:
magicsys: registerCompilerProc(g: ModuleGraph; s: PSym)
registerInitProcs:
cgen: registerInitProcs(g: BModuleList; m: PSym; flags: set[ModuleBackendFlag])
registerModule:
modulegraphs: registerModule(g: ModuleGraph; m: PSym)
registerModuleById:
modulegraphs: registerModuleById(g: ModuleGraph; m: FileIndex)
registerNimScriptSymbol:
magicsys: registerNimScriptSymbol(g: ModuleGraph; s: PSym)
registerPass:
passes: registerPass(g: ModuleGraph; p: TPass)
regOMask:
vmdef: regOMask
regOShift:
vmdef: regOShift
RelativeDir:
pathutils: RelativeDir
RelativeFile:
pathutils: RelativeFile
relativeJumps:
vmdef: relativeJumps
relativeTo:
pathutils: relativeTo(fullPath: AbsoluteFile; baseFilename: AbsoluteDir; sep = DirSep): RelativeFile
rememberEmittedTypeInfo:
modulegraphs: rememberEmittedTypeInfo(g: ModuleGraph; m: FileIndex; ti: string)
rememberExpansion:
semdata: rememberExpansion(c: PContext; info: TLineInfo; expandedSym: PSym)
rememberFlag:
modulegraphs: rememberFlag(g: ModuleGraph; m: PSym; flag: ModuleBackendFlag)
rememberStartupConfig:
ic: rememberStartupConfig(dest: var PackedConfig; config: ConfigRef)
removeFile:
pathutils: removeFile(x: AbsoluteFile)
removeTrailingDirSep:
options: removeTrailingDirSep(path: string): string
renderDefinitionName:
renderer: renderDefinitionName(s: PSym; noQuotes = false): string
renderDocComments:
TRenderFlag.renderDocComments
renderIds:
TRenderFlag.renderIds
renderIr:
TRenderFlag.renderIr
renderModule:
renderer: renderModule(n: PNode; outfile: string; renderFlags: TRenderFlags = {}; fid = FileIndex(-1); conf: ConfigRef = nil)
renderNoBody:
TRenderFlag.renderNoBody
renderNoComments:
TRenderFlag.renderNoComments
renderNone:
TRenderFlag.renderNone
renderNoPragmas:
TRenderFlag.renderNoPragmas
renderNoProcDefs:
TRenderFlag.renderNoProcDefs
renderParamTypes:
typesrenderer: renderParamTypes(n: PNode; sep = defaultParamSeparator): string
renderPlainSymbolName:
typesrenderer: renderPlainSymbolName(n: PNode): string
renderRunnableExamples:
TRenderFlag.renderRunnableExamples
renderSyms:
TRenderFlag.renderSyms
renderTree:
renderer: renderTree(n: PNode; renderFlags: TRenderFlags = {}): string
reorder:
reorder: reorder(graph: ModuleGraph; n: PNode; module: PSym): PNode
replaceComment:
prettybase: replaceComment(conf: ConfigRef; info: TLineInfo)
replaceDeprecated:
prettybase: replaceDeprecated(conf: ConfigRef; info: TLineInfo; oldSym, newSym: PIdent)
prettybase: replaceDeprecated(conf: ConfigRef; info: TLineInfo; oldSym, newSym: PSym)
replaceTypesInBody:
semtypinst: replaceTypesInBody(p: PContext; pt: TIdTable; n: PNode; owner: PSym; allowMetaTypes = false): PNode
replaceTypeVarsN:
semtypinst: replaceTypeVarsN(cl: var TReplTypeVars; n: PNode; start = 0): PNode
replaceTypeVarsT:
semtypinst: replaceTypeVarsT(cl: var TReplTypeVars; t: PType): PType
replayGenericCacheInformation:
replayer: replayGenericCacheInformation(g: ModuleGraph; module: int)
replayStateChanges:
replayer: replayStateChanges(module: PSym; g: ModuleGraph)
requiredParams:
ast: requiredParams(s: PSym): int
requiresEffects:
ast: requiresEffects
requiresInit:
typeallowed: requiresInit(t: PType): bool
resetAllModules:
modulegraphs: resetAllModules(g: ModuleGraph)
resetCompilationLists:
extccomp: resetCompilationLists(conf: ConfigRef)
resetForBackend:
modulegraphs: resetForBackend(g: ModuleGraph)
resetIdentCache:
idents: resetIdentCache()
resetIdTable:
ast: resetIdTable(x: var TIdTable)
resetNimScriptSymbols:
magicsys: resetNimScriptSymbols(g: ModuleGraph)
resetRopeCache:
ropes: resetRopeCache()
resetSystemArtifacts:
modules: resetSystemArtifacts(g: ModuleGraph)
resetSysTypes:
magicsys: resetSysTypes(g: ModuleGraph)
resultPos:
ast: resultPos
rkFloat:
TRegisterKind.rkFloat
rkInt:
TRegisterKind.rkInt
rkNode:
TRegisterKind.rkNode
rkNodeAddr:
TRegisterKind.rkNodeAddr
rkNone:
TRegisterKind.rkNone
rkRegisterAddr:
TRegisterKind.rkRegisterAddr
RodExt:
options: RodExt
RodFile:
rodfiles: RodFile
RodFileError:
rodfiles: RodFileError
RodFileVersion:
nversion: RodFileVersion
RodIter:
ic: RodIter
RodSection:
rodfiles: RodSection
rodViewer:
ic: rodViewer(rodfile: AbsoluteFile; config: ConfigRef; cache: IdentCache)
Rope:
ropes: Rope
rope:
ropes: rope(f: BiggestFloat): Rope
ropes: rope(i: BiggestInt): Rope
ropes: rope(s: string): Rope
ropeConcat:
ropes: ropeConcat(a: varargs[Rope]): Rope
RopeObj:
ropes: RopeObj
routineDefs:
ast: routineDefs
routineKinds:
ast: routineKinds
rstWarnings:
lineinfos: rstWarnings
runJsonBuildInstructions:
extccomp: runJsonBuildInstructions(conf: ConfigRef; jsonFile: AbsoluteFile)
runNimScript:
scriptconfig: runNimScript(cache: IdentCache; scriptName: AbsoluteFile; idgen: IdGenerator; freshDefines = true; conf: ConfigRef; stream: PLLStream)
runtimeFormat:
ropes: runtimeFormat(frmt: FormatStr; args: openArray[Rope]): Rope
s:
cgendata: s(p: BProc; s: TCProcSection): var Rope
Safe:
Nilability.Safe
safeArrLen:
ast: safeArrLen(n: PNode): int
safeInheritanceDiff:
types: safeInheritanceDiff(a, b: PType): int
safeLen:
ast: safeLen(n: PNode): int
safeSemExpr:
sigmatch: safeSemExpr(c: PContext; n: PNode): PNode
safeSkipTypes:
types: safeSkipTypes(t: PType; kinds: TTypeKinds): PType
sameBackendType:
types: sameBackendType(x, y: PType): bool
sameConstant:
vmgen: sameConstant(a, b: PNode): bool
sameDistinctTypes:
types: sameDistinctTypes(a, b: PType): bool
sameEnumTypes:
types: sameEnumTypes(a, b: PType): bool
sameFlags:
types: sameFlags(a, b: PType): bool
sameLocation:
injectdestructors: sameLocation(a, b: PNode): bool
sameObjectTypes:
types: sameObjectTypes(a, b: PType): bool
sameSubexprs:
guards: sameSubexprs(m: TModel; a, b: PNode): bool
sameTree:
guards: sameTree(a, b: PNode): bool
trees: sameTree(a, b: PNode): bool
sameTrees:
patterns: sameTrees(a, b: PNode): bool
sameType:
types: sameType(a, b: PType; flags: TTypeCmpFlags = {}): bool
sameTypeOrNil:
types: sameTypeOrNil(a, b: PType; flags: TTypeCmpFlags = {}): bool
sameValue:
astalgo: sameValue(a, b: PNode): bool
saveRodFile:
ic: saveRodFile(filename: AbsoluteFile; encoder: var PackedEncoder; m: var PackedModule)
scopeDepth:
semdata: scopeDepth(c: PContext): int
sealRodFile:
semdata: sealRodFile(c: PContext)
searchForCompilerproc:
ic: searchForCompilerproc(m: LoadedModule; name: string): int32
searchForProc:
procfind: searchForProc(c: PContext; scope: PScope; fn: PSym): tuple[proto: PSym, comesFromShadowScope: bool]
searchInScopes:
lookups: searchInScopes(c: PContext; s: PIdent; ambiguous: var bool): PSym
searchInScopesFilterBy:
lookups: searchInScopesFilterBy(c: PContext; s: PIdent; filter: TSymKinds): seq[PSym]
searchInstTypes:
semtypinst: searchInstTypes(g: ModuleGraph; key: PType): PType
searchTypeFor:
types: searchTypeFor(t: PType; predicate: TTypePredicate): bool
semAsmOrEmit:
pragmas: semAsmOrEmit(con: PContext; n: PNode; marker: char): PNode
semCaptureSym:
lambdalifting: semCaptureSym(s, owner: PSym)
semConceptDeclaration:
concepts: semConceptDeclaration(c: PContext; n: PNode): PNode
semFinishOperands:
sigmatch: semFinishOperands(c: PContext; n: PNode)
semLocals:
locals: semLocals(c: PContext; n: PNode): PNode
semNodeKindConstraints:
parampatterns: semNodeKindConstraints(n: PNode; conf: ConfigRef; start: Natural): PNode
semPass:
sem: semPass
semtabAll:
modulegraphs: semtabAll(g: ModuleGraph; m: PSym): TStrTable
seNoSideEffect:
TSideEffectAnalysis.seNoSideEffect
seSideEffect:
TSideEffectAnalysis.seSideEffect
setAttachedOp:
modulegraphs: setAttachedOp(g: ModuleGraph; module: int; t: PType; op: TTypeAttachedOp; value: PSym)
setAttachedOpPartial:
modulegraphs: setAttachedOpPartial(g: ModuleGraph; module: int; t: PType; op: TTypeAttachedOp; value: PSym)
setBaseFlags:
parser: setBaseFlags(n: PNode; base: NumericalBase)
setCaseContextIdx:
semdata: setCaseContextIdx(c: PContext; idx: int)
setCC:
extccomp: setCC(conf: ConfigRef; ccname: string; info: TLineInfo)
setCmd:
commands: setCmd(conf: ConfigRef; cmd: Command)
setCommandEarly:
commands: setCommandEarly(conf: ConfigRef; command: string)
setConfigVar:
options: setConfigVar(conf: ConfigRef; key, val: string)
setDefaultLibpath:
options: setDefaultLibpath(conf: ConfigRef)
setDirtyFile:
msgs: setDirtyFile(conf: ConfigRef; fileIdx: FileIndex; filename: AbsoluteFile)
setEffectsForProcType:
sempass2: setEffectsForProcType(g: ModuleGraph; t: PType; n: PNode; s: PSym = nil)
setErrorMaxHighMaybe:
options: setErrorMaxHighMaybe(conf: ConfigRef)
setFromProjectName:
options: setFromProjectName(conf: ConfigRef; projectName: string)
setGlobalValue:
vm: setGlobalValue(c: PCtx; s: PSym; val: PNode)
setHash:
msgs: setHash(conf: ConfigRef; fileIdx: FileIndex; hash: string)
setHasRange:
nimsets: setHasRange(s: PNode): bool
setInfoContextLen:
msgs: setInfoContextLen(conf: ConfigRef; L: int)
setIntLitType:
semdata: setIntLitType(c: PContext; result: PNode)
setLen:
strutils2: setLen(result: var string; n: int; isInit: bool)
setNote:
options: setNote(conf: ConfigRef; note: TNoteKind; enabled = true)
setNoteDefaults:
options: setNoteDefaults(conf: ConfigRef; note: TNoteKind; enabled = true)
setOutFile:
main: setOutFile(conf: ConfigRef)
setResult:
vm: setResult(a: VmArgs; v: AbsoluteDir)
vm: setResult(a: VmArgs; v: BiggestFloat)
vm: setResult(a: VmArgs; v: BiggestInt)
vm: setResult(a: VmArgs; v: bool)
vm: setResult(a: VmArgs; n: PNode)
vm: setResult(a: VmArgs; v: seq[string])
vm: setResult(a: VmArgs; v: string)
setTarget:
platform: setTarget(t: var Target; o: TSystemOS; c: TSystemCPU)
setTargetFromSystem:
platform: setTargetFromSystem(t: var Target)
setToStringProc:
modulegraphs: setToStringProc(g: ModuleGraph; t: PType; value: PSym)
setupCompileTimeVar:
vm: setupCompileTimeVar(module: PSym; idgen: IdGenerator; g: ModuleGraph; n: PNode)
setupGlobalCtx:
vm: setupGlobalCtx(module: PSym; graph: ModuleGraph; idgen: IdGenerator)
setupParser:
syntaxes: setupParser(p: var Parser; fileIdx: FileIndex; cache: IdentCache; config: ConfigRef): bool
setupVM:
scriptconfig: setupVM(module: PSym; cache: IdentCache; scriptName: string; graph: ModuleGraph; idgen: IdGenerator): PEvalContext
setUseIc:
ast: setUseIc(useIc: bool)
seUnknown:
TSideEffectAnalysis.seUnknown
Severity:
lineinfos: Severity
sfAddrTaken:
TSymFlag.sfAddrTaken
sfAllUntyped:
ast: sfAllUntyped
sfAnon:
ast: sfAnon
sfBase:
ast: sfBase
sfBorrow:
TSymFlag.sfBorrow
sfCallsite:
TSymFlag.sfCallsite
sfCompilerProc:
TSymFlag.sfCompilerProc
sfCompileTime:
TSymFlag.sfCompileTime
sfCompileToCpp:
ast: sfCompileToCpp
sfCompileToObjc:
ast: sfCompileToObjc
sfConstructor:
TSymFlag.sfConstructor
sfCppNonPod:
TSymFlag.sfCppNonPod
sfCursor:
TSymFlag.sfCursor
sfCustomPragma:
ast: sfCustomPragma
sfDeprecated:
TSymFlag.sfDeprecated
sfDirty:
ast: sfDirty
sfDiscardable:
TSymFlag.sfDiscardable
sfDiscriminant:
TSymFlag.sfDiscriminant
sfDispatcher:
TSymFlag.sfDispatcher
sfEffectsDelayed:
TSymFlag.sfEffectsDelayed
sfError:
TSymFlag.sfError
sfEscapes:
ast: sfEscapes
sfExperimental:
ast: sfExperimental
sfExplain:
TSymFlag.sfExplain
sfExportc:
TSymFlag.sfExportc
sfExported:
TSymFlag.sfExported
sfForward:
TSymFlag.sfForward
sfFromGeneric:
TSymFlag.sfFromGeneric
sfGeneratedOp:
TSymFlag.sfGeneratedOp
sfGenSym:
TSymFlag.sfGenSym
sfGlobal:
TSymFlag.sfGlobal
sfGoto:
ast: sfGoto
sfImportc:
TSymFlag.sfImportc
sfInfixCall:
TSymFlag.sfInfixCall
sfInjectDestructors:
TSymFlag.sfInjectDestructors
sfIsSelf:
ast: sfIsSelf
sfMainModule:
TSymFlag.sfMainModule
sfMangleCpp:
TSymFlag.sfMangleCpp
sfNamedParamCall:
TSymFlag.sfNamedParamCall
sfNeverRaises:
TSymFlag.sfNeverRaises
sfNoalias:
TSymFlag.sfNoalias
sfNoForward:
ast: sfNoForward
sfNoInit:
ast: sfNoInit
sfNonReloadable:
TSymFlag.sfNonReloadable
sfNoReturn:
TSymFlag.sfNoReturn
sfNoSideEffect:
TSymFlag.sfNoSideEffect
sfOverriden:
TSymFlag.sfOverriden
sfProcvar:
TSymFlag.sfProcvar
sfPure:
TSymFlag.sfPure
sfRegister:
TSymFlag.sfRegister
sfReorder:
ast: sfReorder
sfRequiresInit:
TSymFlag.sfRequiresInit
sfShadowed:
TSymFlag.sfShadowed
sfSideEffect:
TSymFlag.sfSideEffect
sfSingleUsedTemp:
TSymFlag.sfSingleUsedTemp
sfSystemModule:
TSymFlag.sfSystemModule
sfTemplateParam:
TSymFlag.sfTemplateParam
sfThread:
TSymFlag.sfThread
sfUsed:
TSymFlag.sfUsed
sfUsedInFinallyOrExcept:
TSymFlag.sfUsedInFinallyOrExcept
sfVolatile:
TSymFlag.sfVolatile
sfWasForwarded:
TSymFlag.sfWasForwarded
sfWrittenTo:
ast: sfWrittenTo
shallowCopy:
ast: shallowCopy(src: PNode): PNode
SigHash:
modulegraphs: SigHash
sigHash:
sighashes: sigHash(s: PSym): SigHash
simpleSlice:
guards: simpleSlice(a, b: PNode): BiggestInt
simulateCachedModule:
modulegraphs: simulateCachedModule(g: ModuleGraph; moduleSym: PSym; m: PackedModule)
simulateLoadedModule:
ic: simulateLoadedModule(g: var PackedModuleGraph; conf: ConfigRef; cache: IdentCache; moduleSym: PSym; m: PackedModule)
skAlias:
TSymKind.skAlias
skConditional:
TSymKind.skConditional
skConst:
TSymKind.skConst
skConverter:
TSymKind.skConverter
skDynLib:
TSymKind.skDynLib
skEnumField:
TSymKind.skEnumField
skError:
ast: skError
skField:
TSymKind.skField
skForVar:
TSymKind.skForVar
skFunc:
TSymKind.skFunc
skGenericParam:
TSymKind.skGenericParam
skipAddr:
ast: skipAddr(n: PNode): PNode
skipAlias:
lookups: skipAlias(s: PSym; n: PNode; conf: ConfigRef): PSym
skipCodegen:
passes: skipCodegen(config: ConfigRef; n: PNode): bool
skipColon:
ast: skipColon(n: PNode): PNode
skipComment:
parser: skipComment(p: var Parser; node: PNode)
skipConv:
types: skipConv(n: PNode): PNode
skipConvCastAndClosure:
astalgo: skipConvCastAndClosure(n: PNode): PNode
skipConvDfa:
dfa: skipConvDfa(n: PNode): PNode
skipConvTakeType:
types: skipConvTakeType(n: PNode): PNode
skipGenericAlias:
types: skipGenericAlias(t: PType): PType
skipGenericOwner:
ast: skipGenericOwner(s: PSym): PSym
skipHidden:
types: skipHidden(n: PNode): PNode
skipHiddenSubConv:
types: skipHiddenSubConv(n: PNode; g: ModuleGraph; idgen: IdGenerator): PNode
skipInd:
parser: skipInd(p: var Parser)
skipIntLit:
magicsys: skipIntLit(t: PType; id: IdGenerator): PType
skipIntLiteralParams:
semtypinst: skipIntLiteralParams(t: PType; idgen: IdGenerator)
skipPtrs:
types: skipPtrs
skipStmtList:
ast: skipStmtList(n: PNode): PNode
skipTypes:
ast: skipTypes(t: PType; kinds: TTypeKinds): PType
ast: skipTypes(t: PType; kinds: TTypeKinds; maxIters: int): PType
skipTypesOrNil:
ast: skipTypesOrNil(t: PType; kinds: TTypeKinds): PType
skIterator:
TSymKind.skIterator
skLabel:
TSymKind.skLabel
skLet:
TSymKind.skLet
skLocalVars:
ast: skLocalVars
skMacro:
TSymKind.skMacro
skMethod:
TSymKind.skMethod
skModule:
TSymKind.skModule
skPackage:
TSymKind.skPackage
skParam:
TSymKind.skParam
skProc:
TSymKind.skProc
skProcKinds:
ast: skProcKinds
skResult:
TSymKind.skResult
skStub:
TSymKind.skStub
skTemp:
TSymKind.skTemp
skTemplate:
TSymKind.skTemplate
skType:
TSymKind.skType
skUnknown:
TSymKind.skUnknown
skVar:
TSymKind.skVar
slotEmpty:
TSlotKind.slotEmpty
slotFixedLet:
TSlotKind.slotFixedLet
slotFixedVar:
TSlotKind.slotFixedVar
slotSomeTemp:
vmdef: slotSomeTemp
slotTempComplex:
TSlotKind.slotTempComplex
slotTempFloat:
TSlotKind.slotTempFloat
slotTempInt:
TSlotKind.slotTempInt
slotTempPerm:
TSlotKind.slotTempPerm
slotTempStr:
TSlotKind.slotTempStr
slotTempUnknown:
TSlotKind.slotTempUnknown
someInSet:
nimsets: someInSet(s: PNode; a, b: PNode): bool
someSym:
modulegraphs: someSym(g: ModuleGraph; m: PSym; name: PIdent): PSym
someSymFromImportTable:
lookups: someSymFromImportTable(c: PContext; name: PIdent; ambiguous: var bool): PSym
sons:
packed_ast: sons(dest: var PackedTree; tree: PackedTree; n: NodePos): NodePos
sons2:
packed_ast: sons2(tree: PackedTree; n: NodePos): (NodePos, NodePos)
sons3:
packed_ast: sons3(tree: PackedTree; n: NodePos): (NodePos, NodePos, NodePos)
sonsFrom1:
packed_ast: sonsFrom1(tree: PackedTree; n: NodePos): NodePos
sonsReadonly:
packed_ast: sonsReadonly(tree: PackedTree; n: NodePos): NodePos
sonsWithoutLast2:
packed_ast: sonsWithoutLast2(tree: PackedTree; n: NodePos): NodePos
sourceLine:
msgs: sourceLine(conf: ConfigRef; i: TLineInfo): string
SourceMap:
sourcemap: SourceMap
SourceNode:
sourcemap: SourceNode
span:
packed_ast: span(tree: PackedTree; pos: int): int
spawnResult:
spawn: spawnResult(t: PType; inParallel: bool): TSpawnResult
spellSuggestSecretSauce:
options: spellSuggestSecretSauce
splitFile:
pathutils: splitFile(x: AbsoluteFile): tuple[dir: AbsoluteDir, name, ext: string]
srByVar:
TSpawnResult.srByVar
srFlowVar:
TSpawnResult.srFlowVar
srVoid:
TSpawnResult.srVoid
StartSize:
ast: StartSize
StdOrrKind:
options: StdOrrKind
stdOrrStderr:
StdOrrKind.stdOrrStderr
stdOrrStdout:
StdOrrKind.stdOrrStdout
stmtPragmas:
pragmas: stmtPragmas
stmtsContainPragma:
ccgutils: stmtsContainPragma(n: PNode; w: TSpecialWord): bool
stopCompile:
modulegraphs: stopCompile(g: ModuleGraph): bool
store:
bitabs: store[T](f: var RodFile; t: BiTable[T])
storeAny:
vmmarshal: storeAny(s: var string; t: PType; a: PNode; conf: ConfigRef)
stored:
ModuleStatus.stored
storeExpansion:
ic: storeExpansion(c: var PackedEncoder; m: var PackedModule; info: TLineInfo; s: PSym)
storeHeader:
rodfiles: storeHeader(f: var RodFile)
storeInstantiation:
ic: storeInstantiation(c: var PackedEncoder; m: var PackedModule; s: PSym; i: PInstantiation)
storePrim:
rodfiles: storePrim(f: var RodFile; s: string)
rodfiles: storePrim[T](f: var RodFile; x: T)
storeRodNode:
semdata: storeRodNode(c: PContext; n: PNode)
storeSection:
rodfiles: storeSection(f: var RodFile; s: RodSection)
storeSeq:
rodfiles: storeSeq[T](f: var RodFile; s: seq[T])
storeSym:
ic: storeSym(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId
storeTypeInst:
ic: storeTypeInst(c: var PackedEncoder; m: var PackedModule; s: PSym; inst: PType)
storing:
ModuleStatus.storing
strArg:
filters: strArg(conf: ConfigRef; n: PNode; name: string; pos: int; default: string): string
stressTest:
SymbolFilesOption.stressTest
strictEffects:
Feature.strictEffects
strictFuncs:
Feature.strictFuncs
strictNotNil:
Feature.strictNotNil
stringsSection:
RodSection.stringsSection
strTableAdd:
astalgo: strTableAdd(t: var TStrTable; n: PSym)
strTableAdds:
modulegraphs: strTableAdds(g: ModuleGraph; m: PSym; s: PSym)
strTableContains:
astalgo: strTableContains(t: TStrTable; n: PSym): bool
strTableGet:
astalgo: strTableGet(t: TStrTable; name: PIdent): PSym
strTableIncl:
astalgo: strTableIncl(t: var TStrTable; n: PSym; onConflictKeepOld = false): bool
strTableInclReportConflict:
astalgo: strTableInclReportConflict(t: var TStrTable; n: PSym; onConflictKeepOld = false): PSym
StructuralEquivTypes:
ast: StructuralEquivTypes
stupidStmtListExpr:
trees: stupidStmtListExpr(n: PNode): bool
styleCheckDef:
linter: styleCheckDef(conf: ConfigRef; s: PSym)
linter: styleCheckDef(conf: ConfigRef; info: TLineInfo; s: PSym)
linter: styleCheckDef(conf: ConfigRef; info: TLineInfo; s: PSym; k: TSymKind)
styleCheckUse:
linter: styleCheckUse(conf: ConfigRef; info: TLineInfo; s: PSym)
Suggest:
options: Suggest
suggestDecl:
sigmatch: suggestDecl(c: PContext; n: PNode; s: PSym)
suggestEnum:
sigmatch: suggestEnum(c: PContext; n: PNode; t: PType)
suggestExpr:
sigmatch: suggestExpr(c: PContext; n: PNode)
suggestExprNoCheck:
sigmatch: suggestExprNoCheck(c: PContext; n: PNode)
Suggestions:
options: Suggestions
suggestQuit:
msgs: suggestQuit()
suggestSentinel:
sigmatch: suggestSentinel(c: PContext)
suggestStmt:
sigmatch: suggestStmt(c: PContext; n: PNode)
suggestSym:
sigmatch: suggestSym(g: ModuleGraph; info: TLineInfo; s: PSym; usageSym: var PSym; isDecl = true)
suggestWriteln:
msgs: suggestWriteln(conf: ConfigRef; s: string)
symBodyDigest:
sighashes: symBodyDigest(graph: ModuleGraph; sym: PSym): SigHash
SymbolFilesOption:
options: SymbolFilesOption
SymChars:
lexer: SymChars
symdiffSets:
nimsets: symdiffSets(conf: ConfigRef; a, b: PNode): PNode
SymId:
packed_ast: SymId
symId:
packed_ast: symId(n: NodePos): SymId
symsSection:
RodSection.symsSection
SymStartChars:
lexer: SymStartChars
symTabReplace:
astalgo: symTabReplace(t: var TStrTable; prevSym: PSym; newSym: PSym)
symToYaml:
astalgo: symToYaml(conf: ConfigRef; n: PSym; indent: int = 0; maxRecDepth: int = -1): Rope
systemModuleSym:
modulegraphs: systemModuleSym(g: ModuleGraph; name: PIdent): PSym
systemModuleSyms:
modulegraphs: systemModuleSyms(g: ModuleGraph; name: PIdent): PSym
sysTypeFromName:
magicsys: sysTypeFromName(g: ModuleGraph; info: TLineInfo; name: string): PType
szIllegalRecursion:
types: szIllegalRecursion
szTooBigSize:
types: szTooBigSize
szUncomputedSize:
types: szUncomputedSize
szUnknownSize:
types: szUnknownSize
Tabulator:
nimlexbase: Tabulator
taConcept:
TTypeAllowedFlag.taConcept
taField:
TTypeAllowedFlag.taField
tagEffects:
ast: tagEffects
TagsExt:
options: TagsExt
taHeap:
TTypeAllowedFlag.taHeap
taIsOpenArray:
TTypeAllowedFlag.taIsOpenArray
taIsTemplateOrMacro:
TTypeAllowedFlag.taIsTemplateOrMacro
takeType:
types: takeType(formal, arg: PType; g: ModuleGraph; idgen: IdGenerator): PType
TAliasRequest:
parampatterns: TAliasRequest
TAnalysisResult:
aliases: TAnalysisResult
taNoUntyped:
TTypeAllowedFlag.taNoUntyped
taProcContextIsNotMacro:
TTypeAllowedFlag.taProcContextIsNotMacro
Target:
platform: Target
TAssignableResult:
parampatterns: TAssignableResult
TBackend:
options: TBackend
TBaseLexer:
nimlexbase: TBaseLexer
TBitSet:
bitsets: TBitSet
TBlock:
cgendata: TBlock
vmdef: TBlock
TCallingConvention:
ast: TCallingConvention
TCandidate:
sigmatch: TCandidate
TCandidateState:
sigmatch: TCandidateState
TCFileSection:
cgendata: TCFileSection
TCFileSections:
cgendata: TCFileSections
TCheckPointResult:
sigmatch: TCheckPointResult
TCmdLinePass:
commands: TCmdLinePass
TContext:
semdata: TContext
TCProcFlag:
cgendata: TCProcFlag
TCProcSection:
cgendata: TCProcSection
TCProcSections:
cgendata: TCProcSections
TCtx:
vmdef: TCtx
TCTypeKind:
cgendata: TCTypeKind
TDest:
vmdef: TDest
TDistinctCompare:
types: TDistinctCompare
templatePragmas:
pragmas: templatePragmas
Ten:
int128: Ten
TErrorHandling:
msgs: TErrorHandling
TErrorOutput:
lineinfos: TErrorOutput
TErrorOutputs:
lineinfos: TErrorOutputs
testCompileOption:
commands: testCompileOption(conf: ConfigRef; switch: string; info: TLineInfo): bool
testCompileOptionArg:
commands: testCompileOptionArg(conf: ConfigRef; switch, arg: string; info: TLineInfo): bool
TEvalMode:
vmdef: TEvalMode
TexExt:
options: TexExt
TExprFlag:
semdata: TExprFlag
TExprFlags:
semdata: TExprFlags
text:
sourcemap: text(sourceNode: SourceNode; depth: int): string
tfAcyclic:
TTypeFlag.tfAcyclic
tfBorrowDot:
TTypeFlag.tfBorrowDot
tfByCopy:
TTypeFlag.tfByCopy
tfByRef:
TTypeFlag.tfByRef
tfCapturesEnv:
TTypeFlag.tfCapturesEnv
tfCheckedForDestructor:
TTypeFlag.tfCheckedForDestructor
tfCompleteStruct:
TTypeFlag.tfCompleteStruct
tfConceptMatchedTypeSym:
TTypeFlag.tfConceptMatchedTypeSym
tfContravariant:
TTypeFlag.tfContravariant
tfCovariant:
TTypeFlag.tfCovariant
tfEffectSystemWorkaround:
TTypeFlag.tfEffectSystemWorkaround
tfEnumHasHoles:
TTypeFlag.tfEnumHasHoles
tfExplicit:
TTypeFlag.tfExplicit
tfExplicitCallConv:
TTypeFlag.tfExplicitCallConv
tfFinal:
TTypeFlag.tfFinal
tfFromGeneric:
TTypeFlag.tfFromGeneric
tfGcSafe:
ast: tfGcSafe
tfGenericTypeParam:
TTypeFlag.tfGenericTypeParam
tfHasAsgn:
TTypeFlag.tfHasAsgn
tfHasGCedMem:
TTypeFlag.tfHasGCedMem
tfHasMeta:
TTypeFlag.tfHasMeta
tfHasOwned:
TTypeFlag.tfHasOwned
tfHasStatic:
TTypeFlag.tfHasStatic
TFileInfo:
lineinfos: TFileInfo
tfImplicitTypeParam:
TTypeFlag.tfImplicitTypeParam
tfIncompleteStruct:
TTypeFlag.tfIncompleteStruct
tfInferrableStatic:
TTypeFlag.tfInferrableStatic
tfInheritable:
TTypeFlag.tfInheritable
tfIsConstructor:
TTypeFlag.tfIsConstructor
tfIterator:
TTypeFlag.tfIterator
tfNeedsFullInit:
TTypeFlag.tfNeedsFullInit
tfNoSideEffect:
TTypeFlag.tfNoSideEffect
tfNotNil:
TTypeFlag.tfNotNil
tfObjHasKids:
ast: tfObjHasKids
tfPacked:
TTypeFlag.tfPacked
tfPartial:
TTypeFlag.tfPartial
tfRefsAnonObj:
TTypeFlag.tfRefsAnonObj
tfRequiresInit:
TTypeFlag.tfRequiresInit
tfResolved:
TTypeFlag.tfResolved
tfRetType:
TTypeFlag.tfRetType
tfReturnsNew:
ast: tfReturnsNew
tfShallow:
TTypeFlag.tfShallow
tfThread:
TTypeFlag.tfThread
tfTriggersCompileTime:
TTypeFlag.tfTriggersCompileTime
TFullReg:
vmdef: TFullReg
tfUnion:
ast: tfUnion
tfUnresolved:
TTypeFlag.tfUnresolved
tfVarargs:
TTypeFlag.tfVarargs
tfVarIsPtr:
TTypeFlag.tfVarIsPtr
tfWeakCovariant:
TTypeFlag.tfWeakCovariant
tfWildcard:
TTypeFlag.tfWildcard
TGCMode:
options: TGCMode
TGlobalOption:
options: TGlobalOption
TGlobalOptions:
options: TGlobalOptions
theindexFname:
nimpaths: theindexFname
threadVarAccessed:
TCProcFlag.threadVarAccessed
throwAwayLastNode:
packed_ast: throwAwayLastNode(tree: var PackedTree)
TIdent:
idents: TIdent
TIdentIter:
astalgo: TIdentIter
TIdNodePair:
ast: TIdNodePair
TIdNodePairSeq:
ast: TIdNodePairSeq
TIdNodeTable:
ast: TIdNodeTable
TIdObj:
ast: TIdObj
TIdPair:
ast: TIdPair
TIdPairSeq:
ast: TIdPairSeq
TIdTable:
ast: TIdTable
TIIPair:
astalgo: TIIPair
TIIPairSeq:
astalgo: TIIPairSeq
TIITable:
astalgo: TIITable
TImplication:
ast: TImplication
TInfoCC:
extccomp: TInfoCC
TInfoCCProp:
extccomp: TInfoCCProp
TInfoCCProps:
extccomp: TInfoCCProps
TInfoCPU:
platform: TInfoCPU
TInfoOS:
platform: TInfoOS
TInfoOSProp:
platform: TInfoOSProp
TInfoOSProps:
platform: TInfoOSProps
TInstantiation:
ast: TInstantiation
TInstantiationPair:
semdata: TInstantiationPair
TInstr:
vmdef: TInstr
TInstrType:
vmdef: TInstrType
tkAccent:
TokType.tkAccent
tkAddr:
TokType.tkAddr
tkAnd:
TokType.tkAnd
tkAs:
TokType.tkAs
tkAsm:
TokType.tkAsm
tkBind:
TokType.tkBind
tkBlock:
TokType.tkBlock
tkBracketDotLe:
TokType.tkBracketDotLe
tkBracketDotRi:
TokType.tkBracketDotRi
tkBracketLe:
TokType.tkBracketLe
tkBracketLeColon:
TokType.tkBracketLeColon
tkBracketRi:
TokType.tkBracketRi
tkBreak:
TokType.tkBreak
tkCase:
TokType.tkCase
tkCast:
TokType.tkCast
tkCharLit:
TokType.tkCharLit
tkColon:
TokType.tkColon
tkColonColon:
TokType.tkColonColon
tkComma:
TokType.tkComma
tkComment:
TokType.tkComment
tkConcept:
TokType.tkConcept
tkConst:
TokType.tkConst
tkContinue:
TokType.tkContinue
tkConverter:
TokType.tkConverter
tkCurlyDotLe:
TokType.tkCurlyDotLe
tkCurlyDotRi:
TokType.tkCurlyDotRi
tkCurlyLe:
TokType.tkCurlyLe
tkCurlyRi:
TokType.tkCurlyRi
tkCustomLit:
TokType.tkCustomLit
tkDefer:
TokType.tkDefer
tkDiscard:
TokType.tkDiscard
tkDistinct:
TokType.tkDistinct
tkDiv:
TokType.tkDiv
tkDo:
TokType.tkDo
tkDot:
TokType.tkDot
tkDotDot:
TokType.tkDotDot
tkElif:
TokType.tkElif
tkElse:
TokType.tkElse
tkEnd:
TokType.tkEnd
tkEnum:
TokType.tkEnum
tkEof:
TokType.tkEof
tkEquals:
TokType.tkEquals
tkExcept:
TokType.tkExcept
tkExport:
TokType.tkExport
tkFinally:
TokType.tkFinally
tkFloat128Lit:
TokType.tkFloat128Lit
tkFloat32Lit:
TokType.tkFloat32Lit
tkFloat64Lit:
TokType.tkFloat64Lit
tkFloatLit:
TokType.tkFloatLit
tkFor:
TokType.tkFor
tkFrom:
TokType.tkFrom
tkFunc:
TokType.tkFunc
tkGStrLit:
TokType.tkGStrLit
tkGTripleStrLit:
TokType.tkGTripleStrLit
tkHideableEnd:
TokType.tkHideableEnd
tkHideableStart:
TokType.tkHideableStart
tkIf:
TokType.tkIf
tkImport:
TokType.tkImport
tkIn:
TokType.tkIn
tkInclude:
TokType.tkInclude
tkInfixOpr:
TokType.tkInfixOpr
tkInt16Lit:
TokType.tkInt16Lit
tkInt32Lit:
TokType.tkInt32Lit
tkInt64Lit:
TokType.tkInt64Lit
tkInt8Lit:
TokType.tkInt8Lit
tkInterface:
TokType.tkInterface
tkIntLit:
TokType.tkIntLit
tkInvalid:
TokType.tkInvalid
tkIs:
TokType.tkIs
tkIsnot:
TokType.tkIsnot
tkIterator:
TokType.tkIterator
tkLet:
TokType.tkLet
tkMacro:
TokType.tkMacro
tkMethod:
TokType.tkMethod
tkMixin:
TokType.tkMixin
tkMod:
TokType.tkMod
tkNil:
TokType.tkNil
tkNot:
TokType.tkNot
tkNotin:
TokType.tkNotin
tkObject:
TokType.tkObject
tkOf:
TokType.tkOf
tkOpr:
TokType.tkOpr
tkOr:
TokType.tkOr
tkOut:
TokType.tkOut
tkParDotLe:
TokType.tkParDotLe
tkParDotRi:
TokType.tkParDotRi
tkParLe:
TokType.tkParLe
tkParRi:
TokType.tkParRi
tkPostfixOpr:
TokType.tkPostfixOpr
tkPrefixOpr:
TokType.tkPrefixOpr
tkProc:
TokType.tkProc
tkPtr:
TokType.tkPtr
tkRaise:
TokType.tkRaise
tkRef:
TokType.tkRef
tkReturn:
TokType.tkReturn
tkRStrLit:
TokType.tkRStrLit
tkSemiColon:
TokType.tkSemiColon
tkShl:
TokType.tkShl
tkShr:
TokType.tkShr
tkSpaces:
TokType.tkSpaces
tkStatic:
TokType.tkStatic
tkStrLit:
TokType.tkStrLit
tkSymbol:
TokType.tkSymbol
tkTemplate:
TokType.tkTemplate
tkTripleStrLit:
TokType.tkTripleStrLit
tkTry:
TokType.tkTry
tkTuple:
TokType.tkTuple
tkType:
TokType.tkType
tkUInt16Lit:
TokType.tkUInt16Lit
tkUInt32Lit:
TokType.tkUInt32Lit
tkUInt64Lit:
TokType.tkUInt64Lit
tkUInt8Lit:
TokType.tkUInt8Lit
tkUIntLit:
TokType.tkUIntLit
tkUsing:
TokType.tkUsing
tkVar:
TokType.tkVar
tkWhen:
TokType.tkWhen
tkWhile:
TokType.tkWhile
tkXor:
TokType.tkXor
tkYield:
TokType.tkYield
TLabel:
cgendata: TLabel
TLib:
ast: TLib
TLibKind:
ast: TLibKind
TLineInfo:
lineinfos: TLineInfo
TLLRepl:
llstream: TLLRepl
TLLStream:
llstream: TLLStream
TLLStreamKind:
llstream: TLLStreamKind
TLoc:
ast: TLoc
TLocFlag:
ast: TLocFlag
TLocFlags:
ast: TLocFlags
TLocKind:
ast: TLocKind
TLockLevel:
ast: TLockLevel
TLookupFlag:
lookups: TLookupFlag
TMagic:
ast: TMagic
TMatchedConcept:
semdata: TMatchedConcept
TModel:
guards: TModel
TMsgKind:
lineinfos: TMsgKind
TNode:
ast: TNode
TNodeFlag:
ast: TNodeFlag
TNodeFlags:
ast: TNodeFlags
TNodeKind:
ast: TNodeKind
TNodeKinds:
ast: TNodeKinds
TNodePair:
ast: TNodePair
TNodePairSeq:
ast: TNodePairSeq
TNodeSeq:
ast: TNodeSeq
TNodeTable:
ast: TNodeTable
TNoteKind:
lineinfos: TNoteKind
TNoteKinds:
lineinfos: TNoteKinds
toAbsolute:
pathutils: toAbsolute(file: string; base: AbsoluteDir): AbsoluteFile
toAbsoluteDir:
pathutils: toAbsoluteDir(path: string): AbsoluteDir
toBitSet:
nimsets: toBitSet(conf: ConfigRef; s: PNode): TBitSet
TObjectSeq:
ast: TObjectSeq
TObjectSet:
ast: TObjectSet
toCChar:
msgs: toCChar(c: char; result: var string)
toColumn:
msgs: toColumn(info: TLineInfo): int
toFileIndex:
ic: toFileIndex(x: LitId; m: PackedModule; config: ConfigRef): FileIndex
toFileIndexCached:
ic: toFileIndexCached(c: var PackedDecoder; g: PackedModuleGraph; thisModule: int; f: LitId): FileIndex
toFileLineCol:
msgs: toFileLineCol(conf: ConfigRef; info: TLineInfo): string
toFilename:
msgs: toFilename(conf: ConfigRef; fileIdx: FileIndex): string
msgs: toFilename(conf: ConfigRef; info: TLineInfo): string
toFilenameOption:
msgs: toFilenameOption(conf: ConfigRef; fileIdx: FileIndex; opt: FilenameOption): string
toFloat64:
int128: toFloat64(arg: Int128): float64
toFullPath:
msgs: toFullPath(conf: ConfigRef; fileIdx: FileIndex): string
msgs: toFullPath(conf: ConfigRef; info: TLineInfo): string
toFullPathConsiderDirty:
msgs: toFullPathConsiderDirty(conf: ConfigRef; fileIdx: FileIndex): AbsoluteFile
msgs: toFullPathConsiderDirty(conf: ConfigRef; info: TLineInfo): string
toGeneratedFile:
options: toGeneratedFile(conf: ConfigRef; path: AbsoluteFile; ext: string): AbsoluteFile
toHex:
int128: toHex(arg: Int128): string
toHumanStr:
ast: toHumanStr(kind: TSymKind): string
ast: toHumanStr(kind: TTypeKind): string
toInt:
int128: toInt(arg: Int128): int
toInt128:
int128: toInt128(arg: float64): Int128
int128: toInt128[T: SomeInteger | bool](arg: T): Int128
toInt16:
int128: toInt16(arg: Int128): int16
toInt32:
int128: toInt32(arg: Int128): int32
toInt64:
int128: toInt64(arg: Int128): int64
toInt64Checked:
int128: toInt64Checked(arg: Int128; onError: int64): int64
toInt8:
int128: toInt8(arg: Int128): int8
Token:
lexer: Token
tokenize:
sourcemap: tokenize(line: string): (bool, string)
tokKeywordHigh:
lexer: tokKeywordHigh
tokKeywordLow:
lexer: tokKeywordLow
TokType:
lexer: TokType
TokTypes:
lexer: TokTypes
toLinenumber:
msgs: toLinenumber(info: TLineInfo): int
toLit:
vmconv: toLit[T](a: T): PNode
toLowerAscii:
strutils2: toLowerAscii(a: var string)
toMsgFilename:
msgs: toMsgFilename(conf: ConfigRef; fileIdx: FileIndex): string
msgs: toMsgFilename(conf: ConfigRef; info: TLineInfo): string
tooBig:
RodFileError.tooBig
toObject:
ast: toObject(typ: PType): PType
toObjectFromRefPtrGeneric:
ast: toObjectFromRefPtrGeneric(typ: PType): PType
toObjFile:
extccomp: toObjFile(conf: ConfigRef; filename: AbsoluteFile): AbsoluteFile
toPackedGeneratedProcDef:
ic: toPackedGeneratedProcDef(s: PSym; encoder: var PackedEncoder; m: var PackedModule)
toPackedItemId:
packed_ast: toPackedItemId(item: int32): PackedItemId
toPackedNode:
ic: toPackedNode(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModule)
toPackedNodeTopLevel:
ic: toPackedNodeTopLevel(n: PNode; encoder: var PackedEncoder; m: var PackedModule)
TOpcode:
vmdef: TOpcode
topLevelSection:
RodSection.topLevelSection
toProjPath:
msgs: toProjPath(conf: ConfigRef; fileIdx: FileIndex): string
msgs: toProjPath(conf: ConfigRef; info: TLineInfo): string
TOption:
options: TOption
TOptionEntry:
semdata: TOptionEntry
TOptions:
options: TOptions
toRef:
ast: toRef(typ: PType; idgen: IdGenerator): PType
toReplaySection:
RodSection.toReplaySection
toRodFile:
options: toRodFile(conf: ConfigRef; f: AbsoluteFile; ext = RodExt): AbsoluteFile
toSourceMap:
sourcemap: toSourceMap(node: SourceNode; file: string): SourceMapGenerator
toString:
ic: toString(tree: PackedTree; n: NodePos; m: PackedModule): string
ic: toString(tree: PackedTree; n: NodePos; m: PackedModule; nesting: int; result: var string)
toStrMaxPrecision:
rodutils: toStrMaxPrecision(f: BiggestFloat | float32): string
toTreeSet:
nimsets: toTreeSet(conf: ConfigRef; s: TBitSet; settype: PType; info: TLineInfo): PNode
toUInt:
int128: toUInt(arg: Int128): uint
toUInt16:
int128: toUInt16(arg: Int128): uint16
toUInt32:
int128: toUInt32(arg: Int128): uint32
toUInt64:
int128: toUInt64(arg: Int128): uint64
toUInt8:
int128: toUInt8(arg: Int128): uint8
toVar:
ast: toVar(typ: PType; kind: TTypeKind; idgen: IdGenerator): PType
TOverloadIter:
lookups: TOverloadIter
TOverloadIterMode:
lookups: TOverloadIterMode
TPair:
ast: TPair
TPairSeq:
ast: TPairSeq
TParamsEquality:
types: TParamsEquality
TPass:
modulegraphs: TPass
TPassClose:
modulegraphs: TPassClose
TPassContext:
modulegraphs: TPassContext
TPassData:
passes: TPassData
TPassOpen:
modulegraphs: TPassOpen
TPassProcess:
modulegraphs: TPassProcess
TPosition:
vmdef: TPosition
TPreferedDesc:
types: TPreferedDesc
TProcCon:
semdata: TProcCon
trackPosInvalidFileIdx:
lineinfos: trackPosInvalidFileIdx
trackProc:
sempass2: trackProc(c: PContext; s: PSym; body: PNode)
trackStmt:
sempass2: trackStmt(c: PContext; module: PSym; n: PNode; isTopLevel: bool)
Transformation:
pluginsupport: Transformation
transformBody:
transf: transformBody(g: ModuleGraph; idgen: IdGenerator; prc: PSym; cache: bool): PNode
transformClosureIterator:
closureiters: transformClosureIterator(g: ModuleGraph; idgen: IdGenerator; fn: PSym; n: PNode): PNode
transformExpr:
transf: transformExpr(g: ModuleGraph; idgen: IdGenerator; module: PSym; n: PNode): PNode
transformStmt:
transf: transformStmt(g: ModuleGraph; idgen: IdGenerator; module: PSym; n: PNode): PNode
transitionGenericParamToType:
ast: transitionGenericParamToType(s: PSym)
transitionIntKind:
ast: transitionIntKind(n: PNode; kind: range[nkCharLit .. nkUInt64Lit])
transitionNoneToSym:
ast: transitionNoneToSym(n: PNode)
transitionRoutineSymKind:
ast: transitionRoutineSymKind(s: PSym; kind: range[skProc .. skTemplate])
transitionSonsKind:
ast: transitionSonsKind(n: PNode; kind: range[nkComesFrom .. nkTupleConstr])
transitionSymKindCommon:
ast: transitionSymKindCommon(k: TSymKind)
transitionToLet:
ast: transitionToLet(s: PSym)
translateId:
ic: translateId(id: PackedItemId; g: PackedModuleGraph; thisModule: int; config: ConfigRef): ItemId
trBindGenericParam:
TTypeRelFlag.trBindGenericParam
trDontBind:
TTypeRelFlag.trDontBind
treeToYaml:
astalgo: treeToYaml(conf: ConfigRef; n: PNode; indent: int = 0; maxRecDepth: int = -1): Rope
TRegister:
vmdef: TRegister
TRegisterKind:
vmdef: TRegisterKind
TRenderFlag:
renderer: TRenderFlag
TRenderFlags:
renderer: TRenderFlags
TRenderTok:
renderer: TRenderTok
TRenderTokSeq:
renderer: TRenderTokSeq
TReplTypeVars:
semtypinst: TReplTypeVars
trmacrosSection:
RodSection.trmacrosSection
trNoCovariance:
TTypeRelFlag.trNoCovariance
TSandboxFlag:
vmdef: TSandboxFlag
TSandboxFlags:
vmdef: TSandboxFlags
TScope:
ast: TScope
TSideEffectAnalysis:
parampatterns: TSideEffectAnalysis
TSlotKind:
vmdef: TSlotKind
TSpawnResult:
spawn: TSpawnResult
TSpecialWord:
wordrecg: TSpecialWord
TSpecialWords:
wordrecg: TSpecialWords
TSrcGen:
renderer: TSrcGen
TStackFrame:
vmdef: TStackFrame
TStorageLoc:
ast: TStorageLoc
TStringSeq:
options: TStringSeq
TStrTable:
ast: TStrTable
TSym:
ast: TSym
TSymFlag:
ast: TSymFlag
TSymFlags:
ast: TSymFlags
TSymKind:
ast: TSymKind
TSymKinds:
ast: TSymKinds
TSystemCC:
options: TSystemCC
TSystemCPU:
platform: TSystemCPU
TSystemOS:
platform: TSystemOS
TTabIter:
astalgo: TTabIter
TType:
ast: TType
TTypeAllowedFlag:
typeallowed: TTypeAllowedFlag
TTypeAllowedFlags:
typeallowed: TTypeAllowedFlags
TTypeAttachedOp:
ast: TTypeAttachedOp
TTypeCmpFlag:
types: TTypeCmpFlag
TTypeCmpFlags:
types: TTypeCmpFlags
TTypeFieldResult:
types: TTypeFieldResult
TTypeFlag:
ast: TTypeFlag
TTypeFlags:
ast: TTypeFlags
TTypeIter:
types: TTypeIter
TTypeKind:
ast: TTypeKind
TTypeKinds:
ast: TTypeKinds
TTypeMutator:
types: TTypeMutator
TTypePredicate:
types: TTypePredicate
TTypeRelation:
types: TTypeRelation
TTypeRelFlag:
sigmatch: TTypeRelFlag
TTypeRelFlags:
sigmatch: TTypeRelFlags
TTypeSeq:
ast: TTypeSeq
cgendata: TTypeSeq
tyAlias:
TTypeKind.tyAlias
tyAnd:
TTypeKind.tyAnd
tyAnything:
TTypeKind.tyAnything
tyArray:
TTypeKind.tyArray
tyBool:
TTypeKind.tyBool
tyBuiltInTypeClass:
TTypeKind.tyBuiltInTypeClass
tyChar:
TTypeKind.tyChar
tyCompositeTypeClass:
TTypeKind.tyCompositeTypeClass
tyConcept:
TTypeKind.tyConcept
tyCstring:
TTypeKind.tyCstring
tyDistinct:
TTypeKind.tyDistinct
tyEmpty:
TTypeKind.tyEmpty
tyEnum:
TTypeKind.tyEnum
tyError:
ast: tyError
tyFloat:
TTypeKind.tyFloat
tyFloat128:
TTypeKind.tyFloat128
tyFloat32:
TTypeKind.tyFloat32
tyFloat64:
TTypeKind.tyFloat64
tyForward:
TTypeKind.tyForward
tyFromExpr:
TTypeKind.tyFromExpr
tyGenericBody:
TTypeKind.tyGenericBody
tyGenericInst:
TTypeKind.tyGenericInst
tyGenericInvocation:
TTypeKind.tyGenericInvocation
tyGenericLike:
sem: tyGenericLike
tyGenericParam:
TTypeKind.tyGenericParam
tyInferred:
TTypeKind.tyInferred
tyInt:
TTypeKind.tyInt
tyInt16:
TTypeKind.tyInt16
tyInt32:
TTypeKind.tyInt32
tyInt64:
TTypeKind.tyInt64
tyInt8:
TTypeKind.tyInt8
tyIterable:
TTypeKind.tyIterable
tyLent:
TTypeKind.tyLent
tyMagicGenerics:
sem: tyMagicGenerics
tyMetaTypes:
ast: tyMetaTypes
tyNil:
TTypeKind.tyNil
tyNone:
TTypeKind.tyNone
tyNot:
TTypeKind.tyNot
tyObject:
TTypeKind.tyObject
tyOpenArray:
TTypeKind.tyOpenArray
tyOr:
TTypeKind.tyOr
tyOrdinal:
TTypeKind.tyOrdinal
tyOwned:
TTypeKind.tyOwned
typ:
packed_ast: typ(n: NodePos): PackedItemId
typeAllowed:
typeallowed: typeAllowed(t: PType; kind: TSymKind; c: PContext; flags: TTypeAllowedFlags = {}): PType
TypeCache:
cgendata: TypeCache
TypeCacheWithOwner:
cgendata: TypeCacheWithOwner
typeCompleted:
ast: typeCompleted(s: PSym)
typedescInst:
types: typedescInst
typedescPtrs:
types: typedescPtrs
typeInfoSection:
RodSection.typeInfoSection
typeInstCacheItems:
modulegraphs: typeInstCacheItems(g: ModuleGraph; s: PSym): PType
typeInstCacheSection:
RodSection.typeInstCacheSection
typekinds:
astalgo: typekinds(t: PType)
typeMismatch:
types: typeMismatch(conf: ConfigRef; info: TLineInfo; formal, actual: PType; n: PNode)
typePragmas:
pragmas: typePragmas
typeRel:
sigmatch: typeRel(c: var TCandidate; f, aOrig: PType; flags: TTypeRelFlags = {}): TTypeRelation
typesSection:
RodSection.typesSection
typeToString:
types: typeToString(typ: PType; prefer: TPreferedDesc = preferName): string
typeToYaml:
astalgo: typeToYaml(conf: ConfigRef; n: PType; indent: int = 0; maxRecDepth: int = -1): Rope
tyPointer:
TTypeKind.tyPointer
tyProc:
TTypeKind.tyProc
tyProxy:
TTypeKind.tyProxy
typSym:
astmsgs: typSym(t: PType): PSym
tyPtr:
TTypeKind.tyPtr
tyPureObject:
ast: tyPureObject
tyRange:
TTypeKind.tyRange
tyRef:
TTypeKind.tyRef
tySequence:
TTypeKind.tySequence
tySet:
TTypeKind.tySet
tySink:
TTypeKind.tySink
tyStatic:
TTypeKind.tyStatic
tyString:
TTypeKind.tyString
tyTuple:
TTypeKind.tyTuple
tyTypeClasses:
ast: tyTypeClasses
tyTyped:
TTypeKind.tyTyped
tyTypeDesc:
TTypeKind.tyTypeDesc
tyUInt:
TTypeKind.tyUInt
tyUInt16:
TTypeKind.tyUInt16
tyUInt32:
TTypeKind.tyUInt32
tyUInt64:
TTypeKind.tyUInt64
tyUInt8:
TTypeKind.tyUInt8
tyUncheckedArray:
TTypeKind.tyUncheckedArray
tyUnknown:
ast: tyUnknown
tyUnknownTypes:
ast: tyUnknownTypes
tyUntyped:
TTypeKind.tyUntyped
tyUserDefinedGenerics:
sem: tyUserDefinedGenerics
tyUserTypeClass:
TTypeKind.tyUserTypeClass
tyUserTypeClasses:
ast: tyUserTypeClasses
tyUserTypeClassInst:
TTypeKind.tyUserTypeClassInst
tyVar:
TTypeKind.tyVar
tyVarargs:
TTypeKind.tyVarargs
tyVoid:
TTypeKind.tyVoid
undefined:
ModuleStatus.undefined
undefSymbol:
condsyms: undefSymbol(symbols: StringTableRef; symbol: string)
unicodeOperators:
Feature.unicodeOperators
unionSets:
nimsets: unionSets(conf: ConfigRef; a, b: PNode): PNode
uniqueModuleName:
msgs: uniqueModuleName(conf: ConfigRef; fid: FileIndex): string
unknownLineInfo:
lineinfos: unknownLineInfo
UnknownLockLevel:
ast: UnknownLockLevel
Unreachable:
Nilability.Unreachable
UnspecifiedLockLevel:
ast: UnspecifiedLockLevel
upName:
lambdalifting: upName
use:
InstrKind.use
useAliveDataFromDce:
CodegenFlag.useAliveDataFromDce
useEffectSystem:
options: useEffectSystem
usesThreadVars:
CodegenFlag.usesThreadVars
usesWriteBarrier:
options: usesWriteBarrier(conf: ConfigRef): bool
useWriteTracking:
options: useWriteTracking
v2Sf:
SymbolFilesOption.v2Sf
varPragmas:
pragmas: varPragmas
verbosePass:
passaux: verbosePass
Version:
nimblecmd: Version
VersionAsString:
nversion: VersionAsString
versionSection:
RodSection.versionSection
views:
Feature.views
ViewTypeKind:
typeallowed: ViewTypeKind
VmArgs:
vmdef: VmArgs
VmCallback:
vmdef: VmCallback
vmopsDanger:
Feature.vmopsDanger
VT:
nimlexbase: VT
wAcyclic:
TSpecialWord.wAcyclic
wAddr:
TSpecialWord.wAddr
wAlign:
TSpecialWord.wAlign
wAlignas:
TSpecialWord.wAlignas
wAlignof:
TSpecialWord.wAlignof
walk:
sourcemap: walk(node: SourceNode; fn: proc (line: string; original: SourceNode))
wAnd:
TSpecialWord.wAnd
wantMainModule:
modules: wantMainModule(conf: ConfigRef)
warnAnyEnumConv:
TMsgKind.warnAnyEnumConv
warnCannotOpen:
TMsgKind.warnCannotOpen
warnCannotOpenFile:
TMsgKind.warnCannotOpenFile
warnCaseTransition:
TMsgKind.warnCaseTransition
warnCommentXIgnored:
TMsgKind.warnCommentXIgnored
warnConfigDeprecated:
TMsgKind.warnConfigDeprecated
warnCstringConv:
TMsgKind.warnCstringConv
warnCycleCreated:
TMsgKind.warnCycleCreated
warnDeprecated:
TMsgKind.warnDeprecated
warnDestructor:
TMsgKind.warnDestructor
warnDotLikeOps:
TMsgKind.warnDotLikeOps
warnEachIdentIsTuple:
TMsgKind.warnEachIdentIsTuple
warnEffect:
TMsgKind.warnEffect
warnFileChanged:
TMsgKind.warnFileChanged
warnGcMem:
TMsgKind.warnGcMem
warnGcUnsafe:
TMsgKind.warnGcUnsafe
warnGcUnsafe2:
TMsgKind.warnGcUnsafe2
warnHoleEnumConv:
TMsgKind.warnHoleEnumConv
warnInconsistentSpacing:
TMsgKind.warnInconsistentSpacing
warningDeprecated:
msgs: warningDeprecated(conf: ConfigRef; info: TLineInfo = gCmdLineInfo; msg = "")
warnInheritFromException:
TMsgKind.warnInheritFromException
warnLockLevel:
TMsgKind.warnLockLevel
warnMax:
lineinfos: warnMax
warnMin:
lineinfos: warnMin
warnObservableStores:
TMsgKind.warnObservableStores
warnOctalEscape:
TMsgKind.warnOctalEscape
warnProveField:
TMsgKind.warnProveField
warnProveIndex:
TMsgKind.warnProveIndex
warnProveInit:
TMsgKind.warnProveInit
warnResultShadowed:
TMsgKind.warnResultShadowed
warnResultUsed:
TMsgKind.warnResultUsed
warnRstBrokenLink:
TMsgKind.warnRstBrokenLink
warnRstFieldXNotSupported:
TMsgKind.warnRstFieldXNotSupported
warnRstLanguageXNotSupported:
TMsgKind.warnRstLanguageXNotSupported
warnRstRedefinitionOfLabel:
TMsgKind.warnRstRedefinitionOfLabel
warnRstStyle:
TMsgKind.warnRstStyle
warnRstUnknownSubstitutionX:
TMsgKind.warnRstUnknownSubstitutionX
warnSmallLshouldNotBeUsed:
TMsgKind.warnSmallLshouldNotBeUsed
warnStaticIndexCheck:
TMsgKind.warnStaticIndexCheck
warnStrictNotNil:
TMsgKind.warnStrictNotNil
warnSuspiciousEnumConv:
TMsgKind.warnSuspiciousEnumConv
warnTypelessParam:
TMsgKind.warnTypelessParam
warnUninit:
TMsgKind.warnUninit
warnUnknownMagic:
TMsgKind.warnUnknownMagic
warnUnreachableCode:
TMsgKind.warnUnreachableCode
warnUnreachableElse:
TMsgKind.warnUnreachableElse
warnUnsafeCode:
TMsgKind.warnUnsafeCode
warnUnsafeDefault:
TMsgKind.warnUnsafeDefault
warnUnsafeSetLen:
TMsgKind.warnUnsafeSetLen
warnUnusedImportX:
TMsgKind.warnUnusedImportX
warnUseBase:
TMsgKind.warnUseBase
warnUser:
TMsgKind.warnUser
warnWriteToForeignHeap:
TMsgKind.warnWriteToForeignHeap
warnXIsNeverRead:
TMsgKind.warnXIsNeverRead
warnXmightNotBeenInit:
TMsgKind.warnXmightNotBeenInit
wAs:
TSpecialWord.wAs
wAsm:
TSpecialWord.wAsm
wAsmNoStackFrame:
TSpecialWord.wAsmNoStackFrame
wAssert:
TSpecialWord.wAssert
wAssertions:
TSpecialWord.wAssertions
wAssume:
TSpecialWord.wAssume
wAuto:
TSpecialWord.wAuto
wBase:
TSpecialWord.wBase
wBind:
TSpecialWord.wBind
wBitsize:
TSpecialWord.wBitsize
wBlock:
TSpecialWord.wBlock
wBool:
TSpecialWord.wBool
wBoolDefine:
TSpecialWord.wBoolDefine
wBorrow:
TSpecialWord.wBorrow
wBoundChecks:
TSpecialWord.wBoundChecks
wBreak:
TSpecialWord.wBreak
wByCopy:
TSpecialWord.wByCopy
wByRef:
TSpecialWord.wByRef
wCallconv:
TSpecialWord.wCallconv
wCase:
TSpecialWord.wCase
wCast:
TSpecialWord.wCast
wCatch:
TSpecialWord.wCatch
wCdecl:
TSpecialWord.wCdecl
wChar:
TSpecialWord.wChar
wChar16_t:
TSpecialWord.wChar16_t
wChar32_t:
TSpecialWord.wChar32_t
wChecks:
TSpecialWord.wChecks
wClass:
TSpecialWord.wClass
wClosure:
TSpecialWord.wClosure
wCodegenDecl:
TSpecialWord.wCodegenDecl
wColon:
TSpecialWord.wColon
wColonColon:
TSpecialWord.wColonColon
wCompile:
TSpecialWord.wCompile
wCompilerProc:
TSpecialWord.wCompilerProc
wCompileTime:
TSpecialWord.wCompileTime
wCompl:
TSpecialWord.wCompl
wCompleteStruct:
TSpecialWord.wCompleteStruct
wComputedGoto:
TSpecialWord.wComputedGoto
wConcept:
TSpecialWord.wConcept
wConst:
TSpecialWord.wConst
wConst_cast:
TSpecialWord.wConst_cast
wConstexpr:
TSpecialWord.wConstexpr
wConstructor:
TSpecialWord.wConstructor
wContinue:
TSpecialWord.wContinue
wConverter:
TSpecialWord.wConverter
wCore:
TSpecialWord.wCore
wCppNonPod:
TSpecialWord.wCppNonPod
wCursor:
TSpecialWord.wCursor
wDeadCodeElimUnused:
TSpecialWord.wDeadCodeElimUnused
wDebugger:
TSpecialWord.wDebugger
wDecltype:
TSpecialWord.wDecltype
wDefault:
TSpecialWord.wDefault
wDefer:
TSpecialWord.wDefer
wDefine:
TSpecialWord.wDefine
wDelegator:
TSpecialWord.wDelegator
wDelete:
TSpecialWord.wDelete
wDeprecated:
TSpecialWord.wDeprecated
wDestructor:
TSpecialWord.wDestructor
wDirty:
TSpecialWord.wDirty
wDiscard:
TSpecialWord.wDiscard
wDiscardable:
TSpecialWord.wDiscardable
wDistinct:
TSpecialWord.wDistinct
wDiv:
TSpecialWord.wDiv
wDo:
TSpecialWord.wDo
wDot:
TSpecialWord.wDot
wDotDot:
TSpecialWord.wDotDot
wDouble:
TSpecialWord.wDouble
wDynamic_cast:
TSpecialWord.wDynamic_cast
wDynlib:
TSpecialWord.wDynlib
weakLeValue:
astalgo: weakLeValue(a, b: PNode): TImplication
wEffects:
TSpecialWord.wEffects
wEffectsOf:
TSpecialWord.wEffectsOf
wElif:
TSpecialWord.wElif
wElse:
TSpecialWord.wElse
wEmit:
TSpecialWord.wEmit
wEnd:
TSpecialWord.wEnd
wEnsures:
TSpecialWord.wEnsures
wEnum:
TSpecialWord.wEnum
wEquals:
TSpecialWord.wEquals
wError:
TSpecialWord.wError
wExcept:
TSpecialWord.wExcept
wExecuteOnReload:
TSpecialWord.wExecuteOnReload
wExperimental:
TSpecialWord.wExperimental
wExplain:
TSpecialWord.wExplain
wExplicit:
TSpecialWord.wExplicit
wExport:
TSpecialWord.wExport
wExportc:
TSpecialWord.wExportc
wExportCpp:
TSpecialWord.wExportCpp
wExportNims:
TSpecialWord.wExportNims
wExtern:
TSpecialWord.wExtern
wFalse:
TSpecialWord.wFalse
wFastcall:
TSpecialWord.wFastcall
wFatal:
TSpecialWord.wFatal
wFieldChecks:
TSpecialWord.wFieldChecks
wFinal:
TSpecialWord.wFinal
wFinally:
TSpecialWord.wFinally
wFloat:
TSpecialWord.wFloat
wFloatChecks:
TSpecialWord.wFloatChecks
wFor:
TSpecialWord.wFor
wFriend:
TSpecialWord.wFriend
wFrom:
TSpecialWord.wFrom
wFunc:
TSpecialWord.wFunc
wGcSafe:
TSpecialWord.wGcSafe
wGensym:
TSpecialWord.wGensym
wGlobal:
TSpecialWord.wGlobal
wGoto:
TSpecialWord.wGoto
wGuard:
TSpecialWord.wGuard
wHeader:
TSpecialWord.wHeader
whichAlias:
parampatterns: whichAlias(p: PSym): TAliasRequest
whichInitProcs:
cgen: whichInitProcs(m: BModule): set[ModuleBackendFlag]
whichKeyword:
idents: whichKeyword(id: PIdent): TSpecialWord
whichPragma:
trees: whichPragma(n: PNode): TSpecialWord
wHint:
TSpecialWord.wHint
wHintAsError:
TSpecialWord.wHintAsError
wHints:
TSpecialWord.wHints
wIf:
TSpecialWord.wIf
wImmediate:
TSpecialWord.wImmediate
wImplicitStatic:
TSpecialWord.wImplicitStatic
wImport:
TSpecialWord.wImport
wImportc:
TSpecialWord.wImportc
wImportCompilerProc:
TSpecialWord.wImportCompilerProc
wImportCpp:
TSpecialWord.wImportCpp
wImportHidden:
TSpecialWord.wImportHidden
wImportJs:
TSpecialWord.wImportJs
wImportObjC:
TSpecialWord.wImportObjC
wIn:
TSpecialWord.wIn
wInclude:
TSpecialWord.wInclude
wIncompleteStruct:
TSpecialWord.wIncompleteStruct
wInfChecks:
TSpecialWord.wInfChecks
wInheritable:
TSpecialWord.wInheritable
wInject:
TSpecialWord.wInject
wInline:
TSpecialWord.wInline
wInOut:
TSpecialWord.wInOut
wInt:
TSpecialWord.wInt
wIntDefine:
TSpecialWord.wIntDefine
wInterface:
TSpecialWord.wInterface
wInvalid:
TSpecialWord.wInvalid
wInvariant:
TSpecialWord.wInvariant
wIs:
TSpecialWord.wIs
wIsnot:
TSpecialWord.wIsnot
wIterator:
TSpecialWord.wIterator
withInfo:
ast: withInfo(n: PNode; info: TLineInfo): PNode
withPackageName:
options: withPackageName(conf: ConfigRef; path: AbsoluteFile): AbsoluteFile
wLet:
TSpecialWord.wLet
wLib:
TSpecialWord.wLib
wLiftLocals:
TSpecialWord.wLiftLocals
wLine:
TSpecialWord.wLine
wLinearScanEnd:
TSpecialWord.wLinearScanEnd
wLineDir:
TSpecialWord.wLineDir
wLineTrace:
TSpecialWord.wLineTrace
wLink:
TSpecialWord.wLink
wLinksys:
TSpecialWord.wLinksys
wLocalPassc:
TSpecialWord.wLocalPassc
wLocks:
TSpecialWord.wLocks
wLong:
TSpecialWord.wLong
wMacro:
TSpecialWord.wMacro
wMagic:
TSpecialWord.wMagic
wMemTracker:
TSpecialWord.wMemTracker
wMerge:
TSpecialWord.wMerge
wMethod:
TSpecialWord.wMethod
wMinus:
TSpecialWord.wMinus
wMixin:
TSpecialWord.wMixin
wMod:
TSpecialWord.wMod
wMutable:
TSpecialWord.wMutable
wNamespace:
TSpecialWord.wNamespace
wNanChecks:
TSpecialWord.wNanChecks
wNew:
TSpecialWord.wNew
wNil:
TSpecialWord.wNil
wNilChecks:
TSpecialWord.wNilChecks
wNimcall:
TSpecialWord.wNimcall
wNoalias:
TSpecialWord.wNoalias
wNoconv:
TSpecialWord.wNoconv
wNodecl:
TSpecialWord.wNodecl
wNoDestroy:
TSpecialWord.wNoDestroy
wNoexcept:
TSpecialWord.wNoexcept
wNoForward:
TSpecialWord.wNoForward
wNoInit:
TSpecialWord.wNoInit
wNoInline:
TSpecialWord.wNoInline
wNonReloadable:
TSpecialWord.wNonReloadable
wNoreturn:
TSpecialWord.wNoreturn
wNoRewrite:
TSpecialWord.wNoRewrite
wNoSideEffect:
TSpecialWord.wNoSideEffect
wNosinks:
TSpecialWord.wNosinks
wNot:
TSpecialWord.wNot
wNotin:
TSpecialWord.wNotin
wNullptr:
TSpecialWord.wNullptr
wObjChecks:
TSpecialWord.wObjChecks
wObject:
TSpecialWord.wObject
wOf:
TSpecialWord.wOf
wOff:
TSpecialWord.wOff
wOn:
TSpecialWord.wOn
wOneWay:
TSpecialWord.wOneWay
wOperator:
TSpecialWord.wOperator
wOptimization:
TSpecialWord.wOptimization
wOr:
TSpecialWord.wOr
wordExcess:
vmdef: wordExcess
wOut:
TSpecialWord.wOut
wOverflowChecks:
TSpecialWord.wOverflowChecks
wOverride:
TSpecialWord.wOverride
wPackage:
TSpecialWord.wPackage
wPacked:
TSpecialWord.wPacked
wPartial:
TSpecialWord.wPartial
wPassc:
TSpecialWord.wPassc
wPassl:
TSpecialWord.wPassl
wPatterns:
TSpecialWord.wPatterns
wPop:
TSpecialWord.wPop
wPragma:
TSpecialWord.wPragma
wPrivate:
TSpecialWord.wPrivate
wProc:
TSpecialWord.wProc
wProcVar:
TSpecialWord.wProcVar
wProfiler:
TSpecialWord.wProfiler
wProtected:
TSpecialWord.wProtected
wPtr:
TSpecialWord.wPtr
wPublic:
TSpecialWord.wPublic
wPure:
TSpecialWord.wPure
wPush:
TSpecialWord.wPush
wRaise:
TSpecialWord.wRaise
wRaises:
TSpecialWord.wRaises
wRangeChecks:
TSpecialWord.wRangeChecks
wrapInComesFrom:
evaltempl: wrapInComesFrom(info: TLineInfo; sym: PSym; res: PNode): PNode
wrapProcForSpawn:
spawn: wrapProcForSpawn(g: ModuleGraph; idgen: IdGenerator; owner: PSym; spawnExpr: PNode; retType: PType; barrier, dest: PNode = nil): PNode
wReads:
TSpecialWord.wReads
wRef:
TSpecialWord.wRef
wRegister:
TSpecialWord.wRegister
wReinterpret_cast:
TSpecialWord.wReinterpret_cast
wReorder:
TSpecialWord.wReorder
wRequires:
TSpecialWord.wRequires
wRequiresInit:
TSpecialWord.wRequiresInit
wRestrict:
TSpecialWord.wRestrict
wReturn:
TSpecialWord.wReturn
writeCommandLineUsage:
commands: writeCommandLineUsage(conf: ConfigRef)
writeFile:
pathutils: writeFile(x: AbsoluteFile; content: string)
writeJsonBuildInstructions:
extccomp: writeJsonBuildInstructions(conf: ConfigRef)
writeMangledName:
ndi: writeMangledName(f: NdiFile; s: PSym; conf: ConfigRef)
writeMapping:
extccomp: writeMapping(conf: ConfigRef; symbolMapping: Rope)
writeMatches:
sigmatch: writeMatches(c: TCandidate)
writeOnlySf:
SymbolFilesOption.writeOnlySf
writeOutput:
docgen: writeOutput(d: PDoc; useWarning = false; groupedToc = false)
writeOutputJson:
docgen: writeOutputJson(d: PDoc; useWarning = false)
writeRodFiles:
navigator: writeRodFiles(g: ModuleGraph)
writeRope:
ropes: writeRope(f: File; r: Rope)
ropes: writeRope(head: Rope; filename: AbsoluteFile): bool
writeRopeIfNotEqual:
ropes: writeRopeIfNotEqual(r: Rope; filename: AbsoluteFile): bool
wrongHeader:
RodFileError.wrongHeader
WrongNumberOfArguments:
ErrorKind.WrongNumberOfArguments
wrongRedefinition:
lookups: wrongRedefinition(c: PContext; info: TLineInfo; s: string; conflictsWith: TLineInfo; note = errGenerated)
wrongSection:
RodFileError.wrongSection
wSafecall:
TSpecialWord.wSafecall
wSafecode:
TSpecialWord.wSafecode
wShallow:
TSpecialWord.wShallow
wShl:
TSpecialWord.wShl
wShort:
TSpecialWord.wShort
wShr:
TSpecialWord.wShr
wSideEffect:
TSpecialWord.wSideEffect
wSigned:
TSpecialWord.wSigned
wSinkInference:
TSpecialWord.wSinkInference
wSize:
TSpecialWord.wSize
wSizeof:
TSpecialWord.wSizeof
wStackTrace:
TSpecialWord.wStackTrace
wStar:
TSpecialWord.wStar
wStatic:
TSpecialWord.wStatic
wStatic_assert:
TSpecialWord.wStatic_assert
wStaticBoundchecks:
TSpecialWord.wStaticBoundchecks
wStatic_cast:
TSpecialWord.wStatic_cast
wStdcall:
TSpecialWord.wStdcall
wStdErr:
TSpecialWord.wStdErr
wStdIn:
TSpecialWord.wStdIn
wStdOut:
TSpecialWord.wStdOut
wStrDefine:
TSpecialWord.wStrDefine
wStruct:
TSpecialWord.wStruct
wStyleChecks:
TSpecialWord.wStyleChecks
wSubsChar:
TSpecialWord.wSubsChar
wSwitch:
TSpecialWord.wSwitch
wSyscall:
TSpecialWord.wSyscall
wTags:
TSpecialWord.wTags
wTemplate:
TSpecialWord.wTemplate
wThis:
TSpecialWord.wThis
wThiscall:
TSpecialWord.wThiscall
wThread:
TSpecialWord.wThread
wThread_local:
TSpecialWord.wThread_local
wThreadVar:
TSpecialWord.wThreadVar
wThrow:
TSpecialWord.wThrow
wTrMacros:
TSpecialWord.wTrMacros
wTrue:
TSpecialWord.wTrue
wTry:
TSpecialWord.wTry
wTuple:
TSpecialWord.wTuple
wType:
TSpecialWord.wType
wTypedef:
TSpecialWord.wTypedef
wTypeid:
TSpecialWord.wTypeid
wTypename:
TSpecialWord.wTypename
wTypeof:
TSpecialWord.wTypeof
wUnchecked:
TSpecialWord.wUnchecked
wUncheckedAssign:
TSpecialWord.wUncheckedAssign
wUndef:
TSpecialWord.wUndef
wUnion:
TSpecialWord.wUnion
wUnroll:
TSpecialWord.wUnroll
wUnsigned:
TSpecialWord.wUnsigned
wUsed:
TSpecialWord.wUsed
wUsing:
TSpecialWord.wUsing
wVar:
TSpecialWord.wVar
wVarargs:
TSpecialWord.wVarargs
wVirtual:
TSpecialWord.wVirtual
wVoid:
TSpecialWord.wVoid
wVolatile:
TSpecialWord.wVolatile
wWarning:
TSpecialWord.wWarning
wWarningAsError:
TSpecialWord.wWarningAsError
wWarnings:
TSpecialWord.wWarnings
wWchar_t:
TSpecialWord.wWchar_t
wWhen:
TSpecialWord.wWhen
wWhile:
TSpecialWord.wWhile
wWrite:
TSpecialWord.wWrite
wWrites:
TSpecialWord.wWrites
wXor:
TSpecialWord.wXor
wYield:
TSpecialWord.wYield
yes:
AliasKind.yes
Zero:
int128: Zero