jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

the big renamefest: first steps

Browse source
This commit is contained in:
Araq 2014-08-22 23:54:26 +02:00
commit dbf9117c56
56 changed files with 529 additions and 508 deletions
Download patch file Download diff file Expand all files Collapse all files

5
compiler/ast.nim
View file

@ -501,7 +501,8 @@ type
skStub, # symbol is a stub and not yet loaded from the ROD skStub, # symbol is a stub and not yet loaded from the ROD
# file (it is loaded on demand, which may # file (it is loaded on demand, which may
# mean: never) # mean: never)
skPackage # symbol is a package (used for canonicalization) skPackage, # symbol is a package (used for canonicalization)
skAlias # an alias (needs to be resolved immediately)
TSymKinds* = set[TSymKind] TSymKinds* = set[TSymKind]
const const
@ -872,7 +873,7 @@ const
tyProc, tyString, tyError} tyProc, tyString, tyError}
ExportableSymKinds* = {skVar, skConst, skProc, skMethod, skType, ExportableSymKinds* = {skVar, skConst, skProc, skMethod, skType,
skIterator, skClosureIterator, skIterator, skClosureIterator,
skMacro, skTemplate, skConverter, skEnumField, skLet, skStub} skMacro, skTemplate, skConverter, skEnumField, skLet, skStub, skAlias}
PersistentNodeFlags*: TNodeFlags = {nfBase2, nfBase8, nfBase16, PersistentNodeFlags*: TNodeFlags = {nfBase2, nfBase8, nfBase16,
nfDotSetter, nfDotField, nfDotSetter, nfDotField,
nfIsRef} nfIsRef}

12
compiler/ccgstmts.nim
View file

@ -489,6 +489,8 @@ proc genBreakStmt(p: BProc, t: PNode) =
proc getRaiseFrmt(p: BProc): string = proc getRaiseFrmt(p: BProc): string =
if gCmd == cmdCompileToCpp: if gCmd == cmdCompileToCpp:
result = "throw NimException($1, $2);$n" result = "throw NimException($1, $2);$n"
elif getCompilerProc("Exception") != nil:
result = "#raiseException((#Exception*)$1, $2);$n"
else: else:
result = "#raiseException((#E_Base*)$1, $2);$n" result = "#raiseException((#E_Base*)$1, $2);$n"
@ -733,7 +735,10 @@ proc genTryCpp(p: BProc, t: PNode, d: var TLoc) =
i, length, blen: int i, length, blen: int
genLineDir(p, t) genLineDir(p, t)
exc = getTempName() exc = getTempName()
discard cgsym(p.module, "E_Base") if getCompilerProc("Exception") != nil:
discard cgsym(p.module, "Exception")
else:
discard cgsym(p.module, "E_Base")
add(p.nestedTryStmts, t) add(p.nestedTryStmts, t)
startBlock(p, "try {$n") startBlock(p, "try {$n")
expr(p, t.sons[0], d) expr(p, t.sons[0], d)
@ -815,7 +820,10 @@ proc genTry(p: BProc, t: PNode, d: var TLoc) =
discard lists.includeStr(p.module.headerFiles, "<setjmp.h>") discard lists.includeStr(p.module.headerFiles, "<setjmp.h>")
genLineDir(p, t) genLineDir(p, t)
var safePoint = getTempName() var safePoint = getTempName()
discard cgsym(p.module, "E_Base") if getCompilerProc("Exception") != nil:
discard cgsym(p.module, "Exception")
else:
discard cgsym(p.module, "E_Base")
linefmt(p, cpsLocals, "#TSafePoint $1;$n", safePoint) linefmt(p, cpsLocals, "#TSafePoint $1;$n", safePoint)
linefmt(p, cpsStmts, "#pushSafePoint(&$1);$n", safePoint) linefmt(p, cpsStmts, "#pushSafePoint(&$1);$n", safePoint)
linefmt(p, cpsStmts, "$1.status = setjmp($1.context);$n", safePoint) linefmt(p, cpsStmts, "$1.status = setjmp($1.context);$n", safePoint)

1
compiler/condsyms.nim
View file

@ -85,6 +85,7 @@ proc initDefines*() =
defineSymbol("nimnewshared") defineSymbol("nimnewshared")
defineSymbol("nimrequiresnimframe") defineSymbol("nimrequiresnimframe")
defineSymbol("nimparsebiggestfloatmagic") defineSymbol("nimparsebiggestfloatmagic")
defineSymbol("nimalias")
# add platform specific symbols: # add platform specific symbols:
for c in low(CPU)..high(CPU): for c in low(CPU)..high(CPU):

91
compiler/lookups.nim
View file

@ -1,6 +1,6 @@
# #
# #
# The Nimrod Compiler # The Nim Compiler
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
@ -11,7 +11,7 @@
import import
intsets, ast, astalgo, idents, semdata, types, msgs, options, rodread, intsets, ast, astalgo, idents, semdata, types, msgs, options, rodread,
renderer, wordrecg, idgen renderer, wordrecg, idgen, prettybase
proc ensureNoMissingOrUnusedSymbols(scope: PScope) proc ensureNoMissingOrUnusedSymbols(scope: PScope)
@ -65,6 +65,17 @@ iterator walkScopes*(scope: PScope): PScope =
yield current yield current
current = current.parent current = current.parent
proc skipAlias*(s: PSym; n: PNode): PSym =
if s == nil or s.kind != skAlias:
result = s
else:
result = s.owner
if gCmd == cmdPretty:
prettybase.replaceDeprecated(n.info, s, result)
else:
message(n.info, warnDeprecated, "use " & result.name.s & " instead; " &
s.name.s)
proc localSearchInScope*(c: PContext, s: PIdent): PSym = proc localSearchInScope*(c: PContext, s: PIdent): PSym =
result = strTableGet(c.currentScope.symbols, s) result = strTableGet(c.currentScope.symbols, s)
@ -183,15 +194,15 @@ proc lookUp*(c: PContext, n: PNode): PSym =
# Looks up a symbol. Generates an error in case of nil. # Looks up a symbol. Generates an error in case of nil.
case n.kind case n.kind
of nkIdent: of nkIdent:
result = searchInScopes(c, n.ident) result = searchInScopes(c, n.ident).skipAlias(n)
if result == nil: if result == nil:
localError(n.info, errUndeclaredIdentifier, n.ident.s) localError(n.info, errUndeclaredIdentifier, n.ident.s)
result = errorSym(c, n) result = errorSym(c, n)
of nkSym: of nkSym:
result = n.sym result = n.sym
of nkAccQuoted: of nkAccQuoted:
var ident = considerQuotedIdent(n) var ident = considerQuotedIdent(n)
result = searchInScopes(c, ident) result = searchInScopes(c, ident).skipAlias(n)
if result == nil: if result == nil:
localError(n.info, errUndeclaredIdentifier, ident.s) localError(n.info, errUndeclaredIdentifier, ident.s)
result = errorSym(c, n) result = errorSym(c, n)
@ -210,32 +221,32 @@ proc qualifiedLookUp*(c: PContext, n: PNode, flags = {checkUndeclared}): PSym =
case n.kind case n.kind
of nkIdent, nkAccQuoted: of nkIdent, nkAccQuoted:
var ident = considerQuotedIdent(n) var ident = considerQuotedIdent(n)
result = searchInScopes(c, ident) result = searchInScopes(c, ident).skipAlias(n)
if result == nil and checkUndeclared in flags: if result == nil and checkUndeclared in flags:
localError(n.info, errUndeclaredIdentifier, ident.s) localError(n.info, errUndeclaredIdentifier, ident.s)
result = errorSym(c, n) result = errorSym(c, n)
elif checkAmbiguity in flags and result != nil and elif checkAmbiguity in flags and result != nil and
contains(c.ambiguousSymbols, result.id): contains(c.ambiguousSymbols, result.id):
localError(n.info, errUseQualifier, ident.s) localError(n.info, errUseQualifier, ident.s)
of nkSym: of nkSym:
result = n.sym result = n.sym
if checkAmbiguity in flags and contains(c.ambiguousSymbols, result.id): if checkAmbiguity in flags and contains(c.ambiguousSymbols, result.id):
localError(n.info, errUseQualifier, n.sym.name.s) localError(n.info, errUseQualifier, n.sym.name.s)
of nkDotExpr: of nkDotExpr:
result = nil result = nil
var m = qualifiedLookUp(c, n.sons[0], flags*{checkUndeclared}) var m = qualifiedLookUp(c, n.sons[0], flags*{checkUndeclared})
if (m != nil) and (m.kind == skModule): if m != nil and m.kind == skModule:
var ident: PIdent = nil var ident: PIdent = nil
if n.sons[1].kind == nkIdent: if n.sons[1].kind == nkIdent:
ident = n.sons[1].ident ident = n.sons[1].ident
elif n.sons[1].kind == nkAccQuoted: elif n.sons[1].kind == nkAccQuoted:
ident = considerQuotedIdent(n.sons[1]) ident = considerQuotedIdent(n.sons[1])
if ident != nil: if ident != nil:
if m == c.module: if m == c.module:
result = strTableGet(c.topLevelScope.symbols, ident) result = strTableGet(c.topLevelScope.symbols, ident).skipAlias(n)
else: else:
result = strTableGet(m.tab, ident) result = strTableGet(m.tab, ident).skipAlias(n)
if result == nil and checkUndeclared in flags: if result == nil and checkUndeclared in flags:
localError(n.sons[1].info, errUndeclaredIdentifier, ident.s) localError(n.sons[1].info, errUndeclaredIdentifier, ident.s)
result = errorSym(c, n.sons[1]) result = errorSym(c, n.sons[1])
elif n.sons[1].kind == nkSym: elif n.sons[1].kind == nkSym:
@ -256,7 +267,7 @@ proc initOverloadIter*(o: var TOverloadIter, c: PContext, n: PNode): PSym =
o.scope = c.currentScope o.scope = c.currentScope
o.mode = oimNoQualifier o.mode = oimNoQualifier
while true: while true:
result = initIdentIter(o.it, o.scope.symbols, ident) result = initIdentIter(o.it, o.scope.symbols, ident).skipAlias(n)
if result != nil: if result != nil:
break break
else: else:
@ -277,11 +288,12 @@ proc initOverloadIter*(o: var TOverloadIter, c: PContext, n: PNode): PSym =
if ident != nil: if ident != nil:
if o.m == c.module: if o.m == c.module:
# a module may access its private members: # a module may access its private members:
result = initIdentIter(o.it, c.topLevelScope.symbols, ident) result = initIdentIter(o.it, c.topLevelScope.symbols,
ident).skipAlias(n)
o.mode = oimSelfModule o.mode = oimSelfModule
else: else:
result = initIdentIter(o.it, o.m.tab, ident) result = initIdentIter(o.it, o.m.tab, ident).skipAlias(n)
else: else:
localError(n.sons[1].info, errIdentifierExpected, localError(n.sons[1].info, errIdentifierExpected,
renderTree(n.sons[1])) renderTree(n.sons[1]))
result = errorSym(c, n.sons[1]) result = errorSym(c, n.sons[1])
@ -307,18 +319,18 @@ proc nextOverloadIter*(o: var TOverloadIter, c: PContext, n: PNode): PSym =
result = nil result = nil
of oimNoQualifier: of oimNoQualifier:
if o.scope != nil: if o.scope != nil:
result = nextIdentIter(o.it, o.scope.symbols) result = nextIdentIter(o.it, o.scope.symbols).skipAlias(n)
while result == nil: while result == nil:
o.scope = o.scope.parent o.scope = o.scope.parent
if o.scope == nil: break if o.scope == nil: break
result = initIdentIter(o.it, o.scope.symbols, o.it.name) result = initIdentIter(o.it, o.scope.symbols, o.it.name).skipAlias(n)
# BUGFIX: o.it.name <-> n.ident # BUGFIX: o.it.name <-> n.ident
else: else:
result = nil result = nil
of oimSelfModule: of oimSelfModule:
result = nextIdentIter(o.it, c.topLevelScope.symbols) result = nextIdentIter(o.it, c.topLevelScope.symbols).skipAlias(n)
of oimOtherModule: of oimOtherModule:
result = nextIdentIter(o.it, o.m.tab) result = nextIdentIter(o.it, o.m.tab).skipAlias(n)
of oimSymChoice: of oimSymChoice:
if o.symChoiceIndex < sonsLen(n): if o.symChoiceIndex < sonsLen(n):
result = n.sons[o.symChoiceIndex].sym result = n.sons[o.symChoiceIndex].sym
@ -329,31 +341,18 @@ proc nextOverloadIter*(o: var TOverloadIter, c: PContext, n: PNode): PSym =
o.mode = oimSymChoiceLocalLookup o.mode = oimSymChoiceLocalLookup
o.scope = c.currentScope o.scope = c.currentScope
result = firstIdentExcluding(o.it, o.scope.symbols, result = firstIdentExcluding(o.it, o.scope.symbols,
n.sons[0].sym.name, o.inSymChoice) n.sons[0].sym.name, o.inSymChoice).skipAlias(n)
while result == nil: while result == nil:
o.scope = o.scope.parent o.scope = o.scope.parent
if o.scope == nil: break if o.scope == nil: break
result = firstIdentExcluding(o.it, o.scope.symbols, result = firstIdentExcluding(o.it, o.scope.symbols,
n.sons[0].sym.name, o.inSymChoice) n.sons[0].sym.name, o.inSymChoice).skipAlias(n)
of oimSymChoiceLocalLookup: of oimSymChoiceLocalLookup:
result = nextIdentExcluding(o.it, o.scope.symbols, o.inSymChoice) result = nextIdentExcluding(o.it, o.scope.symbols, o.inSymChoice).skipAlias(n)
while result == nil: while result == nil:
o.scope = o.scope.parent o.scope = o.scope.parent
if o.scope == nil: break if o.scope == nil: break
result = firstIdentExcluding(o.it, o.scope.symbols, result = firstIdentExcluding(o.it, o.scope.symbols,
n.sons[0].sym.name, o.inSymChoice) n.sons[0].sym.name, o.inSymChoice).skipAlias(n)
if result != nil and result.kind == skStub: loadStub(result) if result != nil and result.kind == skStub: loadStub(result)
when false:
proc qualifiedLookUpPreferImmediate*(c: PContext, n: PNode,
flags = {checkUndeclared}): PSym =
var o: TOverloadIter
result = initOverloadIter(o, c, n)
var a = result
while a != nil:
if sfImmediate in a.flags: return a
a = nextOverloadIter(o, c, n)
if result == nil and checkUndeclared in flags:
localError(n.info, errUndeclaredIdentifier, n.considerQuotedIdent.s)
result = errorSym(c, n)

12
compiler/magicsys.nim
View file

@ -1,6 +1,6 @@
# #
# #
# The Nimrod Compiler # The Nim Compiler
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
@ -44,6 +44,7 @@ proc getSysSym(name: string): PSym =
result = newSym(skError, getIdent(name), systemModule, systemModule.info) result = newSym(skError, getIdent(name), systemModule, systemModule.info)
result.typ = newType(tyError, systemModule) result.typ = newType(tyError, systemModule)
if result.kind == skStub: loadStub(result) if result.kind == skStub: loadStub(result)
if result.kind == skAlias: result = result.owner
proc getSysMagic*(name: string, m: TMagic): PSym = proc getSysMagic*(name: string, m: TMagic): PSym =
var ti: TIdentIter var ti: TIdentIter
@ -165,13 +166,14 @@ proc setIntLitType*(result: PNode) =
proc getCompilerProc(name: string): PSym = proc getCompilerProc(name: string): PSym =
var ident = getIdent(name, hashIgnoreStyle(name)) var ident = getIdent(name, hashIgnoreStyle(name))
result = strTableGet(compilerprocs, ident) result = strTableGet(compilerprocs, ident)
if result == nil: if result == nil:
result = strTableGet(rodCompilerprocs, ident) result = strTableGet(rodCompilerprocs, ident)
if result != nil: if result != nil:
strTableAdd(compilerprocs, result) strTableAdd(compilerprocs, result)
if result.kind == skStub: loadStub(result) if result.kind == skStub: loadStub(result)
if result.kind == skAlias: result = result.owner
proc registerCompilerProc(s: PSym) =
proc registerCompilerProc(s: PSym) =
strTableAdd(compilerprocs, s) strTableAdd(compilerprocs, s)
proc finishSystem(tab: TStrTable) = discard proc finishSystem(tab: TStrTable) = discard

2
compiler/msgs.nim
View file

@ -368,7 +368,7 @@ const
warnOctalEscape: "octal escape sequences do not exist; leading zero is ignored [OctalEscape]", warnOctalEscape: "octal escape sequences do not exist; leading zero is ignored [OctalEscape]",
warnXIsNeverRead: "\'$1\' is never read [XIsNeverRead]", warnXIsNeverRead: "\'$1\' is never read [XIsNeverRead]",
warnXmightNotBeenInit: "\'$1\' might not have been initialized [XmightNotBeenInit]", warnXmightNotBeenInit: "\'$1\' might not have been initialized [XmightNotBeenInit]",
warnDeprecated: "\'$1\' is deprecated [Deprecated]", warnDeprecated: "$1 is deprecated [Deprecated]",
warnConfigDeprecated: "config file '$1' is deprecated [ConfigDeprecated]", warnConfigDeprecated: "config file '$1' is deprecated [ConfigDeprecated]",
warnSmallLshouldNotBeUsed: "\'l\' should not be used as an identifier; may look like \'1\' (one) [SmallLshouldNotBeUsed]", warnSmallLshouldNotBeUsed: "\'l\' should not be used as an identifier; may look like \'1\' (one) [SmallLshouldNotBeUsed]",
warnUnknownMagic: "unknown magic \'$1\' might crash the compiler [UnknownMagic]", warnUnknownMagic: "unknown magic \'$1\' might crash the compiler [UnknownMagic]",

39
compiler/pragmas.nim
View file

@ -1,6 +1,6 @@
# #
# #
# The Nimrod Compiler # The Nim Compiler
# (c) Copyright 2014 Andreas Rumpf # (c) Copyright 2014 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
@ -45,7 +45,7 @@ const
wBreakpoint, wWatchPoint, wPassl, wPassc, wDeadCodeElim, wDeprecated, wBreakpoint, wWatchPoint, wPassl, wPassc, wDeadCodeElim, wDeprecated,
wFloatchecks, wInfChecks, wNanChecks, wPragma, wEmit, wUnroll, wFloatchecks, wInfChecks, wNanChecks, wPragma, wEmit, wUnroll,
wLinearScanEnd, wPatterns, wEffects, wNoForward, wComputedGoto, wLinearScanEnd, wPatterns, wEffects, wNoForward, wComputedGoto,
wInjectStmt} wInjectStmt, wDeprecated}
lambdaPragmas* = {FirstCallConv..LastCallConv, wImportc, wExportc, wNodecl, lambdaPragmas* = {FirstCallConv..LastCallConv, wImportc, wExportc, wNodecl,
wNosideeffect, wSideeffect, wNoreturn, wDynlib, wHeader, wNosideeffect, wSideeffect, wNoreturn, wDynlib, wHeader,
wDeprecated, wExtern, wThread, wImportCpp, wImportObjC, wAsmNoStackFrame, wDeprecated, wExtern, wThread, wImportCpp, wImportObjC, wAsmNoStackFrame,
@ -542,6 +542,27 @@ proc typeBorrow(sym: PSym, n: PNode) =
localError(n.info, "a type can only borrow `.` for now") localError(n.info, "a type can only borrow `.` for now")
incl(sym.typ.flags, tfBorrowDot) incl(sym.typ.flags, tfBorrowDot)
proc markCompilerProc(s: PSym) =
makeExternExport(s, "$1", s.info)
incl(s.flags, sfCompilerProc)
incl(s.flags, sfUsed)
registerCompilerProc(s)
proc deprecatedStmt(c: PContext; pragma: PNode) =
let pragma = pragma[1]
if pragma.kind != nkBracket:
localError(pragma.info, "list of key:value pairs expected"); return
for n in pragma:
if n.kind in {nkExprColonExpr, nkExprEqExpr}:
let dest = qualifiedLookUp(c, n[1])
let src = considerQuotedIdent(n[0])
let alias = newSym(skAlias, src, dest, n[0].info)
incl(alias.flags, sfExported)
if sfCompilerProc in dest.flags: markCompilerProc(alias)
addInterfaceDecl(c, alias)
else:
localError(n.info, "key:value pair expected")
proc singlePragma(c: PContext, sym: PSym, n: PNode, i: int, proc singlePragma(c: PContext, sym: PSym, n: PNode, i: int,
validPragmas: TSpecialWords): bool = validPragmas: TSpecialWords): bool =
var it = n.sons[i] var it = n.sons[i]
@ -648,17 +669,13 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: int,
processDynLib(c, it, sym) processDynLib(c, it, sym)
of wCompilerproc: of wCompilerproc:
noVal(it) # compilerproc may not get a string! noVal(it) # compilerproc may not get a string!
if sfFromGeneric notin sym.flags: if sfFromGeneric notin sym.flags: markCompilerProc(sym)
makeExternExport(sym, "$1", it.info) of wProcVar:
incl(sym.flags, sfCompilerProc)
incl(sym.flags, sfUsed) # suppress all those stupid warnings
registerCompilerProc(sym)
of wProcVar:
noVal(it) noVal(it)
incl(sym.flags, sfProcvar) incl(sym.flags, sfProcvar)
of wDeprecated: of wDeprecated:
noVal(it) if it.kind == nkExprColonExpr: deprecatedStmt(c, it)
if sym != nil: incl(sym.flags, sfDeprecated) elif sym != nil: incl(sym.flags, sfDeprecated)
else: incl(c.module.flags, sfDeprecated) else: incl(c.module.flags, sfDeprecated)
of wVarargs: of wVarargs:
noVal(it) noVal(it)

114
compiler/pretty.nim
View file

@ -1,6 +1,6 @@
# #
# #
# The Nimrod Compiler # The Nim Compiler
# (c) Copyright 2014 Andreas Rumpf # (c) Copyright 2014 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
@ -8,41 +8,19 @@
# #
## This module implements the code "prettifier". This is part of the toolchain ## This module implements the code "prettifier". This is part of the toolchain
## to convert Nimrod code into a consistent style. ## to convert Nim code into a consistent style.
import import
strutils, os, options, ast, astalgo, msgs, ropes, idents, passes, strutils, os, options, ast, astalgo, msgs, ropes, idents, passes,
intsets, strtabs, semdata intsets, strtabs, semdata, prettybase
const
removeTP = false # when true, "nimrod pretty" converts TTyp to Typ.
type type
TGen = object of TPassContext TGen = object of TPassContext
module*: PSym module*: PSym
PGen = ref TGen PGen = ref TGen
TSourceFile = object
lines: seq[string]
dirty: bool
fullpath: string
var var
gSourceFiles: seq[TSourceFile] = @[]
gCheckExtern: bool gCheckExtern: bool
rules: PStringTable
proc loadFile(info: TLineInfo) =
let i = info.fileIndex
if i >= gSourceFiles.len:
gSourceFiles.setLen(i+1)
if gSourceFiles[i].lines.isNil:
gSourceFiles[i].lines = @[]
let path = info.toFullPath
gSourceFiles[i].fullpath = path
# we want to die here for EIO:
for line in lines(path):
gSourceFiles[i].lines.add(line)
proc overwriteFiles*() = proc overwriteFiles*() =
let overWrite = options.getConfigVar("pretty.overwrite").normalize == "on" let overWrite = options.getConfigVar("pretty.overwrite").normalize == "on"
@ -78,9 +56,6 @@ proc beautifyName(s: string, k: TSymKind): string =
case k case k
of skType, skGenericParam: of skType, skGenericParam:
# Types should start with a capital unless builtins like 'int' etc.: # Types should start with a capital unless builtins like 'int' etc.:
when removeTP:
if s[0] == 'T' and s[1] in {'A'..'Z'}:
i = 1
if s =~ ["int", "uint", "cint", "cuint", "clong", "cstring", "string", if s =~ ["int", "uint", "cint", "cuint", "clong", "cstring", "string",
"char", "byte", "bool", "openArray", "seq", "array", "void", "char", "byte", "bool", "openArray", "seq", "array", "void",
"pointer", "float", "csize", "cdouble", "cchar", "cschar", "pointer", "float", "csize", "cdouble", "cchar", "cschar",
@ -120,26 +95,10 @@ proc checkStyle*(info: TLineInfo, s: string, k: TSymKind) =
if s != beau: if s != beau:
message(info, errGenerated, "name should be: " & beau) message(info, errGenerated, "name should be: " & beau)
const
Letters = {'a'..'z', 'A'..'Z', '0'..'9', '\x80'..'\xFF', '_'}
proc identLen(line: string, start: int): int =
while start+result < line.len and line[start+result] in Letters:
inc result
proc differ(line: string, a, b: int, x: string): bool =
let y = line[a..b]
result = cmpIgnoreStyle(y, x) == 0 and y != x
when false:
var j = 0
for i in a..b:
if line[i] != x[j]: return true
inc j
return false
proc checkDef*(n: PNode; s: PSym) = proc checkDef*(n: PNode; s: PSym) =
# operators stay as they are: # operators stay as they are:
if s.kind in {skResult, skTemp} or s.name.s[0] notin Letters: return if s.kind in {skResult, skTemp} or s.name.s[0] notin prettybase.Letters:
return
if s.kind in {skType, skGenericParam} and sfAnon in s.flags: return if s.kind in {skType, skGenericParam} and sfAnon in s.flags: return
if {sfImportc, sfExportc} * s.flags == {} or gCheckExtern: if {sfImportc, sfExportc} * s.flags == {} or gCheckExtern:
@ -155,7 +114,8 @@ proc checkUse*(info: TLineInfo; s: PSym) =
# for consistency # for consistency
# operators stay as they are: # operators stay as they are:
if s.kind in {skResult, skTemp} or s.name.s[0] notin Letters: return if s.kind in {skResult, skTemp} or s.name.s[0] notin prettybase.Letters:
return
if s.kind in {skType, skGenericParam} and sfAnon in s.flags: return if s.kind in {skType, skGenericParam} and sfAnon in s.flags: return
let newName = s.name.s let newName = s.name.s
@ -165,61 +125,17 @@ proc checkUse*(info: TLineInfo; s: PSym) =
var first = min(info.col.int, line.len) var first = min(info.col.int, line.len)
if first < 0: return if first < 0: return
#inc first, skipIgnoreCase(line, "proc ", first) #inc first, skipIgnoreCase(line, "proc ", first)
while first > 0 and line[first-1] in Letters: dec first while first > 0 and line[first-1] in prettybase.Letters: dec first
if first < 0: return if first < 0: return
if line[first] == '`': inc first if line[first] == '`': inc first
let last = first+identLen(line, first)-1 let last = first+identLen(line, first)-1
if differ(line, first, last, newName): if differ(line, first, last, newName):
# last-first+1 != newName.len or # last-first+1 != newName.len or
var x = line.substr(0, first-1) & newName & line.substr(last+1) var x = line.substr(0, first-1) & newName & line.substr(last+1)
when removeTP:
# the WinAPI module is full of 'TX = X' which after the substitution
# becomes 'X = X'. We remove those lines:
if x.match(peg"\s* {\ident} \s* '=' \s* y$1 ('#' .*)?"):
x = ""
system.shallowCopy(gSourceFiles[info.fileIndex].lines[info.line-1], x) system.shallowCopy(gSourceFiles[info.fileIndex].lines[info.line-1], x)
gSourceFiles[info.fileIndex].dirty = true gSourceFiles[info.fileIndex].dirty = true
when false:
var cannotRename = initIntSet()
proc beautifyName(s: string, k: TSymKind): string =
let allUpper = allCharsInSet(s, {'A'..'Z', '0'..'9', '_'})
result = newStringOfCap(s.len)
var i = 0
case k
of skType, skGenericParam:
# skip leading 'T'
when removeTP:
if s[0] == 'T' and s[1] in {'A'..'Z'}:
i = 1
if s =~ ["int", "uint", "cint", "cuint", "clong", "cstring", "string",
"char", "byte", "bool", "openArray", "seq", "array", "void",
"pointer", "float", "csize", "cdouble", "cchar", "cschar",
"cshort", "cu"]:
result.add s[i]
else:
result.add toUpper(s[i])
of skConst, skEnumField:
# for 'const' we keep how it's spelt; either upper case or lower case:
result.add s[0]
else:
# as a special rule, don't transform 'L' to 'l'
if s.len == 1 and s[0] == 'L': result.add 'L'
else: result.add toLower(s[0])
inc i
while i < s.len:
if s[i] == '_':
inc i
result.add toUpper(s[i])
elif allUpper:
result.add toLower(s[i])
else:
result.add s[i]
inc i
proc check(c: PGen, n: PNode) = proc check(c: PGen, n: PNode) =
case n.kind case n.kind
of nkSym: checkUse(n.info, n.sym) of nkSym: checkUse(n.info, n.sym)
@ -264,18 +180,6 @@ proc myOpen(module: PSym): PPassContext =
g.module = module g.module = module
gCheckExtern = options.getConfigVar("pretty.checkextern").normalize == "on" gCheckExtern = options.getConfigVar("pretty.checkextern").normalize == "on"
result = g result = g
if rules.isNil:
rules = newStringTable(modeStyleInsensitive)
when removeTP:
# XXX activate when the T/P stuff is deprecated
let path = joinPath([getPrefixDir(), "config", "rename.rules.cfg"])
for line in lines(path):
if line.len > 0:
let colon = line.find(':')
if colon > 0:
rules[line.substr(0, colon-1)] = line.substr(colon+1)
else:
rules[line] = line
const prettyPass* = makePass(open = myOpen, process = processSym) const prettyPass* = makePass(open = myOpen, process = processSym)

59
compiler/prettybase.nim Normal file
View file

@ -0,0 +1,59 @@
#
#
# The Nim Compiler
# (c) Copyright 2014 Andreas Rumpf
#
# See the file "copying.txt", included in this
# distribution, for details about the copyright.
#
import ast, msgs, strutils
type
TSourceFile* = object
lines*: seq[string]
dirty*: bool
fullpath*: string
var
gSourceFiles*: seq[TSourceFile] = @[]
proc loadFile*(info: TLineInfo) =
let i = info.fileIndex
if i >= gSourceFiles.len:
gSourceFiles.setLen(i+1)
if gSourceFiles[i].lines.isNil:
gSourceFiles[i].lines = @[]
let path = info.toFullPath
gSourceFiles[i].fullpath = path
# we want to die here for EIO:
for line in lines(path):
gSourceFiles[i].lines.add(line)
const
Letters* = {'a'..'z', 'A'..'Z', '0'..'9', '\x80'..'\xFF', '_'}
proc identLen*(line: string, start: int): int =
while start+result < line.len and line[start+result] in Letters:
inc result
proc differ*(line: string, a, b: int, x: string): bool =
let y = line[a..b]
result = cmpIgnoreStyle(y, x) == 0 and y != x
proc replaceDeprecated*(info: TlineInfo; oldSym, newSym: PSym) =
loadFile(info)
let line = gSourceFiles[info.fileIndex].lines[info.line-1]
var first = min(info.col.int, line.len)
if first < 0: return
#inc first, skipIgnoreCase(line, "proc ", first)
while first > 0 and line[first-1] in Letters: dec first
if first < 0: return
if line[first] == '`': inc first
let last = first+identLen(line, first)-1
if cmpIgnoreStyle(line[first..last], oldSym.name.s) == 0:
var x = line.substr(0, first-1) & newSym.name.s & line.substr(last+1)
system.shallowCopy(gSourceFiles[info.fileIndex].lines[info.line-1], x)
gSourceFiles[info.fileIndex].dirty = true

4
compiler/semgnrc.nim
View file

@ -70,7 +70,7 @@ proc lookup(c: PContext, n: PNode, flags: TSemGenericFlags,
ctx: var TIntSet): PNode = ctx: var TIntSet): PNode =
result = n result = n
let ident = considerQuotedIdent(n) let ident = considerQuotedIdent(n)
var s = searchInScopes(c, ident) var s = searchInScopes(c, ident).skipAlias(n)
if s == nil: if s == nil:
if ident.id notin ctx and withinMixin notin flags: if ident.id notin ctx and withinMixin notin flags:
localError(n.info, errUndeclaredIdentifier, ident.s) localError(n.info, errUndeclaredIdentifier, ident.s)
@ -100,7 +100,7 @@ proc fuzzyLookup(c: PContext, n: PNode, flags: TSemGenericFlags,
result = n result = n
let n = n[1] let n = n[1]
let ident = considerQuotedIdent(n) let ident = considerQuotedIdent(n)
var s = searchInScopes(c, ident) var s = searchInScopes(c, ident).skipAlias(n)
if s != nil and s.kind in routineKinds: if s != nil and s.kind in routineKinds:
if withinBind in flags: if withinBind in flags:
result = newDot(result, symChoice(c, n, s, scClosed)) result = newDot(result, symChoice(c, n, s, scClosed))

15
compiler/sempass2.nim
View file

@ -130,20 +130,27 @@ proc addToIntersection(inter: var TIntersection, s: int) =
proc throws(tracked, n: PNode) = proc throws(tracked, n: PNode) =
if n.typ == nil or n.typ.kind != tyError: tracked.add n if n.typ == nil or n.typ.kind != tyError: tracked.add n
proc getEbase(): PType =
result = if getCompilerProc("Exception") != nil: sysTypeFromName"Exception"
else: sysTypeFromName"E_Base"
proc excType(n: PNode): PType = proc excType(n: PNode): PType =
# reraise is like raising E_Base: # reraise is like raising E_Base:
let t = if n.kind == nkEmpty: sysTypeFromName"E_Base" else: n.typ let t = if n.kind == nkEmpty: getEbase() else: n.typ
result = skipTypes(t, skipPtrs) result = skipTypes(t, skipPtrs)
proc createRaise(n: PNode): PNode = proc createRaise(n: PNode): PNode =
result = newNode(nkType) result = newNode(nkType)
result.typ = sysTypeFromName"E_Base" result.typ = getEbase()
if not n.isNil: result.info = n.info if not n.isNil: result.info = n.info
proc createTag(n: PNode): PNode = proc createTag(n: PNode): PNode =
result = newNode(nkType) result = newNode(nkType)
result.typ = sysTypeFromName"TEffect" if getCompilerProc("RootEffect") != nil:
result.typ = sysTypeFromName"RootEffect"
else:
result.typ = sysTypeFromName"TEffect"
if not n.isNil: result.info = n.info if not n.isNil: result.info = n.info
proc createAnyGlobal(n: PNode): PNode = proc createAnyGlobal(n: PNode): PNode =

4
compiler/transf.nim
View file

@ -782,8 +782,8 @@ proc transformBody*(module: PSym, n: PNode, prc: PSym): PNode =
# result = lambdalifting.liftIterator(prc, result) # result = lambdalifting.liftIterator(prc, result)
incl(result.flags, nfTransf) incl(result.flags, nfTransf)
when useEffectSystem: trackProc(prc, result) when useEffectSystem: trackProc(prc, result)
if prc.name.s == "testbody": #if prc.name.s == "testbody":
echo renderTree(result) # echo renderTree(result)
proc transformStmt*(module: PSym, n: PNode): PNode = proc transformStmt*(module: PSym, n: PNode): PNode =
if nfTransf in n.flags: if nfTransf in n.flags:

59
doc/exception_hierarchy_fragment.txt
View file

@ -1,31 +1,28 @@
* `E_Base <system.html#E_Base>`_ * `Exception <system.html#Exception>`_
* `EAccessViolation <system.html#EAccessViolation>`_ * `AccessViolationError <system.html#AccessViolationError>`_
* `EArithmetic <system.html#EArithmetic>`_ * `ArithmeticError <system.html#ArithmeticError>`_
* `EDivByZero <system.html#EDivByZero>`_ * `DivByZeroError <system.html#DivByZeroError>`_
* `EOverflow <system.html#EOverflow>`_ * `OverflowError <system.html#OverflowError>`_
* `EAssertionFailed <system.html#EAssertionFailed>`_ * `AssertionError <system.html#AssertionError>`_
* `EAsynch <system.html#EAsynch>`_ * `DeadThreadError <system.html#DeadThreadError>`_
* `EControlC <system.html#EControlC>`_ * `FloatingPointError <system.html#FloatingPointError>`_
* `EDeadThread <system.html#EDeadThread>`_ * `FloatDivByZeroError <system.html#FloatDivByZeroError>`_
* `EFloatingPoint <system.html#EFloatingPoint>`_ * `FloatInexactError <system.html#FloatInexactError>`_
* `EFloatDivByZero <system.html#EFloatDivByZero>`_ * `FloatInvalidOpError <system.html#FloatInvalidOpError>`_
* `EFloatInexact <system.html#EFloatInexact>`_ * `FloatOverflowError <system.html#FloatOverflowError>`_
* `EFloatInvalidOp <system.html#EFloatInvalidOp>`_ * `FloatUnderflowError <system.html#FloatUnderflowError>`_
* `EFloatOverflow <system.html#EFloatOverflow>`_ * `FieldError <system.html#InvalidFieldError>`_
* `EFloatUnderflow <system.html#EFloatUnderflow>`_ * `IndexError <system.html#InvalidIndexError>`_
* `EInvalidField <system.html#EInvalidField>`_ * `ObjectAssignmentError <system.html#ObjectAssignmentError>`_
* `EInvalidIndex <system.html#EInvalidIndex>`_ * `ObjectConversionError <system.html#ObjectConversionError>`_
* `EInvalidObjectAssignment <system.html#EInvalidObjectAssignment>`_ * `ValueError <system.html#ValueError>`_
* `EInvalidObjectConversion <system.html#EInvalidObjectConversion>`_ * `KeyError <system.html#KeyError>`_
* `EInvalidValue <system.html#EInvalidValue>`_ * `ReraiseError <system.html#ReraiseError>`_
* `EInvalidKey <system.html#EInvalidKey>`_ * `RangeError <system.html#RangeError>`_
* `ENoExceptionToReraise <system.html#ENoExceptionToReraise>`_ * `OutOfMemoryError <system.html#OutOfMemoryError>`_
* `EOutOfRange <system.html#EOutOfRange>`_ * `ResourceExhaustedError <system.html#ResourceExhaustedError>`_
* `ESynch <system.html#ESynch>`_ * `StackOverflowError <system.html#StackOverflowError>`_
* `EOutOfMemory <system.html#EOutOfMemory>`_ * `SystemError <system.html#SystemError>`_
* `EResourceExhausted <system.html#EResourceExhausted>`_ * `IOError <system.html#IOError>`_
* `EStackOverflow <system.html#EStackOverflow>`_ * `OSError <system.html#OSError>`_
* `ESystem <system.html#ESystem>`_ * `LibraryError <system.html#LibraryError>`_
* `EIO <system.html#EIO>`_
* `EOS <system.html#EOS>`_
* `EInvalidLibrary <system.html#EInvalidLibrary>`_

60
doc/lib.txt
View file

@ -1,15 +1,15 @@
======================= ====================
Nimrod Standard Library Nim Standard Library
======================= ====================
:Author: Andreas Rumpf :Author: Andreas Rumpf
:Version: |nimrodversion| :Version: |nimversion|
.. contents:: .. contents::
"The good thing about reinventing the wheel is that you can get a round one." "The good thing about reinventing the wheel is that you can get a round one."
Though the Nimrod Standard Library is still evolving, it is already quite Though the Nim Standard Library is still evolving, it is already quite
usable. It is divided into *pure libraries*, *impure libraries* and *wrappers*. usable. It is divided into *pure libraries*, *impure libraries* and *wrappers*.
Pure libraries do not depend on any external ``*.dll`` or ``lib*.so`` binary Pure libraries do not depend on any external ``*.dll`` or ``lib*.so`` binary
@ -19,7 +19,7 @@ low-level interface to a C library.
Read this `document <apis.html>`_ for a quick overview of the API design. Read this `document <apis.html>`_ for a quick overview of the API design.
The `bottom <#babel>`_ of this page includes a list of 3rd party packages The `bottom <#babel>`_ of this page includes a list of 3rd party packages
created by the Nimrod community. These packages are a useful addition to the created by the Nim community. These packages are a useful addition to the
modules in the standard library. modules in the standard library.
@ -41,27 +41,27 @@ Core
of ``system``, but an extra import. of ``system``, but an extra import.
* `threads <threads.html>`_ * `threads <threads.html>`_
Nimrod thread support. **Note**: This is part of the system module. Do not Nim thread support. **Note**: This is part of the system module. Do not
import it explicitly. import it explicitly.
* `channels <channels.html>`_ * `channels <channels.html>`_
Nimrod message passing support for threads. **Note**: This is part of the Nim message passing support for threads. **Note**: This is part of the
system module. Do not import it explicitly. system module. Do not import it explicitly.
* `locks <locks.html>`_ * `locks <locks.html>`_
Locks and condition variables for Nimrod. Locks and condition variables for Nim.
* `macros <macros.html>`_ * `macros <macros.html>`_
Contains the AST API and documentation of Nimrod for writing macros. Contains the AST API and documentation of Nim for writing macros.
* `typeinfo <typeinfo.html>`_ * `typeinfo <typeinfo.html>`_
Provides (unsafe) access to Nimrod's run time type information. Provides (unsafe) access to Nim's run time type information.
* `typetraits <typetraits.html>`_ * `typetraits <typetraits.html>`_
This module defines compile-time reflection procs for working with types. This module defines compile-time reflection procs for working with types.
* `actors <actors.html>`_ * `actors <actors.html>`_
Actor support for Nimrod; implemented as a layer on top of the threads and Actor support for Nim; implemented as a layer on top of the threads and
channels modules. channels modules.
@ -71,11 +71,11 @@ Collections and algorithms
* `algorithm <algorithm.html>`_ * `algorithm <algorithm.html>`_
Implements some common generic algorithms like sort or binary search. Implements some common generic algorithms like sort or binary search.
* `tables <tables.html>`_ * `tables <tables.html>`_
Nimrod hash table support. Contains tables, ordered tables and count tables. Nim hash table support. Contains tables, ordered tables and count tables.
* `sets <sets.html>`_ * `sets <sets.html>`_
Nimrod hash and bit set support. Nim hash and bit set support.
* `lists <lists.html>`_ * `lists <lists.html>`_
Nimrod linked list support. Contains singly and doubly linked lists and Nim linked list support. Contains singly and doubly linked lists and
circular lists ("rings"). circular lists ("rings").
* `queues <queues.html>`_ * `queues <queues.html>`_
Implementation of a queue. The underlying implementation uses a ``seq``. Implementation of a queue. The underlying implementation uses a ``seq``.
@ -153,11 +153,11 @@ Generic Operating System Services
* `streams <streams.html>`_ * `streams <streams.html>`_
This module provides a stream interface and two implementations thereof: This module provides a stream interface and two implementations thereof:
the `PFileStream` and the `PStringStream` which implement the stream the `PFileStream` and the `PStringStream` which implement the stream
interface for Nimrod file objects (`TFile`) and strings. Other modules interface for Nim file objects (`TFile`) and strings. Other modules
may provide other implementations for this standard stream interface. may provide other implementations for this standard stream interface.
* `marshal <marshal.html>`_ * `marshal <marshal.html>`_
Contains procs for serialization and deseralization of arbitrary Nimrod Contains procs for serialization and deseralization of arbitrary Nim
data structures. data structures.
* `terminal <terminal.html>`_ * `terminal <terminal.html>`_
@ -273,7 +273,7 @@ Parsers
parser. The configuration file's syntax is similar to the Windows ``.ini`` parser. The configuration file's syntax is similar to the Windows ``.ini``
format, but much more powerful, as it is not a line based parser. String format, but much more powerful, as it is not a line based parser. String
literals, raw string literals and triple quote string literals are supported literals, raw string literals and triple quote string literals are supported
as in the Nimrod programming language. as in the Nim programming language.
* `parsexml <parsexml.html>`_ * `parsexml <parsexml.html>`_
The ``parsexml`` module implements a simple high performance XML/HTML parser. The ``parsexml`` module implements a simple high performance XML/HTML parser.
@ -340,7 +340,7 @@ Cryptography and Hashing
* `hashes <hashes.html>`_ * `hashes <hashes.html>`_
This module implements efficient computations of hash values for diverse This module implements efficient computations of hash values for diverse
Nimrod types. Nim types.
* `md5 <md5.html>`_ * `md5 <md5.html>`_
This module implements the MD5 checksum algorithm. This module implements the MD5 checksum algorithm.
@ -353,7 +353,7 @@ Multimedia support
------------------ ------------------
* `colors <colors.html>`_ * `colors <colors.html>`_
This module implements color handling for Nimrod. It is used by This module implements color handling for Nim. It is used by
the ``graphics`` module. the ``graphics`` module.
@ -426,12 +426,12 @@ Other
----- -----
* `graphics <graphics.html>`_ * `graphics <graphics.html>`_
This module implements graphical output for Nimrod; the current This module implements graphical output for Nim; the current
implementation uses SDL but the interface is meant to support multiple implementation uses SDL but the interface is meant to support multiple
backends some day. backends some day.
* `dialogs <dialogs.html>`_ * `dialogs <dialogs.html>`_
This module implements portable dialogs for Nimrod; the implementation This module implements portable dialogs for Nim; the implementation
builds on the GTK interface. On Windows, native dialogs are shown if builds on the GTK interface. On Windows, native dialogs are shown if
appropriate. appropriate.
@ -444,7 +444,7 @@ Other
* `ssl <ssl.html>`_ * `ssl <ssl.html>`_
This module provides an easy to use sockets-style This module provides an easy to use sockets-style
Nimrod interface to the OpenSSL library. Nim interface to the OpenSSL library.
* `rdstdin <rdstdin.html>`_ * `rdstdin <rdstdin.html>`_
This module contains code for reading from `stdin`:idx:. On UNIX the GNU This module contains code for reading from `stdin`:idx:. On UNIX the GNU
@ -532,7 +532,7 @@ Database support
* `odbcsql <odbcsql.html>`_ * `odbcsql <odbcsql.html>`_
interface to the ODBC driver. interface to the ODBC driver.
* `sphinx <sphinx.html>`_ * `sphinx <sphinx.html>`_
Nimrod wrapper for ``sphinx``. Nim wrapper for ``sphinx``.
XML Processing XML Processing
@ -578,15 +578,15 @@ Scientific computing
Babel Babel
==================== ====================
Babel is a package manager for the Nimrod programming language. Babel is a package manager for the Nim programming language.
For instructions on how to install Babel packages see For instructions on how to install Babel packages see
`its README <https://github.com/nimrod-code/babel#readme>`_. `its README <https://github.com/nim-code/babel#readme>`_.
Official packages Official packages
----------------- -----------------
These packages are officially supported and will therefore be continually These packages are officially supported and will therefore be continually
maintained to ensure that they work with the latest versions of the Nimrod maintained to ensure that they work with the latest versions of the Nim
compiler. compiler.
.. raw:: html .. raw:: html
@ -597,9 +597,9 @@ compiler.
Unofficial packages Unofficial packages
------------------- -------------------
These packages have been developed by independent Nimrod developers and as These packages have been developed by independent Nim developers and as
such may not always be up to date with the latest developments in the such may not always be up to date with the latest developments in the
Nimrod programming language. Nim programming language.
.. raw:: html .. raw:: html
@ -607,4 +607,4 @@ Nimrod programming language.
babelpkglist.js or have javascript disabled in your browser.</b></div> babelpkglist.js or have javascript disabled in your browser.</b></div>
<script type="text/javascript" src="babelpkglist.js"></script> <script type="text/javascript" src="babelpkglist.js"></script>
<script type="text/javascript" src="http://build.nimrod-lang.org/packages?callback=gotPackageList"></script> <script type="text/javascript" src="http://build.nim-lang.org/packages?callback=gotPackageList"></script>

184
doc/manual.txt
View file

@ -1,9 +1,9 @@
============= ==========
Nimrod Manual Nim Manual
============= ==========
:Authors: Andreas Rumpf, Zahary Karadjov :Authors: Andreas Rumpf, Zahary Karadjov
:Version: |nimrodversion| :Version: |nimversion|
.. contents:: .. contents::
@ -17,11 +17,11 @@ Nimrod Manual
About this document About this document
=================== ===================
**Note**: This document is a draft! Several of Nimrod's features need more **Note**: This document is a draft! Several of Nim's features need more
precise wording. This manual will evolve into a proper specification some precise wording. This manual will evolve into a proper specification some
day. day.
This document describes the lexis, the syntax, and the semantics of Nimrod. This document describes the lexis, the syntax, and the semantics of Nim.
The language constructs are explained using an extended BNF, in The language constructs are explained using an extended BNF, in
which ``(a)*`` means 0 or more ``a``'s, ``a+`` means 1 or more ``a``'s, and which ``(a)*`` means 0 or more ``a``'s, ``a+`` means 1 or more ``a``'s, and
@ -48,14 +48,14 @@ and ``a ^* b`` is short for ``(a (b a)*)?``. Example::
arrayConstructor = '[' expr ^* ',' ']' arrayConstructor = '[' expr ^* ',' ']'
Other parts of Nimrod - like scoping rules or runtime semantics are only Other parts of Nim - like scoping rules or runtime semantics are only
described in an informal manner for now. described in an informal manner for now.
Definitions Definitions
=========== ===========
A Nimrod program specifies a computation that acts on a memory consisting of A Nim program specifies a computation that acts on a memory consisting of
components called `locations`:idx:. A variable is basically a name for a components called `locations`:idx:. A variable is basically a name for a
location. Each variable and location is of a certain `type`:idx:. The location. Each variable and location is of a certain `type`:idx:. The
variable's type is called `static type`:idx:, the location's type is called variable's type is called `static type`:idx:, the location's type is called
@ -107,7 +107,7 @@ Lexical Analysis
Encoding Encoding
-------- --------
All Nimrod source files are in the UTF-8 encoding (or its ASCII subset). Other All Nim source files are in the UTF-8 encoding (or its ASCII subset). Other
encodings are not supported. Any of the standard platform line termination encodings are not supported. Any of the standard platform line termination
sequences can be used - the Unix form using ASCII LF (linefeed), the Windows sequences can be used - the Unix form using ASCII LF (linefeed), the Windows
form using the ASCII sequence CR LF (return followed by linefeed), or the old form using the ASCII sequence CR LF (return followed by linefeed), or the old
@ -118,13 +118,13 @@ used equally, regardless of platform.
Indentation Indentation
----------- -----------
Nimrod's standard grammar describes an `indentation sensitive`:idx: language. Nim's standard grammar describes an `indentation sensitive`:idx: language.
This means that all the control structures are recognized by indentation. This means that all the control structures are recognized by indentation.
Indentation consists only of spaces; tabulators are not allowed. Indentation consists only of spaces; tabulators are not allowed.
The indentation handling is implemented as follows: The lexer annotates the The indentation handling is implemented as follows: The lexer annotates the
following token with the preceding number of spaces; indentation is not following token with the preceding number of spaces; indentation is not
a separate token. This trick allows parsing of Nimrod with only 1 token of a separate token. This trick allows parsing of Nim with only 1 token of
lookahead. lookahead.
The parser uses a stack of indentation levels: the stack consists of integers The parser uses a stack of indentation levels: the stack consists of integers
@ -188,7 +188,7 @@ which code snippet the comment refers to.
Identifiers & Keywords Identifiers & Keywords
---------------------- ----------------------
Identifiers in Nimrod can be any string of letters, digits Identifiers in Nim can be any string of letters, digits
and underscores, beginning with a letter. Two immediate following and underscores, beginning with a letter. Two immediate following
underscores ``__`` are not allowed:: underscores ``__`` are not allowed::
@ -209,12 +209,12 @@ The following keywords are reserved and cannot be used as identifiers:
Some keywords are unused; they are reserved for future developments of the Some keywords are unused; they are reserved for future developments of the
language. language.
Nimrod is a `style-insensitive`:idx: language. This means that it is not Nim is a `style-insensitive`:idx: language. This means that it is not
case-sensitive and even underscores are ignored: case-sensitive and even underscores are ignored:
**type** is a reserved word, and so is **TYPE** or **T_Y_P_E**. The idea behind **type** is a reserved word, and so is **TYPE** or **T_Y_P_E**. The idea behind
this is that this allows programmers to use their own preferred spelling style this is that this allows programmers to use their own preferred spelling style
and libraries written by different programmers cannot use incompatible and libraries written by different programmers cannot use incompatible
conventions. A Nimrod-aware editor or IDE can show the identifiers as conventions. A Nim-aware editor or IDE can show the identifiers as
preferred. Another advantage is that it frees the programmer from remembering preferred. Another advantage is that it frees the programmer from remembering
the exact spelling of an identifier. the exact spelling of an identifier.
@ -250,7 +250,7 @@ contain the following `escape sequences`:idx:\ :
================== =================================================== ================== ===================================================
Strings in Nimrod may contain any 8-bit value, even embedded zeros. However Strings in Nim may contain any 8-bit value, even embedded zeros. However
some operations may interpret the first binary zero as a terminator. some operations may interpret the first binary zero as a terminator.
@ -317,7 +317,7 @@ identifier and the opening quotation mark) is a
generalized raw string literal. It is a shortcut for the construct generalized raw string literal. It is a shortcut for the construct
``identifier(r"string literal")``, so it denotes a procedure call with a ``identifier(r"string literal")``, so it denotes a procedure call with a
raw string literal as its only argument. Generalized raw string literals raw string literal as its only argument. Generalized raw string literals
are especially convenient for embedding mini languages directly into Nimrod are especially convenient for embedding mini languages directly into Nim
(for example regular expressions). (for example regular expressions).
The construct ``identifier"""string literal"""`` exists too. It is a shortcut The construct ``identifier"""string literal"""`` exists too. It is a shortcut
@ -357,7 +357,7 @@ literals:
A character is not an Unicode character but a single byte. The reason for this A character is not an Unicode character but a single byte. The reason for this
is efficiency: for the overwhelming majority of use-cases, the resulting is efficiency: for the overwhelming majority of use-cases, the resulting
programs will still handle UTF-8 properly as UTF-8 was specially designed for programs will still handle UTF-8 properly as UTF-8 was specially designed for
this. Another reason is that Nimrod can thus support ``array[char, int]`` or this. Another reason is that Nim can thus support ``array[char, int]`` or
``set[char]`` efficiently as many algorithms rely on this feature. The `TRune` ``set[char]`` efficiently as many algorithms rely on this feature. The `TRune`
type is used for Unicode characters, it can represent any Unicode character. type is used for Unicode characters, it can represent any Unicode character.
``TRune`` is declared in the `unicode module <unicode.html>`_. ``TRune`` is declared in the `unicode module <unicode.html>`_.
@ -441,7 +441,7 @@ is approximately 1.72826e35 according to the IEEE floating point standard.
Operators Operators
--------- ---------
In Nimrod one can define his own operators. An operator is any In Nim one can define his own operators. An operator is any
combination of the following characters:: combination of the following characters::
= + - * / < > = + - * / < >
@ -474,10 +474,10 @@ and not the two tokens `{.`:tok:, `.}`:tok:.
Syntax Syntax
====== ======
This section lists Nimrod's standard syntax. How the parser handles This section lists Nim's standard syntax. How the parser handles
the indentation is already described in the `Lexical Analysis`_ section. the indentation is already described in the `Lexical Analysis`_ section.
Nimrod allows user-definable operators. Nim allows user-definable operators.
Binary operators have 10 different levels of precedence. Binary operators have 10 different levels of precedence.
Relevant character Relevant character
@ -588,7 +588,7 @@ The grammar's start symbol is ``module``.
Types Types
===== =====
All expressions have a type which is known at compile time. Nimrod All expressions have a type which is known at compile time. Nim
is statically typed. One can declare new types, which is in essence defining is statically typed. One can declare new types, which is in essence defining
an identifier that can be used to denote this custom type. an identifier that can be used to denote this custom type.
@ -686,7 +686,7 @@ kinds of integer types are used: the smaller type is converted to the larger.
A `narrowing type conversion`:idx: converts a larger to a smaller type (for A `narrowing type conversion`:idx: converts a larger to a smaller type (for
example ``int32 -> int16``. A `widening type conversion`:idx: converts a example ``int32 -> int16``. A `widening type conversion`:idx: converts a
smaller type to a larger type (for example ``int16 -> int32``). In Nimrod only smaller type to a larger type (for example ``int16 -> int32``). In Nim only
widening type conversions are *implicit*: widening type conversions are *implicit*:
.. code-block:: nimrod .. code-block:: nimrod
@ -723,7 +723,7 @@ determined). Assignments from the base type to one of its subrange types
A subrange type has the same size as its base type (``int`` in the example). A subrange type has the same size as its base type (``int`` in the example).
Nimrod requires `interval arithmetic`:idx: for subrange types over a set Nim requires `interval arithmetic`:idx: for subrange types over a set
of built-in operators that involve constants: ``x %% 3`` is of of built-in operators that involve constants: ``x %% 3`` is of
type ``range[0..2]``. The following built-in operators for integers are type ``range[0..2]``. The following built-in operators for integers are
affected by this rule: ``-``, ``+``, ``*``, ``min``, ``max``, ``succ``, affected by this rule: ``-``, ``+``, ``*``, ``min``, ``max``, ``succ``,
@ -781,12 +781,12 @@ The IEEE standard defines five types of floating-point exceptions:
precision, for example, 2.0 / 3.0, log(1.1) and 0.1 in input. precision, for example, 2.0 / 3.0, log(1.1) and 0.1 in input.
The IEEE exceptions are either ignored at runtime or mapped to the The IEEE exceptions are either ignored at runtime or mapped to the
Nimrod exceptions: `EFloatInvalidOp`:idx:, `EFloatDivByZero`:idx:, Nim exceptions: `EFloatInvalidOp`:idx:, `EFloatDivByZero`:idx:,
`EFloatOverflow`:idx:, `EFloatUnderflow`:idx:, and `EFloatInexact`:idx:. `EFloatOverflow`:idx:, `EFloatUnderflow`:idx:, and `EFloatInexact`:idx:.
These exceptions inherit from the `EFloatingPoint`:idx: base class. These exceptions inherit from the `EFloatingPoint`:idx: base class.
Nimrod provides the pragmas `NaNChecks`:idx: and `InfChecks`:idx: to control Nim provides the pragmas `NaNChecks`:idx: and `InfChecks`:idx: to control
whether the IEEE exceptions are ignored or trap a Nimrod exception: whether the IEEE exceptions are ignored or trap a Nim exception:
.. code-block:: nimrod .. code-block:: nimrod
{.NanChecks: on, InfChecks: on.} {.NanChecks: on, InfChecks: on.}
@ -807,7 +807,7 @@ the ``+``, ``-``, ``*``, ``/`` operators for floating point types.
Boolean type Boolean type
------------ ------------
The boolean type is named `bool`:idx: in Nimrod and can be one of the two The boolean type is named `bool`:idx: in Nim and can be one of the two
pre-defined values ``true`` and ``false``. Conditions in while, pre-defined values ``true`` and ``false``. Conditions in while,
if, elif, when statements need to be of type bool. if, elif, when statements need to be of type bool.
@ -831,12 +831,12 @@ The size of the bool type is one byte.
Character type Character type
-------------- --------------
The character type is named ``char`` in Nimrod. Its size is one byte. The character type is named ``char`` in Nim. Its size is one byte.
Thus it cannot represent an UTF-8 character, but a part of it. Thus it cannot represent an UTF-8 character, but a part of it.
The reason for this is efficiency: for the overwhelming majority of use-cases, The reason for this is efficiency: for the overwhelming majority of use-cases,
the resulting programs will still handle UTF-8 properly as UTF-8 was specially the resulting programs will still handle UTF-8 properly as UTF-8 was specially
designed for this. designed for this.
Another reason is that Nimrod can support ``array[char, int]`` or Another reason is that Nim can support ``array[char, int]`` or
``set[char]`` efficiently as many algorithms rely on this feature. The ``set[char]`` efficiently as many algorithms rely on this feature. The
`TRune` type is used for Unicode characters, it can represent any Unicode `TRune` type is used for Unicode characters, it can represent any Unicode
character. ``TRune`` is declared in the `unicode module <unicode.html>`_. character. ``TRune`` is declared in the `unicode module <unicode.html>`_.
@ -916,8 +916,8 @@ via ``TMyEnum.value``:
String type String type
----------- -----------
All string literals are of the type ``string``. A string in Nimrod is very All string literals are of the type ``string``. A string in Nim is very
similar to a sequence of characters. However, strings in Nimrod are both similar to a sequence of characters. However, strings in Nim are both
zero-terminated and have a length field. One can retrieve the length with the zero-terminated and have a length field. One can retrieve the length with the
builtin ``len`` procedure; the length never counts the terminating zero. builtin ``len`` procedure; the length never counts the terminating zero.
The assignment operator for strings always copies the string. The assignment operator for strings always copies the string.
@ -949,8 +949,8 @@ interfacing with C. The index operation ``s[i]`` means the i-th *char* of
``s``; however no bounds checking for ``cstring`` is performed making the ``s``; however no bounds checking for ``cstring`` is performed making the
index operation unsafe. index operation unsafe.
A Nimrod ``string`` is implicitly convertible A Nim ``string`` is implicitly convertible
to ``cstring`` for convenience. If a Nimrod string is passed to a C-style to ``cstring`` for convenience. If a Nim string is passed to a C-style
variadic proc, it is implicitly converted to ``cstring`` too: variadic proc, it is implicitly converted to ``cstring`` too:
.. code-block:: nimrod .. code-block:: nimrod
@ -1169,7 +1169,7 @@ An example:
.. code-block:: nimrod .. code-block:: nimrod
# This is an example how an abstract syntax tree could be modelled in Nimrod # This is an example how an abstract syntax tree could be modelled in Nim
type type
TNodeKind = enum # the different node types TNodeKind = enum # the different node types
nkInt, # a leaf with an integer value nkInt, # a leaf with an integer value
@ -1230,7 +1230,7 @@ References (similar to pointers in other programming languages) are a
way to introduce many-to-one relationships. This means different references can way to introduce many-to-one relationships. This means different references can
point to and modify the same location in memory (also called `aliasing`:idx:). point to and modify the same location in memory (also called `aliasing`:idx:).
Nimrod distinguishes between `traced`:idx: and `untraced`:idx: references. Nim distinguishes between `traced`:idx: and `untraced`:idx: references.
Untraced references are also called *pointers*. Traced references point to Untraced references are also called *pointers*. Traced references point to
objects of a garbage collected heap, untraced references point to objects of a garbage collected heap, untraced references point to
manually allocated objects or to objects somewhere else in memory. Thus manually allocated objects or to objects somewhere else in memory. Thus
@ -1409,7 +1409,7 @@ Future directions:
Procedural type Procedural type
--------------- ---------------
A procedural type is internally a pointer to a procedure. ``nil`` is A procedural type is internally a pointer to a procedure. ``nil`` is
an allowed value for variables of a procedural type. Nimrod uses procedural an allowed value for variables of a procedural type. Nim uses procedural
types to achieve `functional`:idx: programming techniques. types to achieve `functional`:idx: programming techniques.
Examples: Examples:
@ -1446,10 +1446,10 @@ compatible if they have the same calling convention. As a special extension,
a procedure of the calling convention ``nimcall`` can be passed to a parameter a procedure of the calling convention ``nimcall`` can be passed to a parameter
that expects a proc of the calling convention ``closure``. that expects a proc of the calling convention ``closure``.
Nimrod supports these `calling conventions`:idx:\: Nim supports these `calling conventions`:idx:\:
`nimcall`:idx: `nimcall`:idx:
is the default convention used for a Nimrod **proc**. It is the is the default convention used for a Nim **proc**. It is the
same as ``fastcall``, but only for C compilers that support ``fastcall``. same as ``fastcall``, but only for C compilers that support ``fastcall``.
`closure`:idx: `closure`:idx:
@ -1476,7 +1476,7 @@ Nimrod supports these `calling conventions`:idx:\:
`inline`:idx: `inline`:idx:
The inline convention means the the caller should not call the procedure, The inline convention means the the caller should not call the procedure,
but inline its code directly. Note that Nimrod does not inline, but leaves but inline its code directly. Note that Nim does not inline, but leaves
this to the C compiler; it generates ``__inline`` procedures. This is this to the C compiler; it generates ``__inline`` procedures. This is
only a hint for the compiler: it may completely ignore it and only a hint for the compiler: it may completely ignore it and
it may inline procedures that are not marked as ``inline``. it may inline procedures that are not marked as ``inline``.
@ -1492,7 +1492,7 @@ Nimrod supports these `calling conventions`:idx:\:
`noconv`:idx: `noconv`:idx:
The generated C code will not have any explicit calling convention and thus The generated C code will not have any explicit calling convention and thus
use the C compiler's default calling convention. This is needed because use the C compiler's default calling convention. This is needed because
Nimrod's default calling convention for procedures is ``fastcall`` to Nim's default calling convention for procedures is ``fastcall`` to
improve speed. improve speed.
Most calling conventions exist only for the Windows 32-bit platform. Most calling conventions exist only for the Windows 32-bit platform.
@ -1636,7 +1636,7 @@ Currently only the dot accessor can be borrowed in this way.
Avoiding SQL injection attacks Avoiding SQL injection attacks
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
An SQL statement that is passed from Nimrod to an SQL database might be An SQL statement that is passed from Nim to an SQL database might be
modelled as a string. However, using string templates and filling in the modelled as a string. However, using string templates and filling in the
values is vulnerable to the famous `SQL injection attack`:idx:\: values is vulnerable to the famous `SQL injection attack`:idx:\:
@ -1745,7 +1745,7 @@ describe the type checking done by the compiler.
Type equality Type equality
------------- -------------
Nimrod uses structural type equivalence for most types. Only for objects, Nim uses structural type equivalence for most types. Only for objects,
enumerations and distinct types name equivalence is used. The following enumerations and distinct types name equivalence is used. The following
algorithm (in pseudo-code) determines type equality: algorithm (in pseudo-code) determines type equality:
@ -1932,7 +1932,7 @@ To be written.
Statements and expressions Statements and expressions
========================== ==========================
Nimrod uses the common statement/expression paradigm: Statements do not Nim uses the common statement/expression paradigm: Statements do not
produce a value in contrast to expressions. However, some expressions are produce a value in contrast to expressions. However, some expressions are
statements. statements.
@ -2079,7 +2079,7 @@ Const section
cannot change. The compiler must be able to evaluate the expression in a cannot change. The compiler must be able to evaluate the expression in a
constant declaration at compile time. constant declaration at compile time.
Nimrod contains a sophisticated compile-time evaluator, so procedures which Nim contains a sophisticated compile-time evaluator, so procedures which
have no side-effect can be used in constant expressions too: have no side-effect can be used in constant expressions too:
.. code-block:: nimrod .. code-block:: nimrod
@ -2119,7 +2119,7 @@ time.
The current implementation poses some restrictions for compile time The current implementation poses some restrictions for compile time
evaluation: Code which contains ``cast`` or makes use of the foreign function evaluation: Code which contains ``cast`` or makes use of the foreign function
interface cannot be evaluated at compile time. Later versions of Nimrod will interface cannot be evaluated at compile time. Later versions of Nim will
support the FFI at compile time. support the FFI at compile time.
@ -2374,9 +2374,9 @@ Is equivalent to:
Assembler statement Assembler statement
------------------- -------------------
The direct embedding of assembler code into Nimrod code is supported The direct embedding of assembler code into Nim code is supported
by the unsafe ``asm`` statement. Identifiers in the assembler code that refer to by the unsafe ``asm`` statement. Identifiers in the assembler code that refer to
Nimrod identifiers shall be enclosed in a special character which can be Nim identifiers shall be enclosed in a special character which can be
specified in the statement's pragmas. The default special character is ``'`'``: specified in the statement's pragmas. The default special character is ``'`'``:
.. code-block:: nimrod .. code-block:: nimrod
@ -2425,7 +2425,7 @@ Using statement
The using statement provides syntactic convenience for procs that The using statement provides syntactic convenience for procs that
heavily use a single contextual parameter. When applied to a variable or a heavily use a single contextual parameter. When applied to a variable or a
constant, it will instruct Nimrod to automatically consider the used symbol as constant, it will instruct Nim to automatically consider the used symbol as
a hidden leading parameter for any procedure calls, following the using a hidden leading parameter for any procedure calls, following the using
statement in the current scope. Thus, it behaves much like the hidden `this` statement in the current scope. Thus, it behaves much like the hidden `this`
parameter available in some object-oriented programming languages. parameter available in some object-oriented programming languages.
@ -2502,7 +2502,7 @@ The `case expression` is again very similar to the case statement:
"ice cream" "ice cream"
As seen in the above example, the case expression can also introduce side As seen in the above example, the case expression can also introduce side
effects. When multiple statements are given for a branch, Nimrod will use effects. When multiple statements are given for a branch, Nim will use
the last expression as the result value, much like in an `expr` template. the last expression as the result value, much like in an `expr` template.
Table constructor Table constructor
@ -2582,7 +2582,7 @@ Procedures
========== ==========
What most programming languages call `methods`:idx: or `functions`:idx: are What most programming languages call `methods`:idx: or `functions`:idx: are
called `procedures`:idx: in Nimrod (which is the correct terminology). A called `procedures`:idx: in Nim (which is the correct terminology). A
procedure declaration defines an identifier and associates it with a block procedure declaration defines an identifier and associates it with a block
of code. of code.
A procedure may call itself recursively. A parameter may be given a default A procedure may call itself recursively. A parameter may be given a default
@ -2672,7 +2672,7 @@ postfix notation.
Properties Properties
---------- ----------
Nimrod has no need for *get-properties*: Ordinary get-procedures that are called Nim has no need for *get-properties*: Ordinary get-procedures that are called
with the *method call syntax* achieve the same. But setting a value is with the *method call syntax* achieve the same. But setting a value is
different; for this a special setter syntax is needed: different; for this a special setter syntax is needed:
@ -2961,7 +2961,7 @@ Invocation of a multi-method cannot be ambiguous: collide 2 is preferred over
collide 1 because the resolution works from left to right. collide 1 because the resolution works from left to right.
In the example ``TUnit, TThing`` is preferred over ``TThing, TUnit``. In the example ``TUnit, TThing`` is preferred over ``TThing, TUnit``.
**Performance note**: Nimrod does not produce a virtual method table, but **Performance note**: Nim does not produce a virtual method table, but
generates dispatch trees. This avoids the expensive indirect branch for method generates dispatch trees. This avoids the expensive indirect branch for method
calls and enables inlining. However, other optimizations like compile time calls and enables inlining. However, other optimizations like compile time
evaluation or dead code elimination do not work with methods. evaluation or dead code elimination do not work with methods.
@ -3033,7 +3033,7 @@ into account.
First class iterators First class iterators
--------------------- ---------------------
There are 2 kinds of iterators in Nimrod: *inline* and *closure* iterators. There are 2 kinds of iterators in Nim: *inline* and *closure* iterators.
An `inline iterator`:idx: is an iterator that's always inlined by the compiler An `inline iterator`:idx: is an iterator that's always inlined by the compiler
leading to zero overhead for the abstraction, but may result in a heavy leading to zero overhead for the abstraction, but may result in a heavy
increase in code size. Inline iterators are second class citizens; increase in code size. Inline iterators are second class citizens;
@ -3290,7 +3290,7 @@ Effect system
Exception tracking Exception tracking
------------------ ------------------
Nimrod supports exception tracking. The `raises`:idx: pragma can be used Nim supports exception tracking. The `raises`:idx: pragma can be used
to explicitly define which exceptions a proc/iterator/method/converter is to explicitly define which exceptions a proc/iterator/method/converter is
allowed to raise. The compiler verifies this: allowed to raise. The compiler verifies this:
@ -3367,7 +3367,7 @@ conservative in its effect analysis.
Tag tracking Tag tracking
------------ ------------
The exception tracking is part of Nimrod's `effect system`:idx:. Raising an The exception tracking is part of Nim's `effect system`:idx:. Raising an
exception is an *effect*. Other effects can also be defined. A user defined exception is an *effect*. Other effects can also be defined. A user defined
effect is a means to *tag* a routine and to perform checks against this tag: effect is a means to *tag* a routine and to perform checks against this tag:
@ -3467,7 +3467,7 @@ Example:
for str in inorder(root): for str in inorder(root):
writeln(stdout, str) writeln(stdout, str)
Generics are Nimrod's means to parametrize procs, iterators or types with Generics are Nim's means to parametrize procs, iterators or types with
`type parameters`:idx:. Depending on context, the brackets are used either to `type parameters`:idx:. Depending on context, the brackets are used either to
introduce type parameters or to instantiate a generic proc, iterator or type. introduce type parameters or to instantiate a generic proc, iterator or type.
@ -3515,7 +3515,7 @@ Type Classes
A type class is a special pseudo-type that can be used to match against A type class is a special pseudo-type that can be used to match against
types in the context of overload resolution or the ``is`` operator. types in the context of overload resolution or the ``is`` operator.
Nimrod supports the following built-in type classes: Nim supports the following built-in type classes:
================== =================================================== ================== ===================================================
type class matches type class matches
@ -3553,7 +3553,7 @@ Procedures utilizing type classes in such manner are considered to be
`implicitly generic`:idx:. They will be instantiated once for each unique `implicitly generic`:idx:. They will be instantiated once for each unique
combination of param types used within the program. combination of param types used within the program.
Nimrod also allows for type classes and regular types to be specified Nim also allows for type classes and regular types to be specified
as `type constraints`:idx: of the generic type parameter: as `type constraints`:idx: of the generic type parameter:
.. code-block:: nimrod .. code-block:: nimrod
@ -3579,7 +3579,7 @@ module to illustrate this:
Alternatively, the ``distinct`` type modifier can be applied to the type class Alternatively, the ``distinct`` type modifier can be applied to the type class
to allow each param matching the type class to bind to a different type. to allow each param matching the type class to bind to a different type.
If a proc param doesn't have a type specified, Nimrod will use the If a proc param doesn't have a type specified, Nim will use the
``distinct auto`` type class (also known as ``any``): ``distinct auto`` type class (also known as ``any``):
.. code-block:: nimrod .. code-block:: nimrod
@ -3675,7 +3675,7 @@ Return Type Inference
--------------------- ---------------------
If a type class is used as the return type of a proc and it won't be bound to If a type class is used as the return type of a proc and it won't be bound to
a concrete type by some of the proc params, Nimrod will infer the return type a concrete type by some of the proc params, Nim will infer the return type
from the proc body. This is usually used with the ``auto`` type class: from the proc body. This is usually used with the ``auto`` type class:
.. code-block:: nimrod .. code-block:: nimrod
@ -3684,7 +3684,7 @@ from the proc body. This is usually used with the ``auto`` type class:
The return type will be treated as additional generic param and can be The return type will be treated as additional generic param and can be
explicitly specified at call sites as any other generic param. explicitly specified at call sites as any other generic param.
Future versions of Nimrod may also support overloading based on the return type Future versions of Nim may also support overloading based on the return type
of the overloads. In such settings, the expected result type at call sites may of the overloads. In such settings, the expected result type at call sites may
also influence the inferred return type. also influence the inferred return type.
@ -3760,7 +3760,7 @@ Templates
========= =========
A template is a simple form of a macro: It is a simple substitution A template is a simple form of a macro: It is a simple substitution
mechanism that operates on Nimrod's abstract syntax trees. It is processed in mechanism that operates on Nim's abstract syntax trees. It is processed in
the semantic pass of the compiler. the semantic pass of the compiler.
The syntax to *invoke* a template is the same as calling a procedure. The syntax to *invoke* a template is the same as calling a procedure.
@ -3991,10 +3991,10 @@ to implement `domain specific languages`:idx:. Like templates, macros come in
the 2 flavors *immediate* and *ordinary*. the 2 flavors *immediate* and *ordinary*.
While macros enable advanced compile-time code transformations, they While macros enable advanced compile-time code transformations, they
cannot change Nimrod's syntax. However, this is no real restriction because cannot change Nim's syntax. However, this is no real restriction because
Nimrod's syntax is flexible enough anyway. Nim's syntax is flexible enough anyway.
To write macros, one needs to know how the Nimrod concrete syntax is converted To write macros, one needs to know how the Nim concrete syntax is converted
to an abstract syntax tree. to an abstract syntax tree.
There are two ways to invoke a macro: There are two ways to invoke a macro:
@ -4009,12 +4009,12 @@ The following example implements a powerful ``debug`` command that accepts a
variable number of arguments: variable number of arguments:
.. code-block:: nimrod .. code-block:: nimrod
# to work with Nimrod syntax trees, we need an API that is defined in the # to work with Nim syntax trees, we need an API that is defined in the
# ``macros`` module: # ``macros`` module:
import macros import macros
macro debug(n: varargs[expr]): stmt = macro debug(n: varargs[expr]): stmt =
# `n` is a Nimrod AST that contains the whole macro invocation # `n` is a Nim AST that contains the whole macro invocation
# this macro returns a list of statements: # this macro returns a list of statements:
result = newNimNode(nnkStmtList, n) result = newNimNode(nnkStmtList, n)
# iterate over any argument that is passed to this macro: # iterate over any argument that is passed to this macro:
@ -4313,14 +4313,14 @@ Special Operators
dot operators dot operators
------------- -------------
Nimrod offers a special family of dot operators that can be used to Nim offers a special family of dot operators that can be used to
intercept and rewrite proc call and field access attempts, referring intercept and rewrite proc call and field access attempts, referring
to previously undeclared symbol names. They can be used to provide a to previously undeclared symbol names. They can be used to provide a
fluent interface to objects lying outside the static confines of the fluent interface to objects lying outside the static confines of the
type system such as values from dynamic scripting languages type system such as values from dynamic scripting languages
or dynamic file formats such as JSON or XML. or dynamic file formats such as JSON or XML.
When Nimrod encounters an expression that cannot be resolved by the When Nim encounters an expression that cannot be resolved by the
standard overload resolution rules, the current scope will be searched standard overload resolution rules, the current scope will be searched
for a dot operator that can be matched against a re-written form of for a dot operator that can be matched against a re-written form of
the expression, where the unknown field or proc name is converted to the expression, where the unknown field or proc name is converted to
@ -4504,7 +4504,7 @@ is **wrong**:
echo f() * 2 echo f() * 2
We cannot duplicate 'a' if it denotes an expression that has a side effect! We cannot duplicate 'a' if it denotes an expression that has a side effect!
Fortunately Nimrod supports side effect analysis: Fortunately Nim supports side effect analysis:
.. code-block:: nimrod .. code-block:: nimrod
template optMul{`*`(a, 2)}(a: int{noSideEffect}): int = a+a template optMul{`*`(a, 2)}(a: int{noSideEffect}): int = a+a
@ -4835,7 +4835,7 @@ optimization for types that have copying semantics:
Modules Modules
======= =======
Nimrod supports splitting a program into pieces by a module concept. Nim supports splitting a program into pieces by a module concept.
Each module needs to be in its own file and has its own `namespace`:idx:. Each module needs to be in its own file and has its own `namespace`:idx:.
Modules enable `information hiding`:idx: and `separate compilation`:idx:. Modules enable `information hiding`:idx: and `separate compilation`:idx:.
A module may gain access to symbols of another module by the `import`:idx: A module may gain access to symbols of another module by the `import`:idx:
@ -5023,7 +5023,7 @@ iterator in which case the overloading resolution takes place:
Compiler Messages Compiler Messages
================= =================
The Nimrod compiler emits different kinds of messages: `hint`:idx:, The Nim compiler emits different kinds of messages: `hint`:idx:,
`warning`:idx:, and `error`:idx: messages. An *error* message is emitted if `warning`:idx:, and `error`:idx: messages. An *error* message is emitted if
the compiler encounters any static error. the compiler encounters any static error.
@ -5031,7 +5031,7 @@ the compiler encounters any static error.
Pragmas Pragmas
======= =======
Pragmas are Nimrod's method to give the compiler additional information / Pragmas are Nim's method to give the compiler additional information /
commands without introducing a massive number of new keywords. Pragmas are commands without introducing a massive number of new keywords. Pragmas are
processed on the fly during semantic checking. Pragmas are enclosed in the processed on the fly during semantic checking. Pragmas are enclosed in the
special ``{.`` and ``.}`` curly brackets. Pragmas are also often used as a special ``{.`` and ``.}`` curly brackets. Pragmas are also often used as a
@ -5133,7 +5133,7 @@ shallow pragma
The ``shallow`` pragma affects the semantics of a type: The compiler is The ``shallow`` pragma affects the semantics of a type: The compiler is
allowed to make a shallow copy. This can cause serious semantic issues and allowed to make a shallow copy. This can cause serious semantic issues and
break memory safety! However, it can speed up assignments considerably, break memory safety! However, it can speed up assignments considerably,
because the semantics of Nimrod require deep copying of sequences and strings. because the semantics of Nim require deep copying of sequences and strings.
This can be expensive, especially if sequences are used to build a tree This can be expensive, especially if sequences are used to build a tree
structure: structure:
@ -5223,7 +5223,7 @@ If the ``line`` pragma is used with a parameter, the parameter needs be a
linearScanEnd pragma linearScanEnd pragma
-------------------- --------------------
The ``linearScanEnd`` pragma can be used to tell the compiler how to The ``linearScanEnd`` pragma can be used to tell the compiler how to
compile a Nimrod `case`:idx: statement. Syntactically it has to be used as a compile a Nim `case`:idx: statement. Syntactically it has to be used as a
statement: statement:
.. code-block:: nimrod .. code-block:: nimrod
@ -5251,7 +5251,7 @@ whole ``case`` statement, the whole ``case`` statement uses linear scanning.
computedGoto pragma computedGoto pragma
------------------- -------------------
The ``computedGoto`` pragma can be used to tell the compiler how to The ``computedGoto`` pragma can be used to tell the compiler how to
compile a Nimrod `case`:idx: in a ``while true`` statement. compile a Nim `case`:idx: in a ``while true`` statement.
Syntactically it has to be used as a statement inside the loop: Syntactically it has to be used as a statement inside the loop:
.. code-block:: nimrod .. code-block:: nimrod
@ -5469,7 +5469,7 @@ Pragma pragma
------------- -------------
The ``pragma`` pragma can be used to declare user defined pragmas. This is The ``pragma`` pragma can be used to declare user defined pragmas. This is
useful because Nimrod's templates and macros do not affect pragmas. User useful because Nim's templates and macros do not affect pragmas. User
defined pragmas are in a different module-wide scope than all other symbols. defined pragmas are in a different module-wide scope than all other symbols.
They cannot be imported from a module. They cannot be imported from a module.
@ -5491,12 +5491,12 @@ generation.
Disabling certain messages Disabling certain messages
-------------------------- --------------------------
Nimrod generates some warnings and hints ("line too long") that may annoy the Nim generates some warnings and hints ("line too long") that may annoy the
user. A mechanism for disabling certain messages is provided: Each hint user. A mechanism for disabling certain messages is provided: Each hint
and warning message contains a symbol in brackets. This is the message's and warning message contains a symbol in brackets. This is the message's
identifier that can be used to enable or disable it: identifier that can be used to enable or disable it:
.. code-block:: Nimrod .. code-block:: Nim
{.hint[LineTooLong]: off.} # turn off the hint about too long lines {.hint[LineTooLong]: off.} # turn off the hint about too long lines
This is often better than disabling all warnings at once. This is often better than disabling all warnings at once.
@ -5505,7 +5505,7 @@ This is often better than disabling all warnings at once.
Foreign function interface Foreign function interface
========================== ==========================
Nimrod's `FFI`:idx: (foreign function interface) is extensive and only the Nim's `FFI`:idx: (foreign function interface) is extensive and only the
parts that scale to other future backends (like the LLVM/JavaScript backends) parts that scale to other future backends (like the LLVM/JavaScript backends)
are documented here. are documented here.
@ -5514,7 +5514,7 @@ Importc pragma
-------------- --------------
The ``importc`` pragma provides a means to import a proc or a variable The ``importc`` pragma provides a means to import a proc or a variable
from C. The optional argument is a string containing the C identifier. If from C. The optional argument is a string containing the C identifier. If
the argument is missing, the C name is the Nimrod identifier *exactly as the argument is missing, the C name is the Nim identifier *exactly as
spelled*: spelled*:
.. code-block:: .. code-block::
@ -5532,9 +5532,9 @@ Exportc pragma
The ``exportc`` pragma provides a means to export a type, a variable, or a The ``exportc`` pragma provides a means to export a type, a variable, or a
procedure to C. Enums and constants can't be exported. The optional argument procedure to C. Enums and constants can't be exported. The optional argument
is a string containing the C identifier. If the argument is missing, the C is a string containing the C identifier. If the argument is missing, the C
name is the Nimrod identifier *exactly as spelled*: name is the Nim identifier *exactly as spelled*:
.. code-block:: Nimrod .. code-block:: Nim
proc callme(formatstr: cstring) {.exportc: "callMe", varargs.} proc callme(formatstr: cstring) {.exportc: "callMe", varargs.}
Note that this pragma is somewhat of a misnomer: Other backends will provide Note that this pragma is somewhat of a misnomer: Other backends will provide
@ -5546,7 +5546,7 @@ Extern pragma
Like ``exportc`` or ``importc``, the ``extern`` pragma affects name Like ``exportc`` or ``importc``, the ``extern`` pragma affects name
mangling. The string literal passed to ``extern`` can be a format string: mangling. The string literal passed to ``extern`` can be a format string:
.. code-block:: Nimrod .. code-block:: Nim
proc p(s: string) {.extern: "prefix$1".} = proc p(s: string) {.extern: "prefix$1".} =
echo s echo s
@ -5575,11 +5575,11 @@ the compiler to pass the type by reference (hidden pointer) to procs.
Varargs pragma Varargs pragma
-------------- --------------
The ``varargs`` pragma can be applied to procedures only (and procedure The ``varargs`` pragma can be applied to procedures only (and procedure
types). It tells Nimrod that the proc can take a variable number of parameters types). It tells Nim that the proc can take a variable number of parameters
after the last specified parameter. Nimrod string values will be converted to C after the last specified parameter. Nim string values will be converted to C
strings automatically: strings automatically:
.. code-block:: Nimrod .. code-block:: Nim
proc printf(formatstr: cstring) {.nodecl, varargs.} proc printf(formatstr: cstring) {.nodecl, varargs.}
printf("hallo %s", "world") # "world" will be passed as C string printf("hallo %s", "world") # "world" will be passed as C string
@ -5648,7 +5648,7 @@ With the ``dynlib`` pragma a procedure or a variable can be imported from
a dynamic library (``.dll`` files for Windows, ``lib*.so`` files for UNIX). a dynamic library (``.dll`` files for Windows, ``lib*.so`` files for UNIX).
The non-optional argument has to be the name of the dynamic library: The non-optional argument has to be the name of the dynamic library:
.. code-block:: Nimrod .. code-block:: Nim
proc gtk_image_new(): PGtkWidget proc gtk_image_new(): PGtkWidget
{.cdecl, dynlib: "libgtk-x11-2.0.so", importc.} {.cdecl, dynlib: "libgtk-x11-2.0.so", importc.}
@ -5706,7 +5706,7 @@ With the ``dynlib`` pragma a procedure can also be exported to
a dynamic library. The pragma then has no argument and has to be used in a dynamic library. The pragma then has no argument and has to be used in
conjunction with the ``exportc`` pragma: conjunction with the ``exportc`` pragma:
.. code-block:: Nimrod .. code-block:: Nim
proc exportme(): int {.cdecl, exportc, dynlib.} proc exportme(): int {.cdecl, exportc, dynlib.}
This is only useful if the program is compiled as a dynamic library via the This is only useful if the program is compiled as a dynamic library via the
@ -5721,7 +5721,7 @@ be used. The ``system`` module then contains several threading primitives.
See the `threads <threads.html>`_ and `channels <channels.html>`_ modules See the `threads <threads.html>`_ and `channels <channels.html>`_ modules
for the thread API. for the thread API.
Nimrod's memory model for threads is quite different than that of other common Nim's memory model for threads is quite different than that of other common
programming languages (C, Pascal, Java): Each thread has its own (garbage programming languages (C, Pascal, Java): Each thread has its own (garbage
collected) heap and sharing of memory is restricted to global variables. This collected) heap and sharing of memory is restricted to global variables. This
helps to prevent race conditions. GC efficiency is improved quite a lot, helps to prevent race conditions. GC efficiency is improved quite a lot,
@ -5797,7 +5797,7 @@ exception in one thread terminates the whole *process*!
Spawn Spawn
----- -----
Nimrod has a builtin thread pool that can be used for CPU intensive tasks. For Nim has a builtin thread pool that can be used for CPU intensive tasks. For
IO intensive tasks the upcoming ``async`` and ``await`` features should be IO intensive tasks the upcoming ``async`` and ``await`` features should be
used instead. `spawn`:idx: is used to pass a task to the thread pool: used instead. `spawn`:idx: is used to pass a task to the thread pool:
@ -5828,7 +5828,7 @@ Currently the expression that ``spawn`` takes is however quite restricted:
Taint mode Taint mode
========== ==========
The Nimrod compiler and most parts of the standard library support The Nim compiler and most parts of the standard library support
a taint mode. Input strings are declared with the `TaintedString`:idx: a taint mode. Input strings are declared with the `TaintedString`:idx:
string type declared in the ``system`` module. string type declared in the ``system`` module.

192
doc/nimrodc.txt
View file

@ -1,9 +1,9 @@
=================================== ===================================
Nimrod Compiler User Guide Nim Compiler User Guide
=================================== ===================================
:Author: Andreas Rumpf :Author: Andreas Rumpf
:Version: |nimrodversion| :Version: |nimversion|
.. contents:: .. contents::
@ -15,11 +15,11 @@
Introduction Introduction
============ ============
This document describes the usage of the *Nimrod compiler* This document describes the usage of the *Nim compiler*
on the different supported platforms. It is not a definition of the Nimrod on the different supported platforms. It is not a definition of the Nim
programming language (therefore is the `manual <manual.html>`_). programming language (therefore is the `manual <manual.html>`_).
Nimrod is free software; it is licensed under the Nim is free software; it is licensed under the
`MIT License <http://www.opensource.org/licenses/mit-license.php>`_. `MIT License <http://www.opensource.org/licenses/mit-license.php>`_.
@ -107,14 +107,14 @@ Configuration files
passed as a command line argument to the compiler. passed as a command line argument to the compiler.
The ``nimrod`` executable processes configuration files in the following The ``nim`` executable processes configuration files in the following
directories (in this order; later files overwrite previous settings): directories (in this order; later files overwrite previous settings):
1) ``$nimrod/config/nimrod.cfg``, ``/etc/nimrod.cfg`` (UNIX) or ``%NIMROD%/config/nimrod.cfg`` (Windows). This file can be skipped with the ``--skipCfg`` command line option. 1) ``$nim/config/nim.cfg``, ``/etc/nim.cfg`` (UNIX) or ``%NIMROD%/config/nim.cfg`` (Windows). This file can be skipped with the ``--skipCfg`` command line option.
2) ``/home/$user/.config/nimrod.cfg`` (UNIX) or ``%APPDATA%/nimrod.cfg`` (Windows). This file can be skipped with the ``--skipUserCfg`` command line option. 2) ``/home/$user/.config/nim.cfg`` (UNIX) or ``%APPDATA%/nim.cfg`` (Windows). This file can be skipped with the ``--skipUserCfg`` command line option.
3) ``$parentDir/nimrod.cfg`` where ``$parentDir`` stands for any parent directory of the project file's path. These files can be skipped with the ``--skipParentCfg`` command line option. 3) ``$parentDir/nim.cfg`` where ``$parentDir`` stands for any parent directory of the project file's path. These files can be skipped with the ``--skipParentCfg`` command line option.
4) ``$projectDir/nimrod.cfg`` where ``$projectDir`` stands for the project file's path. This file can be skipped with the ``--skipProjCfg`` command line option. 4) ``$projectDir/nim.cfg`` where ``$projectDir`` stands for the project file's path. This file can be skipped with the ``--skipProjCfg`` command line option.
5) A project can also have a project specific configuration file named ``$project.nimrod.cfg`` that resides in the same directory as ``$project.nim``. This file can be skipped with the ``--skipProjCfg`` command line option. 5) A project can also have a project specific configuration file named ``$project.nim.cfg`` that resides in the same directory as ``$project.nim``. This file can be skipped with the ``--skipProjCfg`` command line option.
Command line settings have priority over configuration file settings. Command line settings have priority over configuration file settings.
@ -122,17 +122,17 @@ Command line settings have priority over configuration file settings.
The default build of a project is a `debug build`:idx:. To compile a The default build of a project is a `debug build`:idx:. To compile a
`release build`:idx: define the ``release`` symbol:: `release build`:idx: define the ``release`` symbol::
nimrod c -d:release myproject.nim nim c -d:release myproject.nim
Search path handling Search path handling
-------------------- --------------------
Nimrod has the concept of a global search path (PATH) that is queried to Nim has the concept of a global search path (PATH) that is queried to
determine where to find imported modules or include files. If multiple files are determine where to find imported modules or include files. If multiple files are
found an ambiguity error is produced. found an ambiguity error is produced.
``nimrod dump`` shows the contents of the PATH. ``nim dump`` shows the contents of the PATH.
However before the PATH is used the current directory is checked for the However before the PATH is used the current directory is checked for the
file's existance. So if PATH contains ``$lib`` and ``$lib/bar`` and the file's existance. So if PATH contains ``$lib`` and ``$lib/bar`` and the
@ -152,10 +152,10 @@ the first matching file is used.
Generated C code directory Generated C code directory
-------------------------- --------------------------
The generated files that Nimrod produces all go into a subdirectory called The generated files that Nim produces all go into a subdirectory called
``nimcache`` in your project directory. This makes it easy to delete all ``nimcache`` in your project directory. This makes it easy to delete all
generated files. Files generated in this directory follow a naming logic which generated files. Files generated in this directory follow a naming logic which
you can read about in the `Nimrod Backend Integration document you can read about in the `Nim Backend Integration document
<backends.html#nimcache-naming-logic>`_. <backends.html#nimcache-naming-logic>`_.
However, the generated C code is not platform independent. C code generated for However, the generated C code is not platform independent. C code generated for
@ -190,14 +190,14 @@ Cross compilation
To cross compile, use for example:: To cross compile, use for example::
nimrod c --cpu:i386 --os:linux --compile_only --gen_script myproject.nim nim c --cpu:i386 --os:linux --compile_only --gen_script myproject.nim
Then move the C code and the compile script ``compile_myproject.sh`` to your Then move the C code and the compile script ``compile_myproject.sh`` to your
Linux i386 machine and run the script. Linux i386 machine and run the script.
Another way is to make Nimrod invoke a cross compiler toolchain:: Another way is to make Nim invoke a cross compiler toolchain::
nimrod c --cpu:arm --os:linux myproject.nim nim c --cpu:arm --os:linux myproject.nim
For cross compilation, the compiler invokes a C compiler named For cross compilation, the compiler invokes a C compiler named
like ``$cpu.$os.$cc`` (for example arm.linux.gcc) and the configuration like ``$cpu.$os.$cc`` (for example arm.linux.gcc) and the configuration
@ -212,16 +212,16 @@ configuration file should contain something like::
DLL generation DLL generation
============== ==============
Nimrod supports the generation of DLLs. However, there must be only one Nim supports the generation of DLLs. However, there must be only one
instance of the GC per process/address space. This instance is contained in instance of the GC per process/address space. This instance is contained in
``nimrtl.dll``. This means that every generated Nimrod DLL depends ``nimrtl.dll``. This means that every generated Nim DLL depends
on ``nimrtl.dll``. To generate the "nimrtl.dll" file, use the command:: on ``nimrtl.dll``. To generate the "nimrtl.dll" file, use the command::
nimrod c -d:release lib/nimrtl.nim nim c -d:release lib/nimrtl.nim
To link against ``nimrtl.dll`` use the command:: To link against ``nimrtl.dll`` use the command::
nimrod c -d:useNimRtl myprog.nim nim c -d:useNimRtl myprog.nim
**Note**: Currently the creation of ``nimrtl.dll`` with thread support has **Note**: Currently the creation of ``nimrtl.dll`` with thread support has
never been tested and is unlikely to work! never been tested and is unlikely to work!
@ -243,9 +243,9 @@ Define Effect
version. version.
``useFork`` Makes ``osproc`` use ``fork`` instead of ``posix_spawn``. ``useFork`` Makes ``osproc`` use ``fork`` instead of ``posix_spawn``.
``useNimRtl`` Compile and link against ``nimrtl.dll``. ``useNimRtl`` Compile and link against ``nimrtl.dll``.
``useMalloc`` Makes Nimrod use C's `malloc`:idx: instead of Nimrod's ``useMalloc`` Makes Nim use C's `malloc`:idx: instead of Nim's
own memory manager. This only works with ``gc:none``. own memory manager. This only works with ``gc:none``.
``useRealtimeGC`` Enables support of Nimrod's GC for *soft* realtime ``useRealtimeGC`` Enables support of Nim's GC for *soft* realtime
systems. See the documentation of the `gc <gc.html>`_ systems. See the documentation of the `gc <gc.html>`_
for further information. for further information.
``nodejs`` The JS target is actually ``node.js``. ``nodejs`` The JS target is actually ``node.js``.
@ -258,8 +258,8 @@ Define Effect
Additional Features Additional Features
=================== ===================
This section describes Nimrod's additional features that are not listed in the This section describes Nim's additional features that are not listed in the
Nimrod manual. Some of the features here only make sense for the C code Nim manual. Some of the features here only make sense for the C code
generator and are subject to change. generator and are subject to change.
@ -267,13 +267,13 @@ NoDecl pragma
------------- -------------
The ``noDecl`` pragma can be applied to almost any symbol (variable, proc, The ``noDecl`` pragma can be applied to almost any symbol (variable, proc,
type, etc.) and is sometimes useful for interoperability with C: type, etc.) and is sometimes useful for interoperability with C:
It tells Nimrod that it should not generate a declaration for the symbol in It tells Nim that it should not generate a declaration for the symbol in
the C code. For example: the C code. For example:
.. code-block:: Nimrod .. code-block:: Nim
var var
EACCES {.importc, noDecl.}: cint # pretend EACCES was a variable, as EACCES {.importc, noDecl.}: cint # pretend EACCES was a variable, as
# Nimrod does not know its value # Nim does not know its value
However, the ``header`` pragma is often the better alternative. However, the ``header`` pragma is often the better alternative.
@ -286,14 +286,14 @@ The ``header`` pragma is very similar to the ``noDecl`` pragma: It can be
applied to almost any symbol and specifies that it should not be declared applied to almost any symbol and specifies that it should not be declared
and instead the generated code should contain an ``#include``: and instead the generated code should contain an ``#include``:
.. code-block:: Nimrod .. code-block:: Nim
type type
PFile {.importc: "FILE*", header: "<stdio.h>".} = distinct pointer PFile {.importc: "FILE*", header: "<stdio.h>".} = distinct pointer
# import C's FILE* type; Nimrod will treat it as a new pointer type # import C's FILE* type; Nim will treat it as a new pointer type
The ``header`` pragma always expects a string constant. The string contant The ``header`` pragma always expects a string constant. The string contant
contains the header file: As usual for C, a system header file is enclosed contains the header file: As usual for C, a system header file is enclosed
in angle brackets: ``<>``. If no angle brackets are given, Nimrod in angle brackets: ``<>``. If no angle brackets are given, Nim
encloses the header file in ``""`` in the generated C code. encloses the header file in ``""`` in the generated C code.
**Note**: This will not work for the LLVM backend. **Note**: This will not work for the LLVM backend.
@ -304,7 +304,7 @@ IncompleteStruct pragma
The ``incompleteStruct`` pragma tells the compiler to not use the The ``incompleteStruct`` pragma tells the compiler to not use the
underlying C ``struct`` in a ``sizeof`` expression: underlying C ``struct`` in a ``sizeof`` expression:
.. code-block:: Nimrod .. code-block:: Nim
type type
TDIR* {.importc: "DIR", header: "<dirent.h>", TDIR* {.importc: "DIR", header: "<dirent.h>",
final, pure, incompleteStruct.} = object final, pure, incompleteStruct.} = object
@ -315,10 +315,10 @@ Compile pragma
The ``compile`` pragma can be used to compile and link a C/C++ source file The ``compile`` pragma can be used to compile and link a C/C++ source file
with the project: with the project:
.. code-block:: Nimrod .. code-block:: Nim
{.compile: "myfile.cpp".} {.compile: "myfile.cpp".}
**Note**: Nimrod computes a CRC checksum and only recompiles the file if it **Note**: Nim computes a CRC checksum and only recompiles the file if it
has changed. You can use the ``-f`` command line option to force recompilation has changed. You can use the ``-f`` command line option to force recompilation
of the file. of the file.
@ -327,7 +327,7 @@ Link pragma
----------- -----------
The ``link`` pragma can be used to link an additional file with the project: The ``link`` pragma can be used to link an additional file with the project:
.. code-block:: Nimrod .. code-block:: Nim
{.link: "myfile.o".} {.link: "myfile.o".}
@ -336,13 +336,13 @@ PassC pragma
The ``passC`` pragma can be used to pass additional parameters to the C The ``passC`` pragma can be used to pass additional parameters to the C
compiler like you would using the commandline switch ``--passC``: compiler like you would using the commandline switch ``--passC``:
.. code-block:: Nimrod .. code-block:: Nim
{.passC: "-Wall -Werror".} {.passC: "-Wall -Werror".}
Note that you can use ``gorge`` from the `system module <system.html>`_ to Note that you can use ``gorge`` from the `system module <system.html>`_ to
embed parameters from an external command at compile time: embed parameters from an external command at compile time:
.. code-block:: Nimrod .. code-block:: Nim
{.passC: gorge("pkg-config --cflags sdl").} {.passC: gorge("pkg-config --cflags sdl").}
PassL pragma PassL pragma
@ -350,13 +350,13 @@ PassL pragma
The ``passL`` pragma can be used to pass additional parameters to the linker The ``passL`` pragma can be used to pass additional parameters to the linker
like you would using the commandline switch ``--passL``: like you would using the commandline switch ``--passL``:
.. code-block:: Nimrod .. code-block:: Nim
{.passL: "-lSDLmain -lSDL".} {.passL: "-lSDLmain -lSDL".}
Note that you can use ``gorge`` from the `system module <system.html>`_ to Note that you can use ``gorge`` from the `system module <system.html>`_ to
embed parameters from an external command at compile time: embed parameters from an external command at compile time:
.. code-block:: Nimrod .. code-block:: Nim
{.passL: gorge("pkg-config --libs sdl").} {.passL: gorge("pkg-config --libs sdl").}
@ -369,16 +369,16 @@ extremely useful for interfacing with `C++`:idx: or `Objective C`:idx: code.
Example: Example:
.. code-block:: Nimrod .. code-block:: Nim
{.emit: """ {.emit: """
static int cvariable = 420; static int cvariable = 420;
""".} """.}
{.push stackTrace:off.} {.push stackTrace:off.}
proc embedsC() = proc embedsC() =
var nimrodVar = 89 var nimVar = 89
# use backticks to access Nimrod symbols within an emit section: # use backticks to access Nim symbols within an emit section:
{.emit: """fprintf(stdout, "%d\n", cvariable + (int)`nimrodVar`);""".} {.emit: """fprintf(stdout, "%d\n", cvariable + (int)`nimVar`);""".}
{.pop.} {.pop.}
embedsC() embedsC()
@ -392,7 +392,7 @@ code then uses the C++ method calling syntax: ``obj->method(arg)``. In
addition with the ``header`` and ``emit`` pragmas this allows *sloppy* addition with the ``header`` and ``emit`` pragmas this allows *sloppy*
interfacing with libraries written in C++: interfacing with libraries written in C++:
.. code-block:: Nimrod .. code-block:: Nim
# Horrible example of how to interface with a C++ engine ... ;-) # Horrible example of how to interface with a C++ engine ... ;-)
{.link: "/usr/lib/libIrrlicht.so".} {.link: "/usr/lib/libIrrlicht.so".}
@ -431,7 +431,7 @@ generated code then uses the Objective C method calling syntax: ``[obj method
param1: arg]``. In addition with the ``header`` and ``emit`` pragmas this param1: arg]``. In addition with the ``header`` and ``emit`` pragmas this
allows *sloppy* interfacing with libraries written in Objective C: allows *sloppy* interfacing with libraries written in Objective C:
.. code-block:: Nimrod .. code-block:: Nim
# horrible example of how to interface with GNUStep ... # horrible example of how to interface with GNUStep ...
{.passL: "-lobjc".} {.passL: "-lobjc".}
@ -475,11 +475,11 @@ emits Objective C code.
CodegenDecl pragma CodegenDecl pragma
------------------ ------------------
The ``codegenDecl`` pragma can be used to directly influence Nimrod's code The ``codegenDecl`` pragma can be used to directly influence Nim's code
generator. It receives a format string that determines how the variable or generator. It receives a format string that determines how the variable or
proc is declared in the generated code: proc is declared in the generated code:
.. code-block:: nimrod .. code-block:: nim
var var
a {.codegenDecl: "$# progmem $#".}: int a {.codegenDecl: "$# progmem $#".}: int
@ -494,7 +494,7 @@ The ``injectStmt`` pragma can be used to inject a statement before every
other statement in the current module. It is only supposed to be used for other statement in the current module. It is only supposed to be used for
debugging: debugging:
.. code-block:: nimrod .. code-block:: nim
{.injectStmt: gcInvariants().} {.injectStmt: gcInvariants().}
# ... complex code here that produces crashes ... # ... complex code here that produces crashes ...
@ -523,7 +523,7 @@ is raised.
Debugger option Debugger option
--------------- ---------------
The ``debugger`` option enables or disables the *Embedded Nimrod Debugger*. The ``debugger`` option enables or disables the *Embedded Nim Debugger*.
See the documentation of endb_ for further information. See the documentation of endb_ for further information.
@ -545,11 +545,11 @@ in C/C++).
Source code style Source code style
================= =================
Nimrod allows you to `mix freely case and underscores as identifier separators Nim allows you to `mix freely case and underscores as identifier separators
<manual.html#identifiers-keywords>`_, so variables named ``MyPrecioussInt`` and <manual.html#identifiers-keywords>`_, so variables named ``MyPrecioussInt`` and
``my_preciouss_int`` are equivalent: ``my_preciouss_int`` are equivalent:
.. code-block:: Nimrod .. code-block:: Nim
var MyPrecioussInt = 3 var MyPrecioussInt = 3
# Following line compiles fine! # Following line compiles fine!
echo my_preciouss_int echo my_preciouss_int
@ -557,16 +557,16 @@ Nimrod allows you to `mix freely case and underscores as identifier separators
Since this can lead to many variants of the same source code (you can use Since this can lead to many variants of the same source code (you can use
`nimgrep <nimgrep.html>`_ instead of your typical ``grep`` to ignore style `nimgrep <nimgrep.html>`_ instead of your typical ``grep`` to ignore style
problems) the compiler provides the command ``pretty`` to help unifying the problems) the compiler provides the command ``pretty`` to help unifying the
style of source code. Running ``nimrod pretty ugly_test.nim`` with this style of source code. Running ``nim pretty ugly_test.nim`` with this
example will generate a secondary file named ``ugly_test.pretty.nim`` with the example will generate a secondary file named ``ugly_test.pretty.nim`` with the
following content: following content:
.. code-block:: Nimrod .. code-block:: Nim
var MyPrecioussInt = 3 var MyPrecioussInt = 3
# Following line compiles fine! # Following line compiles fine!
echo MyPrecioussInt echo MyPrecioussInt
During execution the ``pretty`` command will also run on Nimrod's standard During execution the ``pretty`` command will also run on Nim's standard
library, since it doesn't differentiate the standard library as something library, since it doesn't differentiate the standard library as something
special, and hence will warn of many *errors* which are out of your hand to special, and hence will warn of many *errors* which are out of your hand to
fix, creating respective ``.pretty.nim`` files all the way. You can ignore fix, creating respective ``.pretty.nim`` files all the way. You can ignore
@ -583,11 +583,11 @@ important changes for you to review. In this case the command is warning that a
variable name should not start with a capital letter, which is usually reserved variable name should not start with a capital letter, which is usually reserved
to `object types <tut2.html#objects>`_. To learn about the accepted `camel case to `object types <tut2.html#objects>`_. To learn about the accepted `camel case
style <https://en.wikipedia.org/wiki/Camelcase>`_ read `Coding Guidelines in style <https://en.wikipedia.org/wiki/Camelcase>`_ read `Coding Guidelines in
the Internals of Nimrod Compiler <intern.html#coding-guidelines>`_ or `Coding the Internals of Nim Compiler <intern.html#coding-guidelines>`_ or `Coding
Guidelines <https://github.com/Araq/Nimrod/wiki/Coding-Guidelines>`_ and `NEP 1 Guidelines <https://github.com/Araq/Nim/wiki/Coding-Guidelines>`_ and `NEP 1
: Style Guide for Nimrod Code : Style Guide for Nim Code
<https://github.com/Araq/Nimrod/wiki/NEP-1-:-Style-Guide-for-Nimrod-Code>`_ <https://github.com/Araq/Nim/wiki/NEP-1-:-Style-Guide-for-Nim-Code>`_
from the Nimrod `GitHub wiki<https://github.com/Araq/Nimrod/wiki>`_. from the Nim `GitHub wiki<https://github.com/Araq/Nim/wiki>`_.
This command is safe to run because it will never attempt to overwrite your This command is safe to run because it will never attempt to overwrite your
existing sources, but the respective ``.pretty.nim`` files **will** be existing sources, but the respective ``.pretty.nim`` files **will** be
@ -597,14 +597,14 @@ overwritten without notice.
DynlibOverride DynlibOverride
============== ==============
By default Nimrod's ``dynlib`` pragma causes the compiler to generate By default Nim's ``dynlib`` pragma causes the compiler to generate
``GetProcAddress`` (or their Unix counterparts) ``GetProcAddress`` (or their Unix counterparts)
calls to bind to a DLL. With the ``dynlibOverride`` command line switch this calls to bind to a DLL. With the ``dynlibOverride`` command line switch this
can be prevented and then via ``--passL`` the static library can be linked can be prevented and then via ``--passL`` the static library can be linked
against. For instance, to link statically against Lua this command might work against. For instance, to link statically against Lua this command might work
on Linux:: on Linux::
nimrod c --dynlibOverride:lua --passL:liblua.lib program.nim nim c --dynlibOverride:lua --passL:liblua.lib program.nim
Backend language options Backend language options
@ -614,32 +614,32 @@ The typical compiler usage involves using the ``compile`` or ``c`` command to
transform a ``.nim`` file into one or more ``.c`` files which are then transform a ``.nim`` file into one or more ``.c`` files which are then
compiled with the platform's C compiler into a static binary. However there compiled with the platform's C compiler into a static binary. However there
are other commands to compile to C++, Objective-C or Javascript. More details are other commands to compile to C++, Objective-C or Javascript. More details
can be read in the `Nimrod Backend Integration document <backends.html>`_. can be read in the `Nim Backend Integration document <backends.html>`_.
Nimrod documentation tools Nim documentation tools
========================== =======================
Nimrod provides the `doc`:idx: and `doc2`:idx: commands to generate HTML Nim provides the `doc`:idx: and `doc2`:idx: commands to generate HTML
documentation from ``.nim`` source files. Only exported symbols will appear in documentation from ``.nim`` source files. Only exported symbols will appear in
the output. For more details `see the docgen documentation <docgen.html>`_. the output. For more details `see the docgen documentation <docgen.html>`_.
Nimrod idetools integration Nim idetools integration
=========================== ========================
Nimrod provides language integration with external IDEs through the Nim provides language integration with external IDEs through the
idetools command. See the documentation of `idetools <idetools.html>`_ idetools command. See the documentation of `idetools <idetools.html>`_
for further information. for further information.
Nimrod interactive mode Nim interactive mode
======================= ====================
The Nimrod compiler supports an interactive mode. This is also known as The Nim compiler supports an interactive mode. This is also known as
a `REPL`:idx: (*read eval print loop*). If Nimrod has been built with the a `REPL`:idx: (*read eval print loop*). If Nim has been built with the
``-d:useGnuReadline`` switch, it uses the GNU readline library for terminal ``-d:useGnuReadline`` switch, it uses the GNU readline library for terminal
input management. To start Nimrod in interactive mode use the command input management. To start Nim in interactive mode use the command
``nimrod i``. To quit use the ``quit()`` command. To determine whether an input ``nim i``. To quit use the ``quit()`` command. To determine whether an input
line is an incomplete statement to be continued these rules are used: line is an incomplete statement to be continued these rules are used:
1. The line ends with ``[-+*/\\<>!\?\|%&$@~,;:=#^]\s*$`` (operator symbol followed by optional whitespace). 1. The line ends with ``[-+*/\\<>!\?\|%&$@~,;:=#^]\s*$`` (operator symbol followed by optional whitespace).
@ -648,8 +648,8 @@ line is an incomplete statement to be continued these rules are used:
does not work if the line contains more than one ``"""``. does not work if the line contains more than one ``"""``.
Nimrod for embedded systems Nim for embedded systems
=========================== ========================
The standard library can be avoided to a point where C code generation The standard library can be avoided to a point where C code generation
for 16bit micro controllers is feasible. Use the `standalone`:idx: target for 16bit micro controllers is feasible. Use the `standalone`:idx: target
@ -661,7 +661,7 @@ target.
For example, to generate code for an `AVR`:idx: processor use this command:: For example, to generate code for an `AVR`:idx: processor use this command::
nimrod c --cpu:avr --os:standalone --deadCodeElim:on --genScript x.nim nim c --cpu:avr --os:standalone --deadCodeElim:on --genScript x.nim
For the ``standalone`` target you need to provide For the ``standalone`` target you need to provide
a file ``panicoverride.nim``. a file ``panicoverride.nim``.
@ -669,27 +669,27 @@ See ``tests/manyloc/standalone/panicoverride.nim`` for an example
implementation. implementation.
Nimrod for realtime systems Nim for realtime systems
=========================== ========================
See the documentation of Nimrod's soft realtime `GC <gc.html>`_ for further See the documentation of Nim's soft realtime `GC <gc.html>`_ for further
information. information.
Debugging with Nimrod Debugging with Nim
===================== ==================
Nimrod comes with its own *Embedded Nimrod Debugger*. See Nim comes with its own *Embedded Nim Debugger*. See
the documentation of endb_ for further information. the documentation of endb_ for further information.
Optimizing for Nimrod Optimizing for Nim
===================== ==================
Nimrod has no separate optimizer, but the C code that is produced is very Nim has no separate optimizer, but the C code that is produced is very
efficient. Most C compilers have excellent optimizers, so usually it is efficient. Most C compilers have excellent optimizers, so usually it is
not needed to optimize one's code. Nimrod has been designed to encourage not needed to optimize one's code. Nim has been designed to encourage
efficient code: The most readable code in Nimrod is often the most efficient efficient code: The most readable code in Nim is often the most efficient
too. too.
However, sometimes one has to optimize. Do it in the following order: However, sometimes one has to optimize. Do it in the following order:
@ -706,32 +706,32 @@ This section can only help you with the last item.
Optimizing string handling Optimizing string handling
-------------------------- --------------------------
String assignments are sometimes expensive in Nimrod: They are required to String assignments are sometimes expensive in Nim: They are required to
copy the whole string. However, the compiler is often smart enough to not copy copy the whole string. However, the compiler is often smart enough to not copy
strings. Due to the argument passing semantics, strings are never copied when strings. Due to the argument passing semantics, strings are never copied when
passed to subroutines. The compiler does not copy strings that are a result from passed to subroutines. The compiler does not copy strings that are a result from
a procedure call, because the callee returns a new string anyway. a procedure call, because the callee returns a new string anyway.
Thus it is efficient to do: Thus it is efficient to do:
.. code-block:: Nimrod .. code-block:: Nim
var s = procA() # assignment will not copy the string; procA allocates a new var s = procA() # assignment will not copy the string; procA allocates a new
# string already # string already
However it is not efficient to do: However it is not efficient to do:
.. code-block:: Nimrod .. code-block:: Nim
var s = varA # assignment has to copy the whole string into a new buffer! var s = varA # assignment has to copy the whole string into a new buffer!
For ``let`` symbols a copy is not always necessary: For ``let`` symbols a copy is not always necessary:
.. code-block:: Nimrod .. code-block:: Nim
let s = varA # may only copy a pointer if it safe to do so let s = varA # may only copy a pointer if it safe to do so
If you know what you're doing, you can also mark single string (or sequence) If you know what you're doing, you can also mark single string (or sequence)
objects as `shallow`:idx:\: objects as `shallow`:idx:\:
.. code-block:: Nimrod .. code-block:: Nim
var s = "abc" var s = "abc"
shallow(s) # mark 's' as shallow string shallow(s) # mark 's' as shallow string
var x = s # now might not copy the string! var x = s # now might not copy the string!
@ -744,7 +744,7 @@ The compiler optimizes string case statements: A hashing scheme is used for them
if several different string constants are used. So code like this is reasonably if several different string constants are used. So code like this is reasonably
efficient: efficient:
.. code-block:: Nimrod .. code-block:: Nim
case normalize(k.key) case normalize(k.key)
of "name": c.name = v of "name": c.name = v
of "displayname": c.displayName = v of "displayname": c.displayName = v

18
lib/packages/docutils/highlite.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
@ -31,10 +31,10 @@ type
state: TTokenClass state: TTokenClass
TSourceLanguage* = enum TSourceLanguage* = enum
langNone, langNimrod, langCpp, langCsharp, langC, langJava langNone, langNim, langCpp, langCsharp, langC, langJava
const const
sourceLanguageToStr*: array[TSourceLanguage, string] = ["none", "Nimrod", sourceLanguageToStr*: array[TSourceLanguage, string] = ["none", "Nim",
"C++", "C#", "C", "Java"] "C++", "C#", "C", "Java"]
tokenClassToStr*: array[TTokenClass, string] = ["Eof", "None", "Whitespace", tokenClassToStr*: array[TTokenClass, string] = ["Eof", "None", "Whitespace",
"DecNumber", "BinNumber", "HexNumber", "OctNumber", "FloatNumber", "DecNumber", "BinNumber", "HexNumber", "OctNumber", "FloatNumber",
@ -46,7 +46,7 @@ const
# The following list comes from doc/keywords.txt, make sure it is # The following list comes from doc/keywords.txt, make sure it is
# synchronized with this array by running the module itself as a test case. # synchronized with this array by running the module itself as a test case.
nimrodKeywords = ["addr", "and", "as", "asm", "atomic", "bind", "block", nimKeywords = ["addr", "and", "as", "asm", "atomic", "bind", "block",
"break", "case", "cast", "const", "continue", "converter", "discard", "break", "case", "cast", "const", "continue", "converter", "discard",
"distinct", "div", "do", "elif", "else", "end", "enum", "except", "export", "distinct", "div", "do", "elif", "else", "end", "enum", "except", "export",
"finally", "for", "from", "generic", "if", "import", "in", "include", "finally", "for", "from", "generic", "if", "import", "in", "include",
@ -79,7 +79,7 @@ proc deinitGeneralTokenizer*(g: var TGeneralTokenizer) =
discard discard
proc nimGetKeyword(id: string): TTokenClass = proc nimGetKeyword(id: string): TTokenClass =
for k in nimrodKeywords: for k in nimKeywords:
if cmpIgnoreStyle(id, k) == 0: return gtKeyword if cmpIgnoreStyle(id, k) == 0: return gtKeyword
result = gtIdentifier result = gtIdentifier
when false: when false:
@ -542,7 +542,7 @@ proc javaNextToken(g: var TGeneralTokenizer) =
proc getNextToken*(g: var TGeneralTokenizer, lang: TSourceLanguage) = proc getNextToken*(g: var TGeneralTokenizer, lang: TSourceLanguage) =
case lang case lang
of langNone: assert false of langNone: assert false
of langNimrod: nimNextToken(g) of langNim: nimNextToken(g)
of langCpp: cppNextToken(g) of langCpp: cppNextToken(g)
of langCsharp: csharpNextToken(g) of langCsharp: csharpNextToken(g)
of langC: cNextToken(g) of langC: cNextToken(g)
@ -557,7 +557,7 @@ when isMainModule:
keywords = input.split() keywords = input.split()
break break
doAssert(not keywords.isNil, "Couldn't read any keywords.txt file!") doAssert(not keywords.isNil, "Couldn't read any keywords.txt file!")
doAssert keywords.len == nimrodKeywords.len, "No matching lengths" doAssert keywords.len == nimKeywords.len, "No matching lengths"
for i in 0..keywords.len-1: for i in 0..keywords.len-1:
#echo keywords[i], " == ", nimrodKeywords[i] #echo keywords[i], " == ", nimKeywords[i]
doAssert keywords[i] == nimrodKeywords[i], "Unexpected keyword" doAssert keywords[i] == nimKeywords[i], "Unexpected keyword"

12
lib/packages/docutils/rstgen.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
@ -103,7 +103,7 @@ proc initRstGenerator*(g: var TRstGenerator, target: TOutputTarget,
## ##
## Example: ## Example:
## ##
## .. code-block:: nimrod ## .. code-block:: nim
## ##
## import packages/docutils/rstgen ## import packages/docutils/rstgen
## ##
@ -231,7 +231,7 @@ proc renderRstToOut*(d: var TRstGenerator, n: PRstNode, result: var string)
## ``initRstGenerator`` and parse a rst file with ``rstParse`` from the ## ``initRstGenerator`` and parse a rst file with ``rstParse`` from the
## `packages/docutils/rst module <rst.html>`_. Example: ## `packages/docutils/rst module <rst.html>`_. Example:
## ##
## .. code-block:: nimrod ## .. code-block:: nim
## ##
## # ...configure gen and rst vars... ## # ...configure gen and rst vars...
## var generatedHTML = "" ## var generatedHTML = ""
@ -597,7 +597,7 @@ proc mergeIndexes*(dir: string): string =
## Merges all index files in `dir` and returns the generated index as HTML. ## Merges all index files in `dir` and returns the generated index as HTML.
## ##
## This proc will first scan `dir` for index files with the ``.idx`` ## This proc will first scan `dir` for index files with the ``.idx``
## extension previously created by commands like ``nimrod doc|rst2html`` ## extension previously created by commands like ``nim doc|rst2html``
## which use the ``--index:on`` switch. These index files are the result of ## which use the ``--index:on`` switch. These index files are the result of
## calls to `setIndexTerm() <#setIndexTerm>`_ and `writeIndexFile() ## calls to `setIndexTerm() <#setIndexTerm>`_ and `writeIndexFile()
## <#writeIndexFile>`_, so they are simple tab separated files. ## <#writeIndexFile>`_, so they are simple tab separated files.
@ -768,7 +768,7 @@ proc renderCodeBlock(d: PDoc, n: PRstNode, result: var string) =
var langstr = strip(getArgument(n)) var langstr = strip(getArgument(n))
var lang: TSourceLanguage var lang: TSourceLanguage
if langstr == "": if langstr == "":
lang = langNimrod # default language lang = langNim # default language
else: else:
lang = getSourceLanguage(langstr) lang = getSourceLanguage(langstr)
@ -1123,7 +1123,7 @@ proc rstToHtml*(s: string, options: TRstParseOptions,
## work. For an explanation of the ``config`` parameter see the ## work. For an explanation of the ``config`` parameter see the
## ``initRstGenerator`` proc. Example: ## ``initRstGenerator`` proc. Example:
## ##
## .. code-block:: nimrod ## .. code-block:: nim
## import packages/docutils/rstgen, strtabs ## import packages/docutils/rstgen, strtabs
## ##
## echo rstToHtml("*Hello* **world**!", {}, ## echo rstToHtml("*Hello* **world**!", {},

2
lib/system.nim
View file

@ -2015,7 +2015,7 @@ template accumulateResult*(iter: expr) =
for x in iter: add(result, x) for x in iter: add(result, x)
# we have to compute this here before turning it off in except.nim anyway ... # we have to compute this here before turning it off in except.nim anyway ...
const nimrodStackTrace = compileOption("stacktrace") const NimStackTrace = compileOption("stacktrace")
{.push checks: off.} {.push checks: off.}
# obviously we cannot generate checking operations here :-) # obviously we cannot generate checking operations here :-)

4
lib/system/alloc.nim
View file

@ -1,13 +1,13 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
# distribution, for details about the copyright. # distribution, for details about the copyright.
# #
# Low level allocator for Nimrod. Has been designed to support the GC. # Low level allocator for Nim. Has been designed to support the GC.
# TODO: # TODO:
# - eliminate "used" field # - eliminate "used" field
# - make searching for block O(1) # - make searching for block O(1)

4
lib/system/ansi_c.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2013 Andreas Rumpf # (c) Copyright 2013 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
@ -8,7 +8,7 @@
# #
# This include file contains headers of Ansi C procs # This include file contains headers of Ansi C procs
# and definitions of Ansi C types in Nimrod syntax # and definitions of Ansi C types in Nim syntax
# All symbols are prefixed with 'c_' to avoid ambiguities # All symbols are prefixed with 'c_' to avoid ambiguities
{.push hints:off} {.push hints:off}

2
lib/system/arithm.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

2
lib/system/assign.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

5
lib/system/atomics.nim
View file

@ -1,13 +1,13 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2014 Andreas Rumpf # (c) Copyright 2014 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
# distribution, for details about the copyright. # distribution, for details about the copyright.
# #
# Atomic operations for Nimrod. # Atomic operations for Nim.
{.push stackTrace:off.} {.push stackTrace:off.}
const someGcc = defined(gcc) or defined(llvm_gcc) or defined(clang) const someGcc = defined(gcc) or defined(llvm_gcc) or defined(clang)
@ -159,6 +159,7 @@ when someGcc and hasThreadSupport:
elif defined(vcc) and hasThreadSupport: elif defined(vcc) and hasThreadSupport:
proc addAndFetch*(p: ptr int, val: int): int {. proc addAndFetch*(p: ptr int, val: int): int {.
importc: "NimXadd", nodecl.} importc: "NimXadd", nodecl.}
proc fence*() {.importc: "_ReadWriteBarrier", header: "<intrin.h>".}
else: else:
proc addAndFetch*(p: ptr int, val: int): int {.inline.} = proc addAndFetch*(p: ptr int, val: int): int {.inline.} =

2
lib/system/avltree.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

2
lib/system/cellsets.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2013 Andreas Rumpf # (c) Copyright 2013 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

2
lib/system/cgprocs.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

2
lib/system/channels.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2014 Andreas Rumpf # (c) Copyright 2014 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

2
lib/system/chcks.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2013 Andreas Rumpf # (c) Copyright 2013 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

4
lib/system/debugger.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2013 Andreas Rumpf # (c) Copyright 2013 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
@ -293,7 +293,7 @@ proc checkWatchpoints =
Watchpoints[i].oldValue = newHash Watchpoints[i].oldValue = newHash
proc endb(line: int, file: cstring) {.compilerproc, noinline.} = proc endb(line: int, file: cstring) {.compilerproc, noinline.} =
# This proc is called before every Nimrod code line! # This proc is called before every Nim code line!
if framePtr == nil: return if framePtr == nil: return
if dbgWatchpointHook != nil: checkWatchpoints() if dbgWatchpointHook != nil: checkWatchpoints()
framePtr.line = line # this is done here for smaller code size! framePtr.line = line # this is done here for smaller code size!

2
lib/system/deepcopy.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2014 Andreas Rumpf # (c) Copyright 2014 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

2
lib/system/dyncalls.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

2
lib/system/embedded.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

4
lib/system/endb.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2013 Andreas Rumpf # (c) Copyright 2013 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
@ -11,7 +11,7 @@
# with the application. Mostly we do not use dynamic memory here as that # with the application. Mostly we do not use dynamic memory here as that
# would interfere with the GC and trigger ON/OFF errors if the # would interfere with the GC and trigger ON/OFF errors if the
# user program corrupts memory. Unfortunately, for dispaying # user program corrupts memory. Unfortunately, for dispaying
# variables we use the ``system.repr()`` proc which uses Nimrod # variables we use the ``system.repr()`` proc which uses Nim
# strings and thus allocates memory from the heap. Pity, but # strings and thus allocates memory from the heap. Pity, but
# I do not want to implement ``repr()`` twice. # I do not want to implement ``repr()`` twice.

10
lib/system/excpt.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2014 Andreas Rumpf # (c) Copyright 2014 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
@ -68,8 +68,8 @@ proc popCurrentException {.compilerRtl, inl.} =
# some platforms have native support for stack traces: # some platforms have native support for stack traces:
const const
nativeStackTraceSupported* = (defined(macosx) or defined(linux)) and nativeStackTraceSupported* = (defined(macosx) or defined(linux)) and
not nimrodStackTrace not NimStackTrace
hasSomeStackTrace = nimrodStackTrace or hasSomeStackTrace = NimStackTrace or
defined(nativeStackTrace) and nativeStackTraceSupported defined(nativeStackTrace) and nativeStackTraceSupported
when defined(nativeStacktrace) and nativeStackTraceSupported: when defined(nativeStacktrace) and nativeStackTraceSupported:
@ -177,7 +177,7 @@ proc auxWriteStackTrace(f: PFrame, s: var string) =
when hasSomeStackTrace: when hasSomeStackTrace:
proc rawWriteStackTrace(s: var string) = proc rawWriteStackTrace(s: var string) =
when nimrodStackTrace: when NimStackTrace:
if framePtr == nil: if framePtr == nil:
add(s, "No stack traceback available\n") add(s, "No stack traceback available\n")
else: else:
@ -318,7 +318,7 @@ when not defined(noSignalHandler):
GC_disable() GC_disable()
var buf = newStringOfCap(2000) var buf = newStringOfCap(2000)
rawWriteStackTrace(buf) rawWriteStackTrace(buf)
processSignal(sig, buf.add) # nice hu? currying a la nimrod :-) processSignal(sig, buf.add) # nice hu? currying a la Nim :-)
showErrorMessage(buf) showErrorMessage(buf)
GC_enable() GC_enable()
else: else:

2
lib/system/gc.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2013 Andreas Rumpf # (c) Copyright 2013 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

2
lib/system/gc2.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

4
lib/system/gc_ms.nim
View file

@ -1,13 +1,13 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2014 Andreas Rumpf # (c) Copyright 2014 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
# distribution, for details about the copyright. # distribution, for details about the copyright.
# #
# A simple mark&sweep garbage collector for Nimrod. Define the # A simple mark&sweep garbage collector for Nim. Define the
# symbol ``gcUseBitvectors`` to generate a variant of this GC. # symbol ``gcUseBitvectors`` to generate a variant of this GC.
{.push profiler:off.} {.push profiler:off.}

2
lib/system/hti.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

2
lib/system/inclrtl.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2014 Andreas Rumpf # (c) Copyright 2014 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

4
lib/system/jssys.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
@ -103,7 +103,7 @@ proc raiseException(e: ref E_Base, ename: cstring) {.
if excHandler != nil: if excHandler != nil:
excHandler.exc = e excHandler.exc = e
else: else:
when nimrodStackTrace: when NimStackTrace:
var buf = rawWriteStackTrace() var buf = rawWriteStackTrace()
else: else:
var buf = "" var buf = ""

8
lib/system/mmdisp.nim
View file

@ -1,14 +1,14 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2013 Andreas Rumpf # (c) Copyright 2013 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
# distribution, for details about the copyright. # distribution, for details about the copyright.
# #
# Nimrod high-level memory manager: It supports Boehm's GC, no GC and the # Nim high-level memory manager: It supports Boehm's GC, no GC and the
# native Nimrod GC. The native Nimrod GC is the default. # native Nim GC. The native Nim GC is the default.
#{.push checks:on, assertions:on.} #{.push checks:on, assertions:on.}
{.push checks:off.} {.push checks:off.}
@ -259,7 +259,7 @@ elif defined(nogc) and defined(useMalloc):
elif defined(nogc): elif defined(nogc):
# Even though we don't want the GC, we cannot simply use C's memory manager # Even though we don't want the GC, we cannot simply use C's memory manager
# because Nimrod's runtime wants ``realloc`` to zero out the additional # because Nim's runtime wants ``realloc`` to zero out the additional
# space which C's ``realloc`` does not. And we cannot get the old size of an # space which C's ``realloc`` does not. And we cannot get the old size of an
# object, because C does not support this operation... Even though every # object, because C does not support this operation... Even though every
# possible implementation has to have a way to determine the object's size. # possible implementation has to have a way to determine the object's size.

4
lib/system/profiler.nim
View file

@ -1,13 +1,13 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
# distribution, for details about the copyright. # distribution, for details about the copyright.
# #
# This file implements the Nimrod profiler. The profiler needs support by the # This file implements the Nim profiler. The profiler needs support by the
# code generator. The idea is to inject the instruction stream # code generator. The idea is to inject the instruction stream
# with 'nimProfile()' calls. These calls are injected at every loop end # with 'nimProfile()' calls. These calls are injected at every loop end
# (except perhaps loops that have no side-effects). At every Nth call a # (except perhaps loops that have no side-effects). At every Nth call a

2
lib/system/repr.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

2
lib/system/reprjs.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

2
lib/system/sets.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

2
lib/system/syslocks.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

4
lib/system/sysspawn.nim
View file

@ -1,13 +1,13 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2014 Andreas Rumpf # (c) Copyright 2014 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
# distribution, for details about the copyright. # distribution, for details about the copyright.
# #
## Implements Nimrod's 'spawn'. ## Implements Nim's 'spawn'.
when not declared(NimString): when not declared(NimString):
{.error: "You must not import this module explicitly".} {.error: "You must not import this module explicitly".}

8
lib/system/sysstr.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
@ -119,7 +119,7 @@ proc addChar(s: NimString, c: char): NimString =
inc(result.len) inc(result.len)
# These routines should be used like following: # These routines should be used like following:
# <Nimrod code> # <Nim code>
# s &= "Hello " & name & ", how do you feel?" # s &= "Hello " & name & ", how do you feel?"
# #
# <generated C code> # <generated C code>
@ -130,7 +130,7 @@ proc addChar(s: NimString, c: char): NimString =
# appendString(s, strLit3); # appendString(s, strLit3);
# } # }
# #
# <Nimrod code> # <Nim code>
# s = "Hello " & name & ", how do you feel?" # s = "Hello " & name & ", how do you feel?"
# #
# <generated C code> # <generated C code>
@ -143,7 +143,7 @@ proc addChar(s: NimString, c: char): NimString =
# s = tmp0; # s = tmp0;
# } # }
# #
# <Nimrod code> # <Nim code>
# s = "" # s = ""
# #
# <generated C code> # <generated C code>

14
lib/system/threads.nim
View file

@ -1,17 +1,17 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
# distribution, for details about the copyright. # distribution, for details about the copyright.
# #
## Thread support for Nimrod. **Note**: This is part of the system module. ## Thread support for Nim. **Note**: This is part of the system module.
## Do not import it directly. To activate thread support you need to compile ## Do not import it directly. To activate thread support you need to compile
## with the ``--threads:on`` command line switch. ## with the ``--threads:on`` command line switch.
## ##
## Nimrod's memory model for threads is quite different from other common ## Nim's memory model for threads is quite different from other common
## programming languages (C, Pascal): Each thread has its own ## programming languages (C, Pascal): Each thread has its own
## (garbage collected) heap and sharing of memory is restricted. This helps ## (garbage collected) heap and sharing of memory is restricted. This helps
## to prevent race conditions and improves efficiency. See `the manual for ## to prevent race conditions and improves efficiency. See `the manual for
@ -19,7 +19,7 @@
## ##
## Example: ## Example:
## ##
## .. code-block:: nimrod ## .. code-block:: Nim
## ##
## import locks ## import locks
## ##
@ -245,14 +245,14 @@ when not defined(useNimRtl):
# the GC can examine the stacks? # the GC can examine the stacks?
proc stopTheWord() = discard proc stopTheWord() = discard
# We jump through some hops here to ensure that Nimrod thread procs can have # We jump through some hops here to ensure that Nim thread procs can have
# the Nimrod calling convention. This is needed because thread procs are # the Nim calling convention. This is needed because thread procs are
# ``stdcall`` on Windows and ``noconv`` on UNIX. Alternative would be to just # ``stdcall`` on Windows and ``noconv`` on UNIX. Alternative would be to just
# use ``stdcall`` since it is mapped to ``noconv`` on UNIX anyway. # use ``stdcall`` since it is mapped to ``noconv`` on UNIX anyway.
type type
TThread* {.pure, final.}[TArg] = TThread* {.pure, final.}[TArg] =
object of TGcThread ## Nimrod thread. A thread is a heavy object (~14K) object of TGcThread ## Nim thread. A thread is a heavy object (~14K)
## that **must not** be part of a message! Use ## that **must not** be part of a message! Use
## a ``TThreadId`` for that. ## a ``TThreadId`` for that.
when TArg is void: when TArg is void:

2
lib/system/timers.nim
View file

@ -1,6 +1,6 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this

4
lib/system/widestrs.nim
View file

@ -1,13 +1,13 @@
# #
# #
# Nimrod's Runtime Library # Nim's Runtime Library
# (c) Copyright 2012 Andreas Rumpf # (c) Copyright 2012 Andreas Rumpf
# #
# See the file "copying.txt", included in this # See the file "copying.txt", included in this
# distribution, for details about the copyright. # distribution, for details about the copyright.
# #
# Nimrod support for C/C++'s `wide strings`:idx:. This is part of the system # Nim support for C/C++'s `wide strings`:idx:. This is part of the system
# module! Do not import it directly! # module! Do not import it directly!
when not declared(NimString): when not declared(NimString):

22
tests/parallel/tflowvar.nim
View file

@ -1,11 +1,13 @@
discard """ discard """
output: '''foobarfoobarbazbearbazbear''' output: '''foobarfoobar
bazbearbazbear
1'''
cmd: "nimrod $target --threads:on $options $file" cmd: "nimrod $target --threads:on $options $file"
""" """
import threadpool import threadpool
proc computeSomething(a, b: string): string = a & b & a & b proc computeSomething(a, b: string): string = a & b & a & b & "\n"
proc main = proc main =
let fvA = spawn computeSomething("foo", "bar") let fvA = spawn computeSomething("foo", "bar")
@ -15,3 +17,19 @@ proc main =
main() main()
sync() sync()
type
TIntSeq = seq[int]
proc t(): TIntSeq =
result = @[1]
proc p(): int =
var a: FlowVar[TIntSeq]
parallel:
var aa = spawn t()
a = aa
result = (^a)[0]
echo p()

5
todo.txt
View file

@ -1,6 +1,11 @@
version 0.9.6 version 0.9.6
============= =============
- fix bug #1320
- fix tflowvar codegen test
- split idetools into separate tool
- split docgen into separate tool
- .benign pragma
- scopes are still broken for generic instantiation! - scopes are still broken for generic instantiation!
- implicit deref for parameter matching - implicit deref for parameter matching

2
web/news.txt
View file

@ -29,6 +29,8 @@ News
- ``--threadanalysis:on`` is now the default. To make your program compile - ``--threadanalysis:on`` is now the default. To make your program compile
you can disable it but this is only a temporary solution as this option you can disable it but this is only a temporary solution as this option
will disappear soon! will disappear soon!
- ``system.fileHandle`` has been renamed to ``system.getFileHandle`` to
prevent name conflicts with the new type ``FileHandle``.
Language Additions Language Additions

4
web/question.txt
View file

@ -31,8 +31,8 @@ runtime or interpreter.
What have been the major influences in the language's design? What have been the major influences in the language's design?
------------------------------------------------------------- -------------------------------------------------------------
The language borrows heavily from: Modula 3, Delphi, Ada, C++, Python, Lisp, The language borrows heavily from (in order of impact): Modula 3, Delphi, Ada,
Oberon. As far as possible the list is sorted by the impact of influence. C++, Python, Lisp, Oberon.