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

case consistency part 4

Browse source
This commit is contained in:
Araq 2013-12-27 23:10:36 +01:00
commit 92b8fac94a
122 changed files with 3322 additions and 3322 deletions
Download patch file Download diff file Expand all files Collapse all files

6
compiler/aliases.nim
View file

@ -42,7 +42,7 @@ proc isPartOfAux(n: PNode, b: PType, marker: var TIntSet): TAnalysisResult =
proc isPartOfAux(a, b: PType, marker: var TIntSet): TAnalysisResult = proc isPartOfAux(a, b: PType, marker: var TIntSet): TAnalysisResult =
result = arNo result = arNo
if a == nil or b == nil: return if a == nil or b == nil: return
if ContainsOrIncl(marker, a.id): return if containsOrIncl(marker, a.id): return
if compareTypes(a, b, dcEqIgnoreDistinct): return arYes if compareTypes(a, b, dcEqIgnoreDistinct): return arYes
case a.kind case a.kind
of tyObject: of tyObject:
@ -58,7 +58,7 @@ proc isPartOfAux(a, b: PType, marker: var TIntSet): TAnalysisResult =
proc isPartOf(a, b: PType): TAnalysisResult = proc isPartOf(a, b: PType): TAnalysisResult =
## checks iff 'a' can be part of 'b'. Iterates over VALUE types! ## checks iff 'a' can be part of 'b'. Iterates over VALUE types!
var marker = InitIntSet() var marker = initIntSet()
# watch out: parameters reversed because I'm too lazy to change the code... # watch out: parameters reversed because I'm too lazy to change the code...
result = isPartOfAux(b, a, marker) result = isPartOfAux(b, a, marker)
@ -115,7 +115,7 @@ proc isPartOf*(a, b: PNode): TAnalysisResult =
var x = if a[1].kind == nkHiddenStdConv: a[1][1] else: a[1] var x = if a[1].kind == nkHiddenStdConv: a[1][1] else: a[1]
var y = if b[1].kind == nkHiddenStdConv: b[1][1] else: b[1] var y = if b[1].kind == nkHiddenStdConv: b[1][1] else: b[1]
if SameValue(x, y): result = arYes if sameValue(x, y): result = arYes
else: result = arNo else: result = arNo
# else: maybe and no are accurate # else: maybe and no are accurate
else: else:

22
compiler/ast.nim
View file

@ -548,9 +548,9 @@ type
flags*: TNodeFlags flags*: TNodeFlags
case Kind*: TNodeKind case Kind*: TNodeKind
of nkCharLit..nkUInt64Lit: of nkCharLit..nkUInt64Lit:
intVal*: biggestInt intVal*: BiggestInt
of nkFloatLit..nkFloat128Lit: of nkFloatLit..nkFloat128Lit:
floatVal*: biggestFloat floatVal*: BiggestFloat
of nkStrLit..nkTripleStrLit: of nkStrLit..nkTripleStrLit:
strVal*: string strVal*: string
of nkSym: of nkSym:
@ -911,7 +911,7 @@ template fileIdx*(c: PSym): int32 =
template filename*(c: PSym): string = template filename*(c: PSym): string =
# XXX: this should be used only on module symbols # XXX: this should be used only on module symbols
c.position.int32.toFileName c.position.int32.toFilename
proc appendToModule*(m: PSym, n: PNode) = proc appendToModule*(m: PSym, n: PNode) =
## The compiler will use this internally to add nodes that will be ## The compiler will use this internally to add nodes that will be
@ -930,7 +930,7 @@ const # for all kind of hash tables:
proc copyStrTable(dest: var TStrTable, src: TStrTable) = proc copyStrTable(dest: var TStrTable, src: TStrTable) =
dest.counter = src.counter dest.counter = src.counter
if isNil(src.data): return if isNil(src.data): return
setlen(dest.data, len(src.data)) setLen(dest.data, len(src.data))
for i in countup(0, high(src.data)): dest.data[i] = src.data[i] for i in countup(0, high(src.data)): dest.data[i] = src.data[i]
proc copyIdTable(dest: var TIdTable, src: TIdTable) = proc copyIdTable(dest: var TIdTable, src: TIdTable) =
@ -942,13 +942,13 @@ proc copyIdTable(dest: var TIdTable, src: TIdTable) =
proc copyTable(dest: var TTable, src: TTable) = proc copyTable(dest: var TTable, src: TTable) =
dest.counter = src.counter dest.counter = src.counter
if isNil(src.data): return if isNil(src.data): return
setlen(dest.data, len(src.data)) setLen(dest.data, len(src.data))
for i in countup(0, high(src.data)): dest.data[i] = src.data[i] for i in countup(0, high(src.data)): dest.data[i] = src.data[i]
proc copyObjectSet(dest: var TObjectSet, src: TObjectSet) = proc copyObjectSet(dest: var TObjectSet, src: TObjectSet) =
dest.counter = src.counter dest.counter = src.counter
if isNil(src.data): return if isNil(src.data): return
setlen(dest.data, len(src.data)) setLen(dest.data, len(src.data))
for i in countup(0, high(src.data)): dest.data[i] = src.data[i] for i in countup(0, high(src.data)): dest.data[i] = src.data[i]
proc discardSons(father: PNode) = proc discardSons(father: PNode) =
@ -1204,7 +1204,7 @@ proc newSons(father: PType, length: int) =
if isNil(father.sons): if isNil(father.sons):
newSeq(father.sons, length) newSeq(father.sons, length)
else: else:
setlen(father.sons, length) setLen(father.sons, length)
proc sonsLen(n: PNode): int = proc sonsLen(n: PNode): int =
if isNil(n.sons): result = 0 if isNil(n.sons): result = 0
@ -1214,7 +1214,7 @@ proc newSons(father: PNode, length: int) =
if isNil(father.sons): if isNil(father.sons):
newSeq(father.sons, length) newSeq(father.sons, length)
else: else:
setlen(father.sons, length) setLen(father.sons, length)
proc propagateToOwner*(owner, elem: PType) = proc propagateToOwner*(owner, elem: PType) =
const HaveTheirOwnEmpty = {tySequence, tySet} const HaveTheirOwnEmpty = {tySequence, tySet}
@ -1257,7 +1257,7 @@ proc delSon(father: PNode, idx: int) =
if isNil(father.sons): return if isNil(father.sons): return
var length = sonsLen(father) var length = sonsLen(father)
for i in countup(idx, length - 2): father.sons[i] = father.sons[i + 1] for i in countup(idx, length - 2): father.sons[i] = father.sons[i + 1]
setlen(father.sons, length - 1) setLen(father.sons, length - 1)
proc copyNode(src: PNode): PNode = proc copyNode(src: PNode): PNode =
# does not copy its sons! # does not copy its sons!
@ -1365,14 +1365,14 @@ proc sonsNotNil(n: PNode): bool =
return false return false
result = true result = true
proc getInt*(a: PNode): biggestInt = proc getInt*(a: PNode): BiggestInt =
case a.kind case a.kind
of nkIntLit..nkUInt64Lit: result = a.intVal of nkIntLit..nkUInt64Lit: result = a.intVal
else: else:
internalError(a.info, "getInt") internalError(a.info, "getInt")
result = 0 result = 0
proc getFloat*(a: PNode): biggestFloat = proc getFloat*(a: PNode): BiggestFloat =
case a.kind case a.kind
of nkFloatLit..nkFloat128Lit: result = a.floatVal of nkFloatLit..nkFloat128Lit: result = a.floatVal
else: else:

58
compiler/astalgo.nim
View file

@ -165,7 +165,7 @@ proc lookupInRecord(n: PNode, field: PIdent): PSym =
result = lookupInRecord(n.sons[i], field) result = lookupInRecord(n.sons[i], field)
if result != nil: return if result != nil: return
of nkRecCase: of nkRecCase:
if (n.sons[0].kind != nkSym): InternalError(n.info, "lookupInRecord") if (n.sons[0].kind != nkSym): internalError(n.info, "lookupInRecord")
result = lookupInRecord(n.sons[0], field) result = lookupInRecord(n.sons[0], field)
if result != nil: return if result != nil: return
for i in countup(1, sonsLen(n) - 1): for i in countup(1, sonsLen(n) - 1):
@ -202,7 +202,7 @@ proc spaces(x: int): PRope =
# returns x spaces # returns x spaces
result = toRope(repeatChar(x)) result = toRope(repeatChar(x))
proc toYamlChar(c: Char): string = proc toYamlChar(c: char): string =
case c case c
of '\0'..'\x1F', '\x80'..'\xFF': result = "\\u" & strutils.toHex(ord(c), 4) of '\0'..'\x1F', '\x80'..'\xFF': result = "\\u" & strutils.toHex(ord(c), 4)
of '\'', '\"', '\\': result = '\\' & c of '\'', '\"', '\\': result = '\\' & c
@ -261,7 +261,7 @@ proc strTableToYaml(n: TStrTable, marker: var TIntSet, indent: int,
app(result, "]") app(result, "]")
assert(mycount == n.counter) assert(mycount == n.counter)
proc ropeConstr(indent: int, c: openarray[PRope]): PRope = proc ropeConstr(indent: int, c: openArray[PRope]): PRope =
# array of (name, value) pairs # array of (name, value) pairs
var istr = spaces(indent + 2) var istr = spaces(indent + 2)
result = toRope("{") result = toRope("{")
@ -276,7 +276,7 @@ proc symToYamlAux(n: PSym, marker: var TIntSet, indent: int,
maxRecDepth: int): PRope = maxRecDepth: int): PRope =
if n == nil: if n == nil:
result = toRope("null") result = toRope("null")
elif ContainsOrIncl(marker, n.id): elif containsOrIncl(marker, n.id):
result = ropef("\"$1 @$2\"", [toRope(n.name.s), toRope( result = ropef("\"$1 @$2\"", [toRope(n.name.s), toRope(
strutils.toHex(cast[TAddress](n), sizeof(n) * 2))]) strutils.toHex(cast[TAddress](n), sizeof(n) * 2))])
else: else:
@ -297,7 +297,7 @@ proc typeToYamlAux(n: PType, marker: var TIntSet, indent: int,
maxRecDepth: int): PRope = maxRecDepth: int): PRope =
if n == nil: if n == nil:
result = toRope("null") result = toRope("null")
elif ContainsOrIncl(marker, n.id): elif containsOrIncl(marker, n.id):
result = ropef("\"$1 @$2\"", [toRope($n.kind), toRope( result = ropef("\"$1 @$2\"", [toRope($n.kind), toRope(
strutils.toHex(cast[TAddress](n), sizeof(n) * 2))]) strutils.toHex(cast[TAddress](n), sizeof(n) * 2))])
else: else:
@ -314,7 +314,7 @@ proc typeToYamlAux(n: PType, marker: var TIntSet, indent: int,
makeYamlString($n.kind), makeYamlString($n.kind),
toRope("sym"), symToYamlAux(n.sym, marker, toRope("sym"), symToYamlAux(n.sym, marker,
indent + 2, maxRecDepth - 1), toRope("n"), treeToYamlAux(n.n, marker, indent + 2, maxRecDepth - 1), toRope("n"), treeToYamlAux(n.n, marker,
indent + 2, maxRecDepth - 1), toRope("flags"), FlagsToStr(n.flags), indent + 2, maxRecDepth - 1), toRope("flags"), flagsToStr(n.flags),
toRope("callconv"), toRope("callconv"),
makeYamlString(CallingConvToStr[n.callConv]), makeYamlString(CallingConvToStr[n.callConv]),
toRope("size"), toRope(n.size), toRope("size"), toRope(n.size),
@ -335,7 +335,7 @@ proc treeToYamlAux(n: PNode, marker: var TIntSet, indent: int,
appf(result, ",$N$1\"intVal\": $2", [istr, toRope(n.intVal)]) appf(result, ",$N$1\"intVal\": $2", [istr, toRope(n.intVal)])
of nkFloatLit, nkFloat32Lit, nkFloat64Lit: of nkFloatLit, nkFloat32Lit, nkFloat64Lit:
appf(result, ",$N$1\"floatVal\": $2", appf(result, ",$N$1\"floatVal\": $2",
[istr, toRope(n.floatVal.ToStrMaxPrecision)]) [istr, toRope(n.floatVal.toStrMaxPrecision)])
of nkStrLit..nkTripleStrLit: of nkStrLit..nkTripleStrLit:
appf(result, ",$N$1\"strVal\": $2", [istr, makeYamlString(n.strVal)]) appf(result, ",$N$1\"strVal\": $2", [istr, makeYamlString(n.strVal)])
of nkSym: of nkSym:
@ -359,15 +359,15 @@ proc treeToYamlAux(n: PNode, marker: var TIntSet, indent: int,
appf(result, "$N$1}", [spaces(indent)]) appf(result, "$N$1}", [spaces(indent)])
proc treeToYaml(n: PNode, indent: int = 0, maxRecDepth: int = - 1): PRope = proc treeToYaml(n: PNode, indent: int = 0, maxRecDepth: int = - 1): PRope =
var marker = InitIntSet() var marker = initIntSet()
result = treeToYamlAux(n, marker, indent, maxRecDepth) result = treeToYamlAux(n, marker, indent, maxRecDepth)
proc typeToYaml(n: PType, indent: int = 0, maxRecDepth: int = - 1): PRope = proc typeToYaml(n: PType, indent: int = 0, maxRecDepth: int = - 1): PRope =
var marker = InitIntSet() var marker = initIntSet()
result = typeToYamlAux(n, marker, indent, maxRecDepth) result = typeToYamlAux(n, marker, indent, maxRecDepth)
proc symToYaml(n: PSym, indent: int = 0, maxRecDepth: int = - 1): PRope = proc symToYaml(n: PSym, indent: int = 0, maxRecDepth: int = - 1): PRope =
var marker = InitIntSet() var marker = initIntSet()
result = symToYamlAux(n, marker, indent, maxRecDepth) result = symToYamlAux(n, marker, indent, maxRecDepth)
proc debugTree(n: PNode, indent: int, maxRecDepth: int): PRope proc debugTree(n: PNode, indent: int, maxRecDepth: int): PRope
@ -405,7 +405,7 @@ proc debugTree(n: PNode, indent: int, maxRecDepth: int): PRope =
appf(result, ",$N$1\"intVal\": $2", [istr, toRope(n.intVal)]) appf(result, ",$N$1\"intVal\": $2", [istr, toRope(n.intVal)])
of nkFloatLit, nkFloat32Lit, nkFloat64Lit: of nkFloatLit, nkFloat32Lit, nkFloat64Lit:
appf(result, ",$N$1\"floatVal\": $2", appf(result, ",$N$1\"floatVal\": $2",
[istr, toRope(n.floatVal.ToStrMaxPrecision)]) [istr, toRope(n.floatVal.toStrMaxPrecision)])
of nkStrLit..nkTripleStrLit: of nkStrLit..nkTripleStrLit:
appf(result, ",$N$1\"strVal\": $2", [istr, makeYamlString(n.strVal)]) appf(result, ",$N$1\"strVal\": $2", [istr, makeYamlString(n.strVal)])
of nkSym: of nkSym:
@ -463,7 +463,7 @@ proc objectSetContains(t: TObjectSet, obj: PObject): bool =
result = false result = false
proc objectSetRawInsert(data: var TObjectSeq, obj: PObject) = proc objectSetRawInsert(data: var TObjectSeq, obj: PObject) =
var h: THash = HashNode(obj) and high(data) var h: THash = hashNode(obj) and high(data)
while data[h] != nil: while data[h] != nil:
assert(data[h] != obj) assert(data[h] != obj)
h = nextTry(h, high(data)) h = nextTry(h, high(data))
@ -484,7 +484,7 @@ proc objectSetIncl(t: var TObjectSet, obj: PObject) =
proc objectSetContainsOrIncl(t: var TObjectSet, obj: PObject): bool = proc objectSetContainsOrIncl(t: var TObjectSet, obj: PObject): bool =
# returns true if obj is already in the string table: # returns true if obj is already in the string table:
var h: THash = HashNode(obj) and high(t.data) var h: THash = hashNode(obj) and high(t.data)
while true: while true:
var it = t.data[h] var it = t.data[h]
if it == nil: break if it == nil: break
@ -541,7 +541,7 @@ proc tableEnlarge(t: var TTable) =
swap(t.data, n) swap(t.data, n)
proc tablePut(t: var TTable, key, val: PObject) = proc tablePut(t: var TTable, key, val: PObject) =
var index = TableRawGet(t, key) var index = tableRawGet(t, key)
if index >= 0: if index >= 0:
t.data[index].val = val t.data[index].val = val
else: else:
@ -585,12 +585,12 @@ proc strTableEnlarge(t: var TStrTable) =
var n: TSymSeq var n: TSymSeq
newSeq(n, len(t.data) * growthFactor) newSeq(n, len(t.data) * growthFactor)
for i in countup(0, high(t.data)): for i in countup(0, high(t.data)):
if t.data[i] != nil: StrTableRawInsert(n, t.data[i]) if t.data[i] != nil: strTableRawInsert(n, t.data[i])
swap(t.data, n) swap(t.data, n)
proc strTableAdd(t: var TStrTable, n: PSym) = proc strTableAdd(t: var TStrTable, n: PSym) =
if mustRehash(len(t.data), t.counter): StrTableEnlarge(t) if mustRehash(len(t.data), t.counter): strTableEnlarge(t)
StrTableRawInsert(t.data, n) strTableRawInsert(t.data, n)
inc(t.counter) inc(t.counter)
proc strTableIncl*(t: var TStrTable, n: PSym): bool {.discardable.} = proc strTableIncl*(t: var TStrTable, n: PSym): bool {.discardable.} =
@ -607,8 +607,8 @@ proc strTableIncl*(t: var TStrTable, n: PSym): bool {.discardable.} =
return true # found it return true # found it
h = nextTry(h, high(t.data)) h = nextTry(h, high(t.data))
if mustRehash(len(t.data), t.counter): if mustRehash(len(t.data), t.counter):
StrTableEnlarge(t) strTableEnlarge(t)
StrTableRawInsert(t.data, n) strTableRawInsert(t.data, n)
else: else:
assert(t.data[h] == nil) assert(t.data[h] == nil)
t.data[h] = n t.data[h] = n
@ -627,7 +627,7 @@ proc initIdentIter(ti: var TIdentIter, tab: TStrTable, s: PIdent): PSym =
ti.h = s.h ti.h = s.h
ti.name = s ti.name = s
if tab.Counter == 0: result = nil if tab.Counter == 0: result = nil
else: result = NextIdentIter(ti, tab) else: result = nextIdentIter(ti, tab)
proc nextIdentIter(ti: var TIdentIter, tab: TStrTable): PSym = proc nextIdentIter(ti: var TIdentIter, tab: TStrTable): PSym =
var h, start: THash var h, start: THash
@ -649,7 +649,7 @@ proc nextIdentExcluding*(ti: var TIdentIter, tab: TStrTable,
var start = h var start = h
result = tab.data[h] result = tab.data[h]
while result != nil: while result != nil:
if result.Name.id == ti.name.id and not Contains(excluding, result.id): if result.Name.id == ti.name.id and not contains(excluding, result.id):
break break
h = nextTry(h, high(tab.data)) h = nextTry(h, high(tab.data))
if h == start: if h == start:
@ -657,21 +657,21 @@ proc nextIdentExcluding*(ti: var TIdentIter, tab: TStrTable,
break break
result = tab.data[h] result = tab.data[h]
ti.h = nextTry(h, high(tab.data)) ti.h = nextTry(h, high(tab.data))
if result != nil and Contains(excluding, result.id): result = nil if result != nil and contains(excluding, result.id): result = nil
proc firstIdentExcluding*(ti: var TIdentIter, tab: TStrTable, s: PIdent, proc firstIdentExcluding*(ti: var TIdentIter, tab: TStrTable, s: PIdent,
excluding: TIntSet): PSym = excluding: TIntSet): PSym =
ti.h = s.h ti.h = s.h
ti.name = s ti.name = s
if tab.Counter == 0: result = nil if tab.Counter == 0: result = nil
else: result = NextIdentExcluding(ti, tab, excluding) else: result = nextIdentExcluding(ti, tab, excluding)
proc initTabIter(ti: var TTabIter, tab: TStrTable): PSym = proc initTabIter(ti: var TTabIter, tab: TStrTable): PSym =
ti.h = 0 # we start by zero ... ti.h = 0 # we start by zero ...
if tab.counter == 0: if tab.counter == 0:
result = nil # FIX 1: removed endless loop result = nil # FIX 1: removed endless loop
else: else:
result = NextIter(ti, tab) result = nextIter(ti, tab)
proc nextIter(ti: var TTabIter, tab: TStrTable): PSym = proc nextIter(ti: var TTabIter, tab: TStrTable): PSym =
result = nil result = nil
@ -736,7 +736,7 @@ proc idTablePut(t: var TIdTable, key: PIdObj, val: PObject) =
var var
index: int index: int
n: TIdPairSeq n: TIdPairSeq
index = IdTableRawGet(t, key.id) index = idTableRawGet(t, key.id)
if index >= 0: if index >= 0:
assert(t.data[index].key != nil) assert(t.data[index].key != nil)
t.data[index].val = val t.data[index].val = val
@ -745,10 +745,10 @@ proc idTablePut(t: var TIdTable, key: PIdObj, val: PObject) =
newSeq(n, len(t.data) * growthFactor) newSeq(n, len(t.data) * growthFactor)
for i in countup(0, high(t.data)): for i in countup(0, high(t.data)):
if t.data[i].key != nil: if t.data[i].key != nil:
IdTableRawInsert(n, t.data[i].key, t.data[i].val) idTableRawInsert(n, t.data[i].key, t.data[i].val)
assert(hasEmptySlot(n)) assert(hasEmptySlot(n))
swap(t.data, n) swap(t.data, n)
IdTableRawInsert(t.data, key, val) idTableRawInsert(t.data, key, val)
inc(t.counter) inc(t.counter)
iterator idTablePairs*(t: TIdTable): tuple[key: PIdObj, val: PObject] = iterator idTablePairs*(t: TIdTable): tuple[key: PIdObj, val: PObject] =
@ -785,7 +785,7 @@ proc idNodeTableRawInsert(data: var TIdNodePairSeq, key: PIdObj, val: PNode) =
data[h].val = val data[h].val = val
proc idNodeTablePut(t: var TIdNodeTable, key: PIdObj, val: PNode) = proc idNodeTablePut(t: var TIdNodeTable, key: PIdObj, val: PNode) =
var index = IdNodeTableRawGet(t, key) var index = idNodeTableRawGet(t, key)
if index >= 0: if index >= 0:
assert(t.data[index].key != nil) assert(t.data[index].key != nil)
t.data[index].val = val t.data[index].val = val
@ -837,7 +837,7 @@ proc iiTableRawInsert(data: var TIIPairSeq, key, val: int) =
data[h].val = val data[h].val = val
proc iiTablePut(t: var TIITable, key, val: int) = proc iiTablePut(t: var TIITable, key, val: int) =
var index = IITableRawGet(t, key) var index = iiTableRawGet(t, key)
if index >= 0: if index >= 0:
assert(t.data[index].key != InvalidKey) assert(t.data[index].key != InvalidKey)
t.data[index].val = val t.data[index].val = val

6
compiler/babelcmd.nim
View file

@ -45,9 +45,9 @@ proc `<.`(a, b: string): bool =
proc addPackage(packages: PStringTable, p: string) = proc addPackage(packages: PStringTable, p: string) =
let x = versionSplitPos(p) let x = versionSplitPos(p)
let name = p.subStr(0, x-1) let name = p.substr(0, x-1)
if x < p.len: if x < p.len:
let version = p.subStr(x+1) let version = p.substr(x+1)
if packages[name] <. version: if packages[name] <. version:
packages[name] = version packages[name] = version
else: else:
@ -60,7 +60,7 @@ iterator chosen(packages: PStringTable): string =
proc addBabelPath(p: string, info: TLineInfo) = proc addBabelPath(p: string, info: TLineInfo) =
if not contains(options.searchPaths, p): if not contains(options.searchPaths, p):
if gVerbosity >= 1: Message(info, hintPath, p) if gVerbosity >= 1: message(info, hintPath, p)
lists.PrependStr(options.lazyPaths, p) lists.PrependStr(options.lazyPaths, p)
proc addPathWithNimFiles(p: string, info: TLineInfo) = proc addPathWithNimFiles(p: string, info: TLineInfo) =

4
compiler/ccgcalls.nim
View file

@ -88,7 +88,7 @@ proc openArrayLoc(p: BProc, n: PNode): PRope =
result = ropef("$1->data, $1->$2", [a.rdLoc, lenField()]) result = ropef("$1->data, $1->$2", [a.rdLoc, lenField()])
of tyArray, tyArrayConstr: of tyArray, tyArrayConstr:
result = ropef("$1, $2", [rdLoc(a), toRope(lengthOrd(a.t))]) result = ropef("$1, $2", [rdLoc(a), toRope(lengthOrd(a.t))])
else: InternalError("openArrayLoc: " & typeToString(a.t)) else: internalError("openArrayLoc: " & typeToString(a.t))
proc genArgStringToCString(p: BProc, proc genArgStringToCString(p: BProc,
n: PNode): PRope {.inline.} = n: PNode): PRope {.inline.} =
@ -243,7 +243,7 @@ proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) =
for i in countup(3, length-1): for i in countup(3, length-1):
assert(sonsLen(typ) == sonsLen(typ.n)) assert(sonsLen(typ) == sonsLen(typ.n))
if i >= sonsLen(typ): if i >= sonsLen(typ):
InternalError(ri.info, "varargs for objective C method?") internalError(ri.info, "varargs for objective C method?")
assert(typ.n.sons[i].kind == nkSym) assert(typ.n.sons[i].kind == nkSym)
var param = typ.n.sons[i].sym var param = typ.n.sons[i].sym
app(pl, ~" ") app(pl, ~" ")

204
compiler/ccgexprs.nim
View file

@ -22,7 +22,7 @@ proc intLiteral(i: biggestInt): PRope =
else: else:
result = ~"(IL64(-9223372036854775807) - IL64(1))" result = ~"(IL64(-9223372036854775807) - IL64(1))"
proc int32Literal(i: Int): PRope = proc int32Literal(i: int): PRope =
if i == int(low(int32)): if i == int(low(int32)):
result = ~"(-2147483647 -1)" result = ~"(-2147483647 -1)"
else: else:
@ -39,7 +39,7 @@ proc getStrLit(m: BModule, s: string): PRope =
discard cgsym(m, "TGenericSeq") discard cgsym(m, "TGenericSeq")
result = con("TMP", toRope(backendId())) result = con("TMP", toRope(backendId()))
appf(m.s[cfsData], "STRING_LITERAL($1, $2, $3);$n", appf(m.s[cfsData], "STRING_LITERAL($1, $2, $3);$n",
[result, makeCString(s), ToRope(len(s))]) [result, makeCString(s), toRope(len(s))])
proc genLiteral(p: BProc, n: PNode, ty: PType): PRope = proc genLiteral(p: BProc, n: PNode, ty: PType): PRope =
if ty == nil: internalError(n.info, "genLiteral: ty is nil") if ty == nil: internalError(n.info, "genLiteral: ty is nil")
@ -62,7 +62,7 @@ proc genLiteral(p: BProc, n: PNode, ty: PType): PRope =
of nkNilLit: of nkNilLit:
let t = skipTypes(ty, abstractVarRange) let t = skipTypes(ty, abstractVarRange)
if t.kind == tyProc and t.callConv == ccClosure: if t.kind == tyProc and t.callConv == ccClosure:
var id = NodeTableTestOrSet(p.module.dataCache, n, gBackendId) var id = nodeTableTestOrSet(p.module.dataCache, n, gBackendId)
result = con("TMP", toRope(id)) result = con("TMP", toRope(id))
if id == gBackendId: if id == gBackendId:
# not found in cache: # not found in cache:
@ -74,7 +74,7 @@ proc genLiteral(p: BProc, n: PNode, ty: PType): PRope =
result = toRope("NIM_NIL") result = toRope("NIM_NIL")
of nkStrLit..nkTripleStrLit: of nkStrLit..nkTripleStrLit:
if skipTypes(ty, abstractVarRange).kind == tyString: if skipTypes(ty, abstractVarRange).kind == tyString:
var id = NodeTableTestOrSet(p.module.dataCache, n, gBackendId) var id = nodeTableTestOrSet(p.module.dataCache, n, gBackendId)
if id == gBackendId: if id == gBackendId:
# string literal not found in the cache: # string literal not found in the cache:
result = ropecg(p.module, "((#NimStringDesc*) &$1)", result = ropecg(p.module, "((#NimStringDesc*) &$1)",
@ -84,9 +84,9 @@ proc genLiteral(p: BProc, n: PNode, ty: PType): PRope =
else: else:
result = makeCString(n.strVal) result = makeCString(n.strVal)
of nkFloatLit..nkFloat64Lit: of nkFloatLit..nkFloat64Lit:
result = toRope(n.floatVal.ToStrMaxPrecision) result = toRope(n.floatVal.toStrMaxPrecision)
else: else:
InternalError(n.info, "genLiteral(" & $n.kind & ')') internalError(n.info, "genLiteral(" & $n.kind & ')')
result = nil result = nil
proc genLiteral(p: BProc, n: PNode): PRope = proc genLiteral(p: BProc, n: PNode): PRope =
@ -96,7 +96,7 @@ proc bitSetToWord(s: TBitSet, size: int): BiggestInt =
result = 0 result = 0
when true: when true:
for j in countup(0, size - 1): for j in countup(0, size - 1):
if j < len(s): result = result or `shl`(Ze64(s[j]), j * 8) if j < len(s): result = result or `shl`(ze64(s[j]), j * 8)
else: else:
# not needed, too complex thinking: # not needed, too complex thinking:
if CPU[platform.hostCPU].endian == CPU[targetCPU].endian: if CPU[platform.hostCPU].endian == CPU[targetCPU].endian:
@ -117,7 +117,7 @@ proc genRawSetData(cs: TBitSet, size: int): PRope =
else: frmt = "0x$1, " else: frmt = "0x$1, "
else: else:
frmt = "0x$1}$n" frmt = "0x$1}$n"
appf(result, frmt, [toRope(toHex(Ze64(cs[i]), 2))]) appf(result, frmt, [toRope(toHex(ze64(cs[i]), 2))])
else: else:
result = intLiteral(bitSetToWord(cs, size)) result = intLiteral(bitSetToWord(cs, size))
# result := toRope('0x' + ToHex(bitSetToWord(cs, size), size * 2)) # result := toRope('0x' + ToHex(bitSetToWord(cs, size), size * 2))
@ -127,7 +127,7 @@ proc genSetNode(p: BProc, n: PNode): PRope =
var size = int(getSize(n.typ)) var size = int(getSize(n.typ))
toBitSet(n, cs) toBitSet(n, cs)
if size > 8: if size > 8:
var id = NodeTableTestOrSet(p.module.dataCache, n, gBackendId) var id = nodeTableTestOrSet(p.module.dataCache, n, gBackendId)
result = con("TMP", toRope(id)) result = con("TMP", toRope(id))
if id == gBackendId: if id == gBackendId:
# not found in cache: # not found in cache:
@ -155,7 +155,7 @@ proc getStorageLoc(n: PNode): TStorageLoc =
of tyVar: result = OnUnknown of tyVar: result = OnUnknown
of tyPtr: result = OnStack of tyPtr: result = OnStack
of tyRef: result = OnHeap of tyRef: result = OnHeap
else: InternalError(n.info, "getStorageLoc") else: internalError(n.info, "getStorageLoc")
of nkBracketExpr, nkDotExpr, nkObjDownConv, nkObjUpConv: of nkBracketExpr, nkDotExpr, nkObjDownConv, nkObjUpConv:
result = getStorageLoc(n.sons[0]) result = getStorageLoc(n.sons[0])
else: result = OnUnknown else: result = OnUnknown
@ -343,7 +343,7 @@ proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) =
of tyPtr, tyPointer, tyChar, tyBool, tyEnum, tyCString, of tyPtr, tyPointer, tyChar, tyBool, tyEnum, tyCString,
tyInt..tyUInt64, tyRange, tyVar: tyInt..tyUInt64, tyRange, tyVar:
linefmt(p, cpsStmts, "$1 = $2;$n", rdLoc(dest), rdLoc(src)) linefmt(p, cpsStmts, "$1 = $2;$n", rdLoc(dest), rdLoc(src))
else: InternalError("genAssignment(" & $ty.kind & ')') else: internalError("genAssignment(" & $ty.kind & ')')
proc getDestLoc(p: BProc, d: var TLoc, typ: PType) = proc getDestLoc(p: BProc, d: var TLoc, typ: PType) =
if d.k == locNone: getTemp(p, typ, d) if d.k == locNone: getTemp(p, typ, d)
@ -373,48 +373,48 @@ proc putIntoDest(p: BProc, d: var TLoc, t: PType, r: PRope) =
proc binaryStmt(p: BProc, e: PNode, d: var TLoc, frmt: string) = proc binaryStmt(p: BProc, e: PNode, d: var TLoc, frmt: string) =
var a, b: TLoc var a, b: TLoc
if d.k != locNone: InternalError(e.info, "binaryStmt") if d.k != locNone: internalError(e.info, "binaryStmt")
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
InitLocExpr(p, e.sons[2], b) initLocExpr(p, e.sons[2], b)
lineCg(p, cpsStmts, frmt, rdLoc(a), rdLoc(b)) lineCg(p, cpsStmts, frmt, rdLoc(a), rdLoc(b))
proc unaryStmt(p: BProc, e: PNode, d: var TLoc, frmt: string) = proc unaryStmt(p: BProc, e: PNode, d: var TLoc, frmt: string) =
var a: TLoc var a: TLoc
if d.k != locNone: InternalError(e.info, "unaryStmt") if d.k != locNone: internalError(e.info, "unaryStmt")
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
lineCg(p, cpsStmts, frmt, [rdLoc(a)]) lineCg(p, cpsStmts, frmt, [rdLoc(a)])
proc binaryStmtChar(p: BProc, e: PNode, d: var TLoc, frmt: string) = proc binaryStmtChar(p: BProc, e: PNode, d: var TLoc, frmt: string) =
var a, b: TLoc var a, b: TLoc
if (d.k != locNone): InternalError(e.info, "binaryStmtChar") if (d.k != locNone): internalError(e.info, "binaryStmtChar")
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
InitLocExpr(p, e.sons[2], b) initLocExpr(p, e.sons[2], b)
lineCg(p, cpsStmts, frmt, [rdCharLoc(a), rdCharLoc(b)]) lineCg(p, cpsStmts, frmt, [rdCharLoc(a), rdCharLoc(b)])
proc binaryExpr(p: BProc, e: PNode, d: var TLoc, frmt: string) = proc binaryExpr(p: BProc, e: PNode, d: var TLoc, frmt: string) =
var a, b: TLoc var a, b: TLoc
assert(e.sons[1].typ != nil) assert(e.sons[1].typ != nil)
assert(e.sons[2].typ != nil) assert(e.sons[2].typ != nil)
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
InitLocExpr(p, e.sons[2], b) initLocExpr(p, e.sons[2], b)
putIntoDest(p, d, e.typ, ropecg(p.module, frmt, [rdLoc(a), rdLoc(b)])) putIntoDest(p, d, e.typ, ropecg(p.module, frmt, [rdLoc(a), rdLoc(b)]))
proc binaryExprChar(p: BProc, e: PNode, d: var TLoc, frmt: string) = proc binaryExprChar(p: BProc, e: PNode, d: var TLoc, frmt: string) =
var a, b: TLoc var a, b: TLoc
assert(e.sons[1].typ != nil) assert(e.sons[1].typ != nil)
assert(e.sons[2].typ != nil) assert(e.sons[2].typ != nil)
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
InitLocExpr(p, e.sons[2], b) initLocExpr(p, e.sons[2], b)
putIntoDest(p, d, e.typ, ropecg(p.module, frmt, [a.rdCharLoc, b.rdCharLoc])) putIntoDest(p, d, e.typ, ropecg(p.module, frmt, [a.rdCharLoc, b.rdCharLoc]))
proc unaryExpr(p: BProc, e: PNode, d: var TLoc, frmt: string) = proc unaryExpr(p: BProc, e: PNode, d: var TLoc, frmt: string) =
var a: TLoc var a: TLoc
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
putIntoDest(p, d, e.typ, ropecg(p.module, frmt, [rdLoc(a)])) putIntoDest(p, d, e.typ, ropecg(p.module, frmt, [rdLoc(a)]))
proc unaryExprChar(p: BProc, e: PNode, d: var TLoc, frmt: string) = proc unaryExprChar(p: BProc, e: PNode, d: var TLoc, frmt: string) =
var a: TLoc var a: TLoc
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
putIntoDest(p, d, e.typ, ropecg(p.module, frmt, [rdCharLoc(a)])) putIntoDest(p, d, e.typ, ropecg(p.module, frmt, [rdCharLoc(a)]))
proc binaryArithOverflow(p: BProc, e: PNode, d: var TLoc, m: TMagic) = proc binaryArithOverflow(p: BProc, e: PNode, d: var TLoc, m: TMagic) =
@ -427,8 +427,8 @@ proc binaryArithOverflow(p: BProc, e: PNode, d: var TLoc, m: TMagic) =
var a, b: TLoc var a, b: TLoc
assert(e.sons[1].typ != nil) assert(e.sons[1].typ != nil)
assert(e.sons[2].typ != nil) assert(e.sons[2].typ != nil)
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
InitLocExpr(p, e.sons[2], b) initLocExpr(p, e.sons[2], b)
var t = skipTypes(e.typ, abstractRange) var t = skipTypes(e.typ, abstractRange)
if optOverflowCheck notin p.options: if optOverflowCheck notin p.options:
putIntoDest(p, d, e.typ, ropef("(NI$4)($2 $1 $3)", [toRope(opr[m]), putIntoDest(p, d, e.typ, ropef("(NI$4)($2 $1 $3)", [toRope(opr[m]),
@ -460,7 +460,7 @@ proc unaryArithOverflow(p: BProc, e: PNode, d: var TLoc, m: TMagic) =
a: TLoc a: TLoc
t: PType t: PType
assert(e.sons[1].typ != nil) assert(e.sons[1].typ != nil)
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
t = skipTypes(e.typ, abstractRange) t = skipTypes(e.typ, abstractRange)
if optOverflowCheck in p.options: if optOverflowCheck in p.options:
linefmt(p, cpsStmts, "if ($1 == $2) #raiseOverflow();$n", linefmt(p, cpsStmts, "if ($1 == $2) #raiseOverflow();$n",
@ -526,11 +526,11 @@ proc binaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
"($1 != $2)"] # Xor "($1 != $2)"] # Xor
var var
a, b: TLoc a, b: TLoc
s: biggestInt s: BiggestInt
assert(e.sons[1].typ != nil) assert(e.sons[1].typ != nil)
assert(e.sons[2].typ != nil) assert(e.sons[2].typ != nil)
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
InitLocExpr(p, e.sons[2], b) initLocExpr(p, e.sons[2], b)
# BUGFIX: cannot use result-type here, as it may be a boolean # BUGFIX: cannot use result-type here, as it may be a boolean
s = max(getSize(a.t), getSize(b.t)) * 8 s = max(getSize(a.t), getSize(b.t)) * 8
putIntoDest(p, d, e.typ, putIntoDest(p, d, e.typ,
@ -541,8 +541,8 @@ proc genEqProc(p: BProc, e: PNode, d: var TLoc) =
var a, b: TLoc var a, b: TLoc
assert(e.sons[1].typ != nil) assert(e.sons[1].typ != nil)
assert(e.sons[2].typ != nil) assert(e.sons[2].typ != nil)
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
InitLocExpr(p, e.sons[2], b) initLocExpr(p, e.sons[2], b)
if a.t.callConv == ccClosure: if a.t.callConv == ccClosure:
putIntoDest(p, d, e.typ, putIntoDest(p, d, e.typ,
ropef("($1.ClPrc == $2.ClPrc && $1.ClEnv == $2.ClEnv)", [ ropef("($1.ClPrc == $2.ClPrc && $1.ClEnv == $2.ClEnv)", [
@ -585,7 +585,7 @@ proc unaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
a: TLoc a: TLoc
t: PType t: PType
assert(e.sons[1].typ != nil) assert(e.sons[1].typ != nil)
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
t = skipTypes(e.typ, abstractRange) t = skipTypes(e.typ, abstractRange)
putIntoDest(p, d, e.typ, putIntoDest(p, d, e.typ,
ropef(unArithTab[op], [rdLoc(a), toRope(getSize(t) * 8), ropef(unArithTab[op], [rdLoc(a), toRope(getSize(t) * 8),
@ -606,21 +606,21 @@ proc genDeref(p: BProc, e: PNode, d: var TLoc) =
d.s = OnUnknown d.s = OnUnknown
of tyPtr: of tyPtr:
d.s = OnUnknown # BUGFIX! d.s = OnUnknown # BUGFIX!
else: InternalError(e.info, "genDeref " & $a.t.kind) else: internalError(e.info, "genDeref " & $a.t.kind)
putIntoDest(p, d, a.t.sons[0], ropef("(*$1)", [rdLoc(a)])) putIntoDest(p, d, a.t.sons[0], ropef("(*$1)", [rdLoc(a)]))
proc genAddr(p: BProc, e: PNode, d: var TLoc) = proc genAddr(p: BProc, e: PNode, d: var TLoc) =
# careful 'addr(myptrToArray)' needs to get the ampersand: # careful 'addr(myptrToArray)' needs to get the ampersand:
if e.sons[0].typ.skipTypes(abstractInst).kind in {tyRef, tyPtr}: if e.sons[0].typ.skipTypes(abstractInst).kind in {tyRef, tyPtr}:
var a: TLoc var a: TLoc
InitLocExpr(p, e.sons[0], a) initLocExpr(p, e.sons[0], a)
putIntoDest(p, d, e.typ, con("&", a.r)) putIntoDest(p, d, e.typ, con("&", a.r))
#Message(e.info, warnUser, "HERE NEW &") #Message(e.info, warnUser, "HERE NEW &")
elif mapType(e.sons[0].typ) == ctArray: elif mapType(e.sons[0].typ) == ctArray:
expr(p, e.sons[0], d) expr(p, e.sons[0], d)
else: else:
var a: TLoc var a: TLoc
InitLocExpr(p, e.sons[0], a) initLocExpr(p, e.sons[0], a)
putIntoDest(p, d, e.typ, addrLoc(a)) putIntoDest(p, d, e.typ, addrLoc(a))
template inheritLocation(d: var TLoc, a: TLoc) = template inheritLocation(d: var TLoc, a: TLoc) =
@ -630,7 +630,7 @@ template inheritLocation(d: var TLoc, a: TLoc) =
proc genRecordFieldAux(p: BProc, e: PNode, d, a: var TLoc): PType = proc genRecordFieldAux(p: BProc, e: PNode, d, a: var TLoc): PType =
initLocExpr(p, e.sons[0], a) initLocExpr(p, e.sons[0], a)
if e.sons[1].kind != nkSym: InternalError(e.info, "genRecordFieldAux") if e.sons[1].kind != nkSym: internalError(e.info, "genRecordFieldAux")
d.inheritLocation(a) d.inheritLocation(a)
discard getTypeDesc(p.module, a.t) # fill the record's fields.loc discard getTypeDesc(p.module, a.t) # fill the record's fields.loc
result = a.t result = a.t
@ -664,13 +664,13 @@ proc genRecordField(p: BProc, e: PNode, d: var TLoc) =
var field: PSym = nil var field: PSym = nil
while ty != nil: while ty != nil:
if ty.kind notin {tyTuple, tyObject}: if ty.kind notin {tyTuple, tyObject}:
InternalError(e.info, "genRecordField") internalError(e.info, "genRecordField")
field = lookupInRecord(ty.n, f.name) field = lookupInRecord(ty.n, f.name)
if field != nil: break if field != nil: break
if gCmd != cmdCompileToCpp: app(r, ".Sup") if gCmd != cmdCompileToCpp: app(r, ".Sup")
ty = GetUniqueType(ty.sons[0]) ty = getUniqueType(ty.sons[0])
if field == nil: InternalError(e.info, "genRecordField 2 ") if field == nil: internalError(e.info, "genRecordField 2 ")
if field.loc.r == nil: InternalError(e.info, "genRecordField 3") if field.loc.r == nil: internalError(e.info, "genRecordField 3")
appf(r, ".$1", [field.loc.r]) appf(r, ".$1", [field.loc.r])
putIntoDest(p, d, field.typ, r) putIntoDest(p, d, field.typ, r)
@ -686,11 +686,11 @@ proc genFieldCheck(p: BProc, e: PNode, obj: PRope, field: PSym) =
if op.magic == mNot: it = it.sons[1] if op.magic == mNot: it = it.sons[1]
assert(it.sons[2].kind == nkSym) assert(it.sons[2].kind == nkSym)
initLoc(test, locNone, it.typ, OnStack) initLoc(test, locNone, it.typ, OnStack)
InitLocExpr(p, it.sons[1], u) initLocExpr(p, it.sons[1], u)
initLoc(v, locExpr, it.sons[2].typ, OnUnknown) initLoc(v, locExpr, it.sons[2].typ, OnUnknown)
v.r = ropef("$1.$2", [obj, it.sons[2].sym.loc.r]) v.r = ropef("$1.$2", [obj, it.sons[2].sym.loc.r])
genInExprAux(p, it, u, v, test) genInExprAux(p, it, u, v, test)
let id = NodeTableTestOrSet(p.module.dataCache, let id = nodeTableTestOrSet(p.module.dataCache,
newStrNode(nkStrLit, field.name.s), gBackendId) newStrNode(nkStrLit, field.name.s), gBackendId)
let strLit = if id == gBackendId: getStrLit(p.module, field.name.s) let strLit = if id == gBackendId: getStrLit(p.module, field.name.s)
else: con("TMP", toRope(id)) else: con("TMP", toRope(id))
@ -720,9 +720,9 @@ proc genCheckedRecordField(p: BProc, e: PNode, d: var TLoc) =
if field != nil: break if field != nil: break
if gCmd != cmdCompileToCpp: app(r, ".Sup") if gCmd != cmdCompileToCpp: app(r, ".Sup")
ty = getUniqueType(ty.sons[0]) ty = getUniqueType(ty.sons[0])
if field == nil: InternalError(e.info, "genCheckedRecordField") if field == nil: internalError(e.info, "genCheckedRecordField")
if field.loc.r == nil: if field.loc.r == nil:
InternalError(e.info, "genCheckedRecordField") # generate the checks: internalError(e.info, "genCheckedRecordField") # generate the checks:
genFieldCheck(p, e, r, field) genFieldCheck(p, e, r, field)
app(r, rfmt(nil, ".$1", field.loc.r)) app(r, rfmt(nil, ".$1", field.loc.r))
putIntoDest(p, d, field.typ, r) putIntoDest(p, d, field.typ, r)
@ -774,7 +774,7 @@ proc genOpenArrayElem(p: BProc, e: PNode, d: var TLoc) =
putIntoDest(p, d, elemType(skipTypes(a.t, abstractVar)), putIntoDest(p, d, elemType(skipTypes(a.t, abstractVar)),
rfmt(nil, "$1[$2]", rdLoc(a), rdCharLoc(b))) rfmt(nil, "$1[$2]", rdLoc(a), rdCharLoc(b)))
proc genSeqElem(p: BPRoc, e: PNode, d: var TLoc) = proc genSeqElem(p: BProc, e: PNode, d: var TLoc) =
var a, b: TLoc var a, b: TLoc
initLocExpr(p, e.sons[0], a) initLocExpr(p, e.sons[0], a)
initLocExpr(p, e.sons[1], b) initLocExpr(p, e.sons[1], b)
@ -873,11 +873,11 @@ proc genStrConcat(p: BProc, e: PNode, d: var TLoc) =
# compute the length expression: # compute the length expression:
initLocExpr(p, e.sons[i + 1], a) initLocExpr(p, e.sons[i + 1], a)
if skipTypes(e.sons[i + 1].Typ, abstractVarRange).kind == tyChar: if skipTypes(e.sons[i + 1].Typ, abstractVarRange).kind == tyChar:
Inc(L) inc(L)
app(appends, rfmt(p.module, "#appendChar($1, $2);$n", tmp.r, rdLoc(a))) app(appends, rfmt(p.module, "#appendChar($1, $2);$n", tmp.r, rdLoc(a)))
else: else:
if e.sons[i + 1].kind in {nkStrLit..nkTripleStrLit}: if e.sons[i + 1].kind in {nkStrLit..nkTripleStrLit}:
Inc(L, len(e.sons[i + 1].strVal)) inc(L, len(e.sons[i + 1].strVal))
else: else:
appf(lens, "$1->$2 + ", [rdLoc(a), lenField()]) appf(lens, "$1->$2 + ", [rdLoc(a), lenField()])
app(appends, rfmt(p.module, "#appendString($1, $2);$n", tmp.r, rdLoc(a))) app(appends, rfmt(p.module, "#appendString($1, $2);$n", tmp.r, rdLoc(a)))
@ -911,12 +911,12 @@ proc genStrAppend(p: BProc, e: PNode, d: var TLoc) =
# compute the length expression: # compute the length expression:
initLocExpr(p, e.sons[i + 2], a) initLocExpr(p, e.sons[i + 2], a)
if skipTypes(e.sons[i + 2].Typ, abstractVarRange).kind == tyChar: if skipTypes(e.sons[i + 2].Typ, abstractVarRange).kind == tyChar:
Inc(L) inc(L)
app(appends, rfmt(p.module, "#appendChar($1, $2);$n", app(appends, rfmt(p.module, "#appendChar($1, $2);$n",
rdLoc(dest), rdLoc(a))) rdLoc(dest), rdLoc(a)))
else: else:
if e.sons[i + 2].kind in {nkStrLit..nkTripleStrLit}: if e.sons[i + 2].kind in {nkStrLit..nkTripleStrLit}:
Inc(L, len(e.sons[i + 2].strVal)) inc(L, len(e.sons[i + 2].strVal))
else: else:
appf(lens, "$1->$2 + ", [rdLoc(a), lenField()]) appf(lens, "$1->$2 + ", [rdLoc(a), lenField()])
app(appends, rfmt(p.module, "#appendString($1, $2);$n", app(appends, rfmt(p.module, "#appendString($1, $2);$n",
@ -935,8 +935,8 @@ proc genSeqElemAppend(p: BProc, e: PNode, d: var TLoc) =
else: else:
"$1 = ($2) #incrSeq($1, sizeof($3));$n" "$1 = ($2) #incrSeq($1, sizeof($3));$n"
var a, b, dest: TLoc var a, b, dest: TLoc
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
InitLocExpr(p, e.sons[2], b) initLocExpr(p, e.sons[2], b)
lineCg(p, cpsStmts, seqAppendPattern, [ lineCg(p, cpsStmts, seqAppendPattern, [
rdLoc(a), rdLoc(a),
getTypeDesc(p.module, skipTypes(e.sons[1].typ, abstractVar)), getTypeDesc(p.module, skipTypes(e.sons[1].typ, abstractVar)),
@ -948,7 +948,7 @@ proc genSeqElemAppend(p: BProc, e: PNode, d: var TLoc) =
proc genReset(p: BProc, n: PNode) = proc genReset(p: BProc, n: PNode) =
var a: TLoc var a: TLoc
InitLocExpr(p, n.sons[1], a) initLocExpr(p, n.sons[1], a)
linefmt(p, cpsStmts, "#genericReset((void*)$1, $2);$n", linefmt(p, cpsStmts, "#genericReset((void*)$1, $2);$n",
addrLoc(a), genTypeInfo(p.module, skipTypes(a.t, abstractVarRange))) addrLoc(a), genTypeInfo(p.module, skipTypes(a.t, abstractVarRange)))
@ -959,8 +959,8 @@ proc rawGenNew(p: BProc, a: TLoc, sizeExpr: PRope) =
initLoc(b, locExpr, a.t, OnHeap) initLoc(b, locExpr, a.t, OnHeap)
if sizeExpr.isNil: if sizeExpr.isNil:
sizeExpr = ropef("sizeof($1)", sizeExpr = ropef("sizeof($1)",
getTypeDesc(p.module, skipTypes(reftype.sons[0], abstractRange))) getTypeDesc(p.module, skipTypes(refType.sons[0], abstractRange)))
let args = [getTypeDesc(p.module, reftype), let args = [getTypeDesc(p.module, refType),
genTypeInfo(p.module, refType), genTypeInfo(p.module, refType),
sizeExpr] sizeExpr]
if a.s == OnHeap and usesNativeGC(): if a.s == OnHeap and usesNativeGC():
@ -979,11 +979,11 @@ proc rawGenNew(p: BProc, a: TLoc, sizeExpr: PRope) =
proc genNew(p: BProc, e: PNode) = proc genNew(p: BProc, e: PNode) =
var a: TLoc var a: TLoc
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
# 'genNew' also handles 'unsafeNew': # 'genNew' also handles 'unsafeNew':
if e.len == 3: if e.len == 3:
var se: TLoc var se: TLoc
InitLocExpr(p, e.sons[2], se) initLocExpr(p, e.sons[2], se)
rawGenNew(p, a, se.rdLoc) rawGenNew(p, a, se.rdLoc)
else: else:
rawGenNew(p, a, nil) rawGenNew(p, a, nil)
@ -991,7 +991,7 @@ proc genNew(p: BProc, e: PNode) =
proc genNewSeqAux(p: BProc, dest: TLoc, length: PRope) = proc genNewSeqAux(p: BProc, dest: TLoc, length: PRope) =
let seqtype = skipTypes(dest.t, abstractVarRange) let seqtype = skipTypes(dest.t, abstractVarRange)
let args = [getTypeDesc(p.module, seqtype), let args = [getTypeDesc(p.module, seqtype),
genTypeInfo(p.module, seqType), length] genTypeInfo(p.module, seqtype), length]
var call: TLoc var call: TLoc
initLoc(call, locExpr, dest.t, OnHeap) initLoc(call, locExpr, dest.t, OnHeap)
if dest.s == OnHeap and usesNativeGC(): if dest.s == OnHeap and usesNativeGC():
@ -1007,8 +1007,8 @@ proc genNewSeqAux(p: BProc, dest: TLoc, length: PRope) =
proc genNewSeq(p: BProc, e: PNode) = proc genNewSeq(p: BProc, e: PNode) =
var a, b: TLoc var a, b: TLoc
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
InitLocExpr(p, e.sons[2], b) initLocExpr(p, e.sons[2], b)
genNewSeqAux(p, a, b.rdLoc) genNewSeqAux(p, a, b.rdLoc)
proc genObjConstr(p: BProc, e: PNode, d: var TLoc) = proc genObjConstr(p: BProc, e: PNode, d: var TLoc) =
@ -1032,8 +1032,8 @@ proc genObjConstr(p: BProc, e: PNode, d: var TLoc) =
field = lookupInRecord(ty.n, it.sons[0].sym.name) field = lookupInRecord(ty.n, it.sons[0].sym.name)
if field != nil: break if field != nil: break
if gCmd != cmdCompileToCpp: app(tmp2.r, ".Sup") if gCmd != cmdCompileToCpp: app(tmp2.r, ".Sup")
ty = GetUniqueType(ty.sons[0]) ty = getUniqueType(ty.sons[0])
if field == nil or field.loc.r == nil: InternalError(e.info, "genObjConstr") if field == nil or field.loc.r == nil: internalError(e.info, "genObjConstr")
if it.len == 3 and optFieldCheck in p.options: if it.len == 3 and optFieldCheck in p.options:
genFieldCheck(p, it.sons[2], r, field) genFieldCheck(p, it.sons[2], r, field)
app(tmp2.r, ".") app(tmp2.r, ".")
@ -1088,14 +1088,14 @@ proc genNewFinalize(p: BProc, e: PNode) =
ti: PRope ti: PRope
oldModule: BModule oldModule: BModule
refType = skipTypes(e.sons[1].typ, abstractVarRange) refType = skipTypes(e.sons[1].typ, abstractVarRange)
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
InitLocExpr(p, e.sons[2], f) initLocExpr(p, e.sons[2], f)
initLoc(b, locExpr, a.t, OnHeap) initLoc(b, locExpr, a.t, OnHeap)
ti = genTypeInfo(p.module, refType) ti = genTypeInfo(p.module, refType)
appf(p.module.s[cfsTypeInit3], "$1->finalizer = (void*)$2;$n", [ti, rdLoc(f)]) appf(p.module.s[cfsTypeInit3], "$1->finalizer = (void*)$2;$n", [ti, rdLoc(f)])
b.r = ropecg(p.module, "($1) #newObj($2, sizeof($3))", [ b.r = ropecg(p.module, "($1) #newObj($2, sizeof($3))", [
getTypeDesc(p.module, refType), getTypeDesc(p.module, refType),
ti, getTypeDesc(p.module, skipTypes(reftype.sons[0], abstractRange))]) ti, getTypeDesc(p.module, skipTypes(refType.sons[0], abstractRange))])
genAssignment(p, a, b, {needToKeepAlive}) # set the object type: genAssignment(p, a, b, {needToKeepAlive}) # set the object type:
bt = skipTypes(refType.sons[0], abstractRange) bt = skipTypes(refType.sons[0], abstractRange)
genObjectInit(p, cpsStmts, bt, a, false) genObjectInit(p, cpsStmts, bt, a, false)
@ -1116,7 +1116,7 @@ proc genOf(p: BProc, x: PNode, typ: PType, d: var TLoc) =
app(r, ~".Sup") app(r, ~".Sup")
t = skipTypes(t.sons[0], typedescInst) t = skipTypes(t.sons[0], typedescInst)
if isObjLackingTypeField(t): if isObjLackingTypeField(t):
GlobalError(x.info, errGenerated, globalError(x.info, errGenerated,
"no 'of' operator available for pure objects") "no 'of' operator available for pure objects")
if nilCheck != nil: if nilCheck != nil:
r = rfmt(p.module, "(($1) && #isObj($2.m_type, $3))", r = rfmt(p.module, "(($1) && #isObj($2.m_type, $3))",
@ -1132,7 +1132,7 @@ proc genOf(p: BProc, n: PNode, d: var TLoc) =
proc genRepr(p: BProc, e: PNode, d: var TLoc) = proc genRepr(p: BProc, e: PNode, d: var TLoc) =
# XXX we don't generate keep alive info for now here # XXX we don't generate keep alive info for now here
var a: TLoc var a: TLoc
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
var t = skipTypes(e.sons[1].typ, abstractVarRange) var t = skipTypes(e.sons[1].typ, abstractVarRange)
case t.kind case t.kind
of tyInt..tyInt64, tyUInt..tyUInt64: of tyInt..tyInt64, tyUInt..tyUInt64:
@ -1164,7 +1164,7 @@ proc genRepr(p: BProc, e: PNode, d: var TLoc) =
of tyArray, tyArrayConstr: of tyArray, tyArrayConstr:
putIntoDest(p, b, e.typ, putIntoDest(p, b, e.typ,
ropef("$1, $2", [rdLoc(a), toRope(lengthOrd(a.t))])) ropef("$1, $2", [rdLoc(a), toRope(lengthOrd(a.t))]))
else: InternalError(e.sons[0].info, "genRepr()") else: internalError(e.sons[0].info, "genRepr()")
putIntoDest(p, d, e.typ, putIntoDest(p, d, e.typ,
ropecg(p.module, "#reprOpenArray($1, $2)", [rdLoc(b), ropecg(p.module, "#reprOpenArray($1, $2)", [rdLoc(b),
genTypeInfo(p.module, elemType(t))])) genTypeInfo(p.module, elemType(t))]))
@ -1183,7 +1183,7 @@ proc genGetTypeInfo(p: BProc, e: PNode, d: var TLoc) =
proc genDollar(p: BProc, n: PNode, d: var TLoc, frmt: string) = proc genDollar(p: BProc, n: PNode, d: var TLoc, frmt: string) =
var a: TLoc var a: TLoc
InitLocExpr(p, n.sons[1], a) initLocExpr(p, n.sons[1], a)
a.r = ropecg(p.module, frmt, [rdLoc(a)]) a.r = ropecg(p.module, frmt, [rdLoc(a)])
if d.k == locNone: getTemp(p, n.typ, d) if d.k == locNone: getTemp(p, n.typ, d)
genAssignment(p, d, a, {needToKeepAlive}) genAssignment(p, d, a, {needToKeepAlive})
@ -1208,15 +1208,15 @@ proc genArrayLen(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
else: unaryExpr(p, e, d, "$1->len") else: unaryExpr(p, e, d, "$1->len")
of tyArray, tyArrayConstr: of tyArray, tyArrayConstr:
# YYY: length(sideeffect) is optimized away incorrectly? # YYY: length(sideeffect) is optimized away incorrectly?
if op == mHigh: putIntoDest(p, d, e.typ, toRope(lastOrd(Typ))) if op == mHigh: putIntoDest(p, d, e.typ, toRope(lastOrd(typ)))
else: putIntoDest(p, d, e.typ, toRope(lengthOrd(typ))) else: putIntoDest(p, d, e.typ, toRope(lengthOrd(typ)))
else: InternalError(e.info, "genArrayLen()") else: internalError(e.info, "genArrayLen()")
proc genSetLengthSeq(p: BProc, e: PNode, d: var TLoc) = proc genSetLengthSeq(p: BProc, e: PNode, d: var TLoc) =
var a, b: TLoc var a, b: TLoc
assert(d.k == locNone) assert(d.k == locNone)
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
InitLocExpr(p, e.sons[2], b) initLocExpr(p, e.sons[2], b)
var t = skipTypes(e.sons[1].typ, abstractVar) var t = skipTypes(e.sons[1].typ, abstractVar)
let setLenPattern = if gCmd != cmdCompileToCpp: let setLenPattern = if gCmd != cmdCompileToCpp:
"$1 = ($3) #setLengthSeq(&($1)->Sup, sizeof($4), $2);$n" "$1 = ($3) #setLengthSeq(&($1)->Sup, sizeof($4), $2);$n"
@ -1230,7 +1230,7 @@ proc genSetLengthSeq(p: BProc, e: PNode, d: var TLoc) =
proc genSetLengthStr(p: BProc, e: PNode, d: var TLoc) = proc genSetLengthStr(p: BProc, e: PNode, d: var TLoc) =
binaryStmt(p, e, d, "$1 = #setLengthStr($1, $2);$n") binaryStmt(p, e, d, "$1 = #setLengthStr($1, $2);$n")
keepAlive(P, d) keepAlive(p, d)
proc genSwap(p: BProc, e: PNode, d: var TLoc) = proc genSwap(p: BProc, e: PNode, d: var TLoc) =
# swap(a, b) --> # swap(a, b) -->
@ -1239,8 +1239,8 @@ proc genSwap(p: BProc, e: PNode, d: var TLoc) =
# b = temp # b = temp
var a, b, tmp: TLoc var a, b, tmp: TLoc
getTemp(p, skipTypes(e.sons[1].typ, abstractVar), tmp) getTemp(p, skipTypes(e.sons[1].typ, abstractVar), tmp)
InitLocExpr(p, e.sons[1], a) # eval a initLocExpr(p, e.sons[1], a) # eval a
InitLocExpr(p, e.sons[2], b) # eval b initLocExpr(p, e.sons[2], b) # eval b
genAssignment(p, tmp, a, {}) genAssignment(p, tmp, a, {})
genAssignment(p, a, b, {}) genAssignment(p, a, b, {})
genAssignment(p, b, tmp, {}) genAssignment(p, b, tmp, {})
@ -1256,7 +1256,7 @@ proc rdSetElemLoc(a: TLoc, setType: PType): PRope =
proc fewCmps(s: PNode): bool = proc fewCmps(s: PNode): bool =
# this function estimates whether it is better to emit code # this function estimates whether it is better to emit code
# for constructing the set or generating a bunch of comparisons directly # for constructing the set or generating a bunch of comparisons directly
if s.kind != nkCurly: InternalError(s.info, "fewCmps") if s.kind != nkCurly: internalError(s.info, "fewCmps")
if (getSize(s.typ) <= platform.intSize) and (nfAllConst in s.flags): if (getSize(s.typ) <= platform.intSize) and (nfAllConst in s.flags):
result = false # it is better to emit the set generation code result = false # it is better to emit the set generation code
elif elemType(s.typ).Kind in {tyInt, tyInt16..tyInt64}: elif elemType(s.typ).Kind in {tyInt, tyInt16..tyInt64}:
@ -1278,8 +1278,8 @@ proc genInExprAux(p: BProc, e: PNode, a, b, d: var TLoc) =
proc binaryStmtInExcl(p: BProc, e: PNode, d: var TLoc, frmt: string) = proc binaryStmtInExcl(p: BProc, e: PNode, d: var TLoc, frmt: string) =
var a, b: TLoc var a, b: TLoc
assert(d.k == locNone) assert(d.k == locNone)
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
InitLocExpr(p, e.sons[2], b) initLocExpr(p, e.sons[2], b)
lineF(p, cpsStmts, frmt, [rdLoc(a), rdSetElemLoc(b, a.t)]) lineF(p, cpsStmts, frmt, [rdLoc(a), rdSetElemLoc(b, a.t)])
proc genInOp(p: BProc, e: PNode, d: var TLoc) = proc genInOp(p: BProc, e: PNode, d: var TLoc) =
@ -1299,12 +1299,12 @@ proc genInOp(p: BProc, e: PNode, d: var TLoc) =
var length = sonsLen(e.sons[1]) var length = sonsLen(e.sons[1])
for i in countup(0, length - 1): for i in countup(0, length - 1):
if e.sons[1].sons[i].Kind == nkRange: if e.sons[1].sons[i].Kind == nkRange:
InitLocExpr(p, e.sons[1].sons[i].sons[0], x) initLocExpr(p, e.sons[1].sons[i].sons[0], x)
InitLocExpr(p, e.sons[1].sons[i].sons[1], y) initLocExpr(p, e.sons[1].sons[i].sons[1], y)
appf(b.r, "$1 >= $2 && $1 <= $3", appf(b.r, "$1 >= $2 && $1 <= $3",
[rdCharLoc(a), rdCharLoc(x), rdCharLoc(y)]) [rdCharLoc(a), rdCharLoc(x), rdCharLoc(y)])
else: else:
InitLocExpr(p, e.sons[1].sons[i], x) initLocExpr(p, e.sons[1].sons[i], x)
appf(b.r, "$1 == $2", [rdCharLoc(a), rdCharLoc(x)]) appf(b.r, "$1 == $2", [rdCharLoc(a), rdCharLoc(x)])
if i < length - 1: app(b.r, " || ") if i < length - 1: app(b.r, " || ")
app(b.r, ")") app(b.r, ")")
@ -1312,8 +1312,8 @@ proc genInOp(p: BProc, e: PNode, d: var TLoc) =
else: else:
assert(e.sons[1].typ != nil) assert(e.sons[1].typ != nil)
assert(e.sons[2].typ != nil) assert(e.sons[2].typ != nil)
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
InitLocExpr(p, e.sons[2], b) initLocExpr(p, e.sons[2], b)
genInExprAux(p, e, a, b, d) genInExprAux(p, e, a, b, d)
proc genSetOp(p: BProc, e: PNode, d: var TLoc, op: TMagic) = proc genSetOp(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
@ -1391,7 +1391,7 @@ proc genSomeCast(p: BProc, e: PNode, d: var TLoc) =
# we use whatever C gives us. Except if we have a value-type, we need to go # we use whatever C gives us. Except if we have a value-type, we need to go
# through its address: # through its address:
var a: TLoc var a: TLoc
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
let etyp = skipTypes(e.typ, abstractRange) let etyp = skipTypes(e.typ, abstractRange)
if etyp.kind in ValueTypes and lfIndirect notin a.flags: if etyp.kind in ValueTypes and lfIndirect notin a.flags:
putIntoDest(p, d, e.typ, ropef("(*($1*) ($2))", putIntoDest(p, d, e.typ, ropef("(*($1*) ($2))",
@ -1433,13 +1433,13 @@ proc genRangeChck(p: BProc, n: PNode, d: var TLoc, magic: string) =
var dest = skipTypes(n.typ, abstractVar) var dest = skipTypes(n.typ, abstractVar)
# range checks for unsigned turned out to be buggy and annoying: # range checks for unsigned turned out to be buggy and annoying:
if optRangeCheck notin p.options or dest.kind in {tyUInt..tyUInt64}: if optRangeCheck notin p.options or dest.kind in {tyUInt..tyUInt64}:
InitLocExpr(p, n.sons[0], a) initLocExpr(p, n.sons[0], a)
putIntoDest(p, d, n.typ, ropef("(($1) ($2))", putIntoDest(p, d, n.typ, ropef("(($1) ($2))",
[getTypeDesc(p.module, dest), rdCharLoc(a)])) [getTypeDesc(p.module, dest), rdCharLoc(a)]))
else: else:
InitLocExpr(p, n.sons[0], a) initLocExpr(p, n.sons[0], a)
if leValue(n.sons[2], n.sons[1]): if leValue(n.sons[2], n.sons[1]):
InternalError(n.info, "range check will always fail; empty range") internalError(n.info, "range check will always fail; empty range")
putIntoDest(p, d, dest, ropecg(p.module, "(($1)#$5($2, $3, $4))", [ putIntoDest(p, d, dest, ropecg(p.module, "(($1)#$5($2, $3, $4))", [
getTypeDesc(p.module, dest), rdCharLoc(a), getTypeDesc(p.module, dest), rdCharLoc(a),
genLiteral(p, n.sons[1], dest), genLiteral(p, n.sons[2], dest), genLiteral(p, n.sons[1], dest), genLiteral(p, n.sons[2], dest),
@ -1486,8 +1486,8 @@ proc binaryFloatArith(p: BProc, e: PNode, d: var TLoc, m: TMagic) =
var a, b: TLoc var a, b: TLoc
assert(e.sons[1].typ != nil) assert(e.sons[1].typ != nil)
assert(e.sons[2].typ != nil) assert(e.sons[2].typ != nil)
InitLocExpr(p, e.sons[1], a) initLocExpr(p, e.sons[1], a)
InitLocExpr(p, e.sons[2], b) initLocExpr(p, e.sons[2], b)
putIntoDest(p, d, e.typ, rfmt(nil, "(($4)($2) $1 ($4)($3))", putIntoDest(p, d, e.typ, rfmt(nil, "(($4)($2) $1 ($4)($3))",
toRope(opr[m]), rdLoc(a), rdLoc(b), toRope(opr[m]), rdLoc(a), rdLoc(b),
getSimpleTypeDesc(p.module, e[1].typ))) getSimpleTypeDesc(p.module, e[1].typ)))
@ -1593,7 +1593,7 @@ proc handleConstExpr(p: BProc, n: PNode, d: var TLoc): bool =
if (nfAllConst in n.flags) and (d.k == locNone) and (sonsLen(n) > 0): if (nfAllConst in n.flags) and (d.k == locNone) and (sonsLen(n) > 0):
var t = getUniqueType(n.typ) var t = getUniqueType(n.typ)
discard getTypeDesc(p.module, t) # so that any fields are initialized discard getTypeDesc(p.module, t) # so that any fields are initialized
var id = NodeTableTestOrSet(p.module.dataCache, n, gBackendId) var id = nodeTableTestOrSet(p.module.dataCache, n, gBackendId)
fillLoc(d, locData, t, con("TMP", toRope(id)), OnHeap) fillLoc(d, locData, t, con("TMP", toRope(id)), OnHeap)
if id == gBackendId: if id == gBackendId:
# expression not found in the cache: # expression not found in the cache:
@ -1760,7 +1760,7 @@ proc downConv(p: BProc, n: PNode, d: var TLoc) =
proc exprComplexConst(p: BProc, n: PNode, d: var TLoc) = proc exprComplexConst(p: BProc, n: PNode, d: var TLoc) =
var t = getUniqueType(n.typ) var t = getUniqueType(n.typ)
discard getTypeDesc(p.module, t) # so that any fields are initialized discard getTypeDesc(p.module, t) # so that any fields are initialized
var id = NodeTableTestOrSet(p.module.dataCache, n, gBackendId) var id = nodeTableTestOrSet(p.module.dataCache, n, gBackendId)
var tmp = con("TMP", toRope(id)) var tmp = con("TMP", toRope(id))
if id == gBackendId: if id == gBackendId:
@ -1790,7 +1790,7 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
of skProc, skConverter, skIterator: of skProc, skConverter, skIterator:
genProc(p.module, sym) genProc(p.module, sym)
if sym.loc.r == nil or sym.loc.t == nil: if sym.loc.r == nil or sym.loc.t == nil:
InternalError(n.info, "expr: proc not init " & sym.name.s) internalError(n.info, "expr: proc not init " & sym.name.s)
putLocIntoDest(p, d, sym.loc) putLocIntoDest(p, d, sym.loc)
of skConst: of skConst:
if sfFakeConst in sym.flags: if sfFakeConst in sym.flags:
@ -1805,9 +1805,9 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
of skVar, skForVar, skResult, skLet: of skVar, skForVar, skResult, skLet:
if sfGlobal in sym.flags: genVarPrototype(p.module, sym) if sfGlobal in sym.flags: genVarPrototype(p.module, sym)
if sym.loc.r == nil or sym.loc.t == nil: if sym.loc.r == nil or sym.loc.t == nil:
InternalError(n.info, "expr: var not init " & sym.name.s) internalError(n.info, "expr: var not init " & sym.name.s)
if sfThread in sym.flags: if sfThread in sym.flags:
AccessThreadLocalVar(p, sym) accessThreadLocalVar(p, sym)
if emulatedThreadVars(): if emulatedThreadVars():
putIntoDest(p, d, sym.loc.t, con("NimTV->", sym.loc.r)) putIntoDest(p, d, sym.loc.t, con("NimTV->", sym.loc.r))
else: else:
@ -1816,13 +1816,13 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
putLocIntoDest(p, d, sym.loc) putLocIntoDest(p, d, sym.loc)
of skTemp: of skTemp:
if sym.loc.r == nil or sym.loc.t == nil: if sym.loc.r == nil or sym.loc.t == nil:
InternalError(n.info, "expr: temp not init " & sym.name.s) internalError(n.info, "expr: temp not init " & sym.name.s)
putLocIntoDest(p, d, sym.loc) putLocIntoDest(p, d, sym.loc)
of skParam: of skParam:
if sym.loc.r == nil or sym.loc.t == nil: if sym.loc.r == nil or sym.loc.t == nil:
InternalError(n.info, "expr: param not init " & sym.name.s) internalError(n.info, "expr: param not init " & sym.name.s)
putLocIntoDest(p, d, sym.loc) putLocIntoDest(p, d, sym.loc)
else: InternalError(n.info, "expr(" & $sym.kind & "); unknown symbol") else: internalError(n.info, "expr(" & $sym.kind & "); unknown symbol")
of nkNilLit: of nkNilLit:
if not isEmptyType(n.typ): if not isEmptyType(n.typ):
putIntoDest(p, d, n.typ, genLiteral(p, n)) putIntoDest(p, d, n.typ, genLiteral(p, n))
@ -1876,7 +1876,7 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
of tySequence, tyString: genSeqElem(p, n, d) of tySequence, tyString: genSeqElem(p, n, d)
of tyCString: genCStringElem(p, n, d) of tyCString: genCStringElem(p, n, d)
of tyTuple: genTupleElem(p, n, d) of tyTuple: genTupleElem(p, n, d)
else: InternalError(n.info, "expr(nkBracketExpr, " & $ty.kind & ')') else: internalError(n.info, "expr(nkBracketExpr, " & $ty.kind & ')')
of nkDerefExpr, nkHiddenDeref: genDeref(p, n, d) of nkDerefExpr, nkHiddenDeref: genDeref(p, n, d)
of nkDotExpr: genRecordField(p, n, d) of nkDotExpr: genRecordField(p, n, d)
of nkCheckedFieldExpr: genCheckedRecordField(p, n, d) of nkCheckedFieldExpr: genCheckedRecordField(p, n, d)
@ -1896,7 +1896,7 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
var sym = n.sons[namePos].sym var sym = n.sons[namePos].sym
genProc(p.module, sym) genProc(p.module, sym)
if sym.loc.r == nil or sym.loc.t == nil: if sym.loc.r == nil or sym.loc.t == nil:
InternalError(n.info, "expr: proc not init " & sym.name.s) internalError(n.info, "expr: proc not init " & sym.name.s)
putLocIntoDest(p, d, sym.loc) putLocIntoDest(p, d, sym.loc)
of nkClosure: genClosure(p, n, d) of nkClosure: genClosure(p, n, d)
of nkMetaNode: expr(p, n.sons[0], d) of nkMetaNode: expr(p, n.sons[0], d)
@ -1952,7 +1952,7 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
of nkState: genState(p, n) of nkState: genState(p, n)
of nkGotoState: genGotoState(p, n) of nkGotoState: genGotoState(p, n)
of nkBreakState: genBreakState(p, n) of nkBreakState: genBreakState(p, n)
else: InternalError(n.info, "expr(" & $n.kind & "); unknown node kind") else: internalError(n.info, "expr(" & $n.kind & "); unknown node kind")
proc genNamedConstExpr(p: BProc, n: PNode): PRope = proc genNamedConstExpr(p: BProc, n: PNode): PRope =
if n.kind == nkExprColonExpr: result = genConstExpr(p, n.sons[1]) if n.kind == nkExprColonExpr: result = genConstExpr(p, n.sons[1])

12
compiler/ccgmerge.nim
View file

@ -187,7 +187,7 @@ proc readVerbatimSection(L: var TBaseLexer): PRope =
buf = L.buf buf = L.buf
r.add(tnl) r.add(tnl)
of '\0': of '\0':
InternalError("ccgmerge: expected: " & NimMergeEndMark) internalError("ccgmerge: expected: " & NimMergeEndMark)
break break
else: else:
if atEndMark(buf, pos): if atEndMark(buf, pos):
@ -224,7 +224,7 @@ proc readTypeCache(L: var TBaseLexer, result: var TIdTable) =
# XXX little hack: we create a "fake" type object with the correct Id # XXX little hack: we create a "fake" type object with the correct Id
# better would be to adapt the data structure to not even store the # better would be to adapt the data structure to not even store the
# object as key, but only the Id # object as key, but only the Id
IdTablePut(result, newFakeType(key), value.toRope) idTablePut(result, newFakeType(key), value.toRope)
inc L.bufpos inc L.bufpos
proc readIntSet(L: var TBaseLexer, result: var TIntSet) = proc readIntSet(L: var TBaseLexer, result: var TIntSet) =
@ -250,13 +250,13 @@ proc processMergeInfo(L: var TBaseLexer, m: BModule) =
of "typeInfo": readIntSet(L, m.typeInfoMarker) of "typeInfo": readIntSet(L, m.typeInfoMarker)
of "labels": m.labels = decodeVInt(L.buf, L.bufpos) of "labels": m.labels = decodeVInt(L.buf, L.bufpos)
of "hasframe": m.FrameDeclared = decodeVInt(L.buf, L.bufpos) != 0 of "hasframe": m.FrameDeclared = decodeVInt(L.buf, L.bufpos) != 0
else: InternalError("ccgmerge: unkown key: " & k) else: internalError("ccgmerge: unkown key: " & k)
when not defined(nimhygiene): when not defined(nimhygiene):
{.pragma: inject.} {.pragma: inject.}
template withCFile(cfilename: string, body: stmt) {.immediate.} = template withCFile(cfilename: string, body: stmt) {.immediate.} =
var s = LLStreamOpen(cfilename, fmRead) var s = llStreamOpen(cfilename, fmRead)
if s == nil: return if s == nil: return
var L {.inject.}: TBaseLexer var L {.inject.}: TBaseLexer
openBaseLexer(L, s) openBaseLexer(L, s)
@ -300,9 +300,9 @@ proc readMergeSections(cfilename: string, m: var TMergeSections) =
if sectionB >= 0 and sectionB <= high(TCProcSection).int: if sectionB >= 0 and sectionB <= high(TCProcSection).int:
m.p[TCProcSection(sectionB)] = verbatim m.p[TCProcSection(sectionB)] = verbatim
else: else:
InternalError("ccgmerge: unknown section: " & k) internalError("ccgmerge: unknown section: " & k)
else: else:
InternalError("ccgmerge: '*/' expected") internalError("ccgmerge: '*/' expected")
proc mergeRequired*(m: BModule): bool = proc mergeRequired*(m: BModule): bool =
for i in cfsHeaders..cfsProcs: for i in cfsHeaders..cfsProcs:

54
compiler/ccgstmts.nim
View file

@ -16,7 +16,7 @@ const
# above X strings a hash-switch for strings is generated # above X strings a hash-switch for strings is generated
proc registerGcRoot(p: BProc, v: PSym) = proc registerGcRoot(p: BProc, v: PSym) =
if gSelectedGc in {gcMarkAndSweep, gcGenerational} and if gSelectedGC in {gcMarkAndSweep, gcGenerational} and
containsGarbageCollectedRef(v.loc.t): containsGarbageCollectedRef(v.loc.t):
# we register a specialized marked proc here; this has the advantage # we register a specialized marked proc here; this has the advantage
# that it works out of the box for thread local storage then :-) # that it works out of the box for thread local storage then :-)
@ -26,7 +26,7 @@ proc registerGcRoot(p: BProc, v: PSym) =
proc genVarTuple(p: BProc, n: PNode) = proc genVarTuple(p: BProc, n: PNode) =
var tup, field: TLoc var tup, field: TLoc
if n.kind != nkVarTuple: InternalError(n.info, "genVarTuple") if n.kind != nkVarTuple: internalError(n.info, "genVarTuple")
var L = sonsLen(n) var L = sonsLen(n)
genLineDir(p, n) genLineDir(p, n)
initLocExpr(p, n.sons[L-1], tup) initLocExpr(p, n.sons[L-1], tup)
@ -45,7 +45,7 @@ proc genVarTuple(p: BProc, n: PNode) =
if t.kind == tyTuple: if t.kind == tyTuple:
field.r = ropef("$1.Field$2", [rdLoc(tup), toRope(i)]) field.r = ropef("$1.Field$2", [rdLoc(tup), toRope(i)])
else: else:
if t.n.sons[i].kind != nkSym: InternalError(n.info, "genVarTuple") if t.n.sons[i].kind != nkSym: internalError(n.info, "genVarTuple")
field.r = ropef("$1.$2", field.r = ropef("$1.$2",
[rdLoc(tup), mangleRecFieldName(t.n.sons[i].sym, t)]) [rdLoc(tup), mangleRecFieldName(t.n.sons[i].sym, t)])
putLocIntoDest(p, v.loc, field) putLocIntoDest(p, v.loc, field)
@ -62,7 +62,7 @@ proc startBlock(p: BProc, start: TFormatStr = "{$n",
lineCg(p, cpsStmts, start, args) lineCg(p, cpsStmts, start, args)
inc(p.labels) inc(p.labels)
result = len(p.blocks) result = len(p.blocks)
setlen(p.blocks, result + 1) setLen(p.blocks, result + 1)
p.blocks[result].id = p.labels p.blocks[result].id = p.labels
p.blocks[result].nestedTryStmts = p.nestedTryStmts.len.int16 p.blocks[result].nestedTryStmts = p.nestedTryStmts.len.int16
@ -81,7 +81,7 @@ proc endBlock(p: BProc, blockEnd: PRope) =
let topBlock = p.blocks.len-1 let topBlock = p.blocks.len-1
# the block is merged into the parent block # the block is merged into the parent block
app(p.blocks[topBlock-1].sections[cpsStmts], p.blocks[topBlock].blockBody) app(p.blocks[topBlock-1].sections[cpsStmts], p.blocks[topBlock].blockBody)
setlen(p.blocks, topBlock) setLen(p.blocks, topBlock)
# this is done after the block is popped so $n is # this is done after the block is popped so $n is
# properly indented when pretty printing is enabled # properly indented when pretty printing is enabled
line(p, cpsStmts, blockEnd) line(p, cpsStmts, blockEnd)
@ -200,7 +200,7 @@ proc genConstStmt(p: BProc, t: PNode) =
for i in countup(0, sonsLen(t) - 1): for i in countup(0, sonsLen(t) - 1):
var it = t.sons[i] var it = t.sons[i]
if it.kind == nkCommentStmt: continue if it.kind == nkCommentStmt: continue
if it.kind != nkConstDef: InternalError(t.info, "genConstStmt") if it.kind != nkConstDef: internalError(t.info, "genConstStmt")
var c = it.sons[0].sym var c = it.sons[0].sym
if c.typ.containsCompileTimeOnly: continue if c.typ.containsCompileTimeOnly: continue
if sfFakeConst in c.flags: if sfFakeConst in c.flags:
@ -242,17 +242,17 @@ proc genIf(p: BProc, n: PNode, d: var TLoc) =
if it.len == 2: if it.len == 2:
when newScopeForIf: startBlock(p) when newScopeForIf: startBlock(p)
initLocExpr(p, it.sons[0], a) initLocExpr(p, it.sons[0], a)
Lelse = getLabel(p) lelse = getLabel(p)
inc(p.labels) inc(p.labels)
lineFF(p, cpsStmts, "if (!$1) goto $2;$n", lineFF(p, cpsStmts, "if (!$1) goto $2;$n",
"br i1 $1, label %LOC$3, label %$2$nLOC$3: $n", "br i1 $1, label %LOC$3, label %$2$nLOC$3: $n",
[rdLoc(a), Lelse, toRope(p.labels)]) [rdLoc(a), lelse, toRope(p.labels)])
when not newScopeForIf: startBlock(p) when not newScopeForIf: startBlock(p)
expr(p, it.sons[1], d) expr(p, it.sons[1], d)
endBlock(p) endBlock(p)
if sonsLen(n) > 1: if sonsLen(n) > 1:
lineFF(p, cpsStmts, "goto $1;$n", "br label %$1$n", [lend]) lineFF(p, cpsStmts, "goto $1;$n", "br label %$1$n", [lend])
fixLabel(p, Lelse) fixLabel(p, lelse)
elif it.len == 1: elif it.len == 1:
startBlock(p) startBlock(p)
expr(p, it.sons[0], d) expr(p, it.sons[0], d)
@ -296,7 +296,7 @@ proc genReturnStmt(p: BProc, t: PNode) =
proc genComputedGoto(p: BProc; n: PNode) = proc genComputedGoto(p: BProc; n: PNode) =
# first pass: Generate array of computed labels: # first pass: Generate array of computed labels:
var casePos = -1 var casePos = -1
var arraySize: Int var arraySize: int
for i in 0 .. <n.len: for i in 0 .. <n.len:
let it = n.sons[i] let it = n.sons[i]
if it.kind == nkCaseStmt: if it.kind == nkCaseStmt:
@ -381,7 +381,7 @@ proc genWhileStmt(p: BProc, t: PNode) =
lineF(p, cpsStmts, "if (!$1) goto $2;$n", [rdLoc(a), label]) lineF(p, cpsStmts, "if (!$1) goto $2;$n", [rdLoc(a), label])
var loopBody = t.sons[1] var loopBody = t.sons[1]
if loopBody.stmtsContainPragma(wComputedGoto) and if loopBody.stmtsContainPragma(wComputedGoto) and
hasComputedGoto in CC[ccompiler].props: hasComputedGoto in CC[cCompiler].props:
# for closure support weird loop bodies are generated: # for closure support weird loop bodies are generated:
if loopBody.len == 2 and loopBody.sons[0].kind == nkEmpty: if loopBody.len == 2 and loopBody.sons[0].kind == nkEmpty:
loopBody = loopBody.sons[1] loopBody = loopBody.sons[1]
@ -416,7 +416,7 @@ proc genParForStmt(p: BProc, t: PNode) =
preserveBreakIdx: preserveBreakIdx:
let forLoopVar = t.sons[0].sym let forLoopVar = t.sons[0].sym
var rangeA, rangeB: TLoc var rangeA, rangeB: TLoc
assignLocalVar(P, forLoopVar) assignLocalVar(p, forLoopVar)
#initLoc(forLoopVar.loc, locLocalVar, forLoopVar.typ, onStack) #initLoc(forLoopVar.loc, locLocalVar, forLoopVar.typ, onStack)
#discard mangleName(forLoopVar) #discard mangleName(forLoopVar)
let call = t.sons[1] let call = t.sons[1]
@ -448,7 +448,7 @@ proc genBreakStmt(p: BProc, t: PNode) =
# an unnamed 'break' can only break a loop after 'transf' pass: # an unnamed 'break' can only break a loop after 'transf' pass:
while idx >= 0 and not p.blocks[idx].isLoop: dec idx while idx >= 0 and not p.blocks[idx].isLoop: dec idx
if idx < 0 or not p.blocks[idx].isLoop: if idx < 0 or not p.blocks[idx].isLoop:
InternalError(t.info, "no loop to break") internalError(t.info, "no loop to break")
let label = assignLabel(p.blocks[idx]) let label = assignLabel(p.blocks[idx])
blockLeaveActions(p, p.nestedTryStmts.len - p.blocks[idx].nestedTryStmts) blockLeaveActions(p, p.nestedTryStmts.len - p.blocks[idx].nestedTryStmts)
genLineDir(p, t) genLineDir(p, t)
@ -469,7 +469,7 @@ proc genRaiseStmt(p: BProc, t: PNode) =
genSimpleBlock(p, finallyBlock.sons[0]) genSimpleBlock(p, finallyBlock.sons[0])
if t.sons[0].kind != nkEmpty: if t.sons[0].kind != nkEmpty:
var a: TLoc var a: TLoc
InitLocExpr(p, t.sons[0], a) initLocExpr(p, t.sons[0], a)
var e = rdLoc(a) var e = rdLoc(a)
var typ = skipTypes(t.sons[0].typ, abstractPtrs) var typ = skipTypes(t.sons[0].typ, abstractPtrs)
genLineDir(p, t) genLineDir(p, t)
@ -598,7 +598,7 @@ proc ifSwitchSplitPoint(p: BProc, n: PNode): int =
var stmtBlock = lastSon(branch) var stmtBlock = lastSon(branch)
if stmtBlock.stmtsContainPragma(wLinearScanEnd): if stmtBlock.stmtsContainPragma(wLinearScanEnd):
result = i result = i
elif hasSwitchRange notin CC[ccompiler].props: elif hasSwitchRange notin CC[cCompiler].props:
if branch.kind == nkOfBranch and branchHasTooBigRange(branch): if branch.kind == nkOfBranch and branchHasTooBigRange(branch):
result = i result = i
@ -606,7 +606,7 @@ proc genCaseRange(p: BProc, branch: PNode) =
var length = branch.len var length = branch.len
for j in 0 .. length-2: for j in 0 .. length-2:
if branch[j].kind == nkRange: if branch[j].kind == nkRange:
if hasSwitchRange in CC[ccompiler].props: if hasSwitchRange in CC[cCompiler].props:
lineF(p, cpsStmts, "case $1 ... $2:$n", [ lineF(p, cpsStmts, "case $1 ... $2:$n", [
genLiteral(p, branch[j][0]), genLiteral(p, branch[j][0]),
genLiteral(p, branch[j][1])]) genLiteral(p, branch[j][1])])
@ -614,13 +614,13 @@ proc genCaseRange(p: BProc, branch: PNode) =
var v = copyNode(branch[j][0]) var v = copyNode(branch[j][0])
while v.intVal <= branch[j][1].intVal: while v.intVal <= branch[j][1].intVal:
lineF(p, cpsStmts, "case $1:$n", [genLiteral(p, v)]) lineF(p, cpsStmts, "case $1:$n", [genLiteral(p, v)])
Inc(v.intVal) inc(v.intVal)
else: else:
lineF(p, cpsStmts, "case $1:$n", [genLiteral(p, branch[j])]) lineF(p, cpsStmts, "case $1:$n", [genLiteral(p, branch[j])])
proc genOrdinalCase(p: BProc, n: PNode, d: var TLoc) = proc genOrdinalCase(p: BProc, n: PNode, d: var TLoc) =
# analyse 'case' statement: # analyse 'case' statement:
var splitPoint = IfSwitchSplitPoint(p, n) var splitPoint = ifSwitchSplitPoint(p, n)
# generate if part (might be empty): # generate if part (might be empty):
var a: TLoc var a: TLoc
@ -644,7 +644,7 @@ proc genOrdinalCase(p: BProc, n: PNode, d: var TLoc) =
hasDefault = true hasDefault = true
exprBlock(p, branch.lastSon, d) exprBlock(p, branch.lastSon, d)
lineF(p, cpsStmts, "break;$n") lineF(p, cpsStmts, "break;$n")
if (hasAssume in CC[ccompiler].props) and not hasDefault: if (hasAssume in CC[cCompiler].props) and not hasDefault:
lineF(p, cpsStmts, "default: __assume(0);$n") lineF(p, cpsStmts, "default: __assume(0);$n")
lineF(p, cpsStmts, "}$n") lineF(p, cpsStmts, "}$n")
if lend != nil: fixLabel(p, lend) if lend != nil: fixLabel(p, lend)
@ -850,9 +850,9 @@ proc genAsmOrEmitStmt(p: BProc, t: PNode, isAsmStmt=false): PRope =
r = mangleName(sym) r = mangleName(sym)
sym.loc.r = r # but be consequent! sym.loc.r = r # but be consequent!
res.add(r.ropeToStr) res.add(r.ropeToStr)
else: InternalError(t.sons[i].info, "genAsmOrEmitStmt()") else: internalError(t.sons[i].info, "genAsmOrEmitStmt()")
if isAsmStmt and hasGnuAsm in CC[ccompiler].props: if isAsmStmt and hasGnuAsm in CC[cCompiler].props:
for x in splitLines(res): for x in splitLines(res):
var j = 0 var j = 0
while x[j] in {' ', '\t'}: inc(j) while x[j] in {' ', '\t'}: inc(j)
@ -873,9 +873,9 @@ proc genAsmStmt(p: BProc, t: PNode) =
var s = genAsmOrEmitStmt(p, t, isAsmStmt=true) var s = genAsmOrEmitStmt(p, t, isAsmStmt=true)
if p.prc == nil: if p.prc == nil:
# top level asm statement? # top level asm statement?
appf(p.module.s[cfsProcHeaders], CC[ccompiler].asmStmtFrmt, [s]) appf(p.module.s[cfsProcHeaders], CC[cCompiler].asmStmtFrmt, [s])
else: else:
lineF(p, cpsStmts, CC[ccompiler].asmStmtFrmt, [s]) lineF(p, cpsStmts, CC[cCompiler].asmStmtFrmt, [s])
proc genEmit(p: BProc, t: PNode) = proc genEmit(p: BProc, t: PNode) =
genLineDir(p, t) genLineDir(p, t)
@ -944,7 +944,7 @@ proc genDiscriminantCheck(p: BProc, a, tmp: TLoc, objtype: PType,
assert t.kind == tyObject assert t.kind == tyObject
discard genTypeInfo(p.module, t) discard genTypeInfo(p.module, t)
var L = lengthOrd(field.typ) var L = lengthOrd(field.typ)
if not ContainsOrIncl(p.module.declaredThings, field.id): if not containsOrIncl(p.module.declaredThings, field.id):
appcg(p.module, cfsVars, "extern $1", appcg(p.module, cfsVars, "extern $1",
discriminatorTableDecl(p.module, t, field)) discriminatorTableDecl(p.module, t, field))
lineCg(p, cpsStmts, lineCg(p, cpsStmts,
@ -957,7 +957,7 @@ proc asgnFieldDiscriminant(p: BProc, e: PNode) =
var dotExpr = e.sons[0] var dotExpr = e.sons[0]
var d: PSym var d: PSym
if dotExpr.kind == nkCheckedFieldExpr: dotExpr = dotExpr.sons[0] if dotExpr.kind == nkCheckedFieldExpr: dotExpr = dotExpr.sons[0]
InitLocExpr(p, e.sons[0], a) initLocExpr(p, e.sons[0], a)
getTemp(p, a.t, tmp) getTemp(p, a.t, tmp)
expr(p, e.sons[1], tmp) expr(p, e.sons[1], tmp)
genDiscriminantCheck(p, a, tmp, dotExpr.sons[0].typ, dotExpr.sons[1].sym) genDiscriminantCheck(p, a, tmp, dotExpr.sons[0].typ, dotExpr.sons[1].sym)
@ -965,9 +965,9 @@ proc asgnFieldDiscriminant(p: BProc, e: PNode) =
proc genAsgn(p: BProc, e: PNode, fastAsgn: bool) = proc genAsgn(p: BProc, e: PNode, fastAsgn: bool) =
genLineDir(p, e) genLineDir(p, e)
if not FieldDiscriminantCheckNeeded(p, e): if not fieldDiscriminantCheckNeeded(p, e):
var a: TLoc var a: TLoc
InitLocExpr(p, e.sons[0], a) initLocExpr(p, e.sons[0], a)
if fastAsgn: incl(a.flags, lfNoDeepCopy) if fastAsgn: incl(a.flags, lfNoDeepCopy)
assert(a.t != nil) assert(a.t != nil)
loadInto(p, e.sons[0], e.sons[1], a) loadInto(p, e.sons[0], e.sons[1], a)

4
compiler/ccgtrav.nim
View file

@ -28,7 +28,7 @@ proc genTraverseProc(c: var TTraversalClosure, accessor: PRope, n: PNode) =
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
genTraverseProc(c, accessor, n.sons[i]) genTraverseProc(c, accessor, n.sons[i])
of nkRecCase: of nkRecCase:
if (n.sons[0].kind != nkSym): InternalError(n.info, "genTraverseProc") if (n.sons[0].kind != nkSym): internalError(n.info, "genTraverseProc")
var p = c.p var p = c.p
let disc = n.sons[0].sym let disc = n.sons[0].sym
lineF(p, cpsStmts, "switch ($1.$2) {$n", accessor, disc.loc.r) lineF(p, cpsStmts, "switch ($1.$2) {$n", accessor, disc.loc.r)
@ -74,7 +74,7 @@ proc genTraverseProc(c: var TTraversalClosure, accessor: PRope, typ: PType) =
genTraverseProc(c, accessor.parentObj, typ.sons[i]) genTraverseProc(c, accessor.parentObj, typ.sons[i])
if typ.n != nil: genTraverseProc(c, accessor, typ.n) if typ.n != nil: genTraverseProc(c, accessor, typ.n)
of tyTuple: of tyTuple:
let typ = GetUniqueType(typ) let typ = getUniqueType(typ)
for i in countup(0, sonsLen(typ) - 1): for i in countup(0, sonsLen(typ) - 1):
genTraverseProc(c, rfmt(nil, "$1.Field$2", accessor, i.toRope), typ.sons[i]) genTraverseProc(c, rfmt(nil, "$1.Field$2", accessor, i.toRope), typ.sons[i])
of tyRef, tyString, tySequence: of tyRef, tyString, tySequence:

70
compiler/ccgtypes.nim
View file

@ -76,7 +76,7 @@ proc mangleName(s: PSym): PRope =
else: result = ~"%" else: result = ~"%"
of skTemp, skParam, skType, skEnumField, skModule: of skTemp, skParam, skType, skEnumField, skModule:
result = ~"%" result = ~"%"
else: InternalError(s.info, "mangleName") else: internalError(s.info, "mangleName")
when oKeepVariableNames: when oKeepVariableNames:
let keepOrigName = s.kind in skLocalVars - {skForVar} and let keepOrigName = s.kind in skLocalVars - {skForVar} and
{sfFromGeneric, sfGlobal, sfShadowed, sfGenSym} * s.flags == {} and {sfFromGeneric, sfGlobal, sfShadowed, sfGenSym} * s.flags == {} and
@ -150,7 +150,7 @@ proc getTypeName(typ: PType): PRope =
typ.loc.r = if gCmd != cmdCompileToLLVM: con(typ.typeName, typ.id.toRope) typ.loc.r = if gCmd != cmdCompileToLLVM: con(typ.typeName, typ.id.toRope)
else: con([~"%", typ.typeName, typ.id.toRope]) else: con([~"%", typ.typeName, typ.id.toRope])
result = typ.loc.r result = typ.loc.r
if result == nil: InternalError("getTypeName: " & $typ.kind) if result == nil: internalError("getTypeName: " & $typ.kind)
proc mapSetType(typ: PType): TCTypeKind = proc mapSetType(typ: PType): TCTypeKind =
case int(getSize(typ)) case int(getSize(typ))
@ -194,7 +194,7 @@ proc mapType(typ: PType): TCTypeKind =
of tyCString: result = ctCString of tyCString: result = ctCString
of tyInt..tyUInt64: of tyInt..tyUInt64:
result = TCTypeKind(ord(typ.kind) - ord(tyInt) + ord(ctInt)) result = TCTypeKind(ord(typ.kind) - ord(tyInt) + ord(ctInt))
else: InternalError("mapType") else: internalError("mapType")
proc mapReturnType(typ: PType): TCTypeKind = proc mapReturnType(typ: PType): TCTypeKind =
if skipTypes(typ, typedescInst).kind == tyArray: result = ctPtr if skipTypes(typ, typedescInst).kind == tyArray: result = ctPtr
@ -262,7 +262,7 @@ proc ccgIntroducedPtr(s: PSym): bool =
proc fillResult(param: PSym) = proc fillResult(param: PSym) =
fillLoc(param.loc, locParam, param.typ, ~"Result", fillLoc(param.loc, locParam, param.typ, ~"Result",
OnStack) OnStack)
if (mapReturnType(param.typ) != ctArray) and IsInvalidReturnType(param.typ): if (mapReturnType(param.typ) != ctArray) and isInvalidReturnType(param.typ):
incl(param.loc.flags, lfIndirect) incl(param.loc.flags, lfIndirect)
param.loc.s = OnUnknown param.loc.s = OnUnknown
@ -288,7 +288,7 @@ proc genProcParams(m: BModule, t: PType, rettype, params: var PRope,
else: else:
rettype = getTypeDescAux(m, t.sons[0], check) rettype = getTypeDescAux(m, t.sons[0], check)
for i in countup(1, sonsLen(t.n) - 1): for i in countup(1, sonsLen(t.n) - 1):
if t.n.sons[i].kind != nkSym: InternalError(t.n.info, "genProcParams") if t.n.sons[i].kind != nkSym: internalError(t.n.info, "genProcParams")
var param = t.n.sons[i].sym var param = t.n.sons[i].sym
if isCompileTimeOnly(param.typ): continue if isCompileTimeOnly(param.typ): continue
if params != nil: app(params, ~", ") if params != nil: app(params, ~", ")
@ -375,14 +375,14 @@ proc getTypePre(m: BModule, typ: PType): PRope =
if typ == nil: result = toRope("void") if typ == nil: result = toRope("void")
else: else:
result = getSimpleTypeDesc(m, typ) result = getSimpleTypeDesc(m, typ)
if result == nil: result = CacheGetType(m.typeCache, typ) if result == nil: result = cacheGetType(m.typeCache, typ)
proc getForwardStructFormat(): string = proc getForwardStructFormat(): string =
if gCmd == cmdCompileToCpp: result = "struct $1;$n" if gCmd == cmdCompileToCpp: result = "struct $1;$n"
else: result = "typedef struct $1 $1;$n" else: result = "typedef struct $1 $1;$n"
proc getTypeForward(m: BModule, typ: PType): PRope = proc getTypeForward(m: BModule, typ: PType): PRope =
result = CacheGetType(m.forwTypeCache, typ) result = cacheGetType(m.forwTypeCache, typ)
if result != nil: return if result != nil: return
result = getTypePre(m, typ) result = getTypePre(m, typ)
if result != nil: return if result != nil: return
@ -391,8 +391,8 @@ proc getTypeForward(m: BModule, typ: PType): PRope =
result = getTypeName(typ) result = getTypeName(typ)
if not isImportedType(typ): if not isImportedType(typ):
appf(m.s[cfsForwardTypes], getForwardStructFormat(), [result]) appf(m.s[cfsForwardTypes], getForwardStructFormat(), [result])
IdTablePut(m.forwTypeCache, typ, result) idTablePut(m.forwTypeCache, typ, result)
else: InternalError("getTypeForward(" & $typ.kind & ')') else: internalError("getTypeForward(" & $typ.kind & ')')
proc mangleRecFieldName(field: PSym, rectype: PType): PRope = proc mangleRecFieldName(field: PSym, rectype: PType): PRope =
if (rectype.sym != nil) and if (rectype.sym != nil) and
@ -400,7 +400,7 @@ proc mangleRecFieldName(field: PSym, rectype: PType): PRope =
result = field.loc.r result = field.loc.r
else: else:
result = toRope(mangleField(field.name.s)) result = toRope(mangleField(field.name.s))
if result == nil: InternalError(field.info, "mangleRecFieldName") if result == nil: internalError(field.info, "mangleRecFieldName")
proc genRecordFieldsAux(m: BModule, n: PNode, proc genRecordFieldsAux(m: BModule, n: PNode,
accessExpr: PRope, rectype: PType, accessExpr: PRope, rectype: PType,
@ -415,7 +415,7 @@ proc genRecordFieldsAux(m: BModule, n: PNode,
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
app(result, genRecordFieldsAux(m, n.sons[i], accessExpr, rectype, check)) app(result, genRecordFieldsAux(m, n.sons[i], accessExpr, rectype, check))
of nkRecCase: of nkRecCase:
if (n.sons[0].kind != nkSym): InternalError(n.info, "genRecordFieldsAux") if (n.sons[0].kind != nkSym): internalError(n.info, "genRecordFieldsAux")
app(result, genRecordFieldsAux(m, n.sons[0], accessExpr, rectype, check)) app(result, genRecordFieldsAux(m, n.sons[0], accessExpr, rectype, check))
uname = toRope(mangle(n.sons[0].sym.name.s) & 'U') uname = toRope(mangle(n.sons[0].sym.name.s) & 'U')
if accessExpr != nil: ae = ropef("$1.$2", [accessExpr, uname]) if accessExpr != nil: ae = ropef("$1.$2", [accessExpr, uname])
@ -497,15 +497,15 @@ proc getTypeDescAux(m: BModule, typ: PType, check: var TIntSet): PRope =
# returns only the type's name # returns only the type's name
var var
name, rettype, desc, recdesc: PRope name, rettype, desc, recdesc: PRope
n: biggestInt n: BiggestInt
t, et: PType t, et: PType
t = getUniqueType(typ) t = getUniqueType(typ)
if t == nil: InternalError("getTypeDescAux: t == nil") if t == nil: internalError("getTypeDescAux: t == nil")
if t.sym != nil: useHeader(m, t.sym) if t.sym != nil: useHeader(m, t.sym)
result = getTypePre(m, t) result = getTypePre(m, t)
if result != nil: return if result != nil: return
if ContainsOrIncl(check, t.id): if containsOrIncl(check, t.id):
InternalError("cannot generate C type for: " & typeToString(typ)) internalError("cannot generate C type for: " & typeToString(typ))
# XXX: this BUG is hard to fix -> we need to introduce helper structs, # XXX: this BUG is hard to fix -> we need to introduce helper structs,
# but determining when this needs to be done is hard. We should split # but determining when this needs to be done is hard. We should split
# C type generation into an analysis and a code generation phase somehow. # C type generation into an analysis and a code generation phase somehow.
@ -521,25 +521,25 @@ proc getTypeDescAux(m: BModule, typ: PType, check: var TIntSet): PRope =
# no restriction! We have a forward declaration for structs # no restriction! We have a forward declaration for structs
name = getTypeForward(m, et) name = getTypeForward(m, et)
result = con(name, "*") result = con(name, "*")
IdTablePut(m.typeCache, t, result) idTablePut(m.typeCache, t, result)
pushType(m, et) pushType(m, et)
of tySequence: of tySequence:
# no restriction! We have a forward declaration for structs # no restriction! We have a forward declaration for structs
name = getTypeForward(m, et) name = getTypeForward(m, et)
result = con(name, "**") result = con(name, "**")
IdTablePut(m.typeCache, t, result) idTablePut(m.typeCache, t, result)
pushType(m, et) pushType(m, et)
else: else:
# else we have a strong dependency :-( # else we have a strong dependency :-(
result = con(getTypeDescAux(m, et, check), "*") result = con(getTypeDescAux(m, et, check), "*")
IdTablePut(m.typeCache, t, result) idTablePut(m.typeCache, t, result)
of tyOpenArray, tyVarargs: of tyOpenArray, tyVarargs:
et = getUniqueType(t.sons[0]) et = getUniqueType(t.sons[0])
result = con(getTypeDescAux(m, et, check), "*") result = con(getTypeDescAux(m, et, check), "*")
IdTablePut(m.typeCache, t, result) idTablePut(m.typeCache, t, result)
of tyProc: of tyProc:
result = getTypeName(t) result = getTypeName(t)
IdTablePut(m.typeCache, t, result) idTablePut(m.typeCache, t, result)
genProcParams(m, t, rettype, desc, check) genProcParams(m, t, rettype, desc, check)
if not isImportedType(t): if not isImportedType(t):
if t.callConv != ccClosure: # procedure vars may need a closure! if t.callConv != ccClosure: # procedure vars may need a closure!
@ -553,14 +553,14 @@ proc getTypeDescAux(m: BModule, typ: PType, check: var TIntSet): PRope =
of tySequence: of tySequence:
# we cannot use getTypeForward here because then t would be associated # we cannot use getTypeForward here because then t would be associated
# with the name of the struct, not with the pointer to the struct: # with the name of the struct, not with the pointer to the struct:
result = CacheGetType(m.forwTypeCache, t) result = cacheGetType(m.forwTypeCache, t)
if result == nil: if result == nil:
result = getTypeName(t) result = getTypeName(t)
if not isImportedType(t): if not isImportedType(t):
appf(m.s[cfsForwardTypes], getForwardStructFormat(), [result]) appf(m.s[cfsForwardTypes], getForwardStructFormat(), [result])
IdTablePut(m.forwTypeCache, t, result) idTablePut(m.forwTypeCache, t, result)
assert(CacheGetType(m.typeCache, t) == nil) assert(CacheGetType(m.typeCache, t) == nil)
IdTablePut(m.typeCache, t, con(result, "*")) idTablePut(m.typeCache, t, con(result, "*"))
if not isImportedType(t): if not isImportedType(t):
if skipTypes(t.sons[0], typedescInst).kind != tyEmpty: if skipTypes(t.sons[0], typedescInst).kind != tyEmpty:
const const
@ -579,18 +579,18 @@ proc getTypeDescAux(m: BModule, typ: PType, check: var TIntSet): PRope =
if n <= 0: if n <= 0:
n = 1 # make an array of at least one element n = 1 # make an array of at least one element
result = getTypeName(t) result = getTypeName(t)
IdTablePut(m.typeCache, t, result) idTablePut(m.typeCache, t, result)
if not isImportedType(t): if not isImportedType(t):
appf(m.s[cfsTypes], "typedef $1 $2[$3];$n", appf(m.s[cfsTypes], "typedef $1 $2[$3];$n",
[getTypeDescAux(m, t.sons[1], check), result, ToRope(n)]) [getTypeDescAux(m, t.sons[1], check), result, toRope(n)])
of tyObject, tyTuple: of tyObject, tyTuple:
result = CacheGetType(m.forwTypeCache, t) result = cacheGetType(m.forwTypeCache, t)
if result == nil: if result == nil:
result = getTypeName(t) result = getTypeName(t)
if not isImportedType(t): if not isImportedType(t):
appf(m.s[cfsForwardTypes], getForwardStructFormat(), [result]) appf(m.s[cfsForwardTypes], getForwardStructFormat(), [result])
IdTablePut(m.forwTypeCache, t, result) idTablePut(m.forwTypeCache, t, result)
IdTablePut(m.typeCache, t, result) # always call for sideeffects: idTablePut(m.typeCache, t, result) # always call for sideeffects:
if t.kind != tyTuple: recdesc = getRecordDesc(m, t, result, check) if t.kind != tyTuple: recdesc = getRecordDesc(m, t, result, check)
else: recdesc = getTupleDesc(m, t, result, check) else: recdesc = getTupleDesc(m, t, result, check)
if not isImportedType(t): app(m.s[cfsTypes], recdesc) if not isImportedType(t): app(m.s[cfsTypes], recdesc)
@ -602,7 +602,7 @@ proc getTypeDescAux(m: BModule, typ: PType, check: var TIntSet): PRope =
of 8: result = toRope("NU64") of 8: result = toRope("NU64")
else: else:
result = getTypeName(t) result = getTypeName(t)
IdTablePut(m.typeCache, t, result) idTablePut(m.typeCache, t, result)
if not isImportedType(t): if not isImportedType(t):
appf(m.s[cfsTypes], "typedef NU8 $1[$2];$n", appf(m.s[cfsTypes], "typedef NU8 $1[$2];$n",
[result, toRope(getSize(t))]) [result, toRope(getSize(t))])
@ -610,7 +610,7 @@ proc getTypeDescAux(m: BModule, typ: PType, check: var TIntSet): PRope =
tyIter, tyTypeDesc: tyIter, tyTypeDesc:
result = getTypeDescAux(m, lastSon(t), check) result = getTypeDescAux(m, lastSon(t), check)
else: else:
InternalError("getTypeDescAux(" & $t.kind & ')') internalError("getTypeDescAux(" & $t.kind & ')')
result = nil result = nil
# fixes bug #145: # fixes bug #145:
excl(check, t.id) excl(check, t.id)
@ -737,10 +737,10 @@ proc discriminatorTableName(m: BModule, objtype: PType, d: PSym): PRope =
var objtype = objtype var objtype = objtype
while lookupInRecord(objtype.n, d.name) == nil: while lookupInRecord(objtype.n, d.name) == nil:
objtype = objtype.sons[0] objtype = objtype.sons[0]
if objType.sym == nil: if objtype.sym == nil:
InternalError(d.info, "anonymous obj with discriminator") internalError(d.info, "anonymous obj with discriminator")
result = ropef("NimDT_$1_$2", [ result = ropef("NimDT_$1_$2", [
toRope(objType.sym.name.s.mangle), toRope(d.name.s.mangle)]) toRope(objtype.sym.name.s.mangle), toRope(d.name.s.mangle)])
proc discriminatorTableDecl(m: BModule, objtype: PType, d: PSym): PRope = proc discriminatorTableDecl(m: BModule, objtype: PType, d: PSym): PRope =
discard cgsym(m, "TNimNode") discard cgsym(m, "TNimNode")
@ -911,7 +911,7 @@ include ccgtrav
proc genTypeInfo(m: BModule, t: PType): PRope = proc genTypeInfo(m: BModule, t: PType): PRope =
var t = getUniqueType(t) var t = getUniqueType(t)
result = ropef("NTI$1", [toRope(t.id)]) result = ropef("NTI$1", [toRope(t.id)])
if ContainsOrIncl(m.typeInfoMarker, t.id): if containsOrIncl(m.typeInfoMarker, t.id):
return con("(&".toRope, result, ")".toRope) return con("(&".toRope, result, ")".toRope)
let owner = t.skipTypes(typedescPtrs).owner.getModule let owner = t.skipTypes(typedescPtrs).owner.getModule
if owner != m.module: if owner != m.module:
@ -948,7 +948,7 @@ proc genTypeInfo(m: BModule, t: PType): PRope =
# BUGFIX: use consistently RTTI without proper field names; otherwise # BUGFIX: use consistently RTTI without proper field names; otherwise
# results are not deterministic! # results are not deterministic!
genTupleInfo(m, t, result) genTupleInfo(m, t, result)
else: InternalError("genTypeInfo(" & $t.kind & ')') else: internalError("genTypeInfo(" & $t.kind & ')')
result = con("(&".toRope, result, ")".toRope) result = con("(&".toRope, result, ")".toRope)
proc genTypeSection(m: BModule, n: PNode) = proc genTypeSection(m: BModule, n: PNode) =

10
compiler/ccgutils.nim
View file

@ -27,14 +27,14 @@ proc getPragmaStmt*(n: PNode, w: TSpecialWord): PNode =
proc stmtsContainPragma*(n: PNode, w: TSpecialWord): bool = proc stmtsContainPragma*(n: PNode, w: TSpecialWord): bool =
result = getPragmaStmt(n, w) != nil result = getPragmaStmt(n, w) != nil
proc hashString*(s: string): biggestInt = proc hashString*(s: string): BiggestInt =
# has to be the same algorithm as system.hashString! # has to be the same algorithm as system.hashString!
if CPU[targetCPU].bit == 64: if CPU[targetCPU].bit == 64:
# we have to use the same bitwidth # we have to use the same bitwidth
# as the target CPU # as the target CPU
var b = 0'i64 var b = 0'i64
for i in countup(0, len(s) - 1): for i in countup(0, len(s) - 1):
b = b +% Ord(s[i]) b = b +% ord(s[i])
b = b +% `shl`(b, 10) b = b +% `shl`(b, 10)
b = b xor `shr`(b, 6) b = b xor `shr`(b, 6)
b = b +% `shl`(b, 3) b = b +% `shl`(b, 3)
@ -44,7 +44,7 @@ proc hashString*(s: string): biggestInt =
else: else:
var a = 0'i32 var a = 0'i32
for i in countup(0, len(s) - 1): for i in countup(0, len(s) - 1):
a = a +% Ord(s[i]).int32 a = a +% ord(s[i]).int32
a = a +% `shl`(a, 10'i32) a = a +% `shl`(a, 10'i32)
a = a xor `shr`(a, 6'i32) a = a xor `shr`(a, 6'i32)
a = a +% `shl`(a, 3'i32) a = a +% `shl`(a, 3'i32)
@ -57,7 +57,7 @@ var
gCanonicalTypes: array[TTypeKind, PType] gCanonicalTypes: array[TTypeKind, PType]
proc initTypeTables() = proc initTypeTables() =
for i in countup(low(TTypeKind), high(TTypeKind)): InitIdTable(gTypeTable[i]) for i in countup(low(TTypeKind), high(TTypeKind)): initIdTable(gTypeTable[i])
proc resetCaches* = proc resetCaches* =
## XXX: fix that more properly ## XXX: fix that more properly
@ -169,7 +169,7 @@ proc makeLLVMString*(s: string): PRope =
for i in countup(0, len(s) - 1): for i in countup(0, len(s) - 1):
if (i + 1) mod MaxLineLength == 0: if (i + 1) mod MaxLineLength == 0:
app(result, toRope(res)) app(result, toRope(res))
setlen(res, 0) setLen(res, 0)
case s[i] case s[i]
of '\0'..'\x1F', '\x80'..'\xFF', '\"', '\\': of '\0'..'\x1F', '\x80'..'\xFF', '\"', '\\':
add(res, '\\') add(res, '\\')

68
compiler/cgen.nim
View file

@ -52,7 +52,7 @@ proc emitLazily(s: PSym): bool {.inline.} =
proc initLoc(result: var TLoc, k: TLocKind, typ: PType, s: TStorageLoc) = proc initLoc(result: var TLoc, k: TLocKind, typ: PType, s: TStorageLoc) =
result.k = k result.k = k
result.s = s result.s = s
result.t = GetUniqueType(typ) result.t = getUniqueType(typ)
result.r = nil result.r = nil
result.a = - 1 result.a = - 1
result.flags = {} result.flags = {}
@ -103,7 +103,7 @@ proc ropecg(m: BModule, frmt: TFormatStr, args: varargs[PRope]): PRope =
of '0'..'9': of '0'..'9':
var j = 0 var j = 0
while true: while true:
j = (j * 10) + Ord(frmt[i]) - ord('0') j = (j * 10) + ord(frmt[i]) - ord('0')
inc(i) inc(i)
if i >= length or not (frmt[i] in {'0'..'9'}): break if i >= length or not (frmt[i] in {'0'..'9'}): break
num = j num = j
@ -116,7 +116,7 @@ proc ropecg(m: BModule, frmt: TFormatStr, args: varargs[PRope]): PRope =
of 'N': of 'N':
app(result, rnl) app(result, rnl)
inc(i) inc(i)
else: InternalError("ropes: invalid format string $" & frmt[i]) else: internalError("ropes: invalid format string $" & frmt[i])
elif frmt[i] == '#' and frmt[i+1] in IdentStartChars: elif frmt[i] == '#' and frmt[i+1] in IdentStartChars:
inc(i) inc(i)
var j = i var j = i
@ -128,7 +128,7 @@ proc ropecg(m: BModule, frmt: TFormatStr, args: varargs[PRope]): PRope =
inc(i, 2) inc(i, 2)
var j = 0 var j = 0
while frmt[i] in Digits: while frmt[i] in Digits:
j = (j * 10) + Ord(frmt[i]) - ord('0') j = (j * 10) + ord(frmt[i]) - ord('0')
inc(i) inc(i)
app(result, cgsym(m, args[j-1].ropeToStr)) app(result, cgsym(m, args[j-1].ropeToStr))
var start = i var start = i
@ -522,8 +522,8 @@ proc assignGlobalVar(p: BProc, s: PSym) =
if lfDynamicLib in s.loc.flags: if lfDynamicLib in s.loc.flags:
var q = findPendingModule(p.module, s) var q = findPendingModule(p.module, s)
if q != nil and not ContainsOrIncl(q.declaredThings, s.id): if q != nil and not containsOrIncl(q.declaredThings, s.id):
VarInDynamicLib(q, s) varInDynamicLib(q, s)
else: else:
s.loc.r = mangleDynLibProc(s) s.loc.r = mangleDynLibProc(s)
return return
@ -578,7 +578,7 @@ proc expr(p: BProc, n: PNode, d: var TLoc)
proc genProcPrototype(m: BModule, sym: PSym) proc genProcPrototype(m: BModule, sym: PSym)
proc putLocIntoDest(p: BProc, d: var TLoc, s: TLoc) proc putLocIntoDest(p: BProc, d: var TLoc, s: TLoc)
proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags)
proc intLiteral(i: biggestInt): PRope proc intLiteral(i: BiggestInt): PRope
proc genLiteral(p: BProc, n: PNode): PRope proc genLiteral(p: BProc, n: PNode): PRope
proc initLocExpr(p: BProc, e: PNode, result: var TLoc) = proc initLocExpr(p: BProc, e: PNode, result: var TLoc) =
@ -610,7 +610,7 @@ proc loadDynamicLib(m: BModule, lib: PLib) =
var s: TStringSeq = @[] var s: TStringSeq = @[]
libCandidates(lib.path.strVal, s) libCandidates(lib.path.strVal, s)
if gVerbosity >= 2: if gVerbosity >= 2:
MsgWriteln("Dependency: " & lib.path.strVal) msgWriteln("Dependency: " & lib.path.strVal)
var loadlib: PRope = nil var loadlib: PRope = nil
for i in countup(0, high(s)): for i in countup(0, high(s)):
inc(m.labels) inc(m.labels)
@ -632,7 +632,7 @@ proc loadDynamicLib(m: BModule, lib: PLib) =
"if (!($1 = #nimLoadLibrary($2))) #nimLoadLibraryError($2);$n", "if (!($1 = #nimLoadLibrary($2))) #nimLoadLibraryError($2);$n",
[tmp, rdLoc(dest)]) [tmp, rdLoc(dest)])
if lib.name == nil: InternalError("loadDynamicLib") if lib.name == nil: internalError("loadDynamicLib")
proc mangleDynLibProc(sym: PSym): PRope = proc mangleDynLibProc(sym: PSym): PRope =
if sfCompilerProc in sym.flags: if sfCompilerProc in sym.flags:
@ -672,7 +672,7 @@ proc symInDynamicLib(m: BModule, sym: PSym) =
elif idx.len == 1 and idx[0] in {'0'..'9'}: elif idx.len == 1 and idx[0] in {'0'..'9'}:
app(m.extensionLoaders[idx[0]], load) app(m.extensionLoaders[idx[0]], load)
else: else:
InternalError(sym.info, "wrong index: " & idx) internalError(sym.info, "wrong index: " & idx)
else: else:
appcg(m, m.s[cfsDynLibInit], appcg(m, m.s[cfsDynLibInit],
"\t$1 = ($2) #nimGetProcAddr($3, $4);$n", "\t$1 = ($2) #nimGetProcAddr($3, $4);$n",
@ -708,7 +708,7 @@ proc cgsym(m: BModule, name: string): PRope =
of skProc, skMethod, skConverter, skIterator: genProc(m, sym) of skProc, skMethod, skConverter, skIterator: genProc(m, sym)
of skVar, skResult, skLet: genVarPrototype(m, sym) of skVar, skResult, skLet: genVarPrototype(m, sym)
of skType: discard getTypeDesc(m, sym.typ) of skType: discard getTypeDesc(m, sym.typ)
else: InternalError("cgsym: " & name) else: internalError("cgsym: " & name)
else: else:
# we used to exclude the system module from this check, but for DLL # we used to exclude the system module from this check, but for DLL
# generation support this sloppyness leads to hard to detect bugs, so # generation support this sloppyness leads to hard to detect bugs, so
@ -747,7 +747,7 @@ proc closureSetup(p: BProc, prc: PSym) =
# prc.ast[paramsPos].last contains the type we're after: # prc.ast[paramsPos].last contains the type we're after:
var ls = lastSon(prc.ast[paramsPos]) var ls = lastSon(prc.ast[paramsPos])
if ls.kind != nkSym: if ls.kind != nkSym:
InternalError(prc.info, "closure generation failed") internalError(prc.info, "closure generation failed")
var env = ls.sym var env = ls.sym
#echo "created environment: ", env.id, " for ", prc.name.s #echo "created environment: ", env.id, " for ", prc.name.s
assignLocalVar(p, env) assignLocalVar(p, env)
@ -793,7 +793,7 @@ proc genProcAux(m: BModule, prc: PSym) =
app(generatedProc, initGCFrame(p)) app(generatedProc, initGCFrame(p))
if optStackTrace in prc.options: if optStackTrace in prc.options:
app(generatedProc, p.s(cpsLocals)) app(generatedProc, p.s(cpsLocals))
var procname = CStringLit(p, generatedProc, prc.name.s) var procname = cstringLit(p, generatedProc, prc.name.s)
app(generatedProc, initFrame(p, procname, prc.info.quotedFilename)) app(generatedProc, initFrame(p, procname, prc.info.quotedFilename))
else: else:
app(generatedProc, p.s(cpsLocals)) app(generatedProc, p.s(cpsLocals))
@ -814,13 +814,13 @@ proc genProcPrototype(m: BModule, sym: PSym) =
if lfNoDecl in sym.loc.Flags: return if lfNoDecl in sym.loc.Flags: return
if lfDynamicLib in sym.loc.Flags: if lfDynamicLib in sym.loc.Flags:
if getModule(sym).id != m.module.id and if getModule(sym).id != m.module.id and
not ContainsOrIncl(m.declaredThings, sym.id): not containsOrIncl(m.declaredThings, sym.id):
app(m.s[cfsVars], rfmt(nil, "extern $1 $2;$n", app(m.s[cfsVars], rfmt(nil, "extern $1 $2;$n",
getTypeDesc(m, sym.loc.t), mangleDynLibProc(sym))) getTypeDesc(m, sym.loc.t), mangleDynLibProc(sym)))
if gCmd == cmdCompileToLLVM: incl(sym.loc.flags, lfIndirect) if gCmd == cmdCompileToLLVM: incl(sym.loc.flags, lfIndirect)
elif not ContainsOrIncl(m.declaredProtos, sym.id): elif not containsOrIncl(m.declaredProtos, sym.id):
var header = genProcHeader(m, sym) var header = genProcHeader(m, sym)
if sfPure in sym.flags and hasNakedAttribute in CC[ccompiler].props: if sfPure in sym.flags and hasNakedAttribute in CC[cCompiler].props:
header.app(" __attribute__((naked))") header.app(" __attribute__((naked))")
app(m.s[cfsProcHeaders], rfmt(nil, "$1;$n", header)) app(m.s[cfsProcHeaders], rfmt(nil, "$1;$n", header))
@ -837,16 +837,16 @@ proc genProcNoForward(m: BModule, prc: PSym) =
# We add inline procs to the calling module to enable C based inlining. # We add inline procs to the calling module to enable C based inlining.
# This also means that a check with ``q.declaredThings`` is wrong, we need # This also means that a check with ``q.declaredThings`` is wrong, we need
# a check for ``m.declaredThings``. # a check for ``m.declaredThings``.
if not ContainsOrIncl(m.declaredThings, prc.id): genProcAux(m, prc) if not containsOrIncl(m.declaredThings, prc.id): genProcAux(m, prc)
elif lfDynamicLib in prc.loc.flags: elif lfDynamicLib in prc.loc.flags:
var q = findPendingModule(m, prc) var q = findPendingModule(m, prc)
if q != nil and not ContainsOrIncl(q.declaredThings, prc.id): if q != nil and not containsOrIncl(q.declaredThings, prc.id):
SymInDynamicLib(q, prc) symInDynamicLib(q, prc)
else: else:
SymInDynamicLibPartial(m, prc) symInDynamicLibPartial(m, prc)
elif sfImportc notin prc.flags: elif sfImportc notin prc.flags:
var q = findPendingModule(m, prc) var q = findPendingModule(m, prc)
if q != nil and not ContainsOrIncl(q.declaredThings, prc.id): if q != nil and not containsOrIncl(q.declaredThings, prc.id):
genProcAux(q, prc) genProcAux(q, prc)
proc requestConstImpl(p: BProc, sym: PSym) = proc requestConstImpl(p: BProc, sym: PSym) =
@ -857,12 +857,12 @@ proc requestConstImpl(p: BProc, sym: PSym) =
if lfNoDecl in sym.loc.Flags: return if lfNoDecl in sym.loc.Flags: return
# declare implementation: # declare implementation:
var q = findPendingModule(m, sym) var q = findPendingModule(m, sym)
if q != nil and not ContainsOrIncl(q.declaredThings, sym.id): if q != nil and not containsOrIncl(q.declaredThings, sym.id):
assert q.initProc.module == q assert q.initProc.module == q
appf(q.s[cfsData], "NIM_CONST $1 $2 = $3;$n", appf(q.s[cfsData], "NIM_CONST $1 $2 = $3;$n",
[getTypeDesc(q, sym.typ), sym.loc.r, genConstExpr(q.initProc, sym.ast)]) [getTypeDesc(q, sym.typ), sym.loc.r, genConstExpr(q.initProc, sym.ast)])
# declare header: # declare header:
if q != m and not ContainsOrIncl(m.declaredThings, sym.id): if q != m and not containsOrIncl(m.declaredThings, sym.id):
assert(sym.loc.r != nil) assert(sym.loc.r != nil)
let headerDecl = ropef("extern NIM_CONST $1 $2;$n", let headerDecl = ropef("extern NIM_CONST $1 $2;$n",
[getTypeDesc(m, sym.loc.t), sym.loc.r]) [getTypeDesc(m, sym.loc.t), sym.loc.r])
@ -882,14 +882,14 @@ proc genProc(m: BModule, prc: PSym) =
generatedHeader != nil and lfNoDecl notin prc.loc.Flags: generatedHeader != nil and lfNoDecl notin prc.loc.Flags:
genProcPrototype(generatedHeader, prc) genProcPrototype(generatedHeader, prc)
if prc.typ.callConv == ccInline: if prc.typ.callConv == ccInline:
if not ContainsOrIncl(generatedHeader.declaredThings, prc.id): if not containsOrIncl(generatedHeader.declaredThings, prc.id):
genProcAux(generatedHeader, prc) genProcAux(generatedHeader, prc)
proc genVarPrototypeAux(m: BModule, sym: PSym) = proc genVarPrototypeAux(m: BModule, sym: PSym) =
assert(sfGlobal in sym.flags) assert(sfGlobal in sym.flags)
useHeader(m, sym) useHeader(m, sym)
fillLoc(sym.loc, locGlobalVar, sym.typ, mangleName(sym), OnHeap) fillLoc(sym.loc, locGlobalVar, sym.typ, mangleName(sym), OnHeap)
if (lfNoDecl in sym.loc.Flags) or ContainsOrIncl(m.declaredThings, sym.id): if (lfNoDecl in sym.loc.Flags) or containsOrIncl(m.declaredThings, sym.id):
return return
if sym.owner.id != m.module.id: if sym.owner.id != m.module.id:
# else we already have the symbol generated! # else we already have the symbol generated!
@ -1058,7 +1058,7 @@ proc genInitCode(m: BModule) =
# declare it nevertheless: # declare it nevertheless:
m.FrameDeclared = true m.FrameDeclared = true
if not m.PreventStackTrace: if not m.PreventStackTrace:
var procname = CStringLit(m.initProc, prc, m.module.name.s) var procname = cstringLit(m.initProc, prc, m.module.name.s)
app(prc, initFrame(m.initProc, procname, m.module.info.quotedFilename)) app(prc, initFrame(m.initProc, procname, m.module.info.quotedFilename))
else: else:
app(prc, ~"\tTFrame F; F.len = 0;$N") app(prc, ~"\tTFrame F; F.len = 0;$N")
@ -1127,7 +1127,7 @@ proc initProcOptions(m: BModule): TOptions =
proc rawNewModule(module: PSym, filename: string): BModule = proc rawNewModule(module: PSym, filename: string): BModule =
new(result) new(result)
InitLinkedList(result.headerFiles) initLinkedList(result.headerFiles)
result.declaredThings = initIntSet() result.declaredThings = initIntSet()
result.declaredProtos = initIntSet() result.declaredProtos = initIntSet()
result.cfilename = filename result.cfilename = filename
@ -1159,7 +1159,7 @@ proc nullify[T](arr: var T) =
proc resetModule*(m: var BModule) = proc resetModule*(m: var BModule) =
# between two compilations in CAAS mode, we can throw # between two compilations in CAAS mode, we can throw
# away all the data that was written to disk # away all the data that was written to disk
InitLinkedList(m.headerFiles) initLinkedList(m.headerFiles)
m.declaredProtos = initIntSet() m.declaredProtos = initIntSet()
initIdTable(m.forwTypeCache) initIdTable(m.forwTypeCache)
m.initProc = newProc(nil, m) m.initProc = newProc(nil, m)
@ -1210,7 +1210,7 @@ proc newModule(module: PSym): BModule =
if (optDeadCodeElim in gGlobalOptions): if (optDeadCodeElim in gGlobalOptions):
if (sfDeadCodeElim in module.flags): if (sfDeadCodeElim in module.flags):
InternalError("added pending module twice: " & module.filename) internalError("added pending module twice: " & module.filename)
proc myOpen(module: PSym): PPassContext = proc myOpen(module: PSym): PPassContext =
result = newModule(module) result = newModule(module)
@ -1263,19 +1263,19 @@ proc finishModule(m: BModule) =
# a ``for`` loop here # a ``for`` loop here
var prc = m.forwardedProcs[i] var prc = m.forwardedProcs[i]
if sfForward in prc.flags: if sfForward in prc.flags:
InternalError(prc.info, "still forwarded: " & prc.name.s) internalError(prc.info, "still forwarded: " & prc.name.s)
genProcNoForward(m, prc) genProcNoForward(m, prc)
inc(i) inc(i)
assert(gForwardedProcsCounter >= i) assert(gForwardedProcsCounter >= i)
dec(gForwardedProcsCounter, i) dec(gForwardedProcsCounter, i)
setlen(m.forwardedProcs, 0) setLen(m.forwardedProcs, 0)
proc shouldRecompile(code: PRope, cfile, cfilenoext: string): bool = proc shouldRecompile(code: PRope, cfile, cfilenoext: string): bool =
result = true result = true
if optForceFullMake notin gGlobalOptions: if optForceFullMake notin gGlobalOptions:
var objFile = toObjFile(cfilenoext) var objFile = toObjFile(cfilenoext)
if writeRopeIfNotEqual(code, cfile): return if writeRopeIfNotEqual(code, cfile): return
if ExistsFile(objFile) and os.FileNewer(objFile, cfile): result = false if existsFile(objFile) and os.FileNewer(objFile, cfile): result = false
else: else:
writeRope(code, cfile) writeRope(code, cfile)
@ -1296,7 +1296,7 @@ proc writeModule(m: BModule, pending: bool) =
if sfMainModule in m.module.flags: if sfMainModule in m.module.flags:
# generate main file: # generate main file:
app(m.s[cfsProcHeaders], mainModProcs) app(m.s[cfsProcHeaders], mainModProcs)
GenerateThreadVarsSize(m) generateThreadVarsSize(m)
var code = genModule(m, cfilenoext) var code = genModule(m, cfilenoext)
when hasTinyCBackend: when hasTinyCBackend:
@ -1313,7 +1313,7 @@ proc writeModule(m: BModule, pending: bool) =
var code = genModule(m, cfilenoext) var code = genModule(m, cfilenoext)
writeRope(code, cfile) writeRope(code, cfile)
addFileToCompile(cfilenoext) addFileToCompile(cfilenoext)
elif not ExistsFile(toObjFile(cfilenoext)): elif not existsFile(toObjFile(cfilenoext)):
# Consider: first compilation compiles ``system.nim`` and produces # Consider: first compilation compiles ``system.nim`` and produces
# ``system.c`` but then compilation fails due to an error. This means # ``system.c`` but then compilation fails due to an error. This means
# that ``system.o`` is missing, so we need to call the C compiler for it: # that ``system.o`` is missing, so we need to call the C compiler for it:

4
compiler/cgendata.nim
View file

@ -78,7 +78,7 @@ type
maxFrameLen*: int # max length of frame descriptor maxFrameLen*: int # max length of frame descriptor
module*: BModule # used to prevent excessive parameter passing module*: BModule # used to prevent excessive parameter passing
withinLoop*: int # > 0 if we are within a loop withinLoop*: int # > 0 if we are within a loop
gcFrameId*: natural # for the GC stack marking gcFrameId*: Natural # for the GC stack marking
gcFrameType*: PRope # the struct {} we put the GC markers into gcFrameType*: PRope # the struct {} we put the GC markers into
TTypeSeq* = seq[PType] TTypeSeq* = seq[PType]
@ -108,7 +108,7 @@ type
forwardedProcs*: TSymSeq # keep forwarded procs here forwardedProcs*: TSymSeq # keep forwarded procs here
typeNodes*, nimTypes*: int # used for type info generation typeNodes*, nimTypes*: int # used for type info generation
typeNodesName*, nimTypesName*: PRope # used for type info generation typeNodesName*, nimTypesName*: PRope # used for type info generation
labels*: natural # for generating unique module-scope names labels*: Natural # for generating unique module-scope names
extensionLoaders*: array['0'..'9', PRope] # special procs for the extensionLoaders*: array['0'..'9', PRope] # special procs for the
# OpenGL wrapper # OpenGL wrapper
injectStmt*: PRope injectStmt*: PRope

16
compiler/cgmeth.nim
View file

@ -18,16 +18,16 @@ proc genConv(n: PNode, d: PType, downcast: bool): PNode =
var source = skipTypes(n.typ, abstractPtrs) var source = skipTypes(n.typ, abstractPtrs)
if (source.kind == tyObject) and (dest.kind == tyObject): if (source.kind == tyObject) and (dest.kind == tyObject):
var diff = inheritanceDiff(dest, source) var diff = inheritanceDiff(dest, source)
if diff == high(int): InternalError(n.info, "cgmeth.genConv") if diff == high(int): internalError(n.info, "cgmeth.genConv")
if diff < 0: if diff < 0:
result = newNodeIT(nkObjUpConv, n.info, d) result = newNodeIT(nkObjUpConv, n.info, d)
addSon(result, n) addSon(result, n)
if downCast: InternalError(n.info, "cgmeth.genConv: no upcast allowed") if downcast: internalError(n.info, "cgmeth.genConv: no upcast allowed")
elif diff > 0: elif diff > 0:
result = newNodeIT(nkObjDownConv, n.info, d) result = newNodeIT(nkObjDownConv, n.info, d)
addSon(result, n) addSon(result, n)
if not downCast: if not downcast:
InternalError(n.info, "cgmeth.genConv: no downcast allowed") internalError(n.info, "cgmeth.genConv: no downcast allowed")
else: else:
result = n result = n
else: else:
@ -112,12 +112,12 @@ proc relevantCol(methods: TSymSeq, col: int): bool =
if t.kind == tyObject: if t.kind == tyObject:
for i in countup(1, high(methods)): for i in countup(1, high(methods)):
let t2 = skipTypes(methods[i].typ.sons[col], skipPtrs) let t2 = skipTypes(methods[i].typ.sons[col], skipPtrs)
if not SameType(t2, t): if not sameType(t2, t):
return true return true
proc cmpSignatures(a, b: PSym, relevantCols: TIntSet): int = proc cmpSignatures(a, b: PSym, relevantCols: TIntSet): int =
for col in countup(1, sonsLen(a.typ) - 1): for col in countup(1, sonsLen(a.typ) - 1):
if Contains(relevantCols, col): if contains(relevantCols, col):
var aa = skipTypes(a.typ.sons[col], skipPtrs) var aa = skipTypes(a.typ.sons[col], skipPtrs)
var bb = skipTypes(b.typ.sons[col], skipPtrs) var bb = skipTypes(b.typ.sons[col], skipPtrs)
var d = inheritanceDiff(aa, bb) var d = inheritanceDiff(aa, bb)
@ -154,7 +154,7 @@ proc genDispatcher(methods: TSymSeq, relevantCols: TIntSet): PSym =
var curr = methods[meth] # generate condition: var curr = methods[meth] # generate condition:
var cond: PNode = nil var cond: PNode = nil
for col in countup(1, paramLen - 1): for col in countup(1, paramLen - 1):
if Contains(relevantCols, col): if contains(relevantCols, col):
var isn = newNodeIT(nkCall, base.info, getSysType(tyBool)) var isn = newNodeIT(nkCall, base.info, getSysType(tyBool))
addSon(isn, newSymNode(iss)) addSon(isn, newSymNode(iss))
addSon(isn, newSymNode(base.typ.n.sons[col].sym)) addSon(isn, newSymNode(base.typ.n.sons[col].sym))
@ -195,7 +195,7 @@ proc generateMethodDispatchers*(): PNode =
for bucket in countup(0, len(gMethods) - 1): for bucket in countup(0, len(gMethods) - 1):
var relevantCols = initIntSet() var relevantCols = initIntSet()
for col in countup(1, sonsLen(gMethods[bucket][0].typ) - 1): for col in countup(1, sonsLen(gMethods[bucket][0].typ) - 1):
if relevantCol(gMethods[bucket], col): Incl(relevantCols, col) if relevantCol(gMethods[bucket], col): incl(relevantCols, col)
sortBucket(gMethods[bucket], relevantCols) sortBucket(gMethods[bucket], relevantCols)
addSon(result, newSymNode(genDispatcher(gMethods[bucket], relevantCols))) addSon(result, newSymNode(genDispatcher(gMethods[bucket], relevantCols)))

92
compiler/commands.nim
View file

@ -22,7 +22,7 @@ type
passPP # preprocessor called ProcessCommand() passPP # preprocessor called ProcessCommand()
proc processCommand*(switch: string, pass: TCmdLinePass) proc processCommand*(switch: string, pass: TCmdLinePass)
proc processSwitch*(switch, arg: string, pass: TCmdlinePass, info: TLineInfo) proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo)
# implementation # implementation
@ -36,7 +36,7 @@ const
proc getCommandLineDesc(): string = proc getCommandLineDesc(): string =
result = (HelpMessage % [VersionAsString, platform.os[platform.hostOS].name, result = (HelpMessage % [VersionAsString, platform.os[platform.hostOS].name,
cpu[platform.hostCPU].name]) & Usage CPU[platform.hostCPU].name]) & Usage
proc helpOnError(pass: TCmdLinePass) = proc helpOnError(pass: TCmdLinePass) =
if pass == passCmd1: if pass == passCmd1:
@ -47,14 +47,14 @@ proc writeAdvancedUsage(pass: TCmdLinePass) =
if pass == passCmd1: if pass == passCmd1:
msgWriteln(`%`(HelpMessage, [VersionAsString, msgWriteln(`%`(HelpMessage, [VersionAsString,
platform.os[platform.hostOS].name, platform.os[platform.hostOS].name,
cpu[platform.hostCPU].name]) & AdvancedUsage) CPU[platform.hostCPU].name]) & AdvancedUsage)
quit(0) quit(0)
proc writeVersionInfo(pass: TCmdLinePass) = proc writeVersionInfo(pass: TCmdLinePass) =
if pass == passCmd1: if pass == passCmd1:
msgWriteln(`%`(HelpMessage, [VersionAsString, msgWriteln(`%`(HelpMessage, [VersionAsString,
platform.os[platform.hostOS].name, platform.os[platform.hostOS].name,
cpu[platform.hostCPU].name])) CPU[platform.hostCPU].name]))
quit(0) quit(0)
var var
@ -88,14 +88,14 @@ proc splitSwitch(switch: string, cmd, arg: var string, pass: TCmdLinePass,
elif switch[i] in {':', '=', '['}: arg = substr(switch, i + 1) elif switch[i] in {':', '=', '['}: arg = substr(switch, i + 1)
else: invalidCmdLineOption(pass, switch, info) else: invalidCmdLineOption(pass, switch, info)
proc processOnOffSwitch(op: TOptions, arg: string, pass: TCmdlinePass, proc processOnOffSwitch(op: TOptions, arg: string, pass: TCmdLinePass,
info: TLineInfo) = info: TLineInfo) =
case whichKeyword(arg) case whichKeyword(arg)
of wOn: gOptions = gOptions + op of wOn: gOptions = gOptions + op
of wOff: gOptions = gOptions - op of wOff: gOptions = gOptions - op
else: localError(info, errOnOrOffExpectedButXFound, arg) else: localError(info, errOnOrOffExpectedButXFound, arg)
proc processOnOffSwitchG(op: TGlobalOptions, arg: string, pass: TCmdlinePass, proc processOnOffSwitchG(op: TGlobalOptions, arg: string, pass: TCmdLinePass,
info: TLineInfo) = info: TLineInfo) =
case whichKeyword(arg) case whichKeyword(arg)
of wOn: gGlobalOptions = gGlobalOptions + op of wOn: gGlobalOptions = gGlobalOptions + op
@ -108,7 +108,7 @@ proc expectArg(switch, arg: string, pass: TCmdLinePass, info: TLineInfo) =
proc expectNoArg(switch, arg: string, pass: TCmdLinePass, info: TLineInfo) = proc expectNoArg(switch, arg: string, pass: TCmdLinePass, info: TLineInfo) =
if arg != "": localError(info, errCmdLineNoArgExpected, addPrefix(switch)) if arg != "": localError(info, errCmdLineNoArgExpected, addPrefix(switch))
proc processSpecificNote(arg: string, state: TSpecialWord, pass: TCmdlinePass, proc processSpecificNote(arg: string, state: TSpecialWord, pass: TCmdLinePass,
info: TLineInfo) = info: TLineInfo) =
var id = "" # arg = "X]:on|off" var id = "" # arg = "X]:on|off"
var i = 0 var i = 0
@ -234,7 +234,7 @@ proc track(arg: string, info: TLineInfo) =
optTrackPos = newLineInfo(a[0], line, column) optTrackPos = newLineInfo(a[0], line, column)
msgs.addCheckpoint(optTrackPos) msgs.addCheckpoint(optTrackPos)
proc dynlibOverride(switch, arg: string, pass: TCmdlinePass, info: TLineInfo) = proc dynlibOverride(switch, arg: string, pass: TCmdLinePass, info: TLineInfo) =
if pass in {passCmd2, passPP}: if pass in {passCmd2, passPP}:
expectArg(switch, arg, pass, info) expectArg(switch, arg, pass, info)
options.inclDynlibOverride(arg) options.inclDynlibOverride(arg)
@ -252,7 +252,7 @@ proc processSwitch(switch, arg: string, pass: TCmdlinePass, info: TLineInfo) =
if pass in {passCmd2, passPP}: if pass in {passCmd2, passPP}:
expectArg(switch, arg, pass, info) expectArg(switch, arg, pass, info)
let path = processPath(arg, notRelativeToProj=true) let path = processPath(arg, notRelativeToProj=true)
babelpath(path, info) babelPath(path, info)
of "excludepath": of "excludepath":
expectArg(switch, arg, pass, info) expectArg(switch, arg, pass, info)
let path = processPath(arg) let path = processPath(arg)
@ -269,10 +269,10 @@ proc processSwitch(switch, arg: string, pass: TCmdlinePass, info: TLineInfo) =
optMainModule = arg optMainModule = arg
of "define", "d": of "define", "d":
expectArg(switch, arg, pass, info) expectArg(switch, arg, pass, info)
DefineSymbol(arg) defineSymbol(arg)
of "undef", "u": of "undef", "u":
expectArg(switch, arg, pass, info) expectArg(switch, arg, pass, info)
UndefSymbol(arg) undefSymbol(arg)
of "compile": of "compile":
expectArg(switch, arg, pass, info) expectArg(switch, arg, pass, info)
if pass in {passCmd2, passPP}: processCompile(arg) if pass in {passCmd2, passPP}: processCompile(arg)
@ -321,40 +321,40 @@ proc processSwitch(switch, arg: string, pass: TCmdlinePass, info: TLineInfo) =
defineSymbol("nogc") defineSymbol("nogc")
else: localError(info, errNoneBoehmRefcExpectedButXFound, arg) else: localError(info, errNoneBoehmRefcExpectedButXFound, arg)
of "warnings", "w": processOnOffSwitch({optWarns}, arg, pass, info) of "warnings", "w": processOnOffSwitch({optWarns}, arg, pass, info)
of "warning": ProcessSpecificNote(arg, wWarning, pass, info) of "warning": processSpecificNote(arg, wWarning, pass, info)
of "hint": ProcessSpecificNote(arg, wHint, pass, info) of "hint": processSpecificNote(arg, wHint, pass, info)
of "hints": ProcessOnOffSwitch({optHints}, arg, pass, info) of "hints": processOnOffSwitch({optHints}, arg, pass, info)
of "threadanalysis": ProcessOnOffSwitchG({optThreadAnalysis}, arg, pass, info) of "threadanalysis": processOnOffSwitchG({optThreadAnalysis}, arg, pass, info)
of "stacktrace": ProcessOnOffSwitch({optStackTrace}, arg, pass, info) of "stacktrace": processOnOffSwitch({optStackTrace}, arg, pass, info)
of "linetrace": ProcessOnOffSwitch({optLineTrace}, arg, pass, info) of "linetrace": processOnOffSwitch({optLineTrace}, arg, pass, info)
of "debugger": of "debugger":
ProcessOnOffSwitch({optEndb}, arg, pass, info) processOnOffSwitch({optEndb}, arg, pass, info)
if optEndb in gOptions: DefineSymbol("endb") if optEndb in gOptions: defineSymbol("endb")
else: UndefSymbol("endb") else: undefSymbol("endb")
of "profiler": of "profiler":
ProcessOnOffSwitch({optProfiler}, arg, pass, info) processOnOffSwitch({optProfiler}, arg, pass, info)
if optProfiler in gOptions: DefineSymbol("profiler") if optProfiler in gOptions: defineSymbol("profiler")
else: UndefSymbol("profiler") else: undefSymbol("profiler")
of "checks", "x": ProcessOnOffSwitch(checksOptions, arg, pass, info) of "checks", "x": processOnOffSwitch(checksOptions, arg, pass, info)
of "floatchecks": of "floatchecks":
ProcessOnOffSwitch({optNanCheck, optInfCheck}, arg, pass, info) processOnOffSwitch({optNanCheck, optInfCheck}, arg, pass, info)
of "infchecks": ProcessOnOffSwitch({optInfCheck}, arg, pass, info) of "infchecks": processOnOffSwitch({optInfCheck}, arg, pass, info)
of "nanchecks": ProcessOnOffSwitch({optNanCheck}, arg, pass, info) of "nanchecks": processOnOffSwitch({optNanCheck}, arg, pass, info)
of "objchecks": ProcessOnOffSwitch({optObjCheck}, arg, pass, info) of "objchecks": processOnOffSwitch({optObjCheck}, arg, pass, info)
of "fieldchecks": ProcessOnOffSwitch({optFieldCheck}, arg, pass, info) of "fieldchecks": processOnOffSwitch({optFieldCheck}, arg, pass, info)
of "rangechecks": ProcessOnOffSwitch({optRangeCheck}, arg, pass, info) of "rangechecks": processOnOffSwitch({optRangeCheck}, arg, pass, info)
of "boundchecks": ProcessOnOffSwitch({optBoundsCheck}, arg, pass, info) of "boundchecks": processOnOffSwitch({optBoundsCheck}, arg, pass, info)
of "overflowchecks": ProcessOnOffSwitch({optOverflowCheck}, arg, pass, info) of "overflowchecks": processOnOffSwitch({optOverflowCheck}, arg, pass, info)
of "linedir": ProcessOnOffSwitch({optLineDir}, arg, pass, info) of "linedir": processOnOffSwitch({optLineDir}, arg, pass, info)
of "assertions", "a": ProcessOnOffSwitch({optAssert}, arg, pass, info) of "assertions", "a": processOnOffSwitch({optAssert}, arg, pass, info)
of "deadcodeelim": ProcessOnOffSwitchG({optDeadCodeElim}, arg, pass, info) of "deadcodeelim": processOnOffSwitchG({optDeadCodeElim}, arg, pass, info)
of "threads": ProcessOnOffSwitchG({optThreads}, arg, pass, info) of "threads": processOnOffSwitchG({optThreads}, arg, pass, info)
of "tlsemulation": ProcessOnOffSwitchG({optTlsEmulation}, arg, pass, info) of "tlsemulation": processOnOffSwitchG({optTlsEmulation}, arg, pass, info)
of "taintmode": ProcessOnOffSwitchG({optTaintMode}, arg, pass, info) of "taintmode": processOnOffSwitchG({optTaintMode}, arg, pass, info)
of "implicitstatic": of "implicitstatic":
ProcessOnOffSwitch({optImplicitStatic}, arg, pass, info) processOnOffSwitch({optImplicitStatic}, arg, pass, info)
of "patterns": of "patterns":
ProcessOnOffSwitch({optPatterns}, arg, pass, info) processOnOffSwitch({optPatterns}, arg, pass, info)
of "opt": of "opt":
expectArg(switch, arg, pass, info) expectArg(switch, arg, pass, info)
case arg.normalize case arg.normalize
@ -367,7 +367,7 @@ proc processSwitch(switch, arg: string, pass: TCmdlinePass, info: TLineInfo) =
of "none": of "none":
excl(gOptions, optOptimizeSpeed) excl(gOptions, optOptimizeSpeed)
excl(gOptions, optOptimizeSize) excl(gOptions, optOptimizeSize)
else: LocalError(info, errNoneSpeedOrSizeExpectedButXFound, arg) else: localError(info, errNoneSpeedOrSizeExpectedButXFound, arg)
of "app": of "app":
expectArg(switch, arg, pass, info) expectArg(switch, arg, pass, info)
case arg.normalize case arg.normalize
@ -389,7 +389,7 @@ proc processSwitch(switch, arg: string, pass: TCmdlinePass, info: TLineInfo) =
excl(gGlobalOptions, optGenGuiApp) excl(gGlobalOptions, optGenGuiApp)
defineSymbol("library") defineSymbol("library")
defineSymbol("staticlib") defineSymbol("staticlib")
else: LocalError(info, errGuiConsoleOrLibExpectedButXFound, arg) else: localError(info, errGuiConsoleOrLibExpectedButXFound, arg)
of "passc", "t": of "passc", "t":
expectArg(switch, arg, pass, info) expectArg(switch, arg, pass, info)
if pass in {passCmd2, passPP}: extccomp.addCompileOption(arg) if pass in {passCmd2, passPP}: extccomp.addCompileOption(arg)
@ -409,7 +409,7 @@ proc processSwitch(switch, arg: string, pass: TCmdlinePass, info: TLineInfo) =
headerFile = arg headerFile = arg
incl(gGlobalOptions, optGenIndex) incl(gGlobalOptions, optGenIndex)
of "index": of "index":
ProcessOnOffSwitchG({optGenIndex}, arg, pass, info) processOnOffSwitchG({optGenIndex}, arg, pass, info)
of "import": of "import":
expectArg(switch, arg, pass, info) expectArg(switch, arg, pass, info)
if pass in {passCmd2, passPP}: implicitImports.add arg if pass in {passCmd2, passPP}: implicitImports.add arg
@ -426,7 +426,7 @@ proc processSwitch(switch, arg: string, pass: TCmdlinePass, info: TLineInfo) =
expectArg(switch, arg, pass, info) expectArg(switch, arg, pass, info)
if pass in {passCmd1, passPP}: if pass in {passCmd1, passPP}:
theOS = platform.NameToOS(arg) theOS = platform.NameToOS(arg)
if theOS == osNone: LocalError(info, errUnknownOS, arg) if theOS == osNone: localError(info, errUnknownOS, arg)
elif theOS != platform.hostOS: elif theOS != platform.hostOS:
setTarget(theOS, targetCPU) setTarget(theOS, targetCPU)
condsyms.InitDefines() condsyms.InitDefines()
@ -434,7 +434,7 @@ proc processSwitch(switch, arg: string, pass: TCmdlinePass, info: TLineInfo) =
expectArg(switch, arg, pass, info) expectArg(switch, arg, pass, info)
if pass in {passCmd1, passPP}: if pass in {passCmd1, passPP}:
cpu = platform.NameToCPU(arg) cpu = platform.NameToCPU(arg)
if cpu == cpuNone: LocalError(info, errUnknownCPU, arg) if cpu == cpuNone: localError(info, errUnknownCPU, arg)
elif cpu != platform.hostCPU: elif cpu != platform.hostCPU:
setTarget(targetOS, cpu) setTarget(targetOS, cpu)
condsyms.InitDefines() condsyms.InitDefines()
@ -457,7 +457,7 @@ proc processSwitch(switch, arg: string, pass: TCmdlinePass, info: TLineInfo) =
expectNoArg(switch, arg, pass, info) expectNoArg(switch, arg, pass, info)
helpOnError(pass) helpOnError(pass)
of "symbolfiles": of "symbolfiles":
ProcessOnOffSwitchG({optSymbolFiles}, arg, pass, info) processOnOffSwitchG({optSymbolFiles}, arg, pass, info)
of "skipcfg": of "skipcfg":
expectNoArg(switch, arg, pass, info) expectNoArg(switch, arg, pass, info)
incl(gGlobalOptions, optSkipConfigFile) incl(gGlobalOptions, optSkipConfigFile)

8
compiler/condsyms.nim
View file

@ -78,11 +78,11 @@ proc initDefines*() =
of osMacOSX: of osMacOSX:
defineSymbol("macintosh") defineSymbol("macintosh")
defineSymbol("unix") defineSymbol("unix")
DefineSymbol("posix") defineSymbol("posix")
else: discard else: discard
defineSymbol("cpu" & $cpu[targetCPU].bit) defineSymbol("cpu" & $CPU[targetCPU].bit)
defineSymbol(normalize(endianToStr[cpu[targetCPU].endian])) defineSymbol(normalize(EndianToStr[CPU[targetCPU].endian]))
defineSymbol(cpu[targetCPU].name) defineSymbol(CPU[targetCPU].name)
defineSymbol(platform.os[targetOS].name) defineSymbol(platform.os[targetOS].name)
if platform.OS[targetOS].props.contains(ospLacksThreadVars): if platform.OS[targetOS].props.contains(ospLacksThreadVars):
defineSymbol("emulatedthreadvars") defineSymbol("emulatedthreadvars")

8
compiler/crc.nim
View file

@ -18,8 +18,8 @@ const
InitAdler32* = int32(1) InitAdler32* = int32(1)
proc updateCrc32*(val: int8, crc: TCrc32): TCrc32 {.inline.} proc updateCrc32*(val: int8, crc: TCrc32): TCrc32 {.inline.}
proc updateCrc32*(val: Char, crc: TCrc32): TCrc32 {.inline.} proc updateCrc32*(val: char, crc: TCrc32): TCrc32 {.inline.}
proc crcFromBuf*(buf: Pointer, length: int): TCrc32 proc crcFromBuf*(buf: pointer, length: int): TCrc32
proc strCrc32*(s: string): TCrc32 proc strCrc32*(s: string): TCrc32
proc crcFromFile*(filename: string): TCrc32 proc crcFromFile*(filename: string): TCrc32
proc updateAdler32*(adler: int32, buf: pointer, length: int): int32 proc updateAdler32*(adler: int32, buf: pointer, length: int): int32
@ -75,7 +75,7 @@ const
755167117] 755167117]
proc updateCrc32(val: int8, crc: TCrc32): TCrc32 = proc updateCrc32(val: int8, crc: TCrc32): TCrc32 =
result = TCrc32(crc32Table[(int(crc) xor (int(val) and 0x000000FF)) and result = TCrc32(crc32table[(int(crc) xor (int(val) and 0x000000FF)) and
0x000000FF]) xor (crc shr TCrc32(8)) 0x000000FF]) xor (crc shr TCrc32(8))
proc updateCrc32(val: Char, crc: TCrc32): TCrc32 = proc updateCrc32(val: Char, crc: TCrc32): TCrc32 =
@ -102,7 +102,7 @@ proc crcFromFile(filename: string): TCrc32 =
const const
bufSize = 8000 # don't use 8K for the memory allocator! bufSize = 8000 # don't use 8K for the memory allocator!
var var
bin: tfile bin: TFile
result = InitCrc32 result = InitCrc32
if not open(bin, filename): if not open(bin, filename):
return # not equal if file does not exist return # not equal if file does not exist

2
compiler/depends.nim
View file

@ -43,7 +43,7 @@ proc addDotDependency(c: PPassContext, n: PNode): PNode =
proc generateDot(project: string) = proc generateDot(project: string) =
writeRope(ropef("digraph $1 {$n$2}$n", [ writeRope(ropef("digraph $1 {$n$2}$n", [
toRope(changeFileExt(extractFileName(project), "")), gDotGraph]), toRope(changeFileExt(extractFilename(project), "")), gDotGraph]),
changeFileExt(project, "dot")) changeFileExt(project, "dot"))
proc myOpen(module: PSym): PPassContext = proc myOpen(module: PSym): PPassContext =

24
compiler/docgen.nim
View file

@ -40,11 +40,11 @@ proc compilerMsgHandler(filename: string, line, col: int,
of mwRedefinitionOfLabel: k = warnRedefinitionOfLabel of mwRedefinitionOfLabel: k = warnRedefinitionOfLabel
of mwUnknownSubstitution: k = warnUnknownSubstitutionX of mwUnknownSubstitution: k = warnUnknownSubstitutionX
of mwUnsupportedLanguage: k = warnLanguageXNotSupported of mwUnsupportedLanguage: k = warnLanguageXNotSupported
GlobalError(newLineInfo(filename, line, col), k, arg) globalError(newLineInfo(filename, line, col), k, arg)
proc parseRst(text, filename: string, proc parseRst(text, filename: string,
line, column: int, hasToc: var bool, line, column: int, hasToc: var bool,
rstOptions: TRstParseOptions): PRstNode = rstOptions: TRstParseOptions): PRSTNode =
result = rstParse(text, filename, line, column, hasToc, rstOptions, result = rstParse(text, filename, line, column, hasToc, rstOptions,
options.FindFile, compilerMsgHandler) options.FindFile, compilerMsgHandler)
@ -55,18 +55,18 @@ proc newDocumentor*(filename: string, config: PStringTable): PDoc =
options.FindFile, compilerMsgHandler) options.FindFile, compilerMsgHandler)
result.id = 100 result.id = 100
proc dispA(dest: var PRope, xml, tex: string, args: openarray[PRope]) = proc dispA(dest: var PRope, xml, tex: string, args: openArray[PRope]) =
if gCmd != cmdRst2Tex: appf(dest, xml, args) if gCmd != cmdRst2Tex: appf(dest, xml, args)
else: appf(dest, tex, args) else: appf(dest, tex, args)
proc getVarIdx(varnames: openarray[string], id: string): int = proc getVarIdx(varnames: openArray[string], id: string): int =
for i in countup(0, high(varnames)): for i in countup(0, high(varnames)):
if cmpIgnoreStyle(varnames[i], id) == 0: if cmpIgnoreStyle(varnames[i], id) == 0:
return i return i
result = -1 result = -1
proc ropeFormatNamedVars(frmt: TFormatStr, varnames: openarray[string], proc ropeFormatNamedVars(frmt: TFormatStr, varnames: openArray[string],
varvalues: openarray[PRope]): PRope = varvalues: openArray[PRope]): PRope =
var i = 0 var i = 0
var L = len(frmt) var L = len(frmt)
result = nil result = nil
@ -85,7 +85,7 @@ proc ropeFormatNamedVars(frmt: TFormatStr, varnames: openarray[string],
of '0'..'9': of '0'..'9':
var j = 0 var j = 0
while true: while true:
j = (j * 10) + Ord(frmt[i]) - ord('0') j = (j * 10) + ord(frmt[i]) - ord('0')
inc(i) inc(i)
if (i > L + 0 - 1) or not (frmt[i] in {'0'..'9'}): break if (i > L + 0 - 1) or not (frmt[i] in {'0'..'9'}): break
if j > high(varvalues) + 1: internalError("ropeFormatNamedVars") if j > high(varvalues) + 1: internalError("ropeFormatNamedVars")
@ -112,7 +112,7 @@ proc ropeFormatNamedVars(frmt: TFormatStr, varnames: openarray[string],
var idx = getVarIdx(varnames, id) var idx = getVarIdx(varnames, id)
if idx >= 0: app(result, varvalues[idx]) if idx >= 0: app(result, varvalues[idx])
else: rawMessage(errUnkownSubstitionVar, id) else: rawMessage(errUnkownSubstitionVar, id)
else: InternalError("ropeFormatNamedVars") else: internalError("ropeFormatNamedVars")
var start = i var start = i
while i < L: while i < L:
if frmt[i] != '$': inc(i) if frmt[i] != '$': inc(i)
@ -124,7 +124,7 @@ proc genComment(d: PDoc, n: PNode): string =
var dummyHasToc: bool var dummyHasToc: bool
if n.comment != nil and startsWith(n.comment, "##"): if n.comment != nil and startsWith(n.comment, "##"):
renderRstToOut(d[], parseRst(n.comment, toFilename(n.info), renderRstToOut(d[], parseRst(n.comment, toFilename(n.info),
toLineNumber(n.info), toColumn(n.info), toLinenumber(n.info), toColumn(n.info),
dummyHasToc, d.options + {roSkipPounds}), result) dummyHasToc, d.options + {roSkipPounds}), result)
proc genRecComment(d: PDoc, n: PNode): PRope = proc genRecComment(d: PDoc, n: PNode): PRope =
@ -152,7 +152,7 @@ proc extractDocComment*(s: PSym, d: PDoc = nil): string =
if not d.isNil: if not d.isNil:
var dummyHasToc: bool var dummyHasToc: bool
renderRstToOut(d[], parseRst(n.comment, toFilename(n.info), renderRstToOut(d[], parseRst(n.comment, toFilename(n.info),
toLineNumber(n.info), toColumn(n.info), toLinenumber(n.info), toColumn(n.info),
dummyHasToc, d.options + {roSkipPounds}), dummyHasToc, d.options + {roSkipPounds}),
result) result)
else: else:
@ -186,7 +186,7 @@ proc getName(d: PDoc, n: PNode, splitAfter = -1): string =
internalError(n.info, "getName()") internalError(n.info, "getName()")
result = "" result = ""
proc getRstName(n: PNode): PRstNode = proc getRstName(n: PNode): PRSTNode =
case n.kind case n.kind
of nkPostfix: result = getRstName(n.sons[1]) of nkPostfix: result = getRstName(n.sons[1])
of nkPragmaExpr: result = getRstName(n.sons[0]) of nkPragmaExpr: result = getRstName(n.sons[0])
@ -272,7 +272,7 @@ proc genJSONItem(d: PDoc, n, nameNode: PNode, k: TSymKind): PJsonNode =
result["code"] = %r.buf result["code"] = %r.buf
proc checkForFalse(n: PNode): bool = proc checkForFalse(n: PNode): bool =
result = n.kind == nkIdent and IdentEq(n.ident, "false") result = n.kind == nkIdent and identEq(n.ident, "false")
proc traceDeps(d: PDoc, n: PNode) = proc traceDeps(d: PDoc, n: PNode) =
const k = skModule const k = skModule

12
compiler/evaltempl.nim
View file

@ -37,11 +37,11 @@ proc evalTemplateAux(templ, actual: PNode, c: var TemplCtx, result: PNode) =
result.add copyTree(x) result.add copyTree(x)
else: else:
InternalAssert sfGenSym in s.flags InternalAssert sfGenSym in s.flags
var x = PSym(IdTableGet(c.mapping, s)) var x = PSym(idTableGet(c.mapping, s))
if x == nil: if x == nil:
x = copySym(s, false) x = copySym(s, false)
x.owner = c.genSymOwner x.owner = c.genSymOwner
IdTablePut(c.mapping, s, x) idTablePut(c.mapping, s, x)
result.add newSymNode(x, if c.instLines: actual.info else: templ.info) result.add newSymNode(x, if c.instLines: actual.info else: templ.info)
else: else:
result.add copyNode(c, templ, actual) result.add copyNode(c, templ, actual)
@ -62,13 +62,13 @@ proc evalTemplateArgs(n: PNode, s: PSym): PNode =
a = sonsLen(n) a = sonsLen(n)
else: a = 0 else: a = 0
var f = s.typ.sonsLen var f = s.typ.sonsLen
if a > f: GlobalError(n.info, errWrongNumberOfArguments) if a > f: globalError(n.info, errWrongNumberOfArguments)
result = newNodeI(nkArgList, n.info) result = newNodeI(nkArgList, n.info)
for i in countup(1, f - 1): for i in countup(1, f - 1):
var arg = if i < a: n.sons[i] else: copyTree(s.typ.n.sons[i].sym.ast) var arg = if i < a: n.sons[i] else: copyTree(s.typ.n.sons[i].sym.ast)
if arg == nil or arg.kind == nkEmpty: if arg == nil or arg.kind == nkEmpty:
LocalError(n.info, errWrongNumberOfArguments) localError(n.info, errWrongNumberOfArguments)
addSon(result, arg) addSon(result, arg)
var evalTemplateCounter* = 0 var evalTemplateCounter* = 0
@ -77,7 +77,7 @@ var evalTemplateCounter* = 0
proc evalTemplate*(n: PNode, tmpl, genSymOwner: PSym): PNode = proc evalTemplate*(n: PNode, tmpl, genSymOwner: PSym): PNode =
inc(evalTemplateCounter) inc(evalTemplateCounter)
if evalTemplateCounter > 100: if evalTemplateCounter > 100:
GlobalError(n.info, errTemplateInstantiationTooNested) globalError(n.info, errTemplateInstantiationTooNested)
result = n result = n
# replace each param by the corresponding node: # replace each param by the corresponding node:
@ -93,7 +93,7 @@ proc evalTemplate*(n: PNode, tmpl, genSymOwner: PSym): PNode =
evalTemplateAux(body, args, ctx, result) evalTemplateAux(body, args, ctx, result)
if result.len == 1: result = result.sons[0] if result.len == 1: result = result.sons[0]
else: else:
GlobalError(result.info, errIllFormedAstX, globalError(result.info, errIllFormedAstX,
renderTree(result, {renderNoComments})) renderTree(result, {renderNoComments}))
else: else:
result = copyNode(body) result = copyNode(body)

98
compiler/extccomp.nim
View file

@ -346,13 +346,13 @@ proc getConfigVar(c: TSystemCC, suffix: string): string =
result = getConfigVar(CC[c].name & suffix) result = getConfigVar(CC[c].name & suffix)
proc setCC*(ccname: string) = proc setCC*(ccname: string) =
ccompiler = nameToCC(ccname) cCompiler = nameToCC(ccname)
if ccompiler == ccNone: rawMessage(errUnknownCcompiler, ccname) if cCompiler == ccNone: rawMessage(errUnknownCcompiler, ccname)
compileOptions = getConfigVar(ccompiler, ".options.always") compileOptions = getConfigVar(cCompiler, ".options.always")
linkOptions = getConfigVar(ccompiler, ".options.linker") linkOptions = getConfigVar(cCompiler, ".options.linker")
ccompilerpath = getConfigVar(ccompiler, ".path") ccompilerpath = getConfigVar(cCompiler, ".path")
for i in countup(low(CC), high(CC)): undefSymbol(CC[i].name) for i in countup(low(CC), high(CC)): undefSymbol(CC[i].name)
defineSymbol(CC[ccompiler].name) defineSymbol(CC[cCompiler].name)
proc addOpt(dest: var string, src: string) = proc addOpt(dest: var string, src: string) =
if len(dest) == 0 or dest[len(dest)-1] != ' ': add(dest, " ") if len(dest) == 0 or dest[len(dest)-1] != ' ': add(dest, " ")
@ -368,20 +368,20 @@ proc addCompileOption*(option: string) =
proc initVars*() = proc initVars*() =
# we need to define the symbol here, because ``CC`` may have never been set! # we need to define the symbol here, because ``CC`` may have never been set!
for i in countup(low(CC), high(CC)): undefSymbol(CC[i].name) for i in countup(low(CC), high(CC)): undefSymbol(CC[i].name)
defineSymbol(CC[ccompiler].name) defineSymbol(CC[cCompiler].name)
if gCmd == cmdCompileToCpp: cExt = ".cpp" if gCmd == cmdCompileToCpp: cExt = ".cpp"
elif gCmd == cmdCompileToOC: cExt = ".m" elif gCmd == cmdCompileToOC: cExt = ".m"
addCompileOption(getConfigVar(ccompiler, ".options.always")) addCompileOption(getConfigVar(cCompiler, ".options.always"))
addLinkOption(getConfigVar(ccompiler, ".options.linker")) addLinkOption(getConfigVar(cCompiler, ".options.linker"))
if len(ccompilerPath) == 0: if len(ccompilerpath) == 0:
ccompilerpath = getConfigVar(ccompiler, ".path") ccompilerpath = getConfigVar(cCompiler, ".path")
proc completeCFilePath*(cfile: string, createSubDir: bool = true): string = proc completeCFilePath*(cfile: string, createSubDir: bool = true): string =
result = completeGeneratedFilePath(cfile, createSubDir) result = completeGeneratedFilePath(cfile, createSubDir)
proc toObjFile*(filenameWithoutExt: string): string = proc toObjFile*(filenameWithoutExt: string): string =
# Object file for compilation # Object file for compilation
result = changeFileExt(filenameWithoutExt, cc[ccompiler].objExt) result = changeFileExt(filenameWithoutExt, CC[cCompiler].objExt)
proc addFileToCompile*(filename: string) = proc addFileToCompile*(filename: string) =
appendStr(toCompile, filename) appendStr(toCompile, filename)
@ -400,7 +400,7 @@ proc addFileToLink*(filename: string) =
# BUGFIX: was ``appendStr`` # BUGFIX: was ``appendStr``
proc execExternalProgram*(cmd: string) = proc execExternalProgram*(cmd: string) =
if optListCmd in gGlobalOptions or gVerbosity > 0: MsgWriteln(cmd) if optListCmd in gGlobalOptions or gVerbosity > 0: msgWriteln(cmd)
if execCmd(cmd) != 0: rawMessage(errExecutionOfProgramFailed, "") if execCmd(cmd) != 0: rawMessage(errExecutionOfProgramFailed, "")
proc generateScript(projectFile: string, script: PRope) = proc generateScript(projectFile: string, script: PRope) =
@ -411,17 +411,17 @@ proc generateScript(projectFile: string, script: PRope) =
proc getOptSpeed(c: TSystemCC): string = proc getOptSpeed(c: TSystemCC): string =
result = getConfigVar(c, ".options.speed") result = getConfigVar(c, ".options.speed")
if result == "": if result == "":
result = cc[c].optSpeed # use default settings from this file result = CC[c].optSpeed # use default settings from this file
proc getDebug(c: TSystemCC): string = proc getDebug(c: TSystemCC): string =
result = getConfigVar(c, ".options.debug") result = getConfigVar(c, ".options.debug")
if result == "": if result == "":
result = cc[c].debug # use default settings from this file result = CC[c].debug # use default settings from this file
proc getOptSize(c: TSystemCC): string = proc getOptSize(c: TSystemCC): string =
result = getConfigVar(c, ".options.size") result = getConfigVar(c, ".options.size")
if result == "": if result == "":
result = cc[c].optSize # use default settings from this file result = CC[c].optSize # use default settings from this file
proc noAbsolutePaths: bool {.inline.} = proc noAbsolutePaths: bool {.inline.} =
# We used to check current OS != specified OS, but this makes no sense # We used to check current OS != specified OS, but this makes no sense
@ -436,7 +436,7 @@ const
var fileCounter: int var fileCounter: int
proc add(s: var string, many: openarray[string]) = proc add(s: var string, many: openArray[string]) =
s.add many.join s.add many.join
proc cFileSpecificOptions(cfilename: string): string = proc cFileSpecificOptions(cfilename: string): string =
@ -445,69 +445,69 @@ proc cFileSpecificOptions(cfilename: string): string =
if optCDebug in gGlobalOptions: if optCDebug in gGlobalOptions:
var key = trunk & ".debug" var key = trunk & ".debug"
if existsConfigVar(key): addOpt(result, getConfigVar(key)) if existsConfigVar(key): addOpt(result, getConfigVar(key))
else: addOpt(result, getDebug(ccompiler)) else: addOpt(result, getDebug(cCompiler))
if optOptimizeSpeed in gOptions: if optOptimizeSpeed in gOptions:
var key = trunk & ".speed" var key = trunk & ".speed"
if existsConfigVar(key): addOpt(result, getConfigVar(key)) if existsConfigVar(key): addOpt(result, getConfigVar(key))
else: addOpt(result, getOptSpeed(ccompiler)) else: addOpt(result, getOptSpeed(cCompiler))
elif optOptimizeSize in gOptions: elif optOptimizeSize in gOptions:
var key = trunk & ".size" var key = trunk & ".size"
if existsConfigVar(key): addOpt(result, getConfigVar(key)) if existsConfigVar(key): addOpt(result, getConfigVar(key))
else: addOpt(result, getOptSize(ccompiler)) else: addOpt(result, getOptSize(cCompiler))
var key = trunk & ".always" var key = trunk & ".always"
if existsConfigVar(key): addOpt(result, getConfigVar(key)) if existsConfigVar(key): addOpt(result, getConfigVar(key))
proc getCompileOptions: string = proc getCompileOptions: string =
result = CFileSpecificOptions("__dummy__") result = cFileSpecificOptions("__dummy__")
proc getLinkOptions: string = proc getLinkOptions: string =
result = linkOptions result = linkOptions
for linkedLib in items(cLinkedLibs): for linkedLib in items(cLinkedLibs):
result.add(cc[ccompiler].linkLibCmd % linkedLib.quoteShell) result.add(CC[cCompiler].linkLibCmd % linkedLib.quoteShell)
for libDir in items(cLibs): for libDir in items(cLibs):
result.add([cc[ccompiler].linkDirCmd, libDir.quoteShell]) result.add([CC[cCompiler].linkDirCmd, libDir.quoteShell])
proc needsExeExt(): bool {.inline.} = proc needsExeExt(): bool {.inline.} =
result = (optGenScript in gGlobalOptions and targetOS == osWindows) or result = (optGenScript in gGlobalOptions and targetOS == osWindows) or
(platform.hostOS == osWindows) (platform.hostOS == osWindows)
proc getCompileCFileCmd*(cfilename: string, isExternal = false): string = proc getCompileCFileCmd*(cfilename: string, isExternal = false): string =
var c = ccompiler var c = cCompiler
var options = CFileSpecificOptions(cfilename) var options = cFileSpecificOptions(cfilename)
var exe = getConfigVar(c, ".exe") var exe = getConfigVar(c, ".exe")
if exe.len == 0: exe = cc[c].compilerExe if exe.len == 0: exe = CC[c].compilerExe
if needsExeExt(): exe = addFileExt(exe, "exe") if needsExeExt(): exe = addFileExt(exe, "exe")
if optGenDynLib in gGlobalOptions and if optGenDynLib in gGlobalOptions and
ospNeedsPIC in platform.OS[targetOS].props: ospNeedsPIC in platform.OS[targetOS].props:
add(options, ' ' & cc[c].pic) add(options, ' ' & CC[c].pic)
var includeCmd, compilePattern: string var includeCmd, compilePattern: string
if not noAbsolutePaths(): if not noAbsolutePaths():
# compute include paths: # compute include paths:
includeCmd = cc[c].includeCmd & quoteShell(libpath) includeCmd = CC[c].includeCmd & quoteShell(libpath)
for includeDir in items(cIncludes): for includeDir in items(cIncludes):
includeCmd.add([cc[c].includeCmd, includeDir.quoteShell]) includeCmd.add([CC[c].includeCmd, includeDir.quoteShell])
compilePattern = JoinPath(ccompilerpath, exe) compilePattern = joinPath(ccompilerpath, exe)
else: else:
includeCmd = "" includeCmd = ""
compilePattern = cc[c].compilerExe compilePattern = CC[c].compilerExe
var cfile = if noAbsolutePaths(): extractFileName(cfilename) var cfile = if noAbsolutePaths(): extractFilename(cfilename)
else: cfilename else: cfilename
var objfile = if not isExternal or noAbsolutePaths(): var objfile = if not isExternal or noAbsolutePaths():
toObjFile(cfile) toObjFile(cfile)
else: else:
completeCFilePath(toObjFile(cfile)) completeCFilePath(toObjFile(cfile))
cfile = quoteShell(AddFileExt(cfile, cExt)) cfile = quoteShell(addFileExt(cfile, cExt))
objfile = quoteShell(objfile) objfile = quoteShell(objfile)
result = quoteShell(compilePattern % [ result = quoteShell(compilePattern % [
"file", cfile, "objfile", objfile, "options", options, "file", cfile, "objfile", objfile, "options", options,
"include", includeCmd, "nimrod", getPrefixDir(), "lib", libpath]) "include", includeCmd, "nimrod", getPrefixDir(), "lib", libpath])
add(result, ' ') add(result, ' ')
addf(result, cc[c].compileTmpl, [ addf(result, CC[c].compileTmpl, [
"file", cfile, "objfile", objfile, "file", cfile, "objfile", objfile,
"options", options, "include", includeCmd, "options", options, "include", includeCmd,
"nimrod", quoteShell(getPrefixDir()), "nimrod", quoteShell(getPrefixDir()),
@ -561,7 +561,7 @@ proc callCCompiler*(projectfile: string) =
return # speed up that call if only compiling and no script shall be return # speed up that call if only compiling and no script shall be
# generated # generated
fileCounter = 0 fileCounter = 0
var c = ccompiler var c = cCompiler
var script: PRope = nil var script: PRope = nil
var cmds: TStringSeq = @[] var cmds: TStringSeq = @[]
compileCFile(toCompile, script, cmds, false) compileCFile(toCompile, script, cmds, false)
@ -591,40 +591,40 @@ proc callCCompiler*(projectfile: string) =
let objFile = if noAbsolutePaths(): it.data.extractFilename else: it.data let objFile = if noAbsolutePaths(): it.data.extractFilename else: it.data
add(objfiles, ' ') add(objfiles, ' ')
add(objfiles, quoteShell( add(objfiles, quoteShell(
addFileExt(objFile, cc[ccompiler].objExt))) addFileExt(objFile, CC[cCompiler].objExt)))
it = PStrEntry(it.next) it = PStrEntry(it.next)
if optGenStaticLib in gGlobalOptions: if optGenStaticLib in gGlobalOptions:
linkcmd = cc[c].buildLib % ["libfile", (libNameTmpl() % gProjectName), linkCmd = CC[c].buildLib % ["libfile", (libNameTmpl() % gProjectName),
"objfiles", objfiles] "objfiles", objfiles]
if optCompileOnly notin gGlobalOptions: execExternalProgram(linkCmd) if optCompileOnly notin gGlobalOptions: execExternalProgram(linkCmd)
else: else:
var linkerExe = getConfigVar(c, ".linkerexe") var linkerExe = getConfigVar(c, ".linkerexe")
if len(linkerExe) == 0: linkerExe = cc[c].linkerExe if len(linkerExe) == 0: linkerExe = CC[c].linkerExe
if needsExeExt(): linkerExe = addFileExt(linkerExe, "exe") if needsExeExt(): linkerExe = addFileExt(linkerExe, "exe")
if noAbsolutePaths(): linkCmd = quoteShell(linkerExe) if noAbsolutePaths(): linkCmd = quoteShell(linkerExe)
else: linkCmd = quoteShell(JoinPath(ccompilerpath, linkerExe)) else: linkCmd = quoteShell(joinPath(ccompilerpath, linkerExe))
if optGenGuiApp in gGlobalOptions: buildGui = cc[c].buildGui if optGenGuiApp in gGlobalOptions: buildgui = CC[c].buildGui
else: buildGui = "" else: buildgui = ""
var exefile: string var exefile: string
if optGenDynLib in gGlobalOptions: if optGenDynLib in gGlobalOptions:
exefile = platform.os[targetOS].dllFrmt % splitFile(projectFile).name exefile = platform.os[targetOS].dllFrmt % splitFile(projectfile).name
buildDll = cc[c].buildDll builddll = CC[c].buildDll
else: else:
exefile = splitFile(projectFile).name & platform.os[targetOS].exeExt exefile = splitFile(projectfile).name & platform.os[targetOS].exeExt
buildDll = "" builddll = ""
if options.outFile.len > 0: if options.outFile.len > 0:
exefile = options.outFile exefile = options.outFile
if not noAbsolutePaths(): if not noAbsolutePaths():
if not exeFile.isAbsolute(): if not exefile.isAbsolute():
exefile = joinPath(splitFile(projectFile).dir, exefile) exefile = joinPath(splitFile(projectfile).dir, exefile)
exefile = quoteShell(exefile) exefile = quoteShell(exefile)
let linkOptions = getLinkOptions() let linkOptions = getLinkOptions()
linkCmd = quoteShell(linkCmd % ["builddll", builddll, linkCmd = quoteShell(linkCmd % ["builddll", builddll,
"buildgui", buildgui, "options", linkOptions, "objfiles", objfiles, "buildgui", buildgui, "options", linkOptions, "objfiles", objfiles,
"exefile", exefile, "nimrod", getPrefixDir(), "lib", libpath]) "exefile", exefile, "nimrod", getPrefixDir(), "lib", libpath])
linkCmd.add ' ' linkCmd.add ' '
addf(linkCmd, cc[c].linkTmpl, ["builddll", builddll, addf(linkCmd, CC[c].linkTmpl, ["builddll", builddll,
"buildgui", buildgui, "options", linkOptions, "buildgui", buildgui, "options", linkOptions,
"objfiles", objfiles, "exefile", exefile, "objfiles", objfiles, "exefile", exefile,
"nimrod", quoteShell(getPrefixDir()), "nimrod", quoteShell(getPrefixDir()),
@ -635,7 +635,7 @@ proc callCCompiler*(projectfile: string) =
if optGenScript in gGlobalOptions: if optGenScript in gGlobalOptions:
app(script, linkCmd) app(script, linkCmd)
app(script, tnl) app(script, tnl)
generateScript(projectFile, script) generateScript(projectfile, script)
proc genMappingFiles(list: TLinkedList): PRope = proc genMappingFiles(list: TLinkedList): PRope =
var it = PStrEntry(list.head) var it = PStrEntry(list.head)

106
compiler/filter_tmpl.nim
View file

@ -27,7 +27,7 @@ type
indent, emitPar: int indent, emitPar: int
x: string # the current input line x: string # the current input line
outp: PLLStream # the ouput will be parsed by pnimsyn outp: PLLStream # the ouput will be parsed by pnimsyn
subsChar, NimDirective: Char subsChar, NimDirective: char
emit, conc, toStr: string emit, conc, toStr: string
curly, bracket, par: int curly, bracket, par: int
pendingExprLine: bool pendingExprLine: bool
@ -37,11 +37,11 @@ const
PatternChars = {'a'..'z', 'A'..'Z', '0'..'9', '\x80'..'\xFF', '.', '_'} PatternChars = {'a'..'z', 'A'..'Z', '0'..'9', '\x80'..'\xFF', '.', '_'}
proc newLine(p: var TTmplParser) = proc newLine(p: var TTmplParser) =
LLStreamWrite(p.outp, repeatChar(p.emitPar, ')')) llStreamWrite(p.outp, repeatChar(p.emitPar, ')'))
p.emitPar = 0 p.emitPar = 0
if p.info.line > int16(1): LLStreamWrite(p.outp, "\n") if p.info.line > int16(1): llStreamWrite(p.outp, "\n")
if p.pendingExprLine: if p.pendingExprLine:
LLStreamWrite(p.outp, repeatChar(2)) llStreamWrite(p.outp, repeatChar(2))
p.pendingExprLine = false p.pendingExprLine = false
proc scanPar(p: var TTmplParser, d: int) = proc scanPar(p: var TTmplParser, d: int) =
@ -87,26 +87,26 @@ proc parseLine(p: var TTmplParser) =
dec(p.indent, 2) dec(p.indent, 2)
else: else:
p.info.col = int16(j) p.info.col = int16(j)
LocalError(p.info, errXNotAllowedHere, "end") localError(p.info, errXNotAllowedHere, "end")
LLStreamWrite(p.outp, repeatChar(p.indent)) llStreamWrite(p.outp, repeatChar(p.indent))
LLStreamWrite(p.outp, "#end") llStreamWrite(p.outp, "#end")
of wIf, wWhen, wTry, wWhile, wFor, wBlock, wCase, wProc, wIterator, of wIf, wWhen, wTry, wWhile, wFor, wBlock, wCase, wProc, wIterator,
wConverter, wMacro, wTemplate, wMethod: wConverter, wMacro, wTemplate, wMethod:
LLStreamWrite(p.outp, repeatChar(p.indent)) llStreamWrite(p.outp, repeatChar(p.indent))
LLStreamWrite(p.outp, substr(p.x, d)) llStreamWrite(p.outp, substr(p.x, d))
inc(p.indent, 2) inc(p.indent, 2)
of wElif, wOf, wElse, wExcept, wFinally: of wElif, wOf, wElse, wExcept, wFinally:
LLStreamWrite(p.outp, repeatChar(p.indent - 2)) llStreamWrite(p.outp, repeatChar(p.indent - 2))
LLStreamWrite(p.outp, substr(p.x, d)) llStreamWrite(p.outp, substr(p.x, d))
of wLet, wVar, wConst, wType: of wLet, wVar, wConst, wType:
LLStreamWrite(p.outp, repeatChar(p.indent)) llStreamWrite(p.outp, repeatChar(p.indent))
LLStreamWrite(p.outp, substr(p.x, d)) llStreamWrite(p.outp, substr(p.x, d))
if not p.x.contains({':', '='}): if not p.x.contains({':', '='}):
# no inline element --> treat as block: # no inline element --> treat as block:
inc(p.indent, 2) inc(p.indent, 2)
else: else:
LLStreamWrite(p.outp, repeatChar(p.indent)) llStreamWrite(p.outp, repeatChar(p.indent))
LLStreamWrite(p.outp, substr(p.x, d)) llStreamWrite(p.outp, substr(p.x, d))
p.state = psDirective p.state = psDirective
else: else:
# data line # data line
@ -118,15 +118,15 @@ proc parseLine(p: var TTmplParser) =
case p.state case p.state
of psTempl: of psTempl:
# next line of string literal: # next line of string literal:
LLStreamWrite(p.outp, p.conc) llStreamWrite(p.outp, p.conc)
LLStreamWrite(p.outp, "\n") llStreamWrite(p.outp, "\n")
LLStreamWrite(p.outp, repeatChar(p.indent + 2)) llStreamWrite(p.outp, repeatChar(p.indent + 2))
LLStreamWrite(p.outp, "\"") llStreamWrite(p.outp, "\"")
of psDirective: of psDirective:
newLine(p) newLine(p)
LLStreamWrite(p.outp, repeatChar(p.indent)) llStreamWrite(p.outp, repeatChar(p.indent))
LLStreamWrite(p.outp, p.emit) llStreamWrite(p.outp, p.emit)
LLStreamWrite(p.outp, "(\"") llStreamWrite(p.outp, "(\"")
inc(p.emitPar) inc(p.emitPar)
p.state = psTempl p.state = psTempl
while true: while true:
@ -134,17 +134,17 @@ proc parseLine(p: var TTmplParser) =
of '\0': of '\0':
break break
of '\x01'..'\x1F', '\x80'..'\xFF': of '\x01'..'\x1F', '\x80'..'\xFF':
LLStreamWrite(p.outp, "\\x") llStreamWrite(p.outp, "\\x")
LLStreamWrite(p.outp, toHex(ord(p.x[j]), 2)) llStreamWrite(p.outp, toHex(ord(p.x[j]), 2))
inc(j) inc(j)
of '\\': of '\\':
LLStreamWrite(p.outp, "\\\\") llStreamWrite(p.outp, "\\\\")
inc(j) inc(j)
of '\'': of '\'':
LLStreamWrite(p.outp, "\\\'") llStreamWrite(p.outp, "\\\'")
inc(j) inc(j)
of '\"': of '\"':
LLStreamWrite(p.outp, "\\\"") llStreamWrite(p.outp, "\\\"")
inc(j) inc(j)
else: else:
if p.x[j] == p.subsChar: if p.x[j] == p.subsChar:
@ -153,59 +153,59 @@ proc parseLine(p: var TTmplParser) =
case p.x[j] case p.x[j]
of '{': of '{':
p.info.col = int16(j) p.info.col = int16(j)
LLStreamWrite(p.outp, '\"') llStreamWrite(p.outp, '\"')
LLStreamWrite(p.outp, p.conc) llStreamWrite(p.outp, p.conc)
LLStreamWrite(p.outp, p.toStr) llStreamWrite(p.outp, p.toStr)
LLStreamWrite(p.outp, '(') llStreamWrite(p.outp, '(')
inc(j) inc(j)
curly = 0 curly = 0
while true: while true:
case p.x[j] case p.x[j]
of '\0': of '\0':
LocalError(p.info, errXExpected, "}") localError(p.info, errXExpected, "}")
break break
of '{': of '{':
inc(j) inc(j)
inc(curly) inc(curly)
LLStreamWrite(p.outp, '{') llStreamWrite(p.outp, '{')
of '}': of '}':
inc(j) inc(j)
if curly == 0: break if curly == 0: break
if curly > 0: dec(curly) if curly > 0: dec(curly)
LLStreamWrite(p.outp, '}') llStreamWrite(p.outp, '}')
else: else:
LLStreamWrite(p.outp, p.x[j]) llStreamWrite(p.outp, p.x[j])
inc(j) inc(j)
LLStreamWrite(p.outp, ')') llStreamWrite(p.outp, ')')
LLStreamWrite(p.outp, p.conc) llStreamWrite(p.outp, p.conc)
LLStreamWrite(p.outp, '\"') llStreamWrite(p.outp, '\"')
of 'a'..'z', 'A'..'Z', '\x80'..'\xFF': of 'a'..'z', 'A'..'Z', '\x80'..'\xFF':
LLStreamWrite(p.outp, '\"') llStreamWrite(p.outp, '\"')
LLStreamWrite(p.outp, p.conc) llStreamWrite(p.outp, p.conc)
LLStreamWrite(p.outp, p.toStr) llStreamWrite(p.outp, p.toStr)
LLStreamWrite(p.outp, '(') llStreamWrite(p.outp, '(')
while p.x[j] in PatternChars: while p.x[j] in PatternChars:
LLStreamWrite(p.outp, p.x[j]) llStreamWrite(p.outp, p.x[j])
inc(j) inc(j)
LLStreamWrite(p.outp, ')') llStreamWrite(p.outp, ')')
LLStreamWrite(p.outp, p.conc) llStreamWrite(p.outp, p.conc)
LLStreamWrite(p.outp, '\"') llStreamWrite(p.outp, '\"')
else: else:
if p.x[j] == p.subsChar: if p.x[j] == p.subsChar:
LLStreamWrite(p.outp, p.subsChar) llStreamWrite(p.outp, p.subsChar)
inc(j) inc(j)
else: else:
p.info.col = int16(j) p.info.col = int16(j)
LocalError(p.info, errInvalidExpression, "$") localError(p.info, errInvalidExpression, "$")
else: else:
LLStreamWrite(p.outp, p.x[j]) llStreamWrite(p.outp, p.x[j])
inc(j) inc(j)
LLStreamWrite(p.outp, "\\n\"") llStreamWrite(p.outp, "\\n\"")
proc filterTmpl(stdin: PLLStream, filename: string, call: PNode): PLLStream = proc filterTmpl(stdin: PLLStream, filename: string, call: PNode): PLLStream =
var p: TTmplParser var p: TTmplParser
p.info = newLineInfo(filename, 0, 0) p.info = newLineInfo(filename, 0, 0)
p.outp = LLStreamOpen("") p.outp = llStreamOpen("")
p.inp = stdin p.inp = stdin
p.subsChar = charArg(call, "subschar", 1, '$') p.subsChar = charArg(call, "subschar", 1, '$')
p.nimDirective = charArg(call, "metachar", 2, '#') p.nimDirective = charArg(call, "metachar", 2, '#')
@ -213,9 +213,9 @@ proc filterTmpl(stdin: PLLStream, filename: string, call: PNode): PLLStream =
p.conc = strArg(call, "conc", 4, " & ") p.conc = strArg(call, "conc", 4, " & ")
p.toStr = strArg(call, "tostring", 5, "$") p.toStr = strArg(call, "tostring", 5, "$")
p.x = newStringOfCap(120) p.x = newStringOfCap(120)
while LLStreamReadLine(p.inp, p.x): while llStreamReadLine(p.inp, p.x):
p.info.line = p.info.line + int16(1) p.info.line = p.info.line + int16(1)
parseLine(p) parseLine(p)
newLine(p) newLine(p)
result = p.outp result = p.outp
LLStreamClose(p.inp) llStreamClose(p.inp)

28
compiler/filters.nim
View file

@ -16,13 +16,13 @@ import
proc filterReplace*(stdin: PLLStream, filename: string, call: PNode): PLLStream proc filterReplace*(stdin: PLLStream, filename: string, call: PNode): PLLStream
proc filterStrip*(stdin: PLLStream, filename: string, call: PNode): PLLStream proc filterStrip*(stdin: PLLStream, filename: string, call: PNode): PLLStream
# helpers to retrieve arguments: # helpers to retrieve arguments:
proc charArg*(n: PNode, name: string, pos: int, default: Char): Char proc charArg*(n: PNode, name: string, pos: int, default: char): char
proc strArg*(n: PNode, name: string, pos: int, default: string): string proc strArg*(n: PNode, name: string, pos: int, default: string): string
proc boolArg*(n: PNode, name: string, pos: int, default: bool): bool proc boolArg*(n: PNode, name: string, pos: int, default: bool): bool
# implementation # implementation
proc invalidPragma(n: PNode) = proc invalidPragma(n: PNode) =
LocalError(n.info, errXNotAllowedHere, renderTree(n, {renderNoComments})) localError(n.info, errXNotAllowedHere, renderTree(n, {renderNoComments}))
proc getArg(n: PNode, name: string, pos: int): PNode = proc getArg(n: PNode, name: string, pos: int): PNode =
result = nil result = nil
@ -30,7 +30,7 @@ proc getArg(n: PNode, name: string, pos: int): PNode =
for i in countup(1, sonsLen(n) - 1): for i in countup(1, sonsLen(n) - 1):
if n.sons[i].kind == nkExprEqExpr: if n.sons[i].kind == nkExprEqExpr:
if n.sons[i].sons[0].kind != nkIdent: invalidPragma(n) if n.sons[i].sons[0].kind != nkIdent: invalidPragma(n)
if IdentEq(n.sons[i].sons[0].ident, name): if identEq(n.sons[i].sons[0].ident, name):
return n.sons[i].sons[1] return n.sons[i].sons[1]
elif i == pos: elif i == pos:
return n.sons[i] return n.sons[i]
@ -50,30 +50,30 @@ proc strArg(n: PNode, name: string, pos: int, default: string): string =
proc boolArg(n: PNode, name: string, pos: int, default: bool): bool = proc boolArg(n: PNode, name: string, pos: int, default: bool): bool =
var x = getArg(n, name, pos) var x = getArg(n, name, pos)
if x == nil: result = default if x == nil: result = default
elif (x.kind == nkIdent) and IdentEq(x.ident, "true"): result = true elif (x.kind == nkIdent) and identEq(x.ident, "true"): result = true
elif (x.kind == nkIdent) and IdentEq(x.ident, "false"): result = false elif (x.kind == nkIdent) and identEq(x.ident, "false"): result = false
else: invalidPragma(n) else: invalidPragma(n)
proc filterStrip(stdin: PLLStream, filename: string, call: PNode): PLLStream = proc filterStrip(stdin: PLLStream, filename: string, call: PNode): PLLStream =
var pattern = strArg(call, "startswith", 1, "") var pattern = strArg(call, "startswith", 1, "")
var leading = boolArg(call, "leading", 2, true) var leading = boolArg(call, "leading", 2, true)
var trailing = boolArg(call, "trailing", 3, true) var trailing = boolArg(call, "trailing", 3, true)
result = LLStreamOpen("") result = llStreamOpen("")
var line = newStringOfCap(80) var line = newStringOfCap(80)
while LLStreamReadLine(stdin, line): while llStreamReadLine(stdin, line):
var stripped = strip(line, leading, trailing) var stripped = strip(line, leading, trailing)
if (len(pattern) == 0) or startsWith(stripped, pattern): if (len(pattern) == 0) or startsWith(stripped, pattern):
LLStreamWriteln(result, stripped) llStreamWriteln(result, stripped)
else: else:
LLStreamWriteln(result, line) llStreamWriteln(result, line)
LLStreamClose(stdin) llStreamClose(stdin)
proc filterReplace(stdin: PLLStream, filename: string, call: PNode): PLLStream = proc filterReplace(stdin: PLLStream, filename: string, call: PNode): PLLStream =
var sub = strArg(call, "sub", 1, "") var sub = strArg(call, "sub", 1, "")
if len(sub) == 0: invalidPragma(call) if len(sub) == 0: invalidPragma(call)
var by = strArg(call, "by", 2, "") var by = strArg(call, "by", 2, "")
result = LLStreamOpen("") result = llStreamOpen("")
var line = newStringOfCap(80) var line = newStringOfCap(80)
while LLStreamReadLine(stdin, line): while llStreamReadLine(stdin, line):
LLStreamWriteln(result, replace(line, sub, by)) llStreamWriteln(result, replace(line, sub, by))
LLStreamClose(stdin) llStreamClose(stdin)

6
compiler/guards.nim
View file

@ -251,7 +251,7 @@ proc invalidateFacts*(m: var TModel, n: PNode) =
proc valuesUnequal(a, b: PNode): bool = proc valuesUnequal(a, b: PNode): bool =
if a.isValue and b.isValue: if a.isValue and b.isValue:
result = not SameValue(a, b) result = not sameValue(a, b)
proc pred(n: PNode): PNode = proc pred(n: PNode): PNode =
if n.kind in {nkCharLit..nkUInt64Lit} and n.intVal != low(biggestInt): if n.kind in {nkCharLit..nkUInt64Lit} and n.intVal != low(biggestInt):
@ -484,7 +484,7 @@ proc factImplies(fact, prop: PNode): TImplication =
if a == b: return ~a if a == b: return ~a
return impUnknown return impUnknown
else: else:
InternalError(fact.info, "invalid fact") internalError(fact.info, "invalid fact")
of mAnd: of mAnd:
result = factImplies(fact.sons[1], prop) result = factImplies(fact.sons[1], prop)
if result != impUnknown: return result if result != impUnknown: return result
@ -575,4 +575,4 @@ proc checkFieldAccess*(m: TModel, n: PNode) =
for i in 1..n.len-1: for i in 1..n.len-1:
let check = buildProperFieldCheck(n.sons[0], n.sons[i]) let check = buildProperFieldCheck(n.sons[0], n.sons[i])
if m.doesImply(check) != impYes: if m.doesImply(check) != impYes:
Message(n.info, warnProveField, renderTree(n.sons[0])); break message(n.info, warnProveField, renderTree(n.sons[0])); break

4
compiler/hlo.nim
View file

@ -28,7 +28,7 @@ proc evalPattern(c: PContext, n, orig: PNode): PNode =
else: else:
result = semDirectOp(c, n, {}) result = semDirectOp(c, n, {})
if optHints in gOptions and hintPattern in gNotes: if optHints in gOptions and hintPattern in gNotes:
Message(orig.info, hintPattern, rule & " --> '" & message(orig.info, hintPattern, rule & " --> '" &
renderTree(result, {renderNoComments}) & "'") renderTree(result, {renderNoComments}) & "'")
proc applyPatterns(c: PContext, n: PNode): PNode = proc applyPatterns(c: PContext, n: PNode): PNode =
@ -45,7 +45,7 @@ proc applyPatterns(c: PContext, n: PNode): PNode =
# better be safe than sorry, so check evalTemplateCounter too: # better be safe than sorry, so check evalTemplateCounter too:
inc(evalTemplateCounter) inc(evalTemplateCounter)
if evalTemplateCounter > 100: if evalTemplateCounter > 100:
GlobalError(n.info, errTemplateInstantiationTooNested) globalError(n.info, errTemplateInstantiationTooNested)
# deactivate this pattern: # deactivate this pattern:
c.patterns[i] = nil c.patterns[i] = nil
if x.kind == nkStmtList: if x.kind == nkStmtList:

6
compiler/idgen.nim
View file

@ -38,7 +38,7 @@ proc setId*(id: int) {.inline.} =
gFrontEndId = max(gFrontEndId, id + 1) gFrontEndId = max(gFrontEndId, id + 1)
proc idSynchronizationPoint*(idRange: int) = proc idSynchronizationPoint*(idRange: int) =
gFrontEndId = (gFrontEndId div IdRange + 1) * IdRange + 1 gFrontEndId = (gFrontEndId div idRange + 1) * idRange + 1
proc toGid(f: string): string = proc toGid(f: string): string =
# we used to use ``f.addFileExt("gid")`` (aka ``$project.gid``), but this # we used to use ``f.addFileExt("gid")`` (aka ``$project.gid``), but this
@ -49,7 +49,7 @@ proc toGid(f: string): string =
proc saveMaxIds*(project: string) = proc saveMaxIds*(project: string) =
var f = open(project.toGid, fmWrite) var f = open(project.toGid, fmWrite)
f.writeln($gFrontEndId) f.writeln($gFrontEndId)
f.writeln($gBackEndId) f.writeln($gBackendId)
f.close() f.close()
proc loadMaxIds*(project: string) = proc loadMaxIds*(project: string) =
@ -61,5 +61,5 @@ proc loadMaxIds*(project: string) =
if f.readLine(line): if f.readLine(line):
var backEndId = parseInt(line) var backEndId = parseInt(line)
gFrontEndId = max(gFrontEndId, frontEndId) gFrontEndId = max(gFrontEndId, frontEndId)
gBackEndId = max(gBackEndId, backEndId) gBackendId = max(gBackendId, backEndId)
f.close() f.close()

38
compiler/importer.nim
View file

@ -22,7 +22,7 @@ proc getModuleName*(n: PNode): string =
# The proc won't perform any checks that the path is actually valid # The proc won't perform any checks that the path is actually valid
case n.kind case n.kind
of nkStrLit, nkRStrLit, nkTripleStrLit: of nkStrLit, nkRStrLit, nkTripleStrLit:
result = UnixToNativePath(n.strVal) result = unixToNativePath(n.strVal)
of nkIdent: of nkIdent:
result = n.ident.s result = n.ident.s
of nkSym: of nkSym:
@ -50,7 +50,7 @@ proc checkModuleName*(n: PNode): int32 =
let modulename = n.getModuleName let modulename = n.getModuleName
let fullPath = findModule(modulename, n.info.toFullPath) let fullPath = findModule(modulename, n.info.toFullPath)
if fullPath.len == 0: if fullPath.len == 0:
LocalError(n.info, errCannotOpenFile, modulename) localError(n.info, errCannotOpenFile, modulename)
result = InvalidFileIDX result = InvalidFileIDX
else: else:
result = fullPath.fileInfoIdx result = fullPath.fileInfoIdx
@ -59,32 +59,32 @@ proc rawImportSymbol(c: PContext, s: PSym) =
# This does not handle stubs, because otherwise loading on demand would be # This does not handle stubs, because otherwise loading on demand would be
# pointless in practice. So importing stubs is fine here! # pointless in practice. So importing stubs is fine here!
# check if we have already a symbol of the same name: # check if we have already a symbol of the same name:
var check = StrTableGet(c.importTable.symbols, s.name) var check = strTableGet(c.importTable.symbols, s.name)
if check != nil and check.id != s.id: if check != nil and check.id != s.id:
if s.kind notin OverloadableSyms: if s.kind notin OverloadableSyms:
# s and check need to be qualified: # s and check need to be qualified:
Incl(c.AmbiguousSymbols, s.id) incl(c.AmbiguousSymbols, s.id)
Incl(c.AmbiguousSymbols, check.id) incl(c.AmbiguousSymbols, check.id)
# thanks to 'export' feature, it could be we import the same symbol from # thanks to 'export' feature, it could be we import the same symbol from
# multiple sources, so we need to call 'StrTableAdd' here: # multiple sources, so we need to call 'StrTableAdd' here:
StrTableAdd(c.importTable.symbols, s) strTableAdd(c.importTable.symbols, s)
if s.kind == skType: if s.kind == skType:
var etyp = s.typ var etyp = s.typ
if etyp.kind in {tyBool, tyEnum} and sfPure notin s.flags: if etyp.kind in {tyBool, tyEnum} and sfPure notin s.flags:
for j in countup(0, sonsLen(etyp.n) - 1): for j in countup(0, sonsLen(etyp.n) - 1):
var e = etyp.n.sons[j].sym var e = etyp.n.sons[j].sym
if e.Kind != skEnumField: if e.Kind != skEnumField:
InternalError(s.info, "rawImportSymbol") internalError(s.info, "rawImportSymbol")
# BUGFIX: because of aliases for enums the symbol may already # BUGFIX: because of aliases for enums the symbol may already
# have been put into the symbol table # have been put into the symbol table
# BUGFIX: but only iff they are the same symbols! # BUGFIX: but only iff they are the same symbols!
var it: TIdentIter var it: TIdentIter
check = InitIdentIter(it, c.importTable.symbols, e.name) check = initIdentIter(it, c.importTable.symbols, e.name)
while check != nil: while check != nil:
if check.id == e.id: if check.id == e.id:
e = nil e = nil
break break
check = NextIdentIter(it, c.importTable.symbols) check = nextIdentIter(it, c.importTable.symbols)
if e != nil: if e != nil:
rawImportSymbol(c, e) rawImportSymbol(c, e)
else: else:
@ -94,36 +94,36 @@ proc rawImportSymbol(c: PContext, s: PSym) =
proc importSymbol(c: PContext, n: PNode, fromMod: PSym) = proc importSymbol(c: PContext, n: PNode, fromMod: PSym) =
let ident = lookups.considerAcc(n) let ident = lookups.considerAcc(n)
let s = StrTableGet(fromMod.tab, ident) let s = strTableGet(fromMod.tab, ident)
if s == nil: if s == nil:
LocalError(n.info, errUndeclaredIdentifier, ident.s) localError(n.info, errUndeclaredIdentifier, ident.s)
else: else:
if s.kind == skStub: loadStub(s) if s.kind == skStub: loadStub(s)
if s.Kind notin ExportableSymKinds: if s.Kind notin ExportableSymKinds:
InternalError(n.info, "importSymbol: 2") internalError(n.info, "importSymbol: 2")
# for an enumeration we have to add all identifiers # for an enumeration we have to add all identifiers
case s.Kind case s.Kind
of skProc, skMethod, skIterator, skMacro, skTemplate, skConverter: of skProc, skMethod, skIterator, skMacro, skTemplate, skConverter:
# for a overloadable syms add all overloaded routines # for a overloadable syms add all overloaded routines
var it: TIdentIter var it: TIdentIter
var e = InitIdentIter(it, fromMod.tab, s.name) var e = initIdentIter(it, fromMod.tab, s.name)
while e != nil: while e != nil:
if e.name.id != s.Name.id: InternalError(n.info, "importSymbol: 3") if e.name.id != s.Name.id: internalError(n.info, "importSymbol: 3")
rawImportSymbol(c, e) rawImportSymbol(c, e)
e = NextIdentIter(it, fromMod.tab) e = nextIdentIter(it, fromMod.tab)
else: rawImportSymbol(c, s) else: rawImportSymbol(c, s)
proc importAllSymbolsExcept(c: PContext, fromMod: PSym, exceptSet: TIntSet) = proc importAllSymbolsExcept(c: PContext, fromMod: PSym, exceptSet: TIntSet) =
var i: TTabIter var i: TTabIter
var s = InitTabIter(i, fromMod.tab) var s = initTabIter(i, fromMod.tab)
while s != nil: while s != nil:
if s.kind != skModule: if s.kind != skModule:
if s.kind != skEnumField: if s.kind != skEnumField:
if s.Kind notin ExportableSymKinds: if s.Kind notin ExportableSymKinds:
InternalError(s.info, "importAllSymbols: " & $s.kind) internalError(s.info, "importAllSymbols: " & $s.kind)
if exceptSet.empty or s.name.id notin exceptSet: if exceptSet.empty or s.name.id notin exceptSet:
rawImportSymbol(c, s) rawImportSymbol(c, s)
s = NextIter(i, fromMod.tab) s = nextIter(i, fromMod.tab)
proc importAllSymbols*(c: PContext, fromMod: PSym) = proc importAllSymbols*(c: PContext, fromMod: PSym) =
var exceptSet: TIntSet var exceptSet: TIntSet
@ -160,7 +160,7 @@ proc myImportModule(c: PContext, n: PNode): PSym =
if f != InvalidFileIDX: if f != InvalidFileIDX:
result = importModuleAs(n, gImportModule(c.module, f)) result = importModuleAs(n, gImportModule(c.module, f))
if sfDeprecated in result.flags: if sfDeprecated in result.flags:
Message(n.info, warnDeprecated, result.name.s) message(n.info, warnDeprecated, result.name.s)
proc evalImport(c: PContext, n: PNode): PNode = proc evalImport(c: PContext, n: PNode): PNode =
result = n result = n

80
compiler/jsgen.nim
View file

@ -175,7 +175,7 @@ proc useMagic(p: PProc, name: string) =
# we used to exclude the system module from this check, but for DLL # we used to exclude the system module from this check, but for DLL
# generation support this sloppyness leads to hard to detect bugs, so # generation support this sloppyness leads to hard to detect bugs, so
# we're picky here for the system module too: # we're picky here for the system module too:
if p.prc != nil: GlobalError(p.prc.info, errSystemNeeds, name) if p.prc != nil: globalError(p.prc.info, errSystemNeeds, name)
else: rawMessage(errSystemNeeds, name) else: rawMessage(errSystemNeeds, name)
proc isSimpleExpr(n: PNode): bool = proc isSimpleExpr(n: PNode): bool =
@ -504,7 +504,7 @@ proc genWhileStmt(p: PProc, n: PNode) =
genLineDir(p, n) genLineDir(p, n)
inc(p.unique) inc(p.unique)
var length = len(p.blocks) var length = len(p.blocks)
setlen(p.blocks, length + 1) setLen(p.blocks, length + 1)
p.blocks[length].id = -p.unique p.blocks[length].id = -p.unique
p.blocks[length].isLoop = true p.blocks[length].isLoop = true
let labl = p.unique.toRope let labl = p.unique.toRope
@ -514,7 +514,7 @@ proc genWhileStmt(p: PProc, n: PNode) =
[cond.res, labl]) [cond.res, labl])
genStmt(p, n.sons[1]) genStmt(p, n.sons[1])
appf(p.body, "}$n" | "end ::L$#::$n", [labl]) appf(p.body, "}$n" | "end ::L$#::$n", [labl])
setlen(p.blocks, length) setLen(p.blocks, length)
proc moveInto(p: PProc, src: var TCompRes, dest: TCompRes) = proc moveInto(p: PProc, src: var TCompRes, dest: TCompRes) =
if src.kind != resNone: if src.kind != resNone:
@ -579,7 +579,7 @@ proc genTry(p: PProc, n: PNode, r: var TCompRes) =
useMagic(p, "isObj") useMagic(p, "isObj")
for j in countup(0, blen - 2): for j in countup(0, blen - 2):
if n.sons[i].sons[j].kind != nkType: if n.sons[i].sons[j].kind != nkType:
InternalError(n.info, "genTryStmt") internalError(n.info, "genTryStmt")
if orExpr != nil: app(orExpr, "||" | " or ") if orExpr != nil: app(orExpr, "||" | " or ")
appf(orExpr, "isObj($1.exc.m_type, $2)", appf(orExpr, "isObj($1.exc.m_type, $2)",
[safePoint, genTypeInfo(p, n.sons[i].sons[j].typ)]) [safePoint, genTypeInfo(p, n.sons[i].sons[j].typ)])
@ -641,13 +641,13 @@ proc genCaseJS(p: PProc, n: PNode, r: var TCompRes) =
while v.intVal <= e.sons[1].intVal: while v.intVal <= e.sons[1].intVal:
gen(p, v, cond) gen(p, v, cond)
appf(p.body, "case $1: ", [cond.rdLoc]) appf(p.body, "case $1: ", [cond.rdLoc])
Inc(v.intVal) inc(v.intVal)
else: else:
if stringSwitch: if stringSwitch:
case e.kind case e.kind
of nkStrLit..nkTripleStrLit: appf(p.body, "case $1: ", of nkStrLit..nkTripleStrLit: appf(p.body, "case $1: ",
[makeJSString(e.strVal)]) [makeJSString(e.strVal)])
else: InternalError(e.info, "jsgen.genCaseStmt: 2") else: internalError(e.info, "jsgen.genCaseStmt: 2")
else: else:
gen(p, e, cond) gen(p, e, cond)
appf(p.body, "case $1: ", [cond.rdLoc]) appf(p.body, "case $1: ", [cond.rdLoc])
@ -694,7 +694,7 @@ proc genCaseLua(p: PProc, n: PNode, r: var TCompRes) =
case e.kind case e.kind
of nkStrLit..nkTripleStrLit: appf(p.body, "eqStr($1, $2)", of nkStrLit..nkTripleStrLit: appf(p.body, "eqStr($1, $2)",
[tmp, makeJSString(e.strVal)]) [tmp, makeJSString(e.strVal)])
else: InternalError(e.info, "jsgen.genCaseStmt: 2") else: internalError(e.info, "jsgen.genCaseStmt: 2")
else: else:
gen(p, e, cond) gen(p, e, cond)
appf(p.body, "$1 == $2", [tmp, cond.rdLoc]) appf(p.body, "$1 == $2", [tmp, cond.rdLoc])
@ -713,17 +713,17 @@ proc genBlock(p: PProc, n: PNode, r: var TCompRes) =
let idx = len(p.blocks) let idx = len(p.blocks)
if n.sons[0].kind != nkEmpty: if n.sons[0].kind != nkEmpty:
# named block? # named block?
if (n.sons[0].kind != nkSym): InternalError(n.info, "genBlock") if (n.sons[0].kind != nkSym): internalError(n.info, "genBlock")
var sym = n.sons[0].sym var sym = n.sons[0].sym
sym.loc.k = locOther sym.loc.k = locOther
sym.loc.a = idx sym.loc.a = idx
setlen(p.blocks, idx + 1) setLen(p.blocks, idx + 1)
p.blocks[idx].id = - p.unique # negative because it isn't used yet p.blocks[idx].id = - p.unique # negative because it isn't used yet
let labl = p.unique let labl = p.unique
appf(p.body, "L$1: do {$n" | "", labl.toRope) appf(p.body, "L$1: do {$n" | "", labl.toRope)
gen(p, n.sons[1], r) gen(p, n.sons[1], r)
appf(p.body, "} while(false);$n" | "$n::L$#::$n", labl.toRope) appf(p.body, "} while(false);$n" | "$n::L$#::$n", labl.toRope)
setlen(p.blocks, idx) setLen(p.blocks, idx)
proc genBreakStmt(p: PProc, n: PNode) = proc genBreakStmt(p: PProc, n: PNode) =
var idx: int var idx: int
@ -739,7 +739,7 @@ proc genBreakStmt(p: PProc, n: PNode) =
idx = len(p.blocks) - 1 idx = len(p.blocks) - 1
while idx >= 0 and not p.blocks[idx].isLoop: dec idx while idx >= 0 and not p.blocks[idx].isLoop: dec idx
if idx < 0 or not p.blocks[idx].isLoop: if idx < 0 or not p.blocks[idx].isLoop:
InternalError(n.info, "no loop to break") internalError(n.info, "no loop to break")
p.blocks[idx].id = abs(p.blocks[idx].id) # label is used p.blocks[idx].id = abs(p.blocks[idx].id) # label is used
appf(p.body, "break L$1;$n" | "goto ::L$1::;$n", [toRope(p.blocks[idx].id)]) appf(p.body, "break L$1;$n" | "goto ::L$1::;$n", [toRope(p.blocks[idx].id)])
@ -750,7 +750,7 @@ proc genAsmStmt(p: PProc, n: PNode) =
case n.sons[i].Kind case n.sons[i].Kind
of nkStrLit..nkTripleStrLit: app(p.body, n.sons[i].strVal) of nkStrLit..nkTripleStrLit: app(p.body, n.sons[i].strVal)
of nkSym: app(p.body, mangleName(n.sons[i].sym)) of nkSym: app(p.body, mangleName(n.sons[i].sym))
else: InternalError(n.sons[i].info, "jsgen: genAsmStmt()") else: internalError(n.sons[i].info, "jsgen: genAsmStmt()")
proc genIf(p: PProc, n: PNode, r: var TCompRes) = proc genIf(p: PProc, n: PNode, r: var TCompRes) =
var cond, stmt: TCompRes var cond, stmt: TCompRes
@ -851,7 +851,7 @@ proc getFieldPosition(f: PNode): int =
case f.kind case f.kind
of nkIntLit..nkUInt64Lit: result = int(f.intVal) of nkIntLit..nkUInt64Lit: result = int(f.intVal)
of nkSym: result = f.sym.position of nkSym: result = f.sym.position
else: InternalError(f.info, "genFieldPosition") else: internalError(f.info, "genFieldPosition")
proc genFieldAddr(p: PProc, n: PNode, r: var TCompRes) = proc genFieldAddr(p: PProc, n: PNode, r: var TCompRes) =
var a: TCompRes var a: TCompRes
@ -861,7 +861,7 @@ proc genFieldAddr(p: PProc, n: PNode, r: var TCompRes) =
if skipTypes(b.sons[0].typ, abstractVarRange).kind == tyTuple: if skipTypes(b.sons[0].typ, abstractVarRange).kind == tyTuple:
r.res = makeJSString("Field" & $getFieldPosition(b.sons[1])) r.res = makeJSString("Field" & $getFieldPosition(b.sons[1]))
else: else:
if b.sons[1].kind != nkSym: InternalError(b.sons[1].info, "genFieldAddr") if b.sons[1].kind != nkSym: internalError(b.sons[1].info, "genFieldAddr")
var f = b.sons[1].sym var f = b.sons[1].sym
if f.loc.r == nil: f.loc.r = mangleName(f) if f.loc.r == nil: f.loc.r = mangleName(f)
r.res = makeJSString(ropeToStr(f.loc.r)) r.res = makeJSString(ropeToStr(f.loc.r))
@ -875,7 +875,7 @@ proc genFieldAccess(p: PProc, n: PNode, r: var TCompRes) =
if skipTypes(n.sons[0].typ, abstractVarRange).kind == tyTuple: if skipTypes(n.sons[0].typ, abstractVarRange).kind == tyTuple:
r.res = ropef("$1.Field$2", [r.res, getFieldPosition(n.sons[1]).toRope]) r.res = ropef("$1.Field$2", [r.res, getFieldPosition(n.sons[1]).toRope])
else: else:
if n.sons[1].kind != nkSym: InternalError(n.sons[1].info, "genFieldAddr") if n.sons[1].kind != nkSym: internalError(n.sons[1].info, "genFieldAddr")
var f = n.sons[1].sym var f = n.sons[1].sym
if f.loc.r == nil: f.loc.r = mangleName(f) if f.loc.r == nil: f.loc.r = mangleName(f)
r.res = ropef("$1.$2", [r.res, f.loc.r]) r.res = ropef("$1.$2", [r.res, f.loc.r])
@ -890,14 +890,14 @@ proc genCheckedFieldAccess(p: PProc, n: PNode, r: var TCompRes) =
proc genArrayAddr(p: PProc, n: PNode, r: var TCompRes) = proc genArrayAddr(p: PProc, n: PNode, r: var TCompRes) =
var var
a, b: TCompRes a, b: TCompRes
first: biggestInt first: BiggestInt
r.typ = etyBaseIndex r.typ = etyBaseIndex
gen(p, n.sons[0], a) gen(p, n.sons[0], a)
gen(p, n.sons[1], b) gen(p, n.sons[1], b)
InternalAssert a.typ != etyBaseIndex and b.typ != etyBaseIndex InternalAssert a.typ != etyBaseIndex and b.typ != etyBaseIndex
r.address = a.res r.address = a.res
var typ = skipTypes(n.sons[0].typ, abstractPtrs) var typ = skipTypes(n.sons[0].typ, abstractPtrs)
if typ.kind in {tyArray, tyArrayConstr}: first = FirstOrd(typ.sons[0]) if typ.kind in {tyArray, tyArrayConstr}: first = firstOrd(typ.sons[0])
else: first = 0 else: first = 0
if optBoundsCheck in p.options and not isConstExpr(n.sons[1]): if optBoundsCheck in p.options and not isConstExpr(n.sons[1]):
useMagic(p, "chckIndx") useMagic(p, "chckIndx")
@ -918,9 +918,9 @@ proc genArrayAccess(p: PProc, n: PNode, r: var TCompRes) =
genArrayAddr(p, n, r) genArrayAddr(p, n, r)
of tyTuple: of tyTuple:
genFieldAddr(p, n, r) genFieldAddr(p, n, r)
else: InternalError(n.info, "expr(nkBracketExpr, " & $ty.kind & ')') else: internalError(n.info, "expr(nkBracketExpr, " & $ty.kind & ')')
r.typ = etyNone r.typ = etyNone
if r.res == nil: InternalError(n.info, "genArrayAccess") if r.res == nil: internalError(n.info, "genArrayAccess")
r.res = ropef("$1[$2]", [r.address, r.res]) r.res = ropef("$1[$2]", [r.address, r.res])
r.address = nil r.address = nil
r.kind = resExpr r.kind = resExpr
@ -929,7 +929,7 @@ proc genAddr(p: PProc, n: PNode, r: var TCompRes) =
case n.sons[0].kind case n.sons[0].kind
of nkSym: of nkSym:
let s = n.sons[0].sym let s = n.sons[0].sym
if s.loc.r == nil: InternalError(n.info, "genAddr: 3") if s.loc.r == nil: internalError(n.info, "genAddr: 3")
case s.kind case s.kind
of skVar, skLet, skResult: of skVar, skLet, skResult:
r.kind = resExpr r.kind = resExpr
@ -948,8 +948,8 @@ proc genAddr(p: PProc, n: PNode, r: var TCompRes) =
r.address = s.loc.r r.address = s.loc.r
r.res = toRope("0") r.res = toRope("0")
else: else:
InternalError(n.info, "genAddr: 4") internalError(n.info, "genAddr: 4")
else: InternalError(n.info, "genAddr: 2") else: internalError(n.info, "genAddr: 2")
of nkCheckedFieldExpr: of nkCheckedFieldExpr:
genCheckedFieldAddr(p, n, r) genCheckedFieldAddr(p, n, r)
of nkDotExpr: of nkDotExpr:
@ -963,15 +963,15 @@ proc genAddr(p: PProc, n: PNode, r: var TCompRes) =
genArrayAddr(p, n, r) genArrayAddr(p, n, r)
of tyTuple: of tyTuple:
genFieldAddr(p, n, r) genFieldAddr(p, n, r)
else: InternalError(n.info, "expr(nkBracketExpr, " & $ty.kind & ')') else: internalError(n.info, "expr(nkBracketExpr, " & $ty.kind & ')')
else: InternalError(n.info, "genAddr") else: internalError(n.info, "genAddr")
proc genSym(p: PProc, n: PNode, r: var TCompRes) = proc genSym(p: PProc, n: PNode, r: var TCompRes) =
var s = n.sym var s = n.sym
case s.kind case s.kind
of skVar, skLet, skParam, skTemp, skResult: of skVar, skLet, skParam, skTemp, skResult:
if s.loc.r == nil: if s.loc.r == nil:
InternalError(n.info, "symbol has no generated name: " & s.name.s) internalError(n.info, "symbol has no generated name: " & s.name.s)
var k = mapType(s.typ) var k = mapType(s.typ)
if k == etyBaseIndex: if k == etyBaseIndex:
r.typ = etyBaseIndex r.typ = etyBaseIndex
@ -988,7 +988,7 @@ proc genSym(p: PProc, n: PNode, r: var TCompRes) =
of skConst: of skConst:
genConstant(p, s) genConstant(p, s)
if s.loc.r == nil: if s.loc.r == nil:
InternalError(n.info, "symbol has no generated name: " & s.name.s) internalError(n.info, "symbol has no generated name: " & s.name.s)
r.res = s.loc.r r.res = s.loc.r
of skProc, skConverter, skMethod: of skProc, skConverter, skMethod:
discard mangleName(s) discard mangleName(s)
@ -1010,7 +1010,7 @@ proc genSym(p: PProc, n: PNode, r: var TCompRes) =
else: app(p.g.code, newp) else: app(p.g.code, newp)
else: else:
if s.loc.r == nil: if s.loc.r == nil:
InternalError(n.info, "symbol has no generated name: " & s.name.s) internalError(n.info, "symbol has no generated name: " & s.name.s)
r.res = s.loc.r r.res = s.loc.r
r.kind = resVal r.kind = resVal
@ -1020,7 +1020,7 @@ proc genDeref(p: PProc, n: PNode, r: var TCompRes) =
else: else:
var a: TCompRes var a: TCompRes
gen(p, n.sons[0], a) gen(p, n.sons[0], a)
if a.typ != etyBaseIndex: InternalError(n.info, "genDeref") if a.typ != etyBaseIndex: internalError(n.info, "genDeref")
r.res = ropef("$1[$2]", [a.address, a.res]) r.res = ropef("$1[$2]", [a.address, a.res])
proc genArg(p: PProc, n: PNode, r: var TCompRes) = proc genArg(p: PProc, n: PNode, r: var TCompRes) =
@ -1051,7 +1051,7 @@ proc genInfixCall(p: PProc, n: PNode, r: var TCompRes) =
gen(p, n.sons[1], r) gen(p, n.sons[1], r)
if r.typ == etyBaseIndex: if r.typ == etyBaseIndex:
if r.address == nil: if r.address == nil:
GlobalError(n.info, "cannot invoke with infix syntax") globalError(n.info, "cannot invoke with infix syntax")
r.res = ropef("$1[$2]", [r.address, r.res]) r.res = ropef("$1[$2]", [r.address, r.res])
r.address = nil r.address = nil
r.typ = etyNone r.typ = etyNone
@ -1093,7 +1093,7 @@ proc createRecordVarAux(p: PProc, rec: PNode, c: var int): PRope =
app(result, ": ") app(result, ": ")
app(result, createVar(p, rec.sym.typ, false)) app(result, createVar(p, rec.sym.typ, false))
inc(c) inc(c)
else: InternalError(rec.info, "createRecordVarAux") else: internalError(rec.info, "createRecordVarAux")
proc createVar(p: PProc, typ: PType, indirect: bool): PRope = proc createVar(p: PProc, typ: PType, indirect: bool): PRope =
var t = skipTypes(typ, abstractInst) var t = skipTypes(typ, abstractInst)
@ -1125,7 +1125,7 @@ proc createVar(p: PProc, typ: PType, indirect: bool): PRope =
app(result, "]") app(result, "]")
of tyTuple: of tyTuple:
result = toRope("{") result = toRope("{")
for i in 0.. <t.sonslen: for i in 0.. <t.sonsLen:
if i > 0: app(result, ", ") if i > 0: app(result, ", ")
appf(result, "Field$1: $2" | "Field$# = $#", i.toRope, appf(result, "Field$1: $2" | "Field$# = $#", i.toRope,
createVar(p, t.sons[i], false)) createVar(p, t.sons[i], false))
@ -1173,7 +1173,7 @@ proc genVarInit(p: PProc, v: PSym, n: PNode) =
useMagic(p, "NimCopy") useMagic(p, "NimCopy")
s = ropef("NimCopy($1, $2)", [a.res, genTypeInfo(p, n.typ)]) s = ropef("NimCopy($1, $2)", [a.res, genTypeInfo(p, n.typ)])
of etyBaseIndex: of etyBaseIndex:
if (a.typ != etyBaseIndex): InternalError(n.info, "genVarInit") if (a.typ != etyBaseIndex): internalError(n.info, "genVarInit")
if {sfAddrTaken, sfGlobal} * v.flags != {}: if {sfAddrTaken, sfGlobal} * v.flags != {}:
appf(p.body, "var $1 = [$2, $3];$n" | "local $1 = {$2, $3};$n", appf(p.body, "var $1 = [$2, $3];$n" | "local $1 = {$2, $3};$n",
[v.loc.r, a.address, a.res]) [v.loc.r, a.address, a.res])
@ -1227,7 +1227,7 @@ proc genOrd(p: PProc, n: PNode, r: var TCompRes) =
case skipTypes(n.sons[1].typ, abstractVar).kind case skipTypes(n.sons[1].typ, abstractVar).kind
of tyEnum, tyInt..tyInt64, tyChar: gen(p, n.sons[1], r) of tyEnum, tyInt..tyInt64, tyChar: gen(p, n.sons[1], r)
of tyBool: unaryExpr(p, n, r, "", "($1 ? 1:0)" | "toBool($#)") of tyBool: unaryExpr(p, n, r, "", "($1 ? 1:0)" | "toBool($#)")
else: InternalError(n.info, "genOrd") else: internalError(n.info, "genOrd")
proc genConStrStr(p: PProc, n: PNode, r: var TCompRes) = proc genConStrStr(p: PProc, n: PNode, r: var TCompRes) =
var a: TCompRes var a: TCompRes
@ -1451,7 +1451,7 @@ proc convStrToCStr(p: PProc, n: PNode, r: var TCompRes) =
gen(p, n.sons[0].sons[0], r) gen(p, n.sons[0].sons[0], r)
else: else:
gen(p, n.sons[0], r) gen(p, n.sons[0], r)
if r.res == nil: InternalError(n.info, "convStrToCStr") if r.res == nil: internalError(n.info, "convStrToCStr")
useMagic(p, "toJSStr") useMagic(p, "toJSStr")
r.res = ropef("toJSStr($1)", [r.res]) r.res = ropef("toJSStr($1)", [r.res])
r.kind = resExpr r.kind = resExpr
@ -1463,13 +1463,13 @@ proc convCStrToStr(p: PProc, n: PNode, r: var TCompRes) =
gen(p, n.sons[0].sons[0], r) gen(p, n.sons[0].sons[0], r)
else: else:
gen(p, n.sons[0], r) gen(p, n.sons[0], r)
if r.res == nil: InternalError(n.info, "convCStrToStr") if r.res == nil: internalError(n.info, "convCStrToStr")
useMagic(p, "cstrToNimstr") useMagic(p, "cstrToNimstr")
r.res = ropef("cstrToNimstr($1)", [r.res]) r.res = ropef("cstrToNimstr($1)", [r.res])
r.kind = resExpr r.kind = resExpr
proc genReturnStmt(p: PProc, n: PNode) = proc genReturnStmt(p: PProc, n: PNode) =
if p.procDef == nil: InternalError(n.info, "genReturnStmt") if p.procDef == nil: internalError(n.info, "genReturnStmt")
p.BeforeRetNeeded = true p.BeforeRetNeeded = true
if (n.sons[0].kind != nkEmpty): if (n.sons[0].kind != nkEmpty):
genStmt(p, n.sons[0]) genStmt(p, n.sons[0])
@ -1564,7 +1564,7 @@ proc gen(p: PProc, n: PNode, r: var TCompRes) =
elif f == 0.5 * f: elif f == 0.5 * f:
if f > 0.0: r.res = toRope"Infinity" if f > 0.0: r.res = toRope"Infinity"
else: r.res = toRope"-Infinity" else: r.res = toRope"-Infinity"
else: r.res = toRope(f.ToStrMaxPrecision) else: r.res = toRope(f.toStrMaxPrecision)
of nkCallKinds: of nkCallKinds:
if (n.sons[0].kind == nkSym) and (n.sons[0].sym.magic != mNone): if (n.sons[0].kind == nkSym) and (n.sons[0].sym.magic != mNone):
genMagic(p, n, r) genMagic(p, n, r)
@ -1640,7 +1640,7 @@ proc gen(p: PProc, n: PNode, r: var TCompRes) =
r.res = nil r.res = nil
of nkGotoState, nkState: of nkGotoState, nkState:
internalError(n.info, "first class iterators not implemented") internalError(n.info, "first class iterators not implemented")
else: InternalError(n.info, "gen: unknown node type: " & $n.kind) else: internalError(n.info, "gen: unknown node type: " & $n.kind)
var globals: PGlobals var globals: PGlobals
@ -1671,7 +1671,7 @@ proc myProcess(b: PPassContext, n: PNode): PNode =
if passes.skipCodegen(n): return n if passes.skipCodegen(n): return n
result = n result = n
var m = BModule(b) var m = BModule(b)
if m.module == nil: InternalError(n.info, "myProcess") if m.module == nil: internalError(n.info, "myProcess")
var p = newProc(globals, m, nil, m.module.options) var p = newProc(globals, m, nil, m.module.options)
genModule(p, n) genModule(p, n)
app(p.g.code, p.locals) app(p.g.code, p.locals)
@ -1702,7 +1702,7 @@ proc myClose(b: PPassContext, n: PNode): PNode =
discard writeRopeIfNotEqual(con(genHeader(), code), outfile) discard writeRopeIfNotEqual(con(genHeader(), code), outfile)
proc myOpenCached(s: PSym, rd: PRodReader): PPassContext = proc myOpenCached(s: PSym, rd: PRodReader): PPassContext =
InternalError("symbol files are not possible with the JS code generator") internalError("symbol files are not possible with the JS code generator")
result = nil result = nil
proc myOpen(s: PSym): PPassContext = proc myOpen(s: PSym): PPassContext =

8
compiler/jstypes.nim
View file

@ -37,7 +37,7 @@ proc genObjectFields(p: PProc, typ: PType, n: PNode): PRope =
[mangleName(field), s, makeJSString(field.name.s)]) [mangleName(field), s, makeJSString(field.name.s)])
of nkRecCase: of nkRecCase:
length = sonsLen(n) length = sonsLen(n)
if (n.sons[0].kind != nkSym): InternalError(n.info, "genObjectFields") if (n.sons[0].kind != nkSym): internalError(n.info, "genObjectFields")
field = n.sons[0].sym field = n.sons[0].sym
s = genTypeInfo(p, field.typ) s = genTypeInfo(p, field.typ)
for i in countup(1, length - 1): for i in countup(1, length - 1):
@ -98,7 +98,7 @@ proc genEnumInfo(p: PProc, typ: PType, name: PRope) =
let length = sonsLen(typ.n) let length = sonsLen(typ.n)
var s: PRope = nil var s: PRope = nil
for i in countup(0, length - 1): for i in countup(0, length - 1):
if (typ.n.sons[i].kind != nkSym): InternalError(typ.n.info, "genEnumInfo") if (typ.n.sons[i].kind != nkSym): internalError(typ.n.info, "genEnumInfo")
let field = typ.n.sons[i].sym let field = typ.n.sons[i].sym
if i > 0: app(s, ", " & tnl) if i > 0: app(s, ", " & tnl)
let extName = if field.ast == nil: field.name.s else: field.ast.strVal let extName = if field.ast == nil: field.name.s else: field.ast.strVal
@ -119,7 +119,7 @@ proc genTypeInfo(p: PProc, typ: PType): PRope =
var t = typ var t = typ
if t.kind == tyGenericInst: t = lastSon(t) if t.kind == tyGenericInst: t = lastSon(t)
result = ropef("NTI$1", [toRope(t.id)]) result = ropef("NTI$1", [toRope(t.id)])
if ContainsOrIncl(p.g.TypeInfoGenerated, t.id): return if containsOrIncl(p.g.TypeInfoGenerated, t.id): return
case t.kind case t.kind
of tyDistinct: of tyDistinct:
result = genTypeInfo(p, typ.sons[0]) result = genTypeInfo(p, typ.sons[0])
@ -145,4 +145,4 @@ proc genTypeInfo(p: PProc, typ: PType): PRope =
of tyEnum: genEnumInfo(p, t, result) of tyEnum: genEnumInfo(p, t, result)
of tyObject: genObjectInfo(p, t, result) of tyObject: genObjectInfo(p, t, result)
of tyTuple: genTupleInfo(p, t, result) of tyTuple: genTupleInfo(p, t, result)
else: InternalError("genTypeInfo(" & $t.kind & ')') else: internalError("genTypeInfo(" & $t.kind & ')')

48
compiler/lambdalifting.nim
View file

@ -236,8 +236,8 @@ proc addClosureParam(i: PInnerContext, e: PEnv) =
proc dummyClosureParam(o: POuterContext, i: PInnerContext) = proc dummyClosureParam(o: POuterContext, i: PInnerContext) =
var e = o.currentEnv var e = o.currentEnv
if IdTableGet(o.lambdasToEnv, i.fn) == nil: if idTableGet(o.lambdasToEnv, i.fn) == nil:
IdTablePut(o.lambdasToEnv, i.fn, e) idTablePut(o.lambdasToEnv, i.fn, e)
if i.closureParam == nil: addClosureParam(i, e) if i.closureParam == nil: addClosureParam(i, e)
proc illegalCapture(s: PSym): bool {.inline.} = proc illegalCapture(s: PSym): bool {.inline.} =
@ -249,13 +249,13 @@ proc captureVar(o: POuterContext, i: PInnerContext, local: PSym,
info: TLineInfo) = info: TLineInfo) =
# for inlined variables the owner is still wrong, so it can happen that it's # for inlined variables the owner is still wrong, so it can happen that it's
# not a captured variable at all ... *sigh* # not a captured variable at all ... *sigh*
var it = PEnv(IdTableGet(o.localsToEnv, local)) var it = PEnv(idTableGet(o.localsToEnv, local))
if it == nil: return if it == nil: return
if illegalCapture(local) or o.fn.id != local.owner.id or if illegalCapture(local) or o.fn.id != local.owner.id or
i.fn.typ.callConv notin {ccClosure, ccDefault}: i.fn.typ.callConv notin {ccClosure, ccDefault}:
# Currently captures are restricted to a single level of nesting: # Currently captures are restricted to a single level of nesting:
LocalError(info, errIllegalCaptureX, local.name.s) localError(info, errIllegalCaptureX, local.name.s)
i.fn.typ.callConv = ccClosure i.fn.typ.callConv = ccClosure
#echo "captureVar ", i.fn.name.s, i.fn.id, " ", local.name.s, local.id #echo "captureVar ", i.fn.name.s, i.fn.id, " ", local.name.s, local.id
@ -263,11 +263,11 @@ proc captureVar(o: POuterContext, i: PInnerContext, local: PSym,
# we need to remember which inner most closure belongs to this lambda: # we need to remember which inner most closure belongs to this lambda:
var e = o.currentEnv var e = o.currentEnv
if IdTableGet(o.lambdasToEnv, i.fn) == nil: if idTableGet(o.lambdasToEnv, i.fn) == nil:
IdTablePut(o.lambdasToEnv, i.fn, e) idTablePut(o.lambdasToEnv, i.fn, e)
# variable already captured: # variable already captured:
if IdNodeTableGet(i.localsToAccess, local) != nil: return if idNodeTableGet(i.localsToAccess, local) != nil: return
if i.closureParam == nil: addClosureParam(i, e) if i.closureParam == nil: addClosureParam(i, e)
# check which environment `local` belongs to: # check which environment `local` belongs to:
@ -281,7 +281,7 @@ proc captureVar(o: POuterContext, i: PInnerContext, local: PSym,
access = indirectAccess(access, addDep(e, it, i.fn), info) access = indirectAccess(access, addDep(e, it, i.fn), info)
access = indirectAccess(access, local, info) access = indirectAccess(access, local, info)
incl(o.capturedVars, local.id) incl(o.capturedVars, local.id)
IdNodeTablePut(i.localsToAccess, local, access) idNodeTablePut(i.localsToAccess, local, access)
proc interestingVar(s: PSym): bool {.inline.} = proc interestingVar(s: PSym): bool {.inline.} =
result = s.kind in {skVar, skLet, skTemp, skForVar, skParam, skResult} and result = s.kind in {skVar, skLet, skTemp, skForVar, skParam, skResult} and
@ -309,11 +309,11 @@ proc gatherVars(o: POuterContext, i: PInnerContext, n: PNode) =
elif isInnerProc(s, o.fn) and tfCapturesEnv in s.typ.flags and s != i.fn: elif isInnerProc(s, o.fn) and tfCapturesEnv in s.typ.flags and s != i.fn:
# call to some other inner proc; we need to track the dependencies for # call to some other inner proc; we need to track the dependencies for
# this: # this:
let env = PEnv(IdTableGet(o.lambdasToEnv, i.fn)) let env = PEnv(idTableGet(o.lambdasToEnv, i.fn))
if env == nil: InternalError(n.info, "no environment computed") if env == nil: internalError(n.info, "no environment computed")
if o.currentEnv != env: if o.currentEnv != env:
discard addDep(o.currentEnv, env, i.fn) discard addDep(o.currentEnv, env, i.fn)
InternalError(n.info, "too complex environment handling required") internalError(n.info, "too complex environment handling required")
of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit: nil of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit: nil
else: else:
for k in countup(0, sonsLen(n) - 1): for k in countup(0, sonsLen(n) - 1):
@ -365,7 +365,7 @@ proc transformInnerProc(o: POuterContext, i: PInnerContext, n: PNode): PNode =
result = makeClosure(s, i.closureParam, n.info) result = makeClosure(s, i.closureParam, n.info)
else: else:
# captured symbol? # captured symbol?
result = IdNodeTableGet(i.localsToAccess, n.sym) result = idNodeTableGet(i.localsToAccess, n.sym)
of nkLambdaKinds: of nkLambdaKinds:
result = transformInnerProc(o, i, n.sons[namePos]) result = transformInnerProc(o, i, n.sons[namePos])
of nkProcDef, nkMethodDef, nkConverterDef, nkMacroDef, nkTemplateDef, of nkProcDef, nkMethodDef, nkConverterDef, nkMacroDef, nkTemplateDef,
@ -425,18 +425,18 @@ proc searchForInnerProcs(o: POuterContext, n: PNode) =
if it.kind == nkCommentStmt: nil if it.kind == nkCommentStmt: nil
elif it.kind == nkIdentDefs: elif it.kind == nkIdentDefs:
var L = sonsLen(it) var L = sonsLen(it)
if it.sons[0].kind != nkSym: InternalError(it.info, "transformOuter") if it.sons[0].kind != nkSym: internalError(it.info, "transformOuter")
#echo "set: ", it.sons[0].sym.name.s, " ", o.currentBlock == nil #echo "set: ", it.sons[0].sym.name.s, " ", o.currentBlock == nil
IdTablePut(o.localsToEnv, it.sons[0].sym, o.currentEnv) idTablePut(o.localsToEnv, it.sons[0].sym, o.currentEnv)
searchForInnerProcs(o, it.sons[L-1]) searchForInnerProcs(o, it.sons[L-1])
elif it.kind == nkVarTuple: elif it.kind == nkVarTuple:
var L = sonsLen(it) var L = sonsLen(it)
for j in countup(0, L-3): for j in countup(0, L-3):
#echo "set: ", it.sons[j].sym.name.s, " ", o.currentBlock == nil #echo "set: ", it.sons[j].sym.name.s, " ", o.currentBlock == nil
IdTablePut(o.localsToEnv, it.sons[j].sym, o.currentEnv) idTablePut(o.localsToEnv, it.sons[j].sym, o.currentEnv)
searchForInnerProcs(o, it.sons[L-1]) searchForInnerProcs(o, it.sons[L-1])
else: else:
InternalError(it.info, "transformOuter") internalError(it.info, "transformOuter")
of nkProcDef, nkMethodDef, nkConverterDef, nkMacroDef, nkTemplateDef, of nkProcDef, nkMethodDef, nkConverterDef, nkMacroDef, nkTemplateDef,
nkIteratorDef: nkIteratorDef:
# don't recurse here: # don't recurse here:
@ -490,7 +490,7 @@ proc generateClosureCreation(o: POuterContext, scope: PEnv): PNode =
# maybe later: (sfByCopy in local.flags) # maybe later: (sfByCopy in local.flags)
# add ``env.param = param`` # add ``env.param = param``
result.add(newAsgnStmt(fieldAccess, newSymNode(local), env.info)) result.add(newAsgnStmt(fieldAccess, newSymNode(local), env.info))
IdNodeTablePut(o.localsToAccess, local, fieldAccess) idNodeTablePut(o.localsToAccess, local, fieldAccess)
# add support for 'up' references: # add support for 'up' references:
for e, field in items(scope.deps): for e, field in items(scope.deps):
# add ``env.up = env2`` # add ``env.up = env2``
@ -503,7 +503,7 @@ proc transformOuterProc(o: POuterContext, n: PNode): PNode =
of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit: nil of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit: nil
of nkSym: of nkSym:
var local = n.sym var local = n.sym
var closure = PEnv(IdTableGet(o.lambdasToEnv, local)) var closure = PEnv(idTableGet(o.lambdasToEnv, local))
if closure != nil: if closure != nil:
# we need to replace the lambda with '(lambda, env)': # we need to replace the lambda with '(lambda, env)':
let a = closure.closure let a = closure.closure
@ -521,7 +521,7 @@ proc transformOuterProc(o: POuterContext, n: PNode): PNode =
return makeClosure(local, x, n.info) return makeClosure(local, x, n.info)
if not contains(o.capturedVars, local.id): return if not contains(o.capturedVars, local.id): return
var env = PEnv(IdTableGet(o.localsToEnv, local)) var env = PEnv(idTableGet(o.localsToEnv, local))
if env == nil: return if env == nil: return
var scope = env.attachedNode var scope = env.attachedNode
assert scope.kind == nkStmtList assert scope.kind == nkStmtList
@ -531,7 +531,7 @@ proc transformOuterProc(o: POuterContext, n: PNode): PNode =
# change 'local' to 'closure.local', unless it's a 'byCopy' variable: # change 'local' to 'closure.local', unless it's a 'byCopy' variable:
# if sfByCopy notin local.flags: # if sfByCopy notin local.flags:
result = IdNodeTableGet(o.localsToAccess, local) result = idNodeTableGet(o.localsToAccess, local)
assert result != nil, "cannot find: " & local.name.s assert result != nil, "cannot find: " & local.name.s
# else it is captured by copy and this means that 'outer' should continue # else it is captured by copy and this means that 'outer' should continue
# to access the local as a local. # to access the local as a local.
@ -564,13 +564,13 @@ proc liftLambdas*(fn: PSym, body: PNode): PNode =
let params = fn.typ.n let params = fn.typ.n
for i in 1.. <params.len: for i in 1.. <params.len:
if params.sons[i].kind != nkSym: if params.sons[i].kind != nkSym:
InternalError(params.info, "liftLambdas: strange params") internalError(params.info, "liftLambdas: strange params")
let param = params.sons[i].sym let param = params.sons[i].sym
IdTablePut(o.localsToEnv, param, o.currentEnv) idTablePut(o.localsToEnv, param, o.currentEnv)
# put the 'result' into the environment so it can be captured: # put the 'result' into the environment so it can be captured:
let ast = fn.ast let ast = fn.ast
if resultPos < sonsLen(ast) and ast.sons[resultPos].kind == nkSym: if resultPos < sonsLen(ast) and ast.sons[resultPos].kind == nkSym:
IdTablePut(o.localsToEnv, ast.sons[resultPos].sym, o.currentEnv) idTablePut(o.localsToEnv, ast.sons[resultPos].sym, o.currentEnv)
searchForInnerProcs(o, body) searchForInnerProcs(o, body)
discard transformOuterProc(o, body) discard transformOuterProc(o, body)
result = ex result = ex
@ -793,7 +793,7 @@ proc liftForLoop*(body: PNode): PNode =
addSon(vpart, body[i]) addSon(vpart, body[i])
addSon(vpart, ast.emptyNode) # no explicit type addSon(vpart, ast.emptyNode) # no explicit type
if not env.isnil: if not env.isNil:
call.sons[0] = makeClosure(call.sons[0].sym, env, body.info) call.sons[0] = makeClosure(call.sons[0].sym, env, body.info)
addSon(vpart, call) addSon(vpart, call)
addSon(v2, vpart) addSon(v2, vpart)

122
compiler/lexer.nim
View file

@ -136,7 +136,7 @@ proc printTok*(tok: TToken)
proc tokToStr*(tok: TToken): string proc tokToStr*(tok: TToken): string
proc openLexer*(lex: var TLexer, filename: string, inputstream: PLLStream) = proc openLexer*(lex: var TLexer, filename: string, inputstream: PLLStream) =
OpenLexer(lex, filename.fileInfoIdx, inputStream) openLexer(lex, filename.fileInfoIdx, inputstream)
proc lexMessage*(L: TLexer, msg: TMsgKind, arg = "") proc lexMessage*(L: TLexer, msg: TMsgKind, arg = "")
@ -160,16 +160,16 @@ proc tokToStr*(tok: TToken): string =
of tkFloatLit..tkFloat64Lit: result = $tok.fNumber of tkFloatLit..tkFloat64Lit: result = $tok.fNumber
of tkInvalid, tkStrLit..tkCharLit, tkComment: result = tok.literal of tkInvalid, tkStrLit..tkCharLit, tkComment: result = tok.literal
of tkParLe..tkColon, tkEof, tkAccent: of tkParLe..tkColon, tkEof, tkAccent:
result = tokTypeToStr[tok.tokType] result = TokTypeToStr[tok.tokType]
else: else:
if tok.ident != nil: if tok.ident != nil:
result = tok.ident.s result = tok.ident.s
else: else:
InternalError("tokToStr") internalError("tokToStr")
result = "" result = ""
proc prettyTok*(tok: TToken): string = proc prettyTok*(tok: TToken): string =
if IsKeyword(tok.tokType): result = "keyword " & tok.ident.s if isKeyword(tok.tokType): result = "keyword " & tok.ident.s
else: result = tokToStr(tok) else: result = tokToStr(tok)
proc printTok*(tok: TToken) = proc printTok*(tok: TToken) =
@ -199,7 +199,7 @@ proc fillToken(L: var TToken) =
proc openLexer(lex: var TLexer, fileIdx: int32, inputstream: PLLStream) = proc openLexer(lex: var TLexer, fileIdx: int32, inputstream: PLLStream) =
openBaseLexer(lex, inputstream) openBaseLexer(lex, inputstream)
lex.fileIdx = fileIdx lex.fileIdx = fileidx
lex.indentAhead = - 1 lex.indentAhead = - 1
inc(lex.Linenumber, inputstream.lineOffset) inc(lex.Linenumber, inputstream.lineOffset)
@ -226,7 +226,7 @@ proc matchUnderscoreChars(L: var TLexer, tok: var TToken, chars: TCharSet) =
while true: while true:
if buf[pos] in chars: if buf[pos] in chars:
add(tok.literal, buf[pos]) add(tok.literal, buf[pos])
Inc(pos) inc(pos)
else: else:
break break
if buf[pos] == '_': if buf[pos] == '_':
@ -234,11 +234,11 @@ proc matchUnderscoreChars(L: var TLexer, tok: var TToken, chars: TCharSet) =
lexMessage(L, errInvalidToken, "_") lexMessage(L, errInvalidToken, "_")
break break
add(tok.literal, '_') add(tok.literal, '_')
Inc(pos) inc(pos)
L.bufPos = pos L.bufPos = pos
proc matchTwoChars(L: TLexer, first: Char, second: TCharSet): bool = proc matchTwoChars(L: TLexer, first: char, second: TCharSet): bool =
result = (L.buf[L.bufpos] == first) and (L.buf[L.bufpos + 1] in Second) result = (L.buf[L.bufpos] == first) and (L.buf[L.bufpos + 1] in second)
proc isFloatLiteral(s: string): bool = proc isFloatLiteral(s: string): bool =
for i in countup(0, len(s) - 1): for i in countup(0, len(s) - 1):
@ -249,7 +249,7 @@ proc isFloatLiteral(s: string): bool =
proc getNumber(L: var TLexer): TToken = proc getNumber(L: var TLexer): TToken =
var var
pos, endpos: int pos, endpos: int
xi: biggestInt xi: BiggestInt
# get the base: # get the base:
result.tokType = tkIntLit # int literal until we know better result.tokType = tkIntLit # int literal until we know better
result.literal = "" result.literal = ""
@ -390,22 +390,22 @@ proc getNumber(L: var TLexer): TToken =
xi = `shl`(xi, 4) or (ord(L.buf[pos]) - ord('A') + 10) xi = `shl`(xi, 4) or (ord(L.buf[pos]) - ord('A') + 10)
inc(pos) inc(pos)
else: break else: break
else: InternalError(getLineInfo(L), "getNumber") else: internalError(getLineInfo(L), "getNumber")
case result.tokType case result.tokType
of tkIntLit, tkInt64Lit: result.iNumber = xi of tkIntLit, tkInt64Lit: result.iNumber = xi
of tkInt8Lit: result.iNumber = biggestInt(int8(toU8(int(xi)))) of tkInt8Lit: result.iNumber = BiggestInt(int8(toU8(int(xi))))
of tkInt16Lit: result.iNumber = biggestInt(toU16(int(xi))) of tkInt16Lit: result.iNumber = BiggestInt(toU16(int(xi)))
of tkInt32Lit: result.iNumber = biggestInt(toU32(xi)) of tkInt32Lit: result.iNumber = BiggestInt(toU32(xi))
of tkUIntLit, tkUInt64Lit: result.iNumber = xi of tkUIntLit, tkUInt64Lit: result.iNumber = xi
of tkUInt8Lit: result.iNumber = biggestInt(int8(toU8(int(xi)))) of tkUInt8Lit: result.iNumber = BiggestInt(int8(toU8(int(xi))))
of tkUInt16Lit: result.iNumber = biggestInt(toU16(int(xi))) of tkUInt16Lit: result.iNumber = BiggestInt(toU16(int(xi)))
of tkUInt32Lit: result.iNumber = biggestInt(toU32(xi)) of tkUInt32Lit: result.iNumber = BiggestInt(toU32(xi))
of tkFloat32Lit: of tkFloat32Lit:
result.fNumber = (cast[PFloat32](addr(xi)))[] result.fNumber = (cast[PFloat32](addr(xi)))[]
# note: this code is endian neutral! # note: this code is endian neutral!
# XXX: Test this on big endian machine! # XXX: Test this on big endian machine!
of tkFloat64Lit: result.fNumber = (cast[PFloat64](addr(xi)))[] of tkFloat64Lit: result.fNumber = (cast[PFloat64](addr(xi)))[]
else: InternalError(getLineInfo(L), "getNumber") else: internalError(getLineInfo(L), "getNumber")
elif isFloatLiteral(result.literal) or (result.tokType == tkFloat32Lit) or elif isFloatLiteral(result.literal) or (result.tokType == tkFloat32Lit) or
(result.tokType == tkFloat64Lit): (result.tokType == tkFloat64Lit):
result.fnumber = parseFloat(result.literal) result.fnumber = parseFloat(result.literal)
@ -447,49 +447,49 @@ proc getEscapedChar(L: var TLexer, tok: var TToken) =
of 'n', 'N': of 'n', 'N':
if tok.toktype == tkCharLit: lexMessage(L, errNnotAllowedInCharacter) if tok.toktype == tkCharLit: lexMessage(L, errNnotAllowedInCharacter)
add(tok.literal, tnl) add(tok.literal, tnl)
Inc(L.bufpos) inc(L.bufpos)
of 'r', 'R', 'c', 'C': of 'r', 'R', 'c', 'C':
add(tok.literal, CR) add(tok.literal, CR)
Inc(L.bufpos) inc(L.bufpos)
of 'l', 'L': of 'l', 'L':
add(tok.literal, LF) add(tok.literal, LF)
Inc(L.bufpos) inc(L.bufpos)
of 'f', 'F': of 'f', 'F':
add(tok.literal, FF) add(tok.literal, FF)
inc(L.bufpos) inc(L.bufpos)
of 'e', 'E': of 'e', 'E':
add(tok.literal, ESC) add(tok.literal, ESC)
Inc(L.bufpos) inc(L.bufpos)
of 'a', 'A': of 'a', 'A':
add(tok.literal, BEL) add(tok.literal, BEL)
Inc(L.bufpos) inc(L.bufpos)
of 'b', 'B': of 'b', 'B':
add(tok.literal, BACKSPACE) add(tok.literal, BACKSPACE)
Inc(L.bufpos) inc(L.bufpos)
of 'v', 'V': of 'v', 'V':
add(tok.literal, VT) add(tok.literal, VT)
Inc(L.bufpos) inc(L.bufpos)
of 't', 'T': of 't', 'T':
add(tok.literal, Tabulator) add(tok.literal, Tabulator)
Inc(L.bufpos) inc(L.bufpos)
of '\'', '\"': of '\'', '\"':
add(tok.literal, L.buf[L.bufpos]) add(tok.literal, L.buf[L.bufpos])
Inc(L.bufpos) inc(L.bufpos)
of '\\': of '\\':
add(tok.literal, '\\') add(tok.literal, '\\')
Inc(L.bufpos) inc(L.bufpos)
of 'x', 'X': of 'x', 'X':
inc(L.bufpos) inc(L.bufpos)
var xi = 0 var xi = 0
handleHexChar(L, xi) handleHexChar(L, xi)
handleHexChar(L, xi) handleHexChar(L, xi)
add(tok.literal, Chr(xi)) add(tok.literal, chr(xi))
of '0'..'9': of '0'..'9':
if matchTwoChars(L, '0', {'0'..'9'}): if matchTwoChars(L, '0', {'0'..'9'}):
lexMessage(L, warnOctalEscape) lexMessage(L, warnOctalEscape)
var xi = 0 var xi = 0
handleDecChars(L, xi) handleDecChars(L, xi)
if (xi <= 255): add(tok.literal, Chr(xi)) if (xi <= 255): add(tok.literal, chr(xi))
else: lexMessage(L, errInvalidCharacterConstant) else: lexMessage(L, errInvalidCharacterConstant)
else: lexMessage(L, errInvalidCharacterConstant) else: lexMessage(L, errInvalidCharacterConstant)
@ -528,7 +528,7 @@ proc getString(L: var TLexer, tok: var TToken, rawMode: bool) =
tok.tokType = tkTripleStrLit # long string literal: tok.tokType = tkTripleStrLit # long string literal:
inc(pos, 2) # skip "" inc(pos, 2) # skip ""
# skip leading newline: # skip leading newline:
pos = HandleCRLF(L, pos) pos = handleCRLF(L, pos)
buf = L.buf buf = L.buf
while true: while true:
case buf[pos] case buf[pos]
@ -538,9 +538,9 @@ proc getString(L: var TLexer, tok: var TToken, rawMode: bool) =
L.bufpos = pos + 3 # skip the three """ L.bufpos = pos + 3 # skip the three """
break break
add(tok.literal, '\"') add(tok.literal, '\"')
Inc(pos) inc(pos)
of CR, LF: of CR, LF:
pos = HandleCRLF(L, pos) pos = handleCRLF(L, pos)
buf = L.buf buf = L.buf
add(tok.literal, tnl) add(tok.literal, tnl)
of nimlexbase.EndOfFile: of nimlexbase.EndOfFile:
@ -551,7 +551,7 @@ proc getString(L: var TLexer, tok: var TToken, rawMode: bool) =
break break
else: else:
add(tok.literal, buf[pos]) add(tok.literal, buf[pos])
Inc(pos) inc(pos)
else: else:
# ordinary string literal # ordinary string literal
if rawMode: tok.tokType = tkRStrLit if rawMode: tok.tokType = tkRStrLit
@ -574,18 +574,18 @@ proc getString(L: var TLexer, tok: var TToken, rawMode: bool) =
pos = L.bufPos pos = L.bufPos
else: else:
add(tok.literal, c) add(tok.literal, c)
Inc(pos) inc(pos)
L.bufpos = pos L.bufpos = pos
proc getCharacter(L: var TLexer, tok: var TToken) = proc getCharacter(L: var TLexer, tok: var TToken) =
Inc(L.bufpos) # skip ' inc(L.bufpos) # skip '
var c = L.buf[L.bufpos] var c = L.buf[L.bufpos]
case c case c
of '\0'..Pred(' '), '\'': lexMessage(L, errInvalidCharacterConstant) of '\0'..Pred(' '), '\'': lexMessage(L, errInvalidCharacterConstant)
of '\\': getEscapedChar(L, tok) of '\\': getEscapedChar(L, tok)
else: else:
tok.literal = $c tok.literal = $c
Inc(L.bufpos) inc(L.bufpos)
if L.buf[L.bufpos] != '\'': lexMessage(L, errMissingFinalQuote) if L.buf[L.bufpos] != '\'': lexMessage(L, errMissingFinalQuote)
inc(L.bufpos) # skip ' inc(L.bufpos) # skip '
@ -606,7 +606,7 @@ proc getSymbol(L: var TLexer, tok: var TToken) =
lexMessage(L, errInvalidToken, "_") lexMessage(L, errInvalidToken, "_")
break break
else: break else: break
Inc(pos) inc(pos)
h = !$h h = !$h
tok.ident = getIdent(addr(L.buf[L.bufpos]), pos - L.bufpos, h) tok.ident = getIdent(addr(L.buf[L.bufpos]), pos - L.bufpos, h)
L.bufpos = pos L.bufpos = pos
@ -631,8 +631,8 @@ proc getOperator(L: var TLexer, tok: var TToken) =
while true: while true:
var c = buf[pos] var c = buf[pos]
if c notin OpChars: break if c notin OpChars: break
h = h !& Ord(c) h = h !& ord(c)
Inc(pos) inc(pos)
endOperator(L, tok, pos, h) endOperator(L, tok, pos, h)
proc scanComment(L: var TLexer, tok: var TToken) = proc scanComment(L: var TLexer, tok: var TToken) =
@ -680,17 +680,17 @@ proc skip(L: var TLexer, tok: var TToken) =
while true: while true:
case buf[pos] case buf[pos]
of ' ': of ' ':
Inc(pos) inc(pos)
of Tabulator: of Tabulator:
lexMessagePos(L, errTabulatorsAreNotAllowed, pos) lexMessagePos(L, errTabulatorsAreNotAllowed, pos)
inc(pos) inc(pos)
of CR, LF: of CR, LF:
pos = HandleCRLF(L, pos) pos = handleCRLF(L, pos)
buf = L.buf buf = L.buf
var indent = 0 var indent = 0
while buf[pos] == ' ': while buf[pos] == ' ':
Inc(pos) inc(pos)
Inc(indent) inc(indent)
if buf[pos] > ' ': if buf[pos] > ' ':
tok.indent = indent tok.indent = indent
break break
@ -725,7 +725,7 @@ proc rawGetTok(L: var TLexer, tok: var TToken) =
getOperator(L, tok) getOperator(L, tok)
of ',': of ',':
tok.toktype = tkComma tok.toktype = tkComma
Inc(L.bufpos) inc(L.bufpos)
of 'l': of 'l':
# if we parsed exactly one character and its a small L (l), this # if we parsed exactly one character and its a small L (l), this
# is treated as a warning because it may be confused with the number 1 # is treated as a warning because it may be confused with the number 1
@ -734,58 +734,58 @@ proc rawGetTok(L: var TLexer, tok: var TToken) =
getSymbol(L, tok) getSymbol(L, tok)
of 'r', 'R': of 'r', 'R':
if L.buf[L.bufPos + 1] == '\"': if L.buf[L.bufPos + 1] == '\"':
Inc(L.bufPos) inc(L.bufPos)
getString(L, tok, true) getString(L, tok, true)
else: else:
getSymbol(L, tok) getSymbol(L, tok)
of '(': of '(':
Inc(L.bufpos) inc(L.bufpos)
if L.buf[L.bufPos] == '.' and L.buf[L.bufPos+1] != '.': if L.buf[L.bufPos] == '.' and L.buf[L.bufPos+1] != '.':
tok.toktype = tkParDotLe tok.toktype = tkParDotLe
Inc(L.bufpos) inc(L.bufpos)
else: else:
tok.toktype = tkParLe tok.toktype = tkParLe
of ')': of ')':
tok.toktype = tkParRi tok.toktype = tkParRi
Inc(L.bufpos) inc(L.bufpos)
of '[': of '[':
Inc(L.bufpos) inc(L.bufpos)
if L.buf[L.bufPos] == '.' and L.buf[L.bufPos+1] != '.': if L.buf[L.bufPos] == '.' and L.buf[L.bufPos+1] != '.':
tok.toktype = tkBracketDotLe tok.toktype = tkBracketDotLe
Inc(L.bufpos) inc(L.bufpos)
else: else:
tok.toktype = tkBracketLe tok.toktype = tkBracketLe
of ']': of ']':
tok.toktype = tkBracketRi tok.toktype = tkBracketRi
Inc(L.bufpos) inc(L.bufpos)
of '.': of '.':
if L.buf[L.bufPos+1] == ']': if L.buf[L.bufPos+1] == ']':
tok.tokType = tkBracketDotRi tok.tokType = tkBracketDotRi
Inc(L.bufpos, 2) inc(L.bufpos, 2)
elif L.buf[L.bufPos+1] == '}': elif L.buf[L.bufPos+1] == '}':
tok.tokType = tkCurlyDotRi tok.tokType = tkCurlyDotRi
Inc(L.bufpos, 2) inc(L.bufpos, 2)
elif L.buf[L.bufPos+1] == ')': elif L.buf[L.bufPos+1] == ')':
tok.tokType = tkParDotRi tok.tokType = tkParDotRi
Inc(L.bufpos, 2) inc(L.bufpos, 2)
else: else:
getOperator(L, tok) getOperator(L, tok)
of '{': of '{':
Inc(L.bufpos) inc(L.bufpos)
if L.buf[L.bufPos] == '.' and L.buf[L.bufPos+1] != '.': if L.buf[L.bufPos] == '.' and L.buf[L.bufPos+1] != '.':
tok.toktype = tkCurlyDotLe tok.toktype = tkCurlyDotLe
Inc(L.bufpos) inc(L.bufpos)
else: else:
tok.toktype = tkCurlyLe tok.toktype = tkCurlyLe
of '}': of '}':
tok.toktype = tkCurlyRi tok.toktype = tkCurlyRi
Inc(L.bufpos) inc(L.bufpos)
of ';': of ';':
tok.toktype = tkSemiColon tok.toktype = tkSemiColon
Inc(L.bufpos) inc(L.bufpos)
of '`': of '`':
tok.tokType = tkAccent tok.tokType = tkAccent
Inc(L.bufpos) inc(L.bufpos)
of '\"': of '\"':
# check for extended raw string literal: # check for extended raw string literal:
var rawMode = L.bufpos > 0 and L.buf[L.bufpos-1] in SymChars var rawMode = L.bufpos > 0 and L.buf[L.bufpos-1] in SymChars
@ -810,6 +810,6 @@ proc rawGetTok(L: var TLexer, tok: var TToken) =
tok.literal = $c tok.literal = $c
tok.tokType = tkInvalid tok.tokType = tkInvalid
lexMessage(L, errInvalidToken, c & " (\\" & $(ord(c)) & ')') lexMessage(L, errInvalidToken, c & " (\\" & $(ord(c)) & ')')
Inc(L.bufpos) inc(L.bufpos)
dummyIdent = getIdent("") dummyIdent = getIdent("")

16
compiler/lists.nim
View file

@ -22,7 +22,7 @@ type
head*, tail*: PListEntry head*, tail*: PListEntry
Counter*: int Counter*: int
TCompareProc* = proc (entry: PListEntry, closure: Pointer): bool {.nimcall.} TCompareProc* = proc (entry: PListEntry, closure: pointer): bool {.nimcall.}
proc initLinkedList*(list: var TLinkedList) = proc initLinkedList*(list: var TLinkedList) =
list.Counter = 0 list.Counter = 0
@ -30,7 +30,7 @@ proc initLinkedList*(list: var TLinkedList) =
list.tail = nil list.tail = nil
proc append*(list: var TLinkedList, entry: PListEntry) = proc append*(list: var TLinkedList, entry: PListEntry) =
Inc(list.counter) inc(list.counter)
entry.next = nil entry.next = nil
entry.prev = list.tail entry.prev = list.tail
if list.tail != nil: if list.tail != nil:
@ -54,11 +54,11 @@ proc appendStr*(list: var TLinkedList, data: string) =
append(list, newStrEntry(data)) append(list, newStrEntry(data))
proc includeStr*(list: var TLinkedList, data: string): bool = proc includeStr*(list: var TLinkedList, data: string): bool =
if Contains(list, data): return true if contains(list, data): return true
AppendStr(list, data) # else: add to list appendStr(list, data) # else: add to list
proc prepend*(list: var TLinkedList, entry: PListEntry) = proc prepend*(list: var TLinkedList, entry: PListEntry) =
Inc(list.counter) inc(list.counter)
entry.prev = nil entry.prev = nil
entry.next = list.head entry.next = list.head
if list.head != nil: if list.head != nil:
@ -75,14 +75,14 @@ proc insertBefore*(list: var TLinkedList, pos, entry: PListEntry) =
if pos == list.head: if pos == list.head:
prepend(list, entry) prepend(list, entry)
else: else:
Inc(list.counter) inc(list.counter)
entry.next = pos entry.next = pos
entry.prev = pos.prev entry.prev = pos.prev
if pos.prev != nil: pos.prev.next = entry if pos.prev != nil: pos.prev.next = entry
pos.prev = entry pos.prev = entry
proc remove*(list: var TLinkedList, entry: PListEntry) = proc remove*(list: var TLinkedList, entry: PListEntry) =
Dec(list.counter) dec(list.counter)
if entry == list.tail: if entry == list.tail:
list.tail = entry.prev list.tail = entry.prev
if entry == list.head: if entry == list.head:
@ -110,7 +110,7 @@ proc excludeStr*(list: var TLinkedList, data: string) =
if PStrEntry(it).data == data: remove(list, it) if PStrEntry(it).data == data: remove(list, it)
it = nxt it = nxt
proc find*(list: TLinkedList, fn: TCompareProc, closure: Pointer): PListEntry = proc find*(list: TLinkedList, fn: TCompareProc, closure: pointer): PListEntry =
result = list.head result = list.head
while result != nil: while result != nil:
if fn(result, closure): return if fn(result, closure): return

26
compiler/llstream.nim
View file

@ -23,7 +23,7 @@ type
llsStdIn # stream encapsulates stdin llsStdIn # stream encapsulates stdin
TLLStream* = object of TObject TLLStream* = object of TObject
kind*: TLLStreamKind # accessible for low-level access (lexbase uses this) kind*: TLLStreamKind # accessible for low-level access (lexbase uses this)
f*: tfile f*: TFile
s*: string s*: string
rd*, wr*: int # for string streams rd*, wr*: int # for string streams
lineOffset*: int # for fake stdin line numbers lineOffset*: int # for fake stdin line numbers
@ -31,7 +31,7 @@ type
PLLStream* = ref TLLStream PLLStream* = ref TLLStream
proc llStreamOpen*(data: string): PLLStream proc llStreamOpen*(data: string): PLLStream
proc llStreamOpen*(f: var tfile): PLLStream proc llStreamOpen*(f: var TFile): PLLStream
proc llStreamOpen*(filename: string, mode: TFileMode): PLLStream proc llStreamOpen*(filename: string, mode: TFileMode): PLLStream
proc llStreamOpen*(): PLLStream proc llStreamOpen*(): PLLStream
proc llStreamOpenStdIn*(): PLLStream proc llStreamOpenStdIn*(): PLLStream
@ -40,7 +40,7 @@ proc llStreamRead*(s: PLLStream, buf: pointer, bufLen: int): int
proc llStreamReadLine*(s: PLLStream, line: var string): bool proc llStreamReadLine*(s: PLLStream, line: var string): bool
proc llStreamReadAll*(s: PLLStream): string proc llStreamReadAll*(s: PLLStream): string
proc llStreamWrite*(s: PLLStream, data: string) proc llStreamWrite*(s: PLLStream, data: string)
proc llStreamWrite*(s: PLLStream, data: Char) proc llStreamWrite*(s: PLLStream, data: char)
proc llStreamWrite*(s: PLLStream, buf: pointer, buflen: int) proc llStreamWrite*(s: PLLStream, buf: pointer, buflen: int)
proc llStreamWriteln*(s: PLLStream, data: string) proc llStreamWriteln*(s: PLLStream, data: string)
# implementation # implementation
@ -99,7 +99,7 @@ proc endsWithOpr*(x: string): bool =
result = x.endsWith(LineContinuationOprs) result = x.endsWith(LineContinuationOprs)
proc continueLine(line: string, inTripleString: bool): bool {.inline.} = proc continueLine(line: string, inTripleString: bool): bool {.inline.} =
result = inTriplestring or result = inTripleString or
line[0] == ' ' or line[0] == ' ' or
line.endsWith(LineContinuationOprs+AdditionalLineContinuationOprs) line.endsWith(LineContinuationOprs+AdditionalLineContinuationOprs)
@ -116,7 +116,7 @@ proc llReadFromStdin(s: PLLStream, buf: pointer, bufLen: int): int =
s.rd = 0 s.rd = 0
var line = newStringOfCap(120) var line = newStringOfCap(120)
var triples = 0 var triples = 0
while ReadLineFromStdin(if s.s.len == 0: ">>> " else: "... ", line): while readLineFromStdin(if s.s.len == 0: ">>> " else: "... ", line):
add(s.s, line) add(s.s, line)
add(s.s, "\n") add(s.s, "\n")
inc triples, countTriples(line) inc triples, countTriples(line)
@ -139,7 +139,7 @@ proc llStreamRead(s: PLLStream, buf: pointer, bufLen: int): int =
of llsFile: of llsFile:
result = readBuffer(s.f, buf, bufLen) result = readBuffer(s.f, buf, bufLen)
of llsStdIn: of llsStdIn:
result = LLreadFromStdin(s, buf, bufLen) result = llReadFromStdin(s, buf, bufLen)
proc llStreamReadLine(s: PLLStream, line: var string): bool = proc llStreamReadLine(s: PLLStream, line: var string): bool =
setLen(line, 0) setLen(line, 0)
@ -196,12 +196,12 @@ proc llStreamWrite(s: PLLStream, buf: pointer, buflen: int) =
of llsNone, llsStdIn: of llsNone, llsStdIn:
discard discard
of llsString: of llsString:
if bufLen > 0: if buflen > 0:
setlen(s.s, len(s.s) + bufLen) setLen(s.s, len(s.s) + buflen)
copyMem(addr(s.s[0 + s.wr]), buf, bufLen) copyMem(addr(s.s[0 + s.wr]), buf, buflen)
inc(s.wr, bufLen) inc(s.wr, buflen)
of llsFile: of llsFile:
discard writeBuffer(s.f, buf, bufLen) discard writeBuffer(s.f, buf, buflen)
proc llStreamReadAll(s: PLLStream): string = proc llStreamReadAll(s: PLLStream): string =
const const
@ -218,7 +218,7 @@ proc llStreamReadAll(s: PLLStream): string =
var bytes = readBuffer(s.f, addr(result[0]), bufSize) var bytes = readBuffer(s.f, addr(result[0]), bufSize)
var i = bytes var i = bytes
while bytes == bufSize: while bytes == bufSize:
setlen(result, i + bufSize) setLen(result, i + bufSize)
bytes = readBuffer(s.f, addr(result[i + 0]), bufSize) bytes = readBuffer(s.f, addr(result[i + 0]), bufSize)
inc(i, bytes) inc(i, bytes)
setlen(result, i) setLen(result, i)

14
compiler/lookups.nim
View file

@ -135,20 +135,20 @@ proc wrongRedefinition*(info: TLineInfo, s: string) =
proc addDecl*(c: PContext, sym: PSym) = proc addDecl*(c: PContext, sym: PSym) =
if c.currentScope.addUniqueSym(sym) == Failure: if c.currentScope.addUniqueSym(sym) == Failure:
WrongRedefinition(sym.info, sym.Name.s) wrongRedefinition(sym.info, sym.Name.s)
proc addPrelimDecl*(c: PContext, sym: PSym) = proc addPrelimDecl*(c: PContext, sym: PSym) =
discard c.currentScope.addUniqueSym(sym) discard c.currentScope.addUniqueSym(sym)
proc addDeclAt*(scope: PScope, sym: PSym) = proc addDeclAt*(scope: PScope, sym: PSym) =
if scope.addUniqueSym(sym) == Failure: if scope.addUniqueSym(sym) == Failure:
WrongRedefinition(sym.info, sym.Name.s) wrongRedefinition(sym.info, sym.Name.s)
proc addInterfaceDeclAux(c: PContext, sym: PSym) = proc addInterfaceDeclAux(c: PContext, sym: PSym) =
if sfExported in sym.flags: if sfExported in sym.flags:
# add to interface: # add to interface:
if c.module != nil: StrTableAdd(c.module.tab, sym) if c.module != nil: strTableAdd(c.module.tab, sym)
else: InternalError(sym.info, "AddInterfaceDeclAux") else: internalError(sym.info, "AddInterfaceDeclAux")
proc addInterfaceDeclAt*(c: PContext, scope: PScope, sym: PSym) = proc addInterfaceDeclAt*(c: PContext, scope: PScope, sym: PSym) =
addDeclAt(scope, sym) addDeclAt(scope, sym)
@ -158,7 +158,7 @@ proc addOverloadableSymAt*(scope: PScope, fn: PSym) =
if fn.kind notin OverloadableSyms: if fn.kind notin OverloadableSyms:
internalError(fn.info, "addOverloadableSymAt") internalError(fn.info, "addOverloadableSymAt")
return return
var check = StrTableGet(scope.symbols, fn.name) var check = strTableGet(scope.symbols, fn.name)
if check != nil and check.Kind notin OverloadableSyms: if check != nil and check.Kind notin OverloadableSyms:
wrongRedefinition(fn.info, fn.Name.s) wrongRedefinition(fn.info, fn.Name.s)
else: else:
@ -275,7 +275,7 @@ proc initOverloadIter*(o: var TOverloadIter, c: PContext, n: PNode): PSym =
result = initIdentIter(o.it, c.topLevelScope.symbols, ident) result = initIdentIter(o.it, c.topLevelScope.symbols, ident)
o.mode = oimSelfModule o.mode = oimSelfModule
else: else:
result = InitIdentIter(o.it, o.m.tab, ident) result = initIdentIter(o.it, o.m.tab, ident)
else: else:
localError(n.sons[1].info, errIdentifierExpected, localError(n.sons[1].info, errIdentifierExpected,
renderTree(n.sons[1])) renderTree(n.sons[1]))
@ -317,7 +317,7 @@ proc nextOverloadIter*(o: var TOverloadIter, c: PContext, n: PNode): PSym =
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
Incl(o.inSymChoice, result.id) incl(o.inSymChoice, result.id)
inc o.symChoiceIndex inc o.symChoiceIndex
elif n.kind == nkOpenSymChoice: elif n.kind == nkOpenSymChoice:
# try 'local' symbols too for Koenig's lookup: # try 'local' symbols too for Koenig's lookup:

14
compiler/magicsys.nim
View file

@ -36,7 +36,7 @@ proc newSysType(kind: TTypeKind, size: int): PType =
result.align = size result.align = size
proc getSysSym(name: string): PSym = proc getSysSym(name: string): PSym =
result = StrTableGet(systemModule.tab, getIdent(name)) result = strTableGet(systemModule.tab, getIdent(name))
if result == nil: if result == nil:
rawMessage(errSystemNeeds, name) rawMessage(errSystemNeeds, name)
result = newSym(skError, getIdent(name), systemModule, systemModule.info) result = newSym(skError, getIdent(name), systemModule, systemModule.info)
@ -46,11 +46,11 @@ proc getSysSym(name: string): PSym =
proc getSysMagic*(name: string, m: TMagic): PSym = proc getSysMagic*(name: string, m: TMagic): PSym =
var ti: TIdentIter var ti: TIdentIter
let id = getIdent(name) let id = getIdent(name)
result = InitIdentIter(ti, systemModule.tab, id) result = initIdentIter(ti, systemModule.tab, id)
while result != nil: while result != nil:
if result.kind == skStub: loadStub(result) if result.kind == skStub: loadStub(result)
if result.magic == m: return result if result.magic == m: return result
result = NextIdentIter(ti, systemModule.tab) result = nextIdentIter(ti, systemModule.tab)
rawMessage(errSystemNeeds, name) rawMessage(errSystemNeeds, name)
result = newSym(skError, id, systemModule, systemModule.info) result = newSym(skError, id, systemModule, systemModule.info)
result.typ = newType(tyError, systemModule) result.typ = newType(tyError, systemModule)
@ -82,11 +82,11 @@ proc getSysType(kind: TTypeKind): PType =
of tyCstring: result = sysTypeFromName("cstring") of tyCstring: result = sysTypeFromName("cstring")
of tyPointer: result = sysTypeFromName("pointer") of tyPointer: result = sysTypeFromName("pointer")
of tyNil: result = newSysType(tyNil, ptrSize) of tyNil: result = newSysType(tyNil, ptrSize)
else: InternalError("request for typekind: " & $kind) else: internalError("request for typekind: " & $kind)
gSysTypes[kind] = result gSysTypes[kind] = result
if result.kind != kind: if result.kind != kind:
InternalError("wanted: " & $kind & " got: " & $result.kind) internalError("wanted: " & $kind & " got: " & $result.kind)
if result == nil: InternalError("type not found: " & $kind) if result == nil: internalError("type not found: " & $kind)
var var
intTypeCache: array[-5..64, PType] intTypeCache: array[-5..64, PType]
@ -164,7 +164,7 @@ 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)

104
compiler/main.nim
View file

@ -123,9 +123,9 @@ proc commandCompileToJS =
#incl(gGlobalOptions, optSafeCode) #incl(gGlobalOptions, optSafeCode)
setTarget(osJS, cpuJS) setTarget(osJS, cpuJS)
#initDefines() #initDefines()
DefineSymbol("nimrod") # 'nimrod' is always defined defineSymbol("nimrod") # 'nimrod' is always defined
DefineSymbol("ecmascript") # For backward compatibility defineSymbol("ecmascript") # For backward compatibility
DefineSymbol("js") defineSymbol("js")
semanticPasses() semanticPasses()
registerPass(jsgenPass) registerPass(jsgenPass)
compileProject() compileProject()
@ -134,7 +134,7 @@ proc interactivePasses =
#incl(gGlobalOptions, optSafeCode) #incl(gGlobalOptions, optSafeCode)
#setTarget(osNimrodVM, cpuNimrodVM) #setTarget(osNimrodVM, cpuNimrodVM)
initDefines() initDefines()
DefineSymbol("nimrodvm") defineSymbol("nimrodvm")
when hasFFI: DefineSymbol("nimffi") when hasFFI: DefineSymbol("nimffi")
registerPass(verbosePass) registerPass(verbosePass)
registerPass(semPass) registerPass(semPass)
@ -142,14 +142,14 @@ proc interactivePasses =
proc commandInteractive = proc commandInteractive =
msgs.gErrorMax = high(int) # do not stop after first error msgs.gErrorMax = high(int) # do not stop after first error
InteractivePasses() interactivePasses()
compileSystemModule() compileSystemModule()
if commandArgs.len > 0: if commandArgs.len > 0:
discard CompileModule(fileInfoIdx(gProjectFull), {}) discard compileModule(fileInfoIdx(gProjectFull), {})
else: else:
var m = makeStdinModule() var m = makeStdinModule()
incl(m.flags, sfMainModule) incl(m.flags, sfMainModule)
processModule(m, LLStreamOpenStdIn(), nil) processModule(m, llStreamOpenStdIn(), nil)
const evalPasses = [verbosePass, semPass, evalPass] const evalPasses = [verbosePass, semPass, evalPass]
@ -157,8 +157,8 @@ proc evalNim(nodes: PNode, module: PSym) =
carryPasses(nodes, module, evalPasses) carryPasses(nodes, module, evalPasses)
proc commandEval(exp: string) = proc commandEval(exp: string) =
if SystemModule == nil: if systemModule == nil:
InteractivePasses() interactivePasses()
compileSystemModule() compileSystemModule()
var echoExp = "echo \"eval\\t\", " & "repr(" & exp & ")" var echoExp = "echo \"eval\\t\", " & "repr(" & exp & ")"
evalNim(echoExp.parseString, makeStdinModule()) evalNim(echoExp.parseString, makeStdinModule())
@ -178,7 +178,7 @@ proc commandPretty =
proc commandScan = proc commandScan =
var f = addFileExt(mainCommandArg(), nimExt) var f = addFileExt(mainCommandArg(), nimExt)
var stream = LLStreamOpen(f, fmRead) var stream = llStreamOpen(f, fmRead)
if stream != nil: if stream != nil:
var var
L: TLexer L: TLexer
@ -187,9 +187,9 @@ proc commandScan =
openLexer(L, f, stream) openLexer(L, f, stream)
while true: while true:
rawGetTok(L, tok) rawGetTok(L, tok)
PrintTok(tok) printTok(tok)
if tok.tokType == tkEof: break if tok.tokType == tkEof: break
CloseLexer(L) closeLexer(L)
else: else:
rawMessage(errCannotOpenFile, f) rawMessage(errCannotOpenFile, f)
@ -200,7 +200,7 @@ proc commandSuggest =
# issuing the first compile command. This will leave the compiler # issuing the first compile command. This will leave the compiler
# cache in a state where "no recompilation is necessary", but the # cache in a state where "no recompilation is necessary", but the
# cgen pass was never executed at all. # cgen pass was never executed at all.
CommandCompileToC() commandCompileToC()
if gDirtyBufferIdx != 0: if gDirtyBufferIdx != 0:
discard compileModule(gDirtyBufferIdx, {sfDirty}) discard compileModule(gDirtyBufferIdx, {sfDirty})
resetModule(gDirtyBufferIdx) resetModule(gDirtyBufferIdx)
@ -219,7 +219,7 @@ proc commandSuggest =
proc wantMainModule = proc wantMainModule =
if gProjectFull.len == 0: if gProjectFull.len == 0:
if optMainModule.len == 0: if optMainModule.len == 0:
Fatal(gCmdLineInfo, errCommandExpectsFilename) fatal(gCmdLineInfo, errCommandExpectsFilename)
else: else:
gProjectName = optMainModule gProjectName = optMainModule
gProjectFull = gProjectPath / gProjectName gProjectFull = gProjectPath / gProjectName
@ -228,7 +228,7 @@ proc wantMainModule =
proc requireMainModuleOption = proc requireMainModuleOption =
if optMainModule.len == 0: if optMainModule.len == 0:
Fatal(gCmdLineInfo, errMainModuleMustBeSpecified) fatal(gCmdLineInfo, errMainModuleMustBeSpecified)
else: else:
gProjectName = optMainModule gProjectName = optMainModule
gProjectFull = gProjectPath / gProjectName gProjectFull = gProjectPath / gProjectName
@ -297,7 +297,7 @@ proc mainCommand* =
if gProjectFull.len != 0: if gProjectFull.len != 0:
# current path is always looked first for modules # current path is always looked first for modules
prependStr(searchPaths, gProjectPath) prependStr(searchPaths, gProjectPath)
setID(100) setId(100)
passes.gIncludeFile = includeModule passes.gIncludeFile = includeModule
passes.gImportModule = importModule passes.gImportModule = importModule
case command.normalize case command.normalize
@ -305,20 +305,20 @@ proc mainCommand* =
# compile means compileToC currently # compile means compileToC currently
gCmd = cmdCompileToC gCmd = cmdCompileToC
wantMainModule() wantMainModule()
CommandCompileToC() commandCompileToC()
of "cpp", "compiletocpp": of "cpp", "compiletocpp":
extccomp.cExt = ".cpp" extccomp.cExt = ".cpp"
gCmd = cmdCompileToCpp gCmd = cmdCompileToCpp
if cCompiler == ccGcc: setCC("gpp") if cCompiler == ccGcc: setCC("gpp")
wantMainModule() wantMainModule()
DefineSymbol("cpp") defineSymbol("cpp")
CommandCompileToC() commandCompileToC()
of "objc", "compiletooc": of "objc", "compiletooc":
extccomp.cExt = ".m" extccomp.cExt = ".m"
gCmd = cmdCompileToOC gCmd = cmdCompileToOC
wantMainModule() wantMainModule()
DefineSymbol("objc") defineSymbol("objc")
CommandCompileToC() commandCompileToC()
of "run": of "run":
gCmd = cmdRun gCmd = cmdRun
wantMainModule() wantMainModule()
@ -330,7 +330,7 @@ proc mainCommand* =
of "js", "compiletojs": of "js", "compiletojs":
gCmd = cmdCompileToJS gCmd = cmdCompileToJS
wantMainModule() wantMainModule()
CommandCompileToJS() commandCompileToJS()
of "compiletollvm": of "compiletollvm":
gCmd = cmdCompileToLLVM gCmd = cmdCompileToLLVM
wantMainModule() wantMainModule()
@ -341,52 +341,52 @@ proc mainCommand* =
of "pretty": of "pretty":
gCmd = cmdPretty gCmd = cmdPretty
wantMainModule() wantMainModule()
CommandPretty() commandPretty()
of "doc": of "doc":
gCmd = cmdDoc gCmd = cmdDoc
LoadConfigs(DocConfig) loadConfigs(DocConfig)
wantMainModule() wantMainModule()
CommandDoc() commandDoc()
of "doc2": of "doc2":
gCmd = cmdDoc gCmd = cmdDoc
LoadConfigs(DocConfig) loadConfigs(DocConfig)
wantMainModule() wantMainModule()
DefineSymbol("nimdoc") defineSymbol("nimdoc")
CommandDoc2() commandDoc2()
of "rst2html": of "rst2html":
gCmd = cmdRst2html gCmd = cmdRst2html
LoadConfigs(DocConfig) loadConfigs(DocConfig)
wantMainModule() wantMainModule()
CommandRst2Html() commandRst2Html()
of "rst2tex": of "rst2tex":
gCmd = cmdRst2tex gCmd = cmdRst2tex
LoadConfigs(DocTexConfig) loadConfigs(DocTexConfig)
wantMainModule() wantMainModule()
CommandRst2TeX() commandRst2TeX()
of "jsondoc": of "jsondoc":
gCmd = cmdDoc gCmd = cmdDoc
LoadConfigs(DocConfig) loadConfigs(DocConfig)
wantMainModule() wantMainModule()
DefineSymbol("nimdoc") defineSymbol("nimdoc")
CommandJSON() commandJSON()
of "buildindex": of "buildindex":
gCmd = cmdDoc gCmd = cmdDoc
LoadConfigs(DocConfig) loadConfigs(DocConfig)
CommandBuildIndex() commandBuildIndex()
of "gendepend": of "gendepend":
gCmd = cmdGenDepend gCmd = cmdGenDepend
wantMainModule() wantMainModule()
CommandGenDepend() commandGenDepend()
of "dump": of "dump":
gcmd = cmdDump gCmd = cmdDump
if getconfigvar("dump.format") == "json": if getConfigVar("dump.format") == "json":
requireMainModuleOption() requireMainModuleOption()
var definedSymbols = newJArray() var definedSymbols = newJArray()
for s in definedSymbolNames(): definedSymbols.elems.add(%s) for s in definedSymbolNames(): definedSymbols.elems.add(%s)
var libpaths = newJArray() var libpaths = newJArray()
for dir in itersearchpath(searchpaths): libpaths.elems.add(%dir) for dir in itersearchpath(searchPaths): libpaths.elems.add(%dir)
var dumpdata = % [ var dumpdata = % [
(key: "version", val: %VersionAsString), (key: "version", val: %VersionAsString),
@ -395,17 +395,17 @@ proc mainCommand* =
(key: "lib_paths", val: libpaths) (key: "lib_paths", val: libpaths)
] ]
outWriteLn($dumpdata) outWriteln($dumpdata)
else: else:
outWriteLn("-- list of currently defined symbols --") outWriteln("-- list of currently defined symbols --")
for s in definedSymbolNames(): outWriteLn(s) for s in definedSymbolNames(): outWriteln(s)
outWriteLn("-- end of list --") outWriteln("-- end of list --")
for it in iterSearchPath(searchpaths): msgWriteLn(it) for it in iterSearchPath(searchPaths): msgWriteln(it)
of "check": of "check":
gCmd = cmdCheck gCmd = cmdCheck
wantMainModule() wantMainModule()
CommandCheck() commandCheck()
of "parse": of "parse":
gCmd = cmdParse gCmd = cmdParse
wantMainModule() wantMainModule()
@ -413,11 +413,11 @@ proc mainCommand* =
of "scan": of "scan":
gCmd = cmdScan gCmd = cmdScan
wantMainModule() wantMainModule()
CommandScan() commandScan()
MsgWriteln("Beware: Indentation tokens depend on the parser\'s state!") msgWriteln("Beware: Indentation tokens depend on the parser\'s state!")
of "i": of "i":
gCmd = cmdInteractive gCmd = cmdInteractive
CommandInteractive() commandInteractive()
of "e": of "e":
# XXX: temporary command for easier testing # XXX: temporary command for easier testing
commandEval(mainCommandArg()) commandEval(mainCommandArg())
@ -429,12 +429,12 @@ proc mainCommand* =
commandEval(gEvalExpr) commandEval(gEvalExpr)
else: else:
wantMainModule() wantMainModule()
CommandSuggest() commandSuggest()
of "serve": of "serve":
isServing = true isServing = true
gGlobalOptions.incl(optCaasEnabled) gGlobalOptions.incl(optCaasEnabled)
msgs.gErrorMax = high(int) # do not stop after first error msgs.gErrorMax = high(int) # do not stop after first error
serve(MainCommand) serve(mainCommand)
else: else:
rawMessage(errInvalidCommandX, command) rawMessage(errInvalidCommandX, command)

22
compiler/modules.nim
View file

@ -68,7 +68,7 @@ proc doCRC(fileIdx: int32) =
# echo "FIRST CRC: ", fileIdx.ToFilename # echo "FIRST CRC: ", fileIdx.ToFilename
gMemCacheData[fileIdx].crc = crcFromFile(fileIdx.toFilename) gMemCacheData[fileIdx].crc = crcFromFile(fileIdx.toFilename)
proc addDep(x: Psym, dep: int32) = proc addDep(x: PSym, dep: int32) =
growCache gMemCacheData, dep growCache gMemCacheData, dep
gMemCacheData[x.position].deps.safeAdd(dep) gMemCacheData[x.position].deps.safeAdd(dep)
@ -130,7 +130,7 @@ proc newModule(fileIdx: int32): PSym =
incl(result.flags, sfUsed) incl(result.flags, sfUsed)
initStrTable(result.tab) initStrTable(result.tab)
StrTableAdd(result.tab, result) # a module knows itself strTableAdd(result.tab, result) # a module knows itself
proc compileModule*(fileIdx: int32, flags: TSymFlags): PSym = proc compileModule*(fileIdx: int32, flags: TSymFlags): PSym =
result = getModule(fileIdx) result = getModule(fileIdx)
@ -144,7 +144,7 @@ proc compileModule*(fileIdx: int32, flags: TSymFlags): PSym =
if gCmd in {cmdCompileToC, cmdCompileToCpp, cmdCheck, cmdIdeTools}: if gCmd in {cmdCompileToC, cmdCompileToCpp, cmdCheck, cmdIdeTools}:
rd = handleSymbolFile(result) rd = handleSymbolFile(result)
if result.id < 0: if result.id < 0:
InternalError("handleSymbolFile should have set the module\'s ID") internalError("handleSymbolFile should have set the module\'s ID")
return return
else: else:
result.id = getID() result.id = getID()
@ -155,7 +155,7 @@ proc compileModule*(fileIdx: int32, flags: TSymFlags): PSym =
doCRC fileIdx doCRC fileIdx
else: else:
if checkDepMem(fileIdx) == Yes: if checkDepMem(fileIdx) == Yes:
result = CompileModule(fileIdx, flags) result = compileModule(fileIdx, flags)
else: else:
result = gCompiledModules[fileIdx] result = gCompiledModules[fileIdx]
@ -164,14 +164,14 @@ proc importModule*(s: PSym, fileIdx: int32): PSym {.procvar.} =
result = compileModule(fileIdx, {}) result = compileModule(fileIdx, {})
if optCaasEnabled in gGlobalOptions: addDep(s, fileIdx) if optCaasEnabled in gGlobalOptions: addDep(s, fileIdx)
if sfSystemModule in result.flags: if sfSystemModule in result.flags:
LocalError(result.info, errAttemptToRedefine, result.Name.s) localError(result.info, errAttemptToRedefine, result.Name.s)
proc includeModule*(s: PSym, fileIdx: int32): PNode {.procvar.} = proc includeModule*(s: PSym, fileIdx: int32): PNode {.procvar.} =
result = syntaxes.parseFile(fileIdx) result = syntaxes.parseFile(fileIdx)
if optCaasEnabled in gGlobalOptions: if optCaasEnabled in gGlobalOptions:
growCache gMemCacheData, fileIdx growCache gMemCacheData, fileIdx
addDep(s, fileIdx) addDep(s, fileIdx)
doCrc(fileIdx) doCRC(fileIdx)
proc `==^`(a, b: string): bool = proc `==^`(a, b: string): bool =
try: try:
@ -181,16 +181,16 @@ proc `==^`(a, b: string): bool =
proc compileSystemModule* = proc compileSystemModule* =
if magicsys.SystemModule == nil: if magicsys.SystemModule == nil:
SystemFileIdx = fileInfoIdx(options.libpath/"system.nim") systemFileIdx = fileInfoIdx(options.libpath/"system.nim")
discard CompileModule(SystemFileIdx, {sfSystemModule}) discard compileModule(systemFileIdx, {sfSystemModule})
proc compileProject*(projectFile = gProjectMainIdx) = proc compileProject*(projectFile = gProjectMainIdx) =
let systemFileIdx = fileInfoIdx(options.libpath / "system.nim") let systemFileIdx = fileInfoIdx(options.libpath / "system.nim")
if projectFile == SystemFileIdx: if projectFile == systemFileIdx:
discard CompileModule(projectFile, {sfMainModule, sfSystemModule}) discard compileModule(projectFile, {sfMainModule, sfSystemModule})
else: else:
compileSystemModule() compileSystemModule()
discard CompileModule(projectFile, {sfMainModule}) discard compileModule(projectFile, {sfMainModule})
var stdinModule: PSym var stdinModule: PSym
proc makeStdinModule*(): PSym = proc makeStdinModule*(): PSym =

32
compiler/msgs.nim
View file

@ -445,7 +445,7 @@ type
TErrorOutputs* = set[TErrorOutput] TErrorOutputs* = set[TErrorOutput]
ERecoverableError* = object of EInvalidValue ERecoverableError* = object of EInvalidValue
ESuggestDone* = object of EBase ESuggestDone* = object of E_Base
const const
InvalidFileIDX* = int32(-1) InvalidFileIDX* = int32(-1)
@ -455,7 +455,7 @@ var
fileInfos*: seq[TFileInfo] = @[] fileInfos*: seq[TFileInfo] = @[]
systemFileIdx*: int32 systemFileIdx*: int32
proc toCChar*(c: Char): string = proc toCChar*(c: char): string =
case c case c
of '\0'..'\x1F', '\x80'..'\xFF': result = '\\' & toOctal(c) of '\0'..'\x1F', '\x80'..'\xFF': result = '\\' & toOctal(c)
of '\'', '\"', '\\': result = '\\' & c of '\'', '\"', '\\': result = '\\' & c
@ -474,7 +474,7 @@ proc makeCString*(s: string): PRope =
add(res, '\"') add(res, '\"')
add(res, tnl) add(res, tnl)
app(result, toRope(res)) # reset: app(result, toRope(res)) # reset:
setlen(res, 1) setLen(res, 1)
res[0] = '\"' res[0] = '\"'
add(res, toCChar(s[i])) add(res, toCChar(s[i]))
add(res, '\"') add(res, '\"')
@ -552,7 +552,7 @@ proc unknownLineInfo*(): TLineInfo =
var var
msgContext: seq[TLineInfo] = @[] msgContext: seq[TLineInfo] = @[]
lastError = UnknownLineInfo() lastError = unknownLineInfo()
bufferedMsgs*: seq[string] bufferedMsgs*: seq[string]
errorOutputs* = {eStdOut, eStdErr} errorOutputs* = {eStdOut, eStdErr}
@ -563,9 +563,9 @@ proc clearBufferedMsgs* =
proc suggestWriteln*(s: string) = proc suggestWriteln*(s: string) =
if eStdOut in errorOutputs: if eStdOut in errorOutputs:
when useCaas: when useCaas:
if isNil(stdoutSocket): Writeln(stdout, s) if isNil(stdoutSocket): writeln(stdout, s)
else: else:
Writeln(stdout, s) writeln(stdout, s)
stdoutSocket.send(s & "\c\L") stdoutSocket.send(s & "\c\L")
else: else:
Writeln(stdout, s) Writeln(stdout, s)
@ -601,12 +601,12 @@ proc pushInfoContext*(info: TLineInfo) =
msgContext.add(info) msgContext.add(info)
proc popInfoContext*() = proc popInfoContext*() =
setlen(msgContext, len(msgContext) - 1) setLen(msgContext, len(msgContext) - 1)
proc getInfoContext*(index: int): TLineInfo = proc getInfoContext*(index: int): TLineInfo =
let L = msgContext.len let L = msgContext.len
let i = if index < 0: L + index else: index let i = if index < 0: L + index else: index
if i >=% L: result = UnknownLineInfo() if i >=% L: result = unknownLineInfo()
else: result = msgContext[i] else: result = msgContext[i]
proc toFilename*(fileIdx: int32): string = proc toFilename*(fileIdx: int32): string =
@ -658,16 +658,16 @@ proc addCheckpoint*(filename: string, line: int) =
proc outWriteln*(s: string) = proc outWriteln*(s: string) =
## Writes to stdout. Always. ## Writes to stdout. Always.
if eStdOut in errorOutputs: Writeln(stdout, s) if eStdOut in errorOutputs: writeln(stdout, s)
proc msgWriteln*(s: string) = proc msgWriteln*(s: string) =
## Writes to stdout. If --stdout option is given, writes to stderr instead. ## Writes to stdout. If --stdout option is given, writes to stderr instead.
if gCmd == cmdIdeTools and optCDebug notin gGlobalOptions: return if gCmd == cmdIdeTools and optCDebug notin gGlobalOptions: return
if optStdout in gGlobalOptions: if optStdout in gGlobalOptions:
if eStdErr in errorOutputs: Writeln(stderr, s) if eStdErr in errorOutputs: writeln(stderr, s)
else: else:
if eStdOut in errorOutputs: Writeln(stdout, s) if eStdOut in errorOutputs: writeln(stdout, s)
if eInMemory in errorOutputs: bufferedMsgs.safeAdd(s) if eInMemory in errorOutputs: bufferedMsgs.safeAdd(s)
@ -677,7 +677,7 @@ proc coordToStr(coord: int): string =
proc msgKindToString*(kind: TMsgKind): string = proc msgKindToString*(kind: TMsgKind): string =
# later versions may provide translated error messages # later versions may provide translated error messages
result = msgKindToStr[kind] result = MsgKindToStr[kind]
proc getMessageStr(msg: TMsgKind, arg: string): string = proc getMessageStr(msg: TMsgKind, arg: string): string =
result = msgKindToString(msg) % [arg] result = msgKindToString(msg) % [arg]
@ -721,16 +721,16 @@ proc `==`*(a, b: TLineInfo): bool =
result = a.line == b.line and a.fileIndex == b.fileIndex result = a.line == b.line and a.fileIndex == b.fileIndex
proc writeContext(lastinfo: TLineInfo) = proc writeContext(lastinfo: TLineInfo) =
var info = lastInfo var info = lastinfo
for i in countup(0, len(msgContext) - 1): for i in countup(0, len(msgContext) - 1):
if msgContext[i] != lastInfo and msgContext[i] != info: if msgContext[i] != lastinfo and msgContext[i] != info:
msgWriteln(posContextFormat % [toMsgFilename(msgContext[i]), msgWriteln(posContextFormat % [toMsgFilename(msgContext[i]),
coordToStr(msgContext[i].line), coordToStr(msgContext[i].line),
coordToStr(msgContext[i].col), coordToStr(msgContext[i].col),
getMessageStr(errInstantiationFrom, "")]) getMessageStr(errInstantiationFrom, "")])
info = msgContext[i] info = msgContext[i]
proc rawMessage*(msg: TMsgKind, args: openarray[string]) = proc rawMessage*(msg: TMsgKind, args: openArray[string]) =
var frmt: string var frmt: string
case msg case msg
of errMin..errMax: of errMin..errMax:
@ -813,7 +813,7 @@ proc internalError*(info: TLineInfo, errMsg: string) =
proc internalError*(errMsg: string) = proc internalError*(errMsg: string) =
if gCmd == cmdIdeTools: return if gCmd == cmdIdeTools: return
writeContext(UnknownLineInfo()) writeContext(unknownLineInfo())
rawMessage(errInternal, errMsg) rawMessage(errInternal, errMsg)
template assertNotNil*(e: expr): expr = template assertNotNil*(e: expr): expr =

14
compiler/nimconf.nim
View file

@ -60,7 +60,7 @@ var condStack: seq[bool] = @[]
proc doEnd(L: var TLexer, tok: var TToken) = proc doEnd(L: var TLexer, tok: var TToken) =
if high(condStack) < 0: lexMessage(L, errTokenExpected, "@if") if high(condStack) < 0: lexMessage(L, errTokenExpected, "@if")
ppGetTok(L, tok) # skip 'end' ppGetTok(L, tok) # skip 'end'
setlen(condStack, high(condStack)) setLen(condStack, high(condStack))
type type
TJumpDest = enum TJumpDest = enum
@ -75,7 +75,7 @@ proc doElse(L: var TLexer, tok: var TToken) =
proc doElif(L: var TLexer, tok: var TToken) = proc doElif(L: var TLexer, tok: var TToken) =
if high(condStack) < 0: lexMessage(L, errTokenExpected, "@if") if high(condStack) < 0: lexMessage(L, errTokenExpected, "@if")
var res = EvalppIf(L, tok) var res = evalppIf(L, tok)
if condStack[high(condStack)] or not res: jumpToDirective(L, tok, jdElseEndif) if condStack[high(condStack)] or not res: jumpToDirective(L, tok, jdElseEndif)
else: condStack[high(condStack)] = true else: condStack[high(condStack)] = true
@ -86,7 +86,7 @@ proc jumpToDirective(L: var TLexer, tok: var TToken, dest: TJumpDest) =
ppGetTok(L, tok) ppGetTok(L, tok)
case whichKeyword(tok.ident) case whichKeyword(tok.ident)
of wIf: of wIf:
Inc(nestedIfs) inc(nestedIfs)
of wElse: of wElse:
if (dest == jdElseEndif) and (nestedIfs == 0): if (dest == jdElseEndif) and (nestedIfs == 0):
doElse(L, tok) doElse(L, tok)
@ -99,7 +99,7 @@ proc jumpToDirective(L: var TLexer, tok: var TToken, dest: TJumpDest) =
if nestedIfs == 0: if nestedIfs == 0:
doEnd(L, tok) doEnd(L, tok)
break break
if nestedIfs > 0: Dec(nestedIfs) if nestedIfs > 0: dec(nestedIfs)
else: else:
nil nil
ppGetTok(L, tok) ppGetTok(L, tok)
@ -112,8 +112,8 @@ proc parseDirective(L: var TLexer, tok: var TToken) =
ppGetTok(L, tok) # skip @ ppGetTok(L, tok) # skip @
case whichKeyword(tok.ident) case whichKeyword(tok.ident)
of wIf: of wIf:
setlen(condStack, len(condStack) + 1) setLen(condStack, len(condStack) + 1)
var res = EvalppIf(L, tok) var res = evalppIf(L, tok)
condStack[high(condStack)] = res condStack[high(condStack)] = res
if not res: jumpToDirective(L, tok, jdElseEndif) if not res: jumpToDirective(L, tok, jdElseEndif)
of wElif: doElif(L, tok) of wElif: doElif(L, tok)
@ -196,7 +196,7 @@ proc readConfigFile(filename: string) =
L: TLexer L: TLexer
tok: TToken tok: TToken
stream: PLLStream stream: PLLStream
stream = LLStreamOpen(filename, fmRead) stream = llStreamOpen(filename, fmRead)
if stream != nil: if stream != nil:
initToken(tok) initToken(tok)
openLexer(L, filename, stream) openLexer(L, filename, stream)

14
compiler/nimlexbase.nim
View file

@ -69,7 +69,7 @@ const
proc closeBaseLexer(L: var TBaseLexer) = proc closeBaseLexer(L: var TBaseLexer) =
dealloc(L.buf) dealloc(L.buf)
LLStreamClose(L.stream) llStreamClose(L.stream)
proc fillBuffer(L: var TBaseLexer) = proc fillBuffer(L: var TBaseLexer) =
var var
@ -83,9 +83,9 @@ proc fillBuffer(L: var TBaseLexer) =
toCopy = L.BufLen - L.sentinel - 1 toCopy = L.BufLen - L.sentinel - 1
assert(toCopy >= 0) assert(toCopy >= 0)
if toCopy > 0: if toCopy > 0:
MoveMem(L.buf, addr(L.buf[L.sentinel + 1]), toCopy * chrSize) moveMem(L.buf, addr(L.buf[L.sentinel + 1]), toCopy * chrSize)
# "moveMem" handles overlapping regions # "moveMem" handles overlapping regions
charsRead = LLStreamRead(L.stream, addr(L.buf[toCopy]), charsRead = llStreamRead(L.stream, addr(L.buf[toCopy]),
(L.sentinel + 1) * chrSize) div chrSize (L.sentinel + 1) * chrSize) div chrSize
s = toCopy + charsRead s = toCopy + charsRead
if charsRead < L.sentinel + 1: if charsRead < L.sentinel + 1:
@ -96,7 +96,7 @@ proc fillBuffer(L: var TBaseLexer) =
dec(s) # BUGFIX (valgrind) dec(s) # BUGFIX (valgrind)
while true: while true:
assert(s < L.bufLen) assert(s < L.bufLen)
while (s >= 0) and not (L.buf[s] in NewLines): Dec(s) while (s >= 0) and not (L.buf[s] in NewLines): dec(s)
if s >= 0: if s >= 0:
# we found an appropriate character for a sentinel: # we found an appropriate character for a sentinel:
L.sentinel = s L.sentinel = s
@ -108,7 +108,7 @@ proc fillBuffer(L: var TBaseLexer) =
L.bufLen = L.BufLen * 2 L.bufLen = L.BufLen * 2
L.buf = cast[cstring](realloc(L.buf, L.bufLen * chrSize)) L.buf = cast[cstring](realloc(L.buf, L.bufLen * chrSize))
assert(L.bufLen - oldBuflen == oldBufLen) assert(L.bufLen - oldBuflen == oldBufLen)
charsRead = LLStreamRead(L.stream, addr(L.buf[oldBufLen]), charsRead = llStreamRead(L.stream, addr(L.buf[oldBufLen]),
oldBufLen * chrSize) div chrSize oldBufLen * chrSize) div chrSize
if charsRead < oldBufLen: if charsRead < oldBufLen:
L.buf[oldBufLen + charsRead] = EndOfFile L.buf[oldBufLen + charsRead] = EndOfFile
@ -153,7 +153,7 @@ proc openBaseLexer(L: var TBaseLexer, inputstream: PLLStream, bufLen = 8192) =
L.linenumber = 1 # lines start at 1 L.linenumber = 1 # lines start at 1
L.stream = inputstream L.stream = inputstream
fillBuffer(L) fillBuffer(L)
skip_UTF_8_BOM(L) skipUTF8BOM(L)
proc getColNumber(L: TBaseLexer, pos: int): int = proc getColNumber(L: TBaseLexer, pos: int): int =
result = abs(pos - L.lineStart) result = abs(pos - L.lineStart)
@ -166,4 +166,4 @@ proc getCurrentLine(L: TBaseLexer, marker: bool = true): string =
inc(i) inc(i)
result.add("\n") result.add("\n")
if marker: if marker:
result.add(RepeatChar(getColNumber(L, L.bufpos)) & '^' & "\n") result.add(repeatChar(getColNumber(L, L.bufpos)) & '^' & "\n")

2
compiler/nimrod.nim
View file

@ -36,7 +36,7 @@ proc handleCmdLine() =
writeCommandLineUsage() writeCommandLineUsage()
else: else:
# Process command line arguments: # Process command line arguments:
ProcessCmdLine(passCmd1, "") processCmdLine(passCmd1, "")
if gProjectName != "": if gProjectName != "":
try: try:
gProjectFull = canonicalizePath(gProjectName) gProjectFull = canonicalizePath(gProjectName)

24
compiler/nimsets.nim
View file

@ -32,7 +32,7 @@ proc cardSet*(s: PNode): BiggestInt
proc inSet(s: PNode, elem: PNode): bool = proc inSet(s: PNode, elem: PNode): bool =
if s.kind != nkCurly: if s.kind != nkCurly:
InternalError(s.info, "inSet") internalError(s.info, "inSet")
return false return false
for i in countup(0, sonsLen(s) - 1): for i in countup(0, sonsLen(s) - 1):
if s.sons[i].kind == nkRange: if s.sons[i].kind == nkRange:
@ -61,7 +61,7 @@ proc overlap(a, b: PNode): bool =
proc SomeInSet(s: PNode, a, b: PNode): bool = proc SomeInSet(s: PNode, a, b: PNode): bool =
# checks if some element of a..b is in the set s # checks if some element of a..b is in the set s
if s.kind != nkCurly: if s.kind != nkCurly:
InternalError(s.info, "SomeInSet") internalError(s.info, "SomeInSet")
return false return false
for i in countup(0, sonsLen(s) - 1): for i in countup(0, sonsLen(s) - 1):
if s.sons[i].kind == nkRange: if s.sons[i].kind == nkRange:
@ -82,10 +82,10 @@ proc toBitSet(s: PNode, b: var TBitSet) =
if s.sons[i].kind == nkRange: if s.sons[i].kind == nkRange:
j = getOrdValue(s.sons[i].sons[0]) j = getOrdValue(s.sons[i].sons[0])
while j <= getOrdValue(s.sons[i].sons[1]): while j <= getOrdValue(s.sons[i].sons[1]):
BitSetIncl(b, j - first) bitSetIncl(b, j - first)
inc(j) inc(j)
else: else:
BitSetIncl(b, getOrdValue(s.sons[i]) - first) bitSetIncl(b, getOrdValue(s.sons[i]) - first)
proc toTreeSet(s: TBitSet, settype: PType, info: TLineInfo): PNode = proc toTreeSet(s: TBitSet, settype: PType, info: TLineInfo): PNode =
var var
@ -103,9 +103,9 @@ proc toTreeSet(s: TBitSet, settype: PType, info: TLineInfo): PNode =
a = e a = e
b = e b = e
while true: while true:
Inc(b) inc(b)
if (b >= len(s) * elemSize) or not bitSetIn(s, b): break if (b >= len(s) * elemSize) or not bitSetIn(s, b): break
Dec(b) dec(b)
if a == b: if a == b:
addSon(result, newIntTypeNode(nkIntLit, a + first, elemType)) addSon(result, newIntTypeNode(nkIntLit, a + first, elemType))
else: else:
@ -115,7 +115,7 @@ proc toTreeSet(s: TBitSet, settype: PType, info: TLineInfo): PNode =
addSon(n, newIntTypeNode(nkIntLit, b + first, elemType)) addSon(n, newIntTypeNode(nkIntLit, b + first, elemType))
addSon(result, n) addSon(result, n)
e = b e = b
Inc(e) inc(e)
template nodeSetOp(a, b: PNode, op: expr) {.dirty.} = template nodeSetOp(a, b: PNode, op: expr) {.dirty.} =
var x, y: TBitSet var x, y: TBitSet
@ -124,10 +124,10 @@ template nodeSetOp(a, b: PNode, op: expr) {.dirty.} =
op(x, y) op(x, y)
result = toTreeSet(x, a.typ, a.info) result = toTreeSet(x, a.typ, a.info)
proc unionSets(a, b: PNode): PNode = nodeSetOp(a, b, BitSetUnion) proc unionSets(a, b: PNode): PNode = nodeSetOp(a, b, bitSetUnion)
proc diffSets(a, b: PNode): PNode = nodeSetOp(a, b, BitSetDiff) proc diffSets(a, b: PNode): PNode = nodeSetOp(a, b, bitSetDiff)
proc intersectSets(a, b: PNode): PNode = nodeSetOp(a, b, BitSetIntersect) proc intersectSets(a, b: PNode): PNode = nodeSetOp(a, b, bitSetIntersect)
proc symdiffSets(a, b: PNode): PNode = nodeSetOp(a, b, BitSetSymDiff) proc symdiffSets(a, b: PNode): PNode = nodeSetOp(a, b, bitSetSymDiff)
proc containsSets(a, b: PNode): bool = proc containsSets(a, b: PNode): bool =
var x, y: TBitSet var x, y: TBitSet
@ -156,7 +156,7 @@ proc cardSet(s: PNode): BiggestInt =
result = result + getOrdValue(s.sons[i].sons[1]) - result = result + getOrdValue(s.sons[i].sons[1]) -
getOrdValue(s.sons[i].sons[0]) + 1 getOrdValue(s.sons[i].sons[0]) + 1
else: else:
Inc(result) inc(result)
proc setHasRange(s: PNode): bool = proc setHasRange(s: PNode): bool =
if s.kind != nkCurly: if s.kind != nkCurly:

14
compiler/options.nim
View file

@ -142,7 +142,7 @@ const
# additional configuration variables: # additional configuration variables:
var var
gConfigVars* = newStringTable(modeStyleInsensitive) gConfigVars* = newStringTable(modeStyleInsensitive)
gDllOverrides = newStringtable(modeCaseInsensitive) gDllOverrides = newStringTable(modeCaseInsensitive)
libpath* = "" libpath* = ""
gProjectName* = "" # holds a name like 'nimrod' gProjectName* = "" # holds a name like 'nimrod'
gProjectPath* = "" # holds a path like /home/alice/projects/nimrod/compiler/ gProjectPath* = "" # holds a path like /home/alice/projects/nimrod/compiler/
@ -184,7 +184,7 @@ proc getOutFile*(filename, ext: string): string =
proc getPrefixDir*(): string = proc getPrefixDir*(): string =
## gets the application directory ## gets the application directory
result = SplitPath(getAppDir()).head result = splitPath(getAppDir()).head
proc canonicalizePath*(path: string): string = proc canonicalizePath*(path: string): string =
result = path.expandFilename result = path.expandFilename
@ -261,8 +261,8 @@ iterator iterSearchPath*(SearchPaths: TLinkedList): string =
it = PStrEntry(it.Next) it = PStrEntry(it.Next)
proc rawFindFile(f: string): string = proc rawFindFile(f: string): string =
for it in iterSearchPath(SearchPaths): for it in iterSearchPath(searchPaths):
result = JoinPath(it, f) result = joinPath(it, f)
if existsFile(result): if existsFile(result):
return result.canonicalizePath return result.canonicalizePath
result = "" result = ""
@ -270,7 +270,7 @@ proc rawFindFile(f: string): string =
proc rawFindFile2(f: string): string = proc rawFindFile2(f: string): string =
var it = PStrEntry(lazyPaths.head) var it = PStrEntry(lazyPaths.head)
while it != nil: while it != nil:
result = JoinPath(it.data, f) result = joinPath(it.data, f)
if existsFile(result): if existsFile(result):
bringToFront(lazyPaths, it) bringToFront(lazyPaths, it)
return result.canonicalizePath return result.canonicalizePath
@ -292,7 +292,7 @@ proc findModule*(modulename, currentModule: string): string =
let currentPath = currentModule.splitFile.dir let currentPath = currentModule.splitFile.dir
result = currentPath / m result = currentPath / m
if not existsFile(result): if not existsFile(result):
result = FindFile(m) result = findFile(m)
proc libCandidates*(s: string, dest: var seq[string]) = proc libCandidates*(s: string, dest: var seq[string]) =
var le = strutils.find(s, '(') var le = strutils.find(s, '(')
@ -319,7 +319,7 @@ proc inclDynlibOverride*(lib: string) =
proc isDynlibOverride*(lib: string): bool = proc isDynlibOverride*(lib: string): bool =
result = gDllOverrides.hasKey(lib.canonDynlibName) result = gDllOverrides.hasKey(lib.canonDynlibName)
proc binaryStrSearch*(x: openarray[string], y: string): int = proc binaryStrSearch*(x: openArray[string], y: string): int =
var a = 0 var a = 0
var b = len(x) - 1 var b = len(x) - 1
while a <= b: while a <= b:

4
compiler/parampatterns.nim
View file

@ -42,7 +42,7 @@ const
MaxStackSize* = 64 ## max required stack size by the VM MaxStackSize* = 64 ## max required stack size by the VM
proc patternError(n: PNode) = proc patternError(n: PNode) =
LocalError(n.info, errIllFormedAstX, renderTree(n, {renderNoComments})) localError(n.info, errIllFormedAstX, renderTree(n, {renderNoComments}))
proc add(code: var TPatternCode, op: TOpcode) {.inline.} = proc add(code: var TPatternCode, op: TOpcode) {.inline.} =
add(code, chr(ord(op))) add(code, chr(ord(op)))
@ -125,7 +125,7 @@ proc semNodeKindConstraints*(p: PNode): PNode =
for i in 1.. <p.len: for i in 1.. <p.len:
compileConstraints(p.sons[i], result.strVal) compileConstraints(p.sons[i], result.strVal)
if result.strVal.len > maxStackSize-1: if result.strVal.len > maxStackSize-1:
InternalError(p.info, "parameter pattern too complex") internalError(p.info, "parameter pattern too complex")
else: else:
patternError(p) patternError(p)
result.strVal.add(ppEof) result.strVal.add(ppEof)

14
compiler/parser.nim
View file

@ -77,12 +77,12 @@ proc getTok(p: var TParser) =
proc openParser*(p: var TParser, fileIdx: int32, inputStream: PLLStream) = proc openParser*(p: var TParser, fileIdx: int32, inputStream: PLLStream) =
initToken(p.tok) initToken(p.tok)
openLexer(p.lex, fileIdx, inputstream) openLexer(p.lex, fileIdx, inputStream)
getTok(p) # read the first token getTok(p) # read the first token
p.firstTok = true p.firstTok = true
proc openParser*(p: var TParser, filename: string, inputStream: PLLStream) = proc openParser*(p: var TParser, filename: string, inputStream: PLLStream) =
openParser(p, filename.fileInfoIdx, inputStream) openParser(p, filename.fileInfoIdx, inputstream)
proc closeParser(p: var TParser) = proc closeParser(p: var TParser) =
closeLexer(p.lex) closeLexer(p.lex)
@ -141,7 +141,7 @@ proc expectIdent(p: TParser) =
proc eat(p: var TParser, TokType: TTokType) = proc eat(p: var TParser, TokType: TTokType) =
if p.tok.TokType == TokType: getTok(p) if p.tok.TokType == TokType: getTok(p)
else: lexMessage(p.lex, errTokenExpected, TokTypeToStr[tokType]) else: lexMessage(p.lex, errTokenExpected, TokTypeToStr[TokType])
proc parLineInfo(p: TParser): TLineInfo = proc parLineInfo(p: TParser): TLineInfo =
result = getLineInfo(p.lex, p.tok) result = getLineInfo(p.lex, p.tok)
@ -672,7 +672,7 @@ proc simpleExprAux(p: var TParser, limit: int, mode: TPrimaryMode): PNode =
let modeB = if mode == pmTypeDef: pmTypeDesc else: mode let modeB = if mode == pmTypeDef: pmTypeDesc else: mode
# the operator itself must not start on a new line: # the operator itself must not start on a new line:
while opPrec >= limit and p.tok.indent < 0: while opPrec >= limit and p.tok.indent < 0:
var leftAssoc = ord(IsLeftAssociative(p.tok)) var leftAssoc = ord(isLeftAssociative(p.tok))
var a = newNodeP(nkInfix, p) var a = newNodeP(nkInfix, p)
var opNode = newIdentNodeP(p.tok.ident, p) # skip operator: var opNode = newIdentNodeP(p.tok.ident, p) # skip operator:
getTok(p) getTok(p)
@ -846,7 +846,7 @@ proc parseParamList(p: var TParser, retColon = true): PNode =
optPar(p) optPar(p)
eat(p, tkParRi) eat(p, tkParRi)
let hasRet = if retColon: p.tok.tokType == tkColon let hasRet = if retColon: p.tok.tokType == tkColon
else: p.tok.tokType == tkOpr and IdentEq(p.tok.ident, "->") else: p.tok.tokType == tkOpr and identEq(p.tok.ident, "->")
if hasRet and p.tok.indent < 0: if hasRet and p.tok.indent < 0:
getTok(p) getTok(p)
optInd(p, result) optInd(p, result)
@ -941,7 +941,7 @@ proc primary(p: var TParser, mode: TPrimaryMode): PNode =
#| / 'static' primary #| / 'static' primary
#| / 'bind' primary #| / 'bind' primary
if isOperator(p.tok): if isOperator(p.tok):
let isSigil = IsSigilLike(p.tok) let isSigil = isSigilLike(p.tok)
result = newNodeP(nkPrefix, p) result = newNodeP(nkPrefix, p)
var a = newIdentNodeP(p.tok.ident, p) var a = newIdentNodeP(p.tok.ident, p)
addSon(result, a) addSon(result, a)
@ -1877,7 +1877,7 @@ proc parseTopLevelStmt(p: var TParser): PNode =
break break
proc parseString(s: string, filename: string = "", line: int = 0): PNode = proc parseString(s: string, filename: string = "", line: int = 0): PNode =
var stream = LLStreamOpen(s) var stream = llStreamOpen(s)
stream.lineOffset = line stream.lineOffset = line
var parser: TParser var parser: TParser

6
compiler/passaux.nim
View file

@ -19,12 +19,12 @@ proc verboseOpen(s: PSym): PPassContext =
proc verboseProcess(context: PPassContext, n: PNode): PNode = proc verboseProcess(context: PPassContext, n: PNode): PNode =
result = n result = n
if context != nil: InternalError("logpass: context is not nil") if context != nil: internalError("logpass: context is not nil")
if gVerbosity == 3: if gVerbosity == 3:
# system.nim deactivates all hints, for verbosity:3 we want the processing # system.nim deactivates all hints, for verbosity:3 we want the processing
# messages nonetheless, so we activate them again unconditionally: # messages nonetheless, so we activate them again unconditionally:
incl(msgs.gNotes, hintProcessing) incl(msgs.gNotes, hintProcessing)
Message(n.info, hintProcessing, $idgen.gBackendId) message(n.info, hintProcessing, $idgen.gBackendId)
const verbosePass* = makePass(open = verboseOpen, process = verboseProcess) const verbosePass* = makePass(open = verboseOpen, process = verboseProcess)
@ -34,7 +34,7 @@ proc cleanUp(c: PPassContext, n: PNode): PNode =
if optDeadCodeElim in gGlobalOptions or n == nil: return if optDeadCodeElim in gGlobalOptions or n == nil: return
case n.kind case n.kind
of nkStmtList: of nkStmtList:
for i in countup(0, sonsLen(n) - 1): discard cleanup(c, n.sons[i]) for i in countup(0, sonsLen(n) - 1): discard cleanUp(c, n.sons[i])
of nkProcDef, nkMethodDef: of nkProcDef, nkMethodDef:
if n.sons[namePos].kind == nkSym: if n.sons[namePos].kind == nkSym:
var s = n.sons[namePos].sym var s = n.sons[namePos].sym

8
compiler/passes.nim
View file

@ -30,8 +30,8 @@ type
TPass* = tuple[open: TPassOpen, openCached: TPassOpenCached, TPass* = tuple[open: TPassOpen, openCached: TPassOpenCached,
process: TPassProcess, close: TPassClose] process: TPassProcess, close: TPassClose]
TPassData* = tuple[input: PNode, closeOutput: Pnode] TPassData* = tuple[input: PNode, closeOutput: PNode]
TPasses* = openarray[TPass] TPasses* = openArray[TPass]
# a pass is a tuple of procedure vars ``TPass.close`` may produce additional # a pass is a tuple of procedure vars ``TPass.close`` may produce additional
# nodes. These are passed to the other close procedures. # nodes. These are passed to the other close procedures.
@ -169,7 +169,7 @@ proc processModule(module: PSym, stream: PLLStream, rd: PRodReader) =
openPasses(a, module) openPasses(a, module)
if stream == nil: if stream == nil:
let filename = fileIdx.toFullPath let filename = fileIdx.toFullPath
s = LLStreamOpen(filename, fmRead) s = llStreamOpen(filename, fmRead)
if s == nil: if s == nil:
rawMessage(errCannotOpenFile, filename) rawMessage(errCannotOpenFile, filename)
return return
@ -195,7 +195,7 @@ proc processModule(module: PSym, stream: PLLStream, rd: PRodReader) =
if s.kind != llsStdIn: break if s.kind != llsStdIn: break
closePasses(a) closePasses(a)
# id synchronization point for more consistent code generation: # id synchronization point for more consistent code generation:
IDsynchronizationPoint(1000) idSynchronizationPoint(1000)
else: else:
openPassesCached(a, module, rd) openPassesCached(a, module, rd)
var n = loadInitSection(rd) var n = loadInitSection(rd)

12
compiler/patterns.nim
View file

@ -87,22 +87,22 @@ proc matchChoice(c: PPatternContext, p, n: PNode): bool =
if matches(c, p.sons[i], n): return true if matches(c, p.sons[i], n): return true
proc bindOrCheck(c: PPatternContext, param: PSym, n: PNode): bool = proc bindOrCheck(c: PPatternContext, param: PSym, n: PNode): bool =
var pp = GetLazy(c, param) var pp = getLazy(c, param)
if pp != nil: if pp != nil:
# check if we got the same pattern (already unified): # check if we got the same pattern (already unified):
result = sameTrees(pp, n) #matches(c, pp, n) result = sameTrees(pp, n) #matches(c, pp, n)
elif n.kind == nkArgList or checkTypes(c, param, n): elif n.kind == nkArgList or checkTypes(c, param, n):
PutLazy(c, param, n) putLazy(c, param, n)
result = true result = true
proc gather(c: PPatternContext, param: PSym, n: PNode) = proc gather(c: PPatternContext, param: PSym, n: PNode) =
var pp = GetLazy(c, param) var pp = getLazy(c, param)
if pp != nil and pp.kind == nkArgList: if pp != nil and pp.kind == nkArgList:
pp.add(n) pp.add(n)
else: else:
pp = newNodeI(nkArgList, n.info, 1) pp = newNodeI(nkArgList, n.info, 1)
pp.sons[0] = n pp.sons[0] = n
PutLazy(c, param, pp) putLazy(c, param, pp)
proc matchNested(c: PPatternContext, p, n: PNode, rpn: bool): bool = proc matchNested(c: PPatternContext, p, n: PNode, rpn: bool): bool =
# match ``op * param`` or ``op *| param`` # match ``op * param`` or ``op *| param``
@ -148,7 +148,7 @@ proc matches(c: PPatternContext, p, n: PNode): bool =
of "*": result = matchNested(c, p, n, rpn=false) of "*": result = matchNested(c, p, n, rpn=false)
of "**": result = matchNested(c, p, n, rpn=true) of "**": result = matchNested(c, p, n, rpn=true)
of "~": result = not matches(c, p.sons[1], n) of "~": result = not matches(c, p.sons[1], n)
else: InternalError(p.info, "invalid pattern") else: internalError(p.info, "invalid pattern")
# template {add(a, `&` * b)}(a: string{noalias}, b: varargs[string]) = # template {add(a, `&` * b)}(a: string{noalias}, b: varargs[string]) =
# add(a, b) # add(a, b)
elif p.kind == nkCurlyExpr: elif p.kind == nkCurlyExpr:
@ -256,7 +256,7 @@ proc applyRule*(c: PContext, s: PSym, n: PNode): PNode =
args = newNodeI(nkArgList, n.info) args = newNodeI(nkArgList, n.info)
for i in 1 .. < params.len: for i in 1 .. < params.len:
let param = params.sons[i].sym let param = params.sons[i].sym
let x = GetLazy(ctx, param) let x = getLazy(ctx, param)
# couldn't bind parameter: # couldn't bind parameter:
if isNil(x): return nil if isNil(x): return nil
result.add(x) result.add(x)

8
compiler/platform.nim
View file

@ -200,10 +200,10 @@ proc setTarget*(o: TSystemOS, c: TSystemCPU) =
#echo "new Target: OS: ", o, " CPU: ", c #echo "new Target: OS: ", o, " CPU: ", c
targetCPU = c targetCPU = c
targetOS = o targetOS = o
intSize = cpu[c].intSize div 8 intSize = CPU[c].intSize div 8
floatSize = cpu[c].floatSize div 8 floatSize = CPU[c].floatSize div 8
ptrSize = cpu[c].bit div 8 ptrSize = CPU[c].bit div 8
tnl = os[o].newLine tnl = OS[o].newLine
proc nameToOS(name: string): TSystemOS = proc nameToOS(name: string): TSystemOS =
for i in countup(succ(osNone), high(TSystemOS)): for i in countup(succ(osNone), high(TSystemOS)):

132
compiler/pragmas.nim
View file

@ -70,7 +70,7 @@ proc pragma*(c: PContext, sym: PSym, n: PNode, validPragmas: TSpecialWords)
# implementation # implementation
proc invalidPragma(n: PNode) = proc invalidPragma(n: PNode) =
LocalError(n.info, errInvalidPragmaX, renderTree(n, {renderNoComments})) localError(n.info, errInvalidPragmaX, renderTree(n, {renderNoComments}))
proc pragmaAsm*(c: PContext, n: PNode): char = proc pragmaAsm*(c: PContext, n: PNode): char =
result = '\0' result = '\0'
@ -125,7 +125,7 @@ proc newEmptyStrNode(n: PNode): PNode {.noinline.} =
proc getStrLitNode(c: PContext, n: PNode): PNode = proc getStrLitNode(c: PContext, n: PNode): PNode =
if n.kind != nkExprColonExpr: if n.kind != nkExprColonExpr:
LocalError(n.info, errStringLiteralExpected) localError(n.info, errStringLiteralExpected)
# error correction: # error correction:
result = newEmptyStrNode(n) result = newEmptyStrNode(n)
else: else:
@ -169,7 +169,7 @@ proc processMagic(c: PContext, n: PNode, s: PSym) =
if substr($m, 1) == v: if substr($m, 1) == v:
s.magic = m s.magic = m
break break
if s.magic == mNone: Message(n.info, warnUnknownMagic, v) if s.magic == mNone: message(n.info, warnUnknownMagic, v)
proc wordToCallConv(sw: TSpecialWord): TCallingConvention = proc wordToCallConv(sw: TSpecialWord): TCallingConvention =
# this assumes that the order of special words and calling conventions is # this assumes that the order of special words and calling conventions is
@ -188,11 +188,11 @@ proc onOff(c: PContext, n: PNode, op: TOptions) =
else: gOptions = gOptions - op else: gOptions = gOptions - op
proc pragmaDeadCodeElim(c: PContext, n: PNode) = proc pragmaDeadCodeElim(c: PContext, n: PNode) =
if IsTurnedOn(c, n): incl(c.module.flags, sfDeadCodeElim) if isTurnedOn(c, n): incl(c.module.flags, sfDeadCodeElim)
else: excl(c.module.flags, sfDeadCodeElim) else: excl(c.module.flags, sfDeadCodeElim)
proc pragmaNoForward(c: PContext, n: PNode) = proc pragmaNoForward(c: PContext, n: PNode) =
if IsTurnedOn(c, n): incl(c.module.flags, sfNoForward) if isTurnedOn(c, n): incl(c.module.flags, sfNoForward)
else: excl(c.module.flags, sfNoForward) else: excl(c.module.flags, sfNoForward)
proc processCallConv(c: PContext, n: PNode) = proc processCallConv(c: PContext, n: PNode) =
@ -201,9 +201,9 @@ proc processCallConv(c: PContext, n: PNode) =
case sw case sw
of firstCallConv..lastCallConv: of firstCallConv..lastCallConv:
POptionEntry(c.optionStack.tail).defaultCC = wordToCallConv(sw) POptionEntry(c.optionStack.tail).defaultCC = wordToCallConv(sw)
else: LocalError(n.info, errCallConvExpected) else: localError(n.info, errCallConvExpected)
else: else:
LocalError(n.info, errCallConvExpected) localError(n.info, errCallConvExpected)
proc getLib(c: PContext, kind: TLibKind, path: PNode): PLib = proc getLib(c: PContext, kind: TLibKind, path: PNode): PLib =
var it = PLib(c.libs.head) var it = PLib(c.libs.head)
@ -213,13 +213,13 @@ proc getLib(c: PContext, kind: TLibKind, path: PNode): PLib =
it = PLib(it.next) it = PLib(it.next)
result = newLib(kind) result = newLib(kind)
result.path = path result.path = path
Append(c.libs, result) append(c.libs, result)
if path.kind in {nkStrLit..nkTripleStrLit}: if path.kind in {nkStrLit..nkTripleStrLit}:
result.isOverriden = options.isDynLibOverride(path.strVal) result.isOverriden = options.isDynLibOverride(path.strVal)
proc expectDynlibNode(c: PContext, n: PNode): PNode = proc expectDynlibNode(c: PContext, n: PNode): PNode =
if n.kind != nkExprColonExpr: if n.kind != nkExprColonExpr:
LocalError(n.info, errStringLiteralExpected) localError(n.info, errStringLiteralExpected)
# error correction: # error correction:
result = newEmptyStrNode(n) result = newEmptyStrNode(n)
else: else:
@ -229,7 +229,7 @@ proc expectDynlibNode(c: PContext, n: PNode): PNode =
if result.kind == nkSym and result.sym.kind == skConst: if result.kind == nkSym and result.sym.kind == skConst:
result = result.sym.ast # look it up result = result.sym.ast # look it up
if result.typ == nil or result.typ.kind notin {tyPointer, tyString, tyProc}: if result.typ == nil or result.typ.kind notin {tyPointer, tyString, tyProc}:
LocalError(n.info, errStringLiteralExpected) localError(n.info, errStringLiteralExpected)
result = newEmptyStrNode(n) result = newEmptyStrNode(n)
proc processDynLib(c: PContext, n: PNode, sym: PSym) = proc processDynLib(c: PContext, n: PNode, sym: PSym) =
@ -265,7 +265,7 @@ proc processNote(c: PContext, n: PNode) =
of wWarning: of wWarning:
var x = findStr(msgs.WarningsToStr, n.sons[0].sons[1].ident.s) var x = findStr(msgs.WarningsToStr, n.sons[0].sons[1].ident.s)
if x >= 0: nk = TNoteKind(x + ord(warnMin)) if x >= 0: nk = TNoteKind(x + ord(warnMin))
else: InvalidPragma(n); return else: invalidPragma(n); return
else: else:
invalidPragma(n) invalidPragma(n)
return return
@ -284,26 +284,26 @@ proc processOption(c: PContext, n: PNode): bool =
else: else:
var sw = whichKeyword(n.sons[0].ident) var sw = whichKeyword(n.sons[0].ident)
case sw case sw
of wChecks: OnOff(c, n, checksOptions) of wChecks: onOff(c, n, checksOptions)
of wObjChecks: OnOff(c, n, {optObjCheck}) of wObjChecks: onOff(c, n, {optObjCheck})
of wFieldchecks: OnOff(c, n, {optFieldCheck}) of wFieldchecks: onOff(c, n, {optFieldCheck})
of wRangechecks: OnOff(c, n, {optRangeCheck}) of wRangechecks: onOff(c, n, {optRangeCheck})
of wBoundchecks: OnOff(c, n, {optBoundsCheck}) of wBoundchecks: onOff(c, n, {optBoundsCheck})
of wOverflowchecks: OnOff(c, n, {optOverflowCheck}) of wOverflowchecks: onOff(c, n, {optOverflowCheck})
of wNilchecks: OnOff(c, n, {optNilCheck}) of wNilchecks: onOff(c, n, {optNilCheck})
of wFloatChecks: OnOff(c, n, {optNanCheck, optInfCheck}) of wFloatChecks: onOff(c, n, {optNanCheck, optInfCheck})
of wNaNchecks: OnOff(c, n, {optNanCheck}) of wNaNchecks: onOff(c, n, {optNanCheck})
of wInfChecks: OnOff(c, n, {optInfCheck}) of wInfChecks: onOff(c, n, {optInfCheck})
of wAssertions: OnOff(c, n, {optAssert}) of wAssertions: onOff(c, n, {optAssert})
of wWarnings: OnOff(c, n, {optWarns}) of wWarnings: onOff(c, n, {optWarns})
of wHints: OnOff(c, n, {optHints}) of wHints: onOff(c, n, {optHints})
of wCallConv: processCallConv(c, n) of wCallConv: processCallConv(c, n)
of wLinedir: OnOff(c, n, {optLineDir}) of wLinedir: onOff(c, n, {optLineDir})
of wStacktrace: OnOff(c, n, {optStackTrace}) of wStacktrace: onOff(c, n, {optStackTrace})
of wLinetrace: OnOff(c, n, {optLineTrace}) of wLinetrace: onOff(c, n, {optLineTrace})
of wDebugger: OnOff(c, n, {optEndb}) of wDebugger: onOff(c, n, {optEndb})
of wProfiler: OnOff(c, n, {optProfiler}) of wProfiler: onOff(c, n, {optProfiler})
of wByRef: OnOff(c, n, {optByRef}) of wByRef: onOff(c, n, {optByRef})
of wDynLib: processDynLib(c, n, nil) of wDynLib: processDynLib(c, n, nil)
of wOptimization: of wOptimization:
if n.sons[1].kind != nkIdent: if n.sons[1].kind != nkIdent:
@ -319,14 +319,14 @@ proc processOption(c: PContext, n: PNode): bool =
of "none": of "none":
excl(gOptions, optOptimizeSpeed) excl(gOptions, optOptimizeSpeed)
excl(gOptions, optOptimizeSize) excl(gOptions, optOptimizeSize)
else: LocalError(n.info, errNoneSpeedOrSizeExpected) else: localError(n.info, errNoneSpeedOrSizeExpected)
of wImplicitStatic: OnOff(c, n, {optImplicitStatic}) of wImplicitStatic: onOff(c, n, {optImplicitStatic})
of wPatterns: OnOff(c, n, {optPatterns}) of wPatterns: onOff(c, n, {optPatterns})
else: result = true else: result = true
proc processPush(c: PContext, n: PNode, start: int) = proc processPush(c: PContext, n: PNode, start: int) =
if n.sons[start-1].kind == nkExprColonExpr: if n.sons[start-1].kind == nkExprColonExpr:
LocalError(n.info, errGenerated, "':' after 'push' not supported") localError(n.info, errGenerated, "':' after 'push' not supported")
var x = newOptionEntry() var x = newOptionEntry()
var y = POptionEntry(c.optionStack.tail) var y = POptionEntry(c.optionStack.tail)
x.options = gOptions x.options = gOptions
@ -344,7 +344,7 @@ proc processPush(c: PContext, n: PNode, start: int) =
proc processPop(c: PContext, n: PNode) = proc processPop(c: PContext, n: PNode) =
if c.optionStack.counter <= 1: if c.optionStack.counter <= 1:
LocalError(n.info, errAtPopWithoutPush) localError(n.info, errAtPopWithoutPush)
else: else:
gOptions = POptionEntry(c.optionStack.tail).options gOptions = POptionEntry(c.optionStack.tail).options
gNotes = POptionEntry(c.optionStack.tail).notes gNotes = POptionEntry(c.optionStack.tail).notes
@ -352,15 +352,15 @@ proc processPop(c: PContext, n: PNode) =
proc processDefine(c: PContext, n: PNode) = proc processDefine(c: PContext, n: PNode) =
if (n.kind == nkExprColonExpr) and (n.sons[1].kind == nkIdent): if (n.kind == nkExprColonExpr) and (n.sons[1].kind == nkIdent):
DefineSymbol(n.sons[1].ident.s) defineSymbol(n.sons[1].ident.s)
Message(n.info, warnDeprecated, "define") message(n.info, warnDeprecated, "define")
else: else:
invalidPragma(n) invalidPragma(n)
proc processUndef(c: PContext, n: PNode) = proc processUndef(c: PContext, n: PNode) =
if (n.kind == nkExprColonExpr) and (n.sons[1].kind == nkIdent): if (n.kind == nkExprColonExpr) and (n.sons[1].kind == nkIdent):
UndefSymbol(n.sons[1].ident.s) undefSymbol(n.sons[1].ident.s)
Message(n.info, warnDeprecated, "undef") message(n.info, warnDeprecated, "undef")
else: else:
invalidPragma(n) invalidPragma(n)
@ -372,13 +372,13 @@ proc processCompile(c: PContext, n: PNode) =
var s = expectStrLit(c, n) var s = expectStrLit(c, n)
var found = findFile(s) var found = findFile(s)
if found == "": found = s if found == "": found = s
var trunc = ChangeFileExt(found, "") var trunc = changeFileExt(found, "")
extccomp.addExternalFileToCompile(found) extccomp.addExternalFileToCompile(found)
extccomp.addFileToLink(completeCFilePath(trunc, false)) extccomp.addFileToLink(completeCFilePath(trunc, false))
proc processCommonLink(c: PContext, n: PNode, feature: TLinkFeature) = proc processCommonLink(c: PContext, n: PNode, feature: TLinkFeature) =
var f = expectStrLit(c, n) var f = expectStrLit(c, n)
if splitFile(f).ext == "": f = addFileExt(f, cc[ccompiler].objExt) if splitFile(f).ext == "": f = addFileExt(f, CC[cCompiler].objExt)
var found = findFile(f) var found = findFile(f)
if found == "": found = f # use the default if found == "": found = f # use the default
case feature case feature
@ -408,7 +408,7 @@ proc semAsmOrEmit*(con: PContext, n: PNode, marker: char): PNode =
result = newNode(if n.kind == nkAsmStmt: nkAsmStmt else: nkArgList, n.info) result = newNode(if n.kind == nkAsmStmt: nkAsmStmt else: nkArgList, n.info)
var str = n.sons[1].strVal var str = n.sons[1].strVal
if str == "": if str == "":
LocalError(n.info, errEmptyAsm) localError(n.info, errEmptyAsm)
return return
# now parse the string literal and substitute symbols: # now parse the string literal and substitute symbols:
var a = 0 var a = 0
@ -458,9 +458,9 @@ proc pragmaLine(c: PContext, n: PNode) =
if x.kind == nkExprColonExpr: x = x.sons[1] if x.kind == nkExprColonExpr: x = x.sons[1]
if y.kind == nkExprColonExpr: y = y.sons[1] if y.kind == nkExprColonExpr: y = y.sons[1]
if x.kind != nkStrLit: if x.kind != nkStrLit:
LocalError(n.info, errStringLiteralExpected) localError(n.info, errStringLiteralExpected)
elif y.kind != nkIntLit: elif y.kind != nkIntLit:
LocalError(n.info, errIntLiteralExpected) localError(n.info, errIntLiteralExpected)
else: else:
n.info.fileIndex = msgs.fileInfoIdx(x.strVal) n.info.fileIndex = msgs.fileInfoIdx(x.strVal)
n.info.line = int16(y.intVal) n.info.line = int16(y.intVal)
@ -476,11 +476,11 @@ proc processPragma(c: PContext, n: PNode, i: int) =
elif it.sons[0].kind != nkIdent: invalidPragma(n) elif it.sons[0].kind != nkIdent: invalidPragma(n)
elif it.sons[1].kind != nkIdent: invalidPragma(n) elif it.sons[1].kind != nkIdent: invalidPragma(n)
var userPragma = NewSym(skTemplate, it.sons[1].ident, nil, it.info) var userPragma = newSym(skTemplate, it.sons[1].ident, nil, it.info)
var body = newNodeI(nkPragma, n.info) var body = newNodeI(nkPragma, n.info)
for j in i+1 .. sonsLen(n)-1: addSon(body, n.sons[j]) for j in i+1 .. sonsLen(n)-1: addSon(body, n.sons[j])
userPragma.ast = body userPragma.ast = body
StrTableAdd(c.userPragmas, userPragma) strTableAdd(c.userPragmas, userPragma)
proc pragmaRaisesOrTags(c: PContext, n: PNode) = proc pragmaRaisesOrTags(c: PContext, n: PNode) =
proc processExc(c: PContext, x: PNode) = proc processExc(c: PContext, x: PNode) =
@ -503,11 +503,11 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: int,
var it = n.sons[i] var it = n.sons[i]
var key = if it.kind == nkExprColonExpr: it.sons[0] else: it var key = if it.kind == nkExprColonExpr: it.sons[0] else: it
if key.kind == nkIdent: if key.kind == nkIdent:
var userPragma = StrTableGet(c.userPragmas, key.ident) var userPragma = strTableGet(c.userPragmas, key.ident)
if userPragma != nil: if userPragma != nil:
inc c.InstCounter inc c.InstCounter
if c.InstCounter > 100: if c.InstCounter > 100:
GlobalError(it.info, errRecursiveDependencyX, userPragma.name.s) globalError(it.info, errRecursiveDependencyX, userPragma.name.s)
pragma(c, sym, userPragma.ast, validPragmas) pragma(c, sym, userPragma.ast, validPragmas)
dec c.InstCounter dec c.InstCounter
else: else:
@ -534,15 +534,15 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: int,
of wAlign: of wAlign:
if sym.typ == nil: invalidPragma(it) if sym.typ == nil: invalidPragma(it)
var align = expectIntLit(c, it) var align = expectIntLit(c, it)
if not IsPowerOfTwo(align) and align != 0: if not isPowerOfTwo(align) and align != 0:
LocalError(it.info, errPowerOfTwoExpected) localError(it.info, errPowerOfTwoExpected)
else: else:
sym.typ.align = align sym.typ.align = align
of wSize: of wSize:
if sym.typ == nil: invalidPragma(it) if sym.typ == nil: invalidPragma(it)
var size = expectIntLit(c, it) var size = expectIntLit(c, it)
if not IsPowerOfTwo(size) or size <= 0 or size > 8: if not isPowerOfTwo(size) or size <= 0 or size > 8:
LocalError(it.info, errPowerOfTwoExpected) localError(it.info, errPowerOfTwoExpected)
else: else:
sym.typ.size = size sym.typ.size = size
of wNodecl: of wNodecl:
@ -572,7 +572,7 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: int,
incl(sym.flags, sfGlobal) incl(sym.flags, sfGlobal)
incl(sym.flags, sfPure) incl(sym.flags, sfPure)
of wMerge: of wMerge:
noval(it) noVal(it)
incl(sym.flags, sfMerge) incl(sym.flags, sfMerge)
of wHeader: of wHeader:
var lib = getLib(c, libHeader, getStrLitNode(c, it)) var lib = getLib(c, libHeader, getStrLitNode(c, it))
@ -640,8 +640,8 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: int,
incl(sym.flags, sfThread) incl(sym.flags, sfThread)
incl(sym.flags, sfProcVar) incl(sym.flags, sfProcVar)
if sym.typ != nil: incl(sym.typ.flags, tfThread) if sym.typ != nil: incl(sym.typ.flags, tfThread)
of wHint: Message(it.info, hintUser, expectStrLit(c, it)) of wHint: message(it.info, hintUser, expectStrLit(c, it))
of wWarning: Message(it.info, warnUser, expectStrLit(c, it)) of wWarning: message(it.info, warnUser, expectStrLit(c, it))
of wError: of wError:
if sym != nil and sym.isRoutine: if sym != nil and sym.isRoutine:
# This is subtle but correct: the error *statement* is only # This is subtle but correct: the error *statement* is only
@ -651,8 +651,8 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: int,
noVal(it) noVal(it)
incl(sym.flags, sfError) incl(sym.flags, sfError)
else: else:
LocalError(it.info, errUser, expectStrLit(c, it)) localError(it.info, errUser, expectStrLit(c, it))
of wFatal: Fatal(it.info, errUser, expectStrLit(c, it)) of wFatal: fatal(it.info, errUser, expectStrLit(c, it))
of wDefine: processDefine(c, it) of wDefine: processDefine(c, it)
of wUndef: processUndef(c, it) of wUndef: processUndef(c, it)
of wCompile: processCompile(c, it) of wCompile: processCompile(c, it)
@ -660,8 +660,8 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: int,
of wLinkSys: processCommonLink(c, it, linkSys) of wLinkSys: processCommonLink(c, it, linkSys)
of wPassL: extccomp.addLinkOption(expectStrLit(c, it)) of wPassL: extccomp.addLinkOption(expectStrLit(c, it))
of wPassC: extccomp.addCompileOption(expectStrLit(c, it)) of wPassC: extccomp.addCompileOption(expectStrLit(c, it))
of wBreakpoint: PragmaBreakpoint(c, it) of wBreakpoint: pragmaBreakpoint(c, it)
of wWatchpoint: PragmaWatchpoint(c, it) of wWatchpoint: pragmaWatchpoint(c, it)
of wPush: of wPush:
processPush(c, n, i + 1) processPush(c, n, i + 1)
result = true result = true
@ -684,13 +684,13 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: int,
wPatterns: wPatterns:
if processOption(c, it): if processOption(c, it):
# calling conventions (boring...): # calling conventions (boring...):
LocalError(it.info, errOptionExpected) localError(it.info, errOptionExpected)
of firstCallConv..lastCallConv: of firstCallConv..lastCallConv:
assert(sym != nil) assert(sym != nil)
if sym.typ == nil: invalidPragma(it) if sym.typ == nil: invalidPragma(it)
else: sym.typ.callConv = wordToCallConv(k) else: sym.typ.callConv = wordToCallConv(k)
of wEmit: PragmaEmit(c, it) of wEmit: pragmaEmit(c, it)
of wUnroll: PragmaUnroll(c, it) of wUnroll: pragmaUnroll(c, it)
of wLinearScanEnd, wComputedGoto: noVal(it) of wLinearScanEnd, wComputedGoto: noVal(it)
of wEffects: of wEffects:
# is later processed in effect analysis: # is later processed in effect analysis:
@ -706,7 +706,7 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: int,
of wByRef: of wByRef:
noVal(it) noVal(it)
if sym == nil or sym.typ == nil: if sym == nil or sym.typ == nil:
if processOption(c, it): LocalError(it.info, errOptionExpected) if processOption(c, it): localError(it.info, errOptionExpected)
else: else:
incl(sym.typ.flags, tfByRef) incl(sym.typ.flags, tfByRef)
of wByCopy: of wByCopy:
@ -718,7 +718,7 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: int,
# as they are handled directly in 'evalTemplate'. # as they are handled directly in 'evalTemplate'.
noVal(it) noVal(it)
if sym == nil: invalidPragma(it) if sym == nil: invalidPragma(it)
of wLine: PragmaLine(c, it) of wLine: pragmaLine(c, it)
of wRaises, wTags: pragmaRaisesOrTags(c, it) of wRaises, wTags: pragmaRaisesOrTags(c, it)
of wOperator: of wOperator:
if sym == nil: invalidPragma(it) if sym == nil: invalidPragma(it)
@ -741,11 +741,11 @@ proc implictPragmas*(c: PContext, sym: PSym, n: PNode,
if not o.isNil: if not o.isNil:
for i in countup(0, sonsLen(o) - 1): for i in countup(0, sonsLen(o) - 1):
if singlePragma(c, sym, o, i, validPragmas): if singlePragma(c, sym, o, i, validPragmas):
InternalError(n.info, "implicitPragmas") internalError(n.info, "implicitPragmas")
it = it.next.POptionEntry it = it.next.POptionEntry
if lfExportLib in sym.loc.flags and sfExportc notin sym.flags: if lfExportLib in sym.loc.flags and sfExportc notin sym.flags:
LocalError(n.info, errDynlibRequiresExportc) localError(n.info, errDynlibRequiresExportc)
var lib = POptionEntry(c.optionstack.tail).dynlib var lib = POptionEntry(c.optionstack.tail).dynlib
if {lfDynamicLib, lfHeader} * sym.loc.flags == {} and if {lfDynamicLib, lfHeader} * sym.loc.flags == {} and
sfImportc in sym.flags and lib != nil: sfImportc in sym.flags and lib != nil:

4
compiler/pretty.nim
View file

@ -46,7 +46,7 @@ proc loadFile(info: TLineInfo) =
proc overwriteFiles*() = proc overwriteFiles*() =
for i in 0 .. high(gSourceFiles): for i in 0 .. high(gSourceFiles):
if not gSourceFiles[i].dirty: continue if not gSourceFiles[i].dirty: continue
let newFile = gSourceFiles[i].fullpath.changeFileExt(".pretty.nim") let newFile = gSourceFiles[i].fullpath #.changeFileExt(".pretty.nim")
try: try:
var f = open(newFile, fmWrite) var f = open(newFile, fmWrite)
for line in gSourceFiles[i].lines: for line in gSourceFiles[i].lines:
@ -167,7 +167,7 @@ proc checkUse(c: PGen; n: PNode) =
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: when removeTP:
# the WinAPI module is full of 'TX = X' which after the substitution # the WinAPI module is full of 'TX = X' which after the substitution
# becomes 'X = X'. We remove those lines: # becomes 'X = X'. We remove those lines:

10
compiler/procfind.nim
View file

@ -44,12 +44,12 @@ proc searchForProc*(c: PContext, scope: PScope, fn: PSym): PSym =
if result.Kind == fn.kind and isGenericRoutine(result): if result.Kind == fn.kind and isGenericRoutine(result):
let genR = result.ast.sons[genericParamsPos] let genR = result.ast.sons[genericParamsPos]
let genF = fn.ast.sons[genericParamsPos] let genF = fn.ast.sons[genericParamsPos]
if ExprStructuralEquivalent(genR, genF) and if exprStructuralEquivalent(genR, genF) and
ExprStructuralEquivalent(result.ast.sons[paramsPos], exprStructuralEquivalent(result.ast.sons[paramsPos],
fn.ast.sons[paramsPos]) and fn.ast.sons[paramsPos]) and
equalGenericParams(genR, genF): equalGenericParams(genR, genF):
return return
result = NextIdentIter(it, scope.symbols) result = nextIdentIter(it, scope.symbols)
else: else:
while result != nil: while result != nil:
if result.Kind == fn.kind and not isGenericRoutine(result): if result.Kind == fn.kind and not isGenericRoutine(result):
@ -57,11 +57,11 @@ proc searchForProc*(c: PContext, scope: PScope, fn: PSym): PSym =
of paramsEqual: of paramsEqual:
return return
of paramsIncompatible: of paramsIncompatible:
LocalError(fn.info, errNotOverloadable, fn.name.s) localError(fn.info, errNotOverloadable, fn.name.s)
return return
of paramsNotEqual: of paramsNotEqual:
nil nil
result = NextIdentIter(it, scope.symbols) result = nextIdentIter(it, scope.symbols)
when false: when false:
proc paramsFitBorrow(child, parent: PNode): bool = proc paramsFitBorrow(child, parent: PNode): bool =

20
compiler/renderer.nim
View file

@ -76,7 +76,7 @@ proc initSrcGen(g: var TSrcGen, renderFlags: TRenderFlags) =
proc addTok(g: var TSrcGen, kind: TTokType, s: string) = proc addTok(g: var TSrcGen, kind: TTokType, s: string) =
var length = len(g.tokens) var length = len(g.tokens)
setlen(g.tokens, length + 1) setLen(g.tokens, length + 1)
g.tokens[length].kind = kind g.tokens[length].kind = kind
g.tokens[length].length = int16(len(s)) g.tokens[length].length = int16(len(s))
add(g.buf, s) add(g.buf, s)
@ -127,7 +127,7 @@ proc putLong(g: var TSrcGen, kind: TTokType, s: string, lineLen: int) =
addTok(g, kind, s) addTok(g, kind, s)
g.lineLen = lineLen g.lineLen = lineLen
proc toNimChar(c: Char): string = proc toNimChar(c: char): string =
case c case c
of '\0': result = "\\0" of '\0': result = "\\0"
of '\x01'..'\x1F', '\x80'..'\xFF': result = "\\x" & strutils.toHex(ord(c), 2) of '\x01'..'\x1F', '\x80'..'\xFF': result = "\\x" & strutils.toHex(ord(c), 2)
@ -241,14 +241,14 @@ proc containsNL(s: string): bool =
proc pushCom(g: var TSrcGen, n: PNode) = proc pushCom(g: var TSrcGen, n: PNode) =
var length = len(g.comStack) var length = len(g.comStack)
setlen(g.comStack, length + 1) setLen(g.comStack, length + 1)
g.comStack[length] = n g.comStack[length] = n
proc popAllComs(g: var TSrcGen) = proc popAllComs(g: var TSrcGen) =
setlen(g.comStack, 0) setLen(g.comStack, 0)
proc popCom(g: var TSrcGen) = proc popCom(g: var TSrcGen) =
setlen(g.comStack, len(g.comStack) - 1) setLen(g.comStack, len(g.comStack) - 1)
const const
Space = " " Space = " "
@ -278,7 +278,7 @@ proc gcoms(g: var TSrcGen) =
popAllComs(g) popAllComs(g)
proc lsub(n: PNode): int proc lsub(n: PNode): int
proc litAux(n: PNode, x: biggestInt, size: int): string = proc litAux(n: PNode, x: BiggestInt, size: int): string =
proc skip(t: PType): PType = proc skip(t: PType): PType =
result = t result = t
while result.kind in {tyGenericInst, tyRange, tyVar, tyDistinct, tyOrdinal, while result.kind in {tyGenericInst, tyRange, tyVar, tyDistinct, tyOrdinal,
@ -295,7 +295,7 @@ proc litAux(n: PNode, x: biggestInt, size: int): string =
elif nfBase16 in n.flags: result = "0x" & toHex(x, size * 2) elif nfBase16 in n.flags: result = "0x" & toHex(x, size * 2)
else: result = $x else: result = $x
proc ulitAux(n: PNode, x: biggestInt, size: int): string = proc ulitAux(n: PNode, x: BiggestInt, size: int): string =
if nfBase2 in n.flags: result = "0b" & toBin(x, size * 8) if nfBase2 in n.flags: result = "0b" & toBin(x, size * 8)
elif nfBase8 in n.flags: result = "0o" & toOct(x, size * 3) elif nfBase8 in n.flags: result = "0o" & toOct(x, size * 3)
elif nfBase16 in n.flags: result = "0x" & toHex(x, size * 2) elif nfBase16 in n.flags: result = "0x" & toHex(x, size * 2)
@ -341,7 +341,7 @@ proc atom(n: PNode): string =
if (n.typ != nil) and (n.typ.sym != nil): result = n.typ.sym.name.s if (n.typ != nil) and (n.typ.sym != nil): result = n.typ.sym.name.s
else: result = "[type node]" else: result = "[type node]"
else: else:
InternalError("rnimsyn.atom " & $n.kind) internalError("rnimsyn.atom " & $n.kind)
result = "" result = ""
proc lcomma(n: PNode, start: int = 0, theEnd: int = - 1): int = proc lcomma(n: PNode, start: int = 0, theEnd: int = - 1): int =
@ -1252,7 +1252,7 @@ proc gsub(g: var TSrcGen, n: PNode, c: TContext) =
put(g, tkParRi, ")") put(g, tkParRi, ")")
else: else:
#nkNone, nkExplicitTypeListCall: #nkNone, nkExplicitTypeListCall:
InternalError(n.info, "rnimsyn.gsub(" & $n.kind & ')') internalError(n.info, "rnimsyn.gsub(" & $n.kind & ')')
proc renderTree(n: PNode, renderFlags: TRenderFlags = {}): string = proc renderTree(n: PNode, renderFlags: TRenderFlags = {}): string =
var g: TSrcGen var g: TSrcGen
@ -1263,7 +1263,7 @@ proc renderTree(n: PNode, renderFlags: TRenderFlags = {}): string =
proc renderModule(n: PNode, filename: string, proc renderModule(n: PNode, filename: string,
renderFlags: TRenderFlags = {}) = renderFlags: TRenderFlags = {}) =
var var
f: tfile f: TFile
g: TSrcGen g: TSrcGen
initSrcGen(g, renderFlags) initSrcGen(g, renderFlags)
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):

108
compiler/rodread.nim
View file

@ -306,7 +306,7 @@ proc decodeType(r: PRodReader, info: TLineInfo): PType =
internalError(info, "decodeType: no id") internalError(info, "decodeType: no id")
# here this also avoids endless recursion for recursive type # here this also avoids endless recursion for recursive type
idTablePut(gTypeTable, result, result) idTablePut(gTypeTable, result, result)
if r.s[r.pos] == '(': result.n = decodeNode(r, UnknownLineInfo()) if r.s[r.pos] == '(': result.n = decodeNode(r, unknownLineInfo())
if r.s[r.pos] == '$': if r.s[r.pos] == '$':
inc(r.pos) inc(r.pos)
result.flags = cast[TTypeFlags](int32(decodeVInt(r.s, r.pos))) result.flags = cast[TTypeFlags](int32(decodeVInt(r.s, r.pos)))
@ -335,7 +335,7 @@ proc decodeType(r: PRodReader, info: TLineInfo): PType =
if r.s[r.pos] == '(': if r.s[r.pos] == '(':
inc(r.pos) inc(r.pos)
if r.s[r.pos] == ')': inc(r.pos) if r.s[r.pos] == ')': inc(r.pos)
else: InternalError(info, "decodeType ^(" & r.s[r.pos]) else: internalError(info, "decodeType ^(" & r.s[r.pos])
rawAddSon(result, nil) rawAddSon(result, nil)
else: else:
var d = decodeVInt(r.s, r.pos) var d = decodeVInt(r.s, r.pos)
@ -347,10 +347,10 @@ proc decodeLib(r: PRodReader, info: TLineInfo): PLib =
new(result) new(result)
inc(r.pos) inc(r.pos)
result.kind = TLibKind(decodeVInt(r.s, r.pos)) result.kind = TLibKind(decodeVInt(r.s, r.pos))
if r.s[r.pos] != '|': InternalError("decodeLib: 1") if r.s[r.pos] != '|': internalError("decodeLib: 1")
inc(r.pos) inc(r.pos)
result.name = toRope(decodeStr(r.s, r.pos)) result.name = toRope(decodeStr(r.s, r.pos))
if r.s[r.pos] != '|': InternalError("decodeLib: 2") if r.s[r.pos] != '|': internalError("decodeLib: 2")
inc(r.pos) inc(r.pos)
result.path = decodeNode(r, info) result.path = decodeNode(r, info)
@ -375,13 +375,13 @@ proc decodeSym(r: PRodReader, info: TLineInfo): PSym =
inc(r.pos) inc(r.pos)
ident = getIdent(decodeStr(r.s, r.pos)) ident = getIdent(decodeStr(r.s, r.pos))
else: else:
InternalError(info, "decodeSym: no ident") internalError(info, "decodeSym: no ident")
#echo "decoding: {", ident.s #echo "decoding: {", ident.s
result = PSym(IdTableGet(r.syms, id)) result = PSym(idTableGet(r.syms, id))
if result == nil: if result == nil:
new(result) new(result)
result.id = id result.id = id
IdTablePut(r.syms, result, result) idTablePut(r.syms, result, result)
if debugIds: registerID(result) if debugIds: registerID(result)
elif result.id != id: elif result.id != id:
internalError(info, "decodeSym: wrong id") internalError(info, "decodeSym: wrong id")
@ -427,7 +427,7 @@ proc decodeSym(r: PRodReader, info: TLineInfo): PSym =
result.annex = decodeLib(r, info) result.annex = decodeLib(r, info)
if r.s[r.pos] == '#': if r.s[r.pos] == '#':
inc(r.pos) inc(r.pos)
result.constraint = decodeNode(r, UnknownLineInfo()) result.constraint = decodeNode(r, unknownLineInfo())
if r.s[r.pos] == '(': if r.s[r.pos] == '(':
if result.kind in routineKinds: if result.kind in routineKinds:
result.ast = decodeNodeLazyBody(r, result.info, result) result.ast = decodeNodeLazyBody(r, result.info, result)
@ -458,7 +458,7 @@ proc skipSection(r: PRodReader) =
else: discard else: discard
inc(r.pos) inc(r.pos)
else: else:
InternalError("skipSection " & $r.line) internalError("skipSection " & $r.line)
proc rdWord(r: PRodReader): string = proc rdWord(r: PRodReader): string =
result = "" result = ""
@ -472,11 +472,11 @@ proc newStub(r: PRodReader, name: string, id: int): PSym =
result.id = id result.id = id
result.name = getIdent(name) result.name = getIdent(name)
result.position = r.readerIndex result.position = r.readerIndex
setID(id) #MessageOut(result.name.s); setId(id) #MessageOut(result.name.s);
if debugIds: registerID(result) if debugIds: registerID(result)
proc processInterf(r: PRodReader, module: PSym) = proc processInterf(r: PRodReader, module: PSym) =
if r.interfIdx == 0: InternalError("processInterf") if r.interfIdx == 0: internalError("processInterf")
r.pos = r.interfIdx r.pos = r.interfIdx
while (r.s[r.pos] > '\x0A') and (r.s[r.pos] != ')'): while (r.s[r.pos] > '\x0A') and (r.s[r.pos] != ')'):
var w = decodeStr(r.s, r.pos) var w = decodeStr(r.s, r.pos)
@ -485,23 +485,23 @@ proc processInterf(r: PRodReader, module: PSym) =
inc(r.pos) # #10 inc(r.pos) # #10
var s = newStub(r, w, key) var s = newStub(r, w, key)
s.owner = module s.owner = module
StrTableAdd(module.tab, s) strTableAdd(module.tab, s)
IdTablePut(r.syms, s, s) idTablePut(r.syms, s, s)
proc processCompilerProcs(r: PRodReader, module: PSym) = proc processCompilerProcs(r: PRodReader, module: PSym) =
if r.compilerProcsIdx == 0: InternalError("processCompilerProcs") if r.compilerProcsIdx == 0: internalError("processCompilerProcs")
r.pos = r.compilerProcsIdx r.pos = r.compilerProcsIdx
while (r.s[r.pos] > '\x0A') and (r.s[r.pos] != ')'): while (r.s[r.pos] > '\x0A') and (r.s[r.pos] != ')'):
var w = decodeStr(r.s, r.pos) var w = decodeStr(r.s, r.pos)
inc(r.pos) inc(r.pos)
var key = decodeVInt(r.s, r.pos) var key = decodeVInt(r.s, r.pos)
inc(r.pos) # #10 inc(r.pos) # #10
var s = PSym(IdTableGet(r.syms, key)) var s = PSym(idTableGet(r.syms, key))
if s == nil: if s == nil:
s = newStub(r, w, key) s = newStub(r, w, key)
s.owner = module s.owner = module
IdTablePut(r.syms, s, s) idTablePut(r.syms, s, s)
StrTableAdd(rodCompilerProcs, s) strTableAdd(rodCompilerprocs, s)
proc processIndex(r: PRodReader; idx: var TIndex; outf: TFile = nil) = proc processIndex(r: PRodReader; idx: var TIndex; outf: TFile = nil) =
var key, val, tmp: int var key, val, tmp: int
@ -516,11 +516,11 @@ proc processIndex(r: PRodReader; idx: var TIndex; outf: TFile = nil) =
else: else:
key = idx.lastIdxKey + 1 key = idx.lastIdxKey + 1
val = tmp + idx.lastIdxVal val = tmp + idx.lastIdxVal
IITablePut(idx.tab, key, val) iiTablePut(idx.tab, key, val)
if not outf.isNil: outf.write(key, " ", val, "\n") if not outf.isNil: outf.write(key, " ", val, "\n")
idx.lastIdxKey = key idx.lastIdxKey = key
idx.lastIdxVal = val idx.lastIdxVal = val
setID(key) # ensure that this id will not be used setId(key) # ensure that this id will not be used
if r.s[r.pos] == '\x0A': if r.s[r.pos] == '\x0A':
inc(r.pos) inc(r.pos)
inc(r.line) inc(r.line)
@ -558,7 +558,7 @@ proc processRodFile(r: PRodReader, crc: TCrc32) =
of "ID": of "ID":
inc(r.pos) # skip ':' inc(r.pos) # skip ':'
r.moduleID = decodeVInt(r.s, r.pos) r.moduleID = decodeVInt(r.s, r.pos)
setID(r.moduleID) setId(r.moduleID)
of "ORIGFILE": of "ORIGFILE":
inc(r.pos) inc(r.pos)
r.origFile = decodeStr(r.s, r.pos) r.origFile = decodeStr(r.s, r.pos)
@ -603,7 +603,7 @@ proc processRodFile(r: PRodReader, crc: TCrc32) =
inc(r.pos) # skip ' ' inc(r.pos) # skip ' '
inclCrc = decodeVInt(r.s, r.pos) inclCrc = decodeVInt(r.s, r.pos)
if r.reason == rrNone: if r.reason == rrNone:
if not ExistsFile(w) or (inclCrc != int(crcFromFile(w))): if not existsFile(w) or (inclCrc != int(crcFromFile(w))):
r.reason = rrInclDeps r.reason = rrInclDeps
if r.s[r.pos] == '\x0A': if r.s[r.pos] == '\x0A':
inc(r.pos) inc(r.pos)
@ -639,7 +639,7 @@ proc processRodFile(r: PRodReader, crc: TCrc32) =
r.initIdx = r.pos + 2 # "(\10" r.initIdx = r.pos + 2 # "(\10"
skipSection(r) skipSection(r)
else: else:
InternalError("invalid section: '" & section & internalError("invalid section: '" & section &
"' at " & $r.line & " in " & r.filename) "' at " & $r.line & " in " & r.filename)
#MsgWriteln("skipping section: " & section & #MsgWriteln("skipping section: " & section &
# " at " & $r.line & " in " & r.filename) # " at " & $r.line & " in " & r.filename)
@ -670,13 +670,13 @@ proc newRodReader(modfilename: string, crc: TCrc32,
r.line = 1 r.line = 1
r.readerIndex = readerIndex r.readerIndex = readerIndex
r.filename = modfilename r.filename = modfilename
InitIdTable(r.syms) initIdTable(r.syms)
# we terminate the file explicitely with ``\0``, so the cast to `cstring` # we terminate the file explicitely with ``\0``, so the cast to `cstring`
# is safe: # is safe:
r.s = cast[cstring](r.memFile.mem) r.s = cast[cstring](r.memFile.mem)
if startsWith(r.s, "NIM:"): if startsWith(r.s, "NIM:"):
initIITable(r.index.tab) initIiTable(r.index.tab)
initIITable(r.imports.tab) # looks like a ROD file initIiTable(r.imports.tab) # looks like a ROD file
inc(r.pos, 4) inc(r.pos, 4)
var version = "" var version = ""
while r.s[r.pos] notin {'\0', '\x0A'}: while r.s[r.pos] notin {'\0', '\x0A'}:
@ -691,12 +691,12 @@ proc newRodReader(modfilename: string, crc: TCrc32,
result = nil result = nil
proc rrGetType(r: PRodReader, id: int, info: TLineInfo): PType = proc rrGetType(r: PRodReader, id: int, info: TLineInfo): PType =
result = PType(IdTableGet(gTypeTable, id)) result = PType(idTableGet(gTypeTable, id))
if result == nil: if result == nil:
# load the type: # load the type:
var oldPos = r.pos var oldPos = r.pos
var d = IITableGet(r.index.tab, id) var d = iiTableGet(r.index.tab, id)
if d == invalidKey: InternalError(info, "rrGetType") if d == invalidKey: internalError(info, "rrGetType")
r.pos = d + r.dataIdx r.pos = d + r.dataIdx
result = decodeType(r, info) result = decodeType(r, info)
r.pos = oldPos r.pos = oldPos
@ -715,7 +715,7 @@ var gMods*: TFileModuleMap = @[]
proc decodeSymSafePos(rd: PRodReader, offset: int, info: TLineInfo): PSym = proc decodeSymSafePos(rd: PRodReader, offset: int, info: TLineInfo): PSym =
# all compiled modules # all compiled modules
if rd.dataIdx == 0: InternalError(info, "dataIdx == 0") if rd.dataIdx == 0: internalError(info, "dataIdx == 0")
var oldPos = rd.pos var oldPos = rd.pos
rd.pos = offset + rd.dataIdx rd.pos = offset + rd.dataIdx
result = decodeSym(rd, info) result = decodeSym(rd, info)
@ -725,7 +725,7 @@ proc findSomeWhere(id: int) =
for i in countup(0, high(gMods)): for i in countup(0, high(gMods)):
var rd = gMods[i].rd var rd = gMods[i].rd
if rd != nil: if rd != nil:
var d = IITableGet(rd.index.tab, id) var d = iiTableGet(rd.index.tab, id)
if d != invalidKey: if d != invalidKey:
echo "found id ", id, " in ", gMods[i].filename echo "found id ", id, " in ", gMods[i].filename
@ -740,33 +740,33 @@ proc getReader(moduleId: int): PRodReader =
return nil return nil
proc rrGetSym(r: PRodReader, id: int, info: TLineInfo): PSym = proc rrGetSym(r: PRodReader, id: int, info: TLineInfo): PSym =
result = PSym(IdTableGet(r.syms, id)) result = PSym(idTableGet(r.syms, id))
if result == nil: if result == nil:
# load the symbol: # load the symbol:
var d = IITableGet(r.index.tab, id) var d = iiTableGet(r.index.tab, id)
if d == invalidKey: if d == invalidKey:
# import from other module: # import from other module:
var moduleID = IiTableGet(r.imports.tab, id) var moduleID = iiTableGet(r.imports.tab, id)
if moduleID < 0: if moduleID < 0:
var x = "" var x = ""
encodeVInt(id, x) encodeVInt(id, x)
InternalError(info, "missing from both indexes: +" & x) internalError(info, "missing from both indexes: +" & x)
var rd = getReader(moduleID) var rd = getReader(moduleID)
d = IITableGet(rd.index.tab, id) d = iiTableGet(rd.index.tab, id)
if d != invalidKey: if d != invalidKey:
result = decodeSymSafePos(rd, d, info) result = decodeSymSafePos(rd, d, info)
else: else:
var x = "" var x = ""
encodeVInt(id, x) encodeVInt(id, x)
when false: findSomeWhere(id) when false: findSomeWhere(id)
InternalError(info, "rrGetSym: no reader found: +" & x) internalError(info, "rrGetSym: no reader found: +" & x)
else: else:
# own symbol: # own symbol:
result = decodeSymSafePos(r, d, info) result = decodeSymSafePos(r, d, info)
if result != nil and result.kind == skStub: rawLoadStub(result) if result != nil and result.kind == skStub: rawLoadStub(result)
proc loadInitSection(r: PRodReader): PNode = proc loadInitSection(r: PRodReader): PNode =
if r.initIdx == 0 or r.dataIdx == 0: InternalError("loadInitSection") if r.initIdx == 0 or r.dataIdx == 0: internalError("loadInitSection")
var oldPos = r.pos var oldPos = r.pos
r.pos = r.initIdx r.pos = r.initIdx
result = newNode(nkStmtList) result = newNode(nkStmtList)
@ -775,7 +775,7 @@ proc loadInitSection(r: PRodReader): PNode =
inc(r.pos) # #10 inc(r.pos) # #10
var p = r.pos var p = r.pos
r.pos = d + r.dataIdx r.pos = d + r.dataIdx
addSon(result, decodeNode(r, UnknownLineInfo())) addSon(result, decodeNode(r, unknownLineInfo()))
r.pos = p r.pos = p
r.pos = oldPos r.pos = oldPos
@ -783,20 +783,20 @@ proc loadConverters(r: PRodReader) =
# We have to ensure that no exported converter is a stub anymore, and the # We have to ensure that no exported converter is a stub anymore, and the
# import mechanism takes care of the rest. # import mechanism takes care of the rest.
if r.convertersIdx == 0 or r.dataIdx == 0: if r.convertersIdx == 0 or r.dataIdx == 0:
InternalError("importConverters") internalError("importConverters")
r.pos = r.convertersIdx r.pos = r.convertersIdx
while r.s[r.pos] > '\x0A': while r.s[r.pos] > '\x0A':
var d = decodeVInt(r.s, r.pos) var d = decodeVInt(r.s, r.pos)
discard rrGetSym(r, d, UnknownLineInfo()) discard rrGetSym(r, d, unknownLineInfo())
if r.s[r.pos] == ' ': inc(r.pos) if r.s[r.pos] == ' ': inc(r.pos)
proc loadMethods(r: PRodReader) = proc loadMethods(r: PRodReader) =
if r.methodsIdx == 0 or r.dataIdx == 0: if r.methodsIdx == 0 or r.dataIdx == 0:
InternalError("loadMethods") internalError("loadMethods")
r.pos = r.methodsIdx r.pos = r.methodsIdx
while r.s[r.pos] > '\x0A': while r.s[r.pos] > '\x0A':
var d = decodeVInt(r.s, r.pos) var d = decodeVInt(r.s, r.pos)
r.methods.add(rrGetSym(r, d, UnknownLineInfo())) r.methods.add(rrGetSym(r, d, unknownLineInfo()))
if r.s[r.pos] == ' ': inc(r.pos) if r.s[r.pos] == ' ': inc(r.pos)
proc getCRC*(fileIdx: int32): TCrc32 = proc getCRC*(fileIdx: int32): TCrc32 =
@ -834,7 +834,7 @@ proc checkDep(fileIdx: int32): TReasonForRecompile =
# NOTE: we need to process the entire module graph so that no ID will # NOTE: we need to process the entire module graph so that no ID will
# be used twice! However, compilation speed does not suffer much from # be used twice! However, compilation speed does not suffer much from
# this, since results are cached. # this, since results are cached.
var res = checkDep(SystemFileIdx) var res = checkDep(systemFileIdx)
if res != rrNone: result = rrModDeps if res != rrNone: result = rrModDeps
for i in countup(0, high(r.modDeps)): for i in countup(0, high(r.modDeps)):
res = checkDep(r.modDeps[i]) res = checkDep(r.modDeps[i])
@ -858,11 +858,11 @@ proc handleSymbolFile(module: PSym): PRodReader =
idgen.loadMaxIds(options.gProjectPath / options.gProjectName) idgen.loadMaxIds(options.gProjectPath / options.gProjectName)
discard checkDep(fileIdx) discard checkDep(fileIdx)
if gMods[fileIdx].reason == rrEmpty: InternalError("handleSymbolFile") if gMods[fileIdx].reason == rrEmpty: internalError("handleSymbolFile")
result = gMods[fileIdx].rd result = gMods[fileIdx].rd
if result != nil: if result != nil:
module.id = result.moduleID module.id = result.moduleID
IdTablePut(result.syms, module, module) idTablePut(result.syms, module, module)
processInterf(result, module) processInterf(result, module)
processCompilerProcs(result, module) processCompilerProcs(result, module)
loadConverters(result) loadConverters(result)
@ -871,12 +871,12 @@ proc handleSymbolFile(module: PSym): PRodReader =
module.id = getID() module.id = getID()
proc rawLoadStub(s: PSym) = proc rawLoadStub(s: PSym) =
if s.kind != skStub: InternalError("loadStub") if s.kind != skStub: internalError("loadStub")
var rd = gMods[s.position].rd var rd = gMods[s.position].rd
var theId = s.id # used for later check var theId = s.id # used for later check
var d = IITableGet(rd.index.tab, s.id) var d = iiTableGet(rd.index.tab, s.id)
if d == invalidKey: InternalError("loadStub: invalid key") if d == invalidKey: internalError("loadStub: invalid key")
var rs = decodeSymSafePos(rd, d, UnknownLineInfo()) var rs = decodeSymSafePos(rd, d, unknownLineInfo())
if rs != s: if rs != s:
#echo "rs: ", toHex(cast[int](rs.position), int.sizeof * 2), #echo "rs: ", toHex(cast[int](rs.position), int.sizeof * 2),
# "\ns: ", toHex(cast[int](s.position), int.sizeof * 2) # "\ns: ", toHex(cast[int](s.position), int.sizeof * 2)
@ -913,7 +913,7 @@ proc getBody*(s: PSym): PNode =
s.offset = 0 s.offset = 0
initIdTable(gTypeTable) initIdTable(gTypeTable)
initStrTable(rodCompilerProcs) initStrTable(rodCompilerprocs)
# viewer: # viewer:
proc writeNode(f: TFile; n: PNode) = proc writeNode(f: TFile; n: PNode) =
@ -1038,7 +1038,7 @@ proc viewFile(rodfile: string) =
of "ID": of "ID":
inc(r.pos) # skip ':' inc(r.pos) # skip ':'
r.moduleID = decodeVInt(r.s, r.pos) r.moduleID = decodeVInt(r.s, r.pos)
setID(r.moduleID) setId(r.moduleID)
outf.writeln("ID:", $r.moduleID) outf.writeln("ID:", $r.moduleID)
of "ORIGFILE": of "ORIGFILE":
inc(r.pos) inc(r.pos)
@ -1140,12 +1140,12 @@ proc viewFile(rodfile: string) =
outf.write("DATA(\n") outf.write("DATA(\n")
while r.s[r.pos] != ')': while r.s[r.pos] != ')':
if r.s[r.pos] == '(': if r.s[r.pos] == '(':
outf.writeNode decodeNode(r, UnknownLineInfo()) outf.writeNode decodeNode(r, unknownLineInfo())
outf.write("\n") outf.write("\n")
elif r.s[r.pos] == '[': elif r.s[r.pos] == '[':
outf.writeType decodeType(r, UnknownLineInfo()) outf.writeType decodeType(r, unknownLineInfo())
else: else:
outf.writeSym decodeSym(r, UnknownLineInfo()) outf.writeSym decodeSym(r, unknownLineInfo())
if r.s[r.pos] == '\x0A': if r.s[r.pos] == '\x0A':
inc(r.pos) inc(r.pos)
inc(r.line) inc(r.line)

2
compiler/rodutils.nim
View file

@ -119,7 +119,7 @@ template decodeIntImpl() =
proc decodeVInt*(s: cstring, pos: var int): int = proc decodeVInt*(s: cstring, pos: var int): int =
decodeIntImpl() decodeIntImpl()
proc decodeVBiggestInt*(s: cstring, pos: var int): biggestInt = proc decodeVBiggestInt*(s: cstring, pos: var int): BiggestInt =
decodeIntImpl() decodeIntImpl()
iterator decodeVIntArray*(s: cstring): int = iterator decodeVIntArray*(s: cstring): int =

52
compiler/rodwrite.nim
View file

@ -56,7 +56,7 @@ proc fileIdx(w: PRodWriter, filename: string): int =
if w.files[i] == filename: if w.files[i] == filename:
return i return i
result = len(w.files) result = len(w.files)
setlen(w.files, result + 1) setLen(w.files, result + 1)
w.files[result] = filename w.files[result] = filename
template filename*(w: PRodWriter): string = template filename*(w: PRodWriter): string =
@ -66,8 +66,8 @@ proc newRodWriter(crc: TCrc32, module: PSym): PRodWriter =
new(result) new(result)
result.sstack = @[] result.sstack = @[]
result.tstack = @[] result.tstack = @[]
InitIITable(result.index.tab) initIiTable(result.index.tab)
InitIITable(result.imports.tab) initIiTable(result.imports.tab)
result.index.r = "" result.index.r = ""
result.imports.r = "" result.imports.r = ""
result.crc = crc result.crc = crc
@ -101,12 +101,12 @@ proc addInclDep(w: PRodWriter, dep: string) =
proc pushType(w: PRodWriter, t: PType) = proc pushType(w: PRodWriter, t: PType) =
# check so that the stack does not grow too large: # check so that the stack does not grow too large:
if IiTableGet(w.index.tab, t.id) == invalidKey: if iiTableGet(w.index.tab, t.id) == invalidKey:
w.tstack.add(t) w.tstack.add(t)
proc pushSym(w: PRodWriter, s: PSym) = proc pushSym(w: PRodWriter, s: PSym) =
# check so that the stack does not grow too large: # check so that the stack does not grow too large:
if IiTableGet(w.index.tab, s.id) == invalidKey: if iiTableGet(w.index.tab, s.id) == invalidKey:
w.sstack.add(s) w.sstack.add(s)
proc encodeNode(w: PRodWriter, fInfo: TLineInfo, n: PNode, proc encodeNode(w: PRodWriter, fInfo: TLineInfo, n: PNode,
@ -120,19 +120,19 @@ proc encodeNode(w: PRodWriter, fInfo: TLineInfo, n: PNode,
# we do not write comments for now # we do not write comments for now
# Line information takes easily 20% or more of the filesize! Therefore we # Line information takes easily 20% or more of the filesize! Therefore we
# omit line information if it is the same as the father's line information: # omit line information if it is the same as the father's line information:
if finfo.fileIndex != n.info.fileIndex: if fInfo.fileIndex != n.info.fileIndex:
result.add('?') result.add('?')
encodeVInt(n.info.col, result) encodeVInt(n.info.col, result)
result.add(',') result.add(',')
encodeVInt(n.info.line, result) encodeVInt(n.info.line, result)
result.add(',') result.add(',')
encodeVInt(fileIdx(w, toFilename(n.info)), result) encodeVInt(fileIdx(w, toFilename(n.info)), result)
elif finfo.line != n.info.line: elif fInfo.line != n.info.line:
result.add('?') result.add('?')
encodeVInt(n.info.col, result) encodeVInt(n.info.col, result)
result.add(',') result.add(',')
encodeVInt(n.info.line, result) encodeVInt(n.info.line, result)
elif finfo.col != n.info.col: elif fInfo.col != n.info.col:
result.add('?') result.add('?')
encodeVInt(n.info.col, result) encodeVInt(n.info.col, result)
# No need to output the file index, as this is the serialization of one # No need to output the file index, as this is the serialization of one
@ -190,7 +190,7 @@ proc encodeLoc(w: PRodWriter, loc: TLoc, result: var string) =
if loc.a != 0: if loc.a != 0:
add(result, '?') add(result, '?')
encodeVInt(loc.a, result) encodeVInt(loc.a, result)
if oldlen + 1 == result.len: if oldLen + 1 == result.len:
# no data was necessary, so remove the '<' again: # no data was necessary, so remove the '<' again:
setLen(result, oldLen) setLen(result, oldLen)
else: else:
@ -202,7 +202,7 @@ proc encodeType(w: PRodWriter, t: PType, result: var string) =
result.add("[]") result.add("[]")
return return
# we need no surrounding [] here because the type is in a line of its own # we need no surrounding [] here because the type is in a line of its own
if t.kind == tyForward: InternalError("encodeType: tyForward") if t.kind == tyForward: internalError("encodeType: tyForward")
# for the new rodfile viewer we use a preceeding [ so that the data section # for the new rodfile viewer we use a preceeding [ so that the data section
# can easily be disambiguated: # can easily be disambiguated:
add(result, '[') add(result, '[')
@ -210,7 +210,7 @@ proc encodeType(w: PRodWriter, t: PType, result: var string) =
add(result, '+') add(result, '+')
encodeVInt(t.id, result) encodeVInt(t.id, result)
if t.n != nil: if t.n != nil:
encodeNode(w, UnknownLineInfo(), t.n, result) encodeNode(w, unknownLineInfo(), t.n, result)
if t.flags != {}: if t.flags != {}:
add(result, '$') add(result, '$')
encodeVInt(cast[int32](t.flags), result) encodeVInt(cast[int32](t.flags), result)
@ -292,7 +292,7 @@ proc encodeSym(w: PRodWriter, s: PSym, result: var string) =
if s.annex != nil: encodeLib(w, s.annex, s.info, result) if s.annex != nil: encodeLib(w, s.annex, s.info, result)
if s.constraint != nil: if s.constraint != nil:
add(result, '#') add(result, '#')
encodeNode(w, UnknownLineInfo(), s.constraint, result) encodeNode(w, unknownLineInfo(), s.constraint, result)
# lazy loading will soon reload the ast lazily, so the ast needs to be # lazy loading will soon reload the ast lazily, so the ast needs to be
# the last entry of a symbol: # the last entry of a symbol:
if s.ast != nil: if s.ast != nil:
@ -322,7 +322,7 @@ proc addToIndex(w: var TIndex, key, val: int) =
add(w.r, rodNL) add(w.r, rodNL)
w.lastIdxKey = key w.lastIdxKey = key
w.lastIdxVal = val w.lastIdxVal = val
IiTablePut(w.tab, key, val) iiTablePut(w.tab, key, val)
const debugWrittenIds = false const debugWrittenIds = false
@ -336,9 +336,9 @@ proc symStack(w: PRodWriter): int =
if sfForward in s.flags: if sfForward in s.flags:
w.sstack[result] = s w.sstack[result] = s
inc result inc result
elif IiTableGet(w.index.tab, s.id) == invalidKey: elif iiTableGet(w.index.tab, s.id) == invalidKey:
var m = getModule(s) var m = getModule(s)
if m == nil: InternalError("symStack: module nil: " & s.name.s) if m == nil: internalError("symStack: module nil: " & s.name.s)
if (m.id == w.module.id) or (sfFromGeneric in s.flags): if (m.id == w.module.id) or (sfFromGeneric in s.flags):
# put definition in here # put definition in here
var L = w.data.len var L = w.data.len
@ -364,7 +364,7 @@ proc symStack(w: PRodWriter): int =
if s.kind == skMethod and sfDispatcher notin s.flags: if s.kind == skMethod and sfDispatcher notin s.flags:
if w.methods.len != 0: add(w.methods, ' ') if w.methods.len != 0: add(w.methods, ' ')
encodeVInt(s.id, w.methods) encodeVInt(s.id, w.methods)
elif IiTableGet(w.imports.tab, s.id) == invalidKey: elif iiTableGet(w.imports.tab, s.id) == invalidKey:
addToIndex(w.imports, s.id, m.id) addToIndex(w.imports, s.id, m.id)
when debugWrittenIds: when debugWrittenIds:
if not Contains(debugWritten, s.id): if not Contains(debugWritten, s.id):
@ -374,7 +374,7 @@ proc symStack(w: PRodWriter): int =
debug(m) debug(m)
InternalError("Symbol referred to but never written") InternalError("Symbol referred to but never written")
inc(i) inc(i)
setlen(w.sstack, result) setLen(w.sstack, result)
proc typeStack(w: PRodWriter): int = proc typeStack(w: PRodWriter): int =
var i = 0 var i = 0
@ -383,13 +383,13 @@ proc typeStack(w: PRodWriter): int =
if t.kind == tyForward: if t.kind == tyForward:
w.tstack[result] = t w.tstack[result] = t
inc result inc result
elif IiTableGet(w.index.tab, t.id) == invalidKey: elif iiTableGet(w.index.tab, t.id) == invalidKey:
var L = w.data.len var L = w.data.len
addToIndex(w.index, t.id, L) addToIndex(w.index, t.id, L)
encodeType(w, t, w.data) encodeType(w, t, w.data)
add(w.data, rodNL) add(w.data, rodNL)
inc(i) inc(i)
setlen(w.tstack, result) setLen(w.tstack, result)
proc processStacks(w: PRodWriter, finalPass: bool) = proc processStacks(w: PRodWriter, finalPass: bool) =
var oldS = 0 var oldS = 0
@ -401,7 +401,7 @@ proc processStacks(w: PRodWriter, finalPass: bool) =
oldS = slen oldS = slen
oldT = tlen oldT = tlen
if finalPass and (oldS != 0 or oldT != 0): if finalPass and (oldS != 0 or oldT != 0):
InternalError("could not serialize some forwarded symbols/types") internalError("could not serialize some forwarded symbols/types")
proc rawAddInterfaceSym(w: PRodWriter, s: PSym) = proc rawAddInterfaceSym(w: PRodWriter, s: PSym) =
pushSym(w, s) pushSym(w, s)
@ -416,7 +416,7 @@ proc addInterfaceSym(w: PRodWriter, s: PSym) =
proc addStmt(w: PRodWriter, n: PNode) = proc addStmt(w: PRodWriter, n: PNode) =
encodeVInt(w.data.len, w.init) encodeVInt(w.data.len, w.init)
add(w.init, rodNL) add(w.init, rodNL)
encodeNode(w, UnknownLineInfo(), n, w.data) encodeNode(w, unknownLineInfo(), n, w.data)
add(w.data, rodNL) add(w.data, rodNL)
processStacks(w, false) processStacks(w, false)
@ -534,9 +534,9 @@ proc process(c: PPassContext, n: PNode): PNode =
of nkProcDef, nkMethodDef, nkIteratorDef, nkConverterDef, of nkProcDef, nkMethodDef, nkIteratorDef, nkConverterDef,
nkTemplateDef, nkMacroDef: nkTemplateDef, nkMacroDef:
var s = n.sons[namePos].sym var s = n.sons[namePos].sym
if s == nil: InternalError(n.info, "rodwrite.process") if s == nil: internalError(n.info, "rodwrite.process")
if n.sons[bodyPos] == nil: if n.sons[bodyPos] == nil:
InternalError(n.info, "rodwrite.process: body is nil") internalError(n.info, "rodwrite.process: body is nil")
if n.sons[bodyPos].kind != nkEmpty or s.magic != mNone or if n.sons[bodyPos].kind != nkEmpty or s.magic != mNone or
sfForward notin s.flags: sfForward notin s.flags:
addInterfaceSym(w, s) addInterfaceSym(w, s)
@ -549,7 +549,7 @@ proc process(c: PPassContext, n: PNode): PNode =
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
var a = n.sons[i] var a = n.sons[i]
if a.kind == nkCommentStmt: continue if a.kind == nkCommentStmt: continue
if a.sons[0].kind != nkSym: InternalError(a.info, "rodwrite.process") if a.sons[0].kind != nkSym: internalError(a.info, "rodwrite.process")
var s = a.sons[0].sym var s = a.sons[0].sym
addInterfaceSym(w, s) addInterfaceSym(w, s)
# this takes care of enum fields too # this takes care of enum fields too
@ -576,8 +576,8 @@ proc process(c: PPassContext, n: PNode): PNode =
nil nil
proc myOpen(module: PSym): PPassContext = proc myOpen(module: PSym): PPassContext =
if module.id < 0: InternalError("rodwrite: module ID not set") if module.id < 0: internalError("rodwrite: module ID not set")
var w = newRodWriter(module.fileIdx.GetCRC, module) var w = newRodWriter(module.fileIdx.getCRC, module)
rawAddInterfaceSym(w, module) rawAddInterfaceSym(w, module)
result = w result = w

14
compiler/ropes.nim
View file

@ -162,9 +162,9 @@ proc toRope(s: string): PRope =
proc ropeSeqInsert(rs: var TRopeSeq, r: PRope, at: Natural) = proc ropeSeqInsert(rs: var TRopeSeq, r: PRope, at: Natural) =
var length = len(rs) var length = len(rs)
if at > length: if at > length:
setlen(rs, at + 1) setLen(rs, at + 1)
else: else:
setlen(rs, length + 1) # move old rope elements: setLen(rs, length + 1) # move old rope elements:
for i in countdown(length, at + 1): for i in countdown(length, at + 1):
rs[i] = rs[i - 1] # this is correct, I used pen and paper to validate it rs[i] = rs[i - 1] # this is correct, I used pen and paper to validate it
rs[at] = r rs[at] = r
@ -228,9 +228,9 @@ proc writeRope*(f: TFile, c: PRope) =
write(f, it.data) write(f, it.data)
proc writeRope*(head: PRope, filename: string, useWarning = false) = proc writeRope*(head: PRope, filename: string, useWarning = false) =
var f: tfile var f: TFile
if open(f, filename, fmWrite): if open(f, filename, fmWrite):
if head != nil: WriteRope(f, head) if head != nil: writeRope(f, head)
close(f) close(f)
else: else:
errorHandler(rCannotOpenFile, filename, useWarning) errorHandler(rCannotOpenFile, filename, useWarning)
@ -258,7 +258,7 @@ proc ropef(frmt: TFormatStr, args: varargs[PRope]): PRope =
of '0'..'9': of '0'..'9':
var j = 0 var j = 0
while true: while true:
j = (j * 10) + Ord(frmt[i]) - ord('0') j = (j * 10) + ord(frmt[i]) - ord('0')
inc(i) inc(i)
if (i > length + 0 - 1) or not (frmt[i] in {'0'..'9'}): break if (i > length + 0 - 1) or not (frmt[i] in {'0'..'9'}): break
num = j num = j
@ -296,10 +296,10 @@ proc appf(c: var PRope, frmt: TFormatStr, args: varargs[PRope]) =
const const
bufSize = 1024 # 1 KB is reasonable bufSize = 1024 # 1 KB is reasonable
proc auxRopeEqualsFile(r: PRope, bin: var tfile, buf: Pointer): bool = proc auxRopeEqualsFile(r: PRope, bin: var TFile, buf: pointer): bool =
if r.data != nil: if r.data != nil:
if r.length > bufSize: if r.length > bufSize:
ErrorHandler(rTokenTooLong, r.data) errorHandler(rTokenTooLong, r.data)
return return
var readBytes = readBuffer(bin, buf, r.length) var readBytes = readBuffer(bin, buf, r.length)
result = readBytes == r.length and result = readBytes == r.length and

12
compiler/saturate.nim
View file

@ -9,7 +9,7 @@
## Saturated arithmetic routines. XXX Make part of the stdlib? ## Saturated arithmetic routines. XXX Make part of the stdlib?
proc `|+|`*(a, b: biggestInt): biggestInt = proc `|+|`*(a, b: BiggestInt): BiggestInt =
## saturated addition. ## saturated addition.
result = a +% b result = a +% b
if (result xor a) >= 0'i64 or (result xor b) >= 0'i64: if (result xor a) >= 0'i64 or (result xor b) >= 0'i64:
@ -19,7 +19,7 @@ proc `|+|`*(a, b: biggestInt): biggestInt =
else: else:
result = high(result) result = high(result)
proc `|-|`*(a, b: biggestInt): biggestInt = proc `|-|`*(a, b: BiggestInt): BiggestInt =
result = a -% b result = a -% b
if (result xor a) >= 0'i64 or (result xor not b) >= 0'i64: if (result xor a) >= 0'i64 or (result xor not b) >= 0'i64:
return result return result
@ -28,14 +28,14 @@ proc `|-|`*(a, b: biggestInt): biggestInt =
else: else:
result = high(result) result = high(result)
proc `|abs|`*(a: biggestInt): biggestInt = proc `|abs|`*(a: BiggestInt): BiggestInt =
if a != low(a): if a != low(a):
if a >= 0: result = a if a >= 0: result = a
else: result = -a else: result = -a
else: else:
result = low(a) result = low(a)
proc `|div|`*(a, b: biggestInt): biggestInt = proc `|div|`*(a, b: BiggestInt): BiggestInt =
# (0..5) div (0..4) == (0..5) div (1..4) == (0 div 4) .. (5 div 1) # (0..5) div (0..4) == (0..5) div (1..4) == (0 div 4) .. (5 div 1)
if b == 0'i64: if b == 0'i64:
# make the same as ``div 1``: # make the same as ``div 1``:
@ -45,13 +45,13 @@ proc `|div|`*(a, b: biggestInt): biggestInt =
else: else:
result = a div b result = a div b
proc `|mod|`*(a, b: biggestInt): biggestInt = proc `|mod|`*(a, b: BiggestInt): BiggestInt =
if b == 0'i64: if b == 0'i64:
result = a result = a
else: else:
result = a mod b result = a mod b
proc `|*|`*(a, b: biggestInt): biggestInt = proc `|*|`*(a, b: BiggestInt): BiggestInt =
var var
resAsFloat, floatProd: float64 resAsFloat, floatProd: float64
result = a *% b result = a *% b

30
compiler/sem.nim
View file

@ -47,19 +47,19 @@ proc indexTypesMatch(c: PContext, f, a: PType, arg: PNode): PNode
proc typeMismatch(n: PNode, formal, actual: PType) = proc typeMismatch(n: PNode, formal, actual: PType) =
if formal.kind != tyError and actual.kind != tyError: if formal.kind != tyError and actual.kind != tyError:
LocalError(n.Info, errGenerated, msgKindToString(errTypeMismatch) & localError(n.Info, errGenerated, msgKindToString(errTypeMismatch) &
typeToString(actual) & ") " & typeToString(actual) & ") " &
`%`(msgKindToString(errButExpectedX), [typeToString(formal)])) `%`(msgKindToString(errButExpectedX), [typeToString(formal)]))
proc fitNode(c: PContext, formal: PType, arg: PNode): PNode = proc fitNode(c: PContext, formal: PType, arg: PNode): PNode =
if arg.typ.isNil: if arg.typ.isNil:
LocalError(arg.info, errExprXHasNoType, localError(arg.info, errExprXHasNoType,
renderTree(arg, {renderNoComments})) renderTree(arg, {renderNoComments}))
# error correction: # error correction:
result = copyNode(arg) result = copyNode(arg)
result.typ = formal result.typ = formal
else: else:
result = IndexTypesMatch(c, formal, arg.typ, arg) result = indexTypesMatch(c, formal, arg.typ, arg)
if result == nil: if result == nil:
typeMismatch(arg, formal, arg.typ) typeMismatch(arg, formal, arg.typ)
# error correction: # error correction:
@ -176,7 +176,7 @@ when false:
proc semConstExpr(c: PContext, n: PNode): PNode = proc semConstExpr(c: PContext, n: PNode): PNode =
var e = semExprWithType(c, n) var e = semExprWithType(c, n)
if e == nil: if e == nil:
LocalError(n.info, errConstExprExpected) localError(n.info, errConstExprExpected)
return n return n
result = getConstExpr(c.module, e) result = getConstExpr(c.module, e)
if result == nil: if result == nil:
@ -184,10 +184,10 @@ proc semConstExpr(c: PContext, n: PNode): PNode =
if result == nil or result.kind == nkEmpty: if result == nil or result.kind == nkEmpty:
if e.info != n.info: if e.info != n.info:
pushInfoContext(n.info) pushInfoContext(n.info)
LocalError(e.info, errConstExprExpected) localError(e.info, errConstExprExpected)
popInfoContext() popInfoContext()
else: else:
LocalError(e.info, errConstExprExpected) localError(e.info, errConstExprExpected)
# error correction: # error correction:
result = e result = e
else: else:
@ -241,7 +241,7 @@ proc semMacroExpr(c: PContext, n, nOrig: PNode, sym: PSym,
semCheck: bool = true): PNode = semCheck: bool = true): PNode =
markUsed(n, sym) markUsed(n, sym)
if sym == c.p.owner: if sym == c.p.owner:
GlobalError(n.info, errRecursiveDependencyX, sym.name.s) globalError(n.info, errRecursiveDependencyX, sym.name.s)
#if c.evalContext == nil: #if c.evalContext == nil:
# c.evalContext = c.createEvalContext(emStatic) # c.evalContext = c.createEvalContext(emStatic)
@ -257,11 +257,11 @@ proc semConstBoolExpr(c: PContext, n: PNode): PNode =
let nn = semExprWithType(c, n) let nn = semExprWithType(c, n)
result = fitNode(c, getSysType(tyBool), nn) result = fitNode(c, getSysType(tyBool), nn)
if result == nil: if result == nil:
LocalError(n.info, errConstExprExpected) localError(n.info, errConstExprExpected)
return nn return nn
result = getConstExpr(c.module, result) result = getConstExpr(c.module, result)
if result == nil: if result == nil:
LocalError(n.info, errConstExprExpected) localError(n.info, errConstExprExpected)
result = nn result = nn
include semtypes, semtempl, semgnrc, semstmts, semexprs include semtypes, semtempl, semgnrc, semstmts, semexprs
@ -271,14 +271,14 @@ proc addCodeForGenerics(c: PContext, n: PNode) =
var prc = c.generics[i].inst.sym var prc = c.generics[i].inst.sym
if prc.kind in {skProc, skMethod, skConverter} and prc.magic == mNone: if prc.kind in {skProc, skMethod, skConverter} and prc.magic == mNone:
if prc.ast == nil or prc.ast.sons[bodyPos] == nil: if prc.ast == nil or prc.ast.sons[bodyPos] == nil:
InternalError(prc.info, "no code for " & prc.name.s) internalError(prc.info, "no code for " & prc.name.s)
else: else:
addSon(n, prc.ast) addSon(n, prc.ast)
c.lastGenericIdx = c.generics.len c.lastGenericIdx = c.generics.len
proc myOpen(module: PSym): PPassContext = proc myOpen(module: PSym): PPassContext =
var c = newContext(module) var c = newContext(module)
if c.p != nil: InternalError(module.info, "sem.myOpen") if c.p != nil: internalError(module.info, "sem.myOpen")
c.semConstExpr = semConstExpr c.semConstExpr = semConstExpr
c.semExpr = semExpr c.semExpr = semExpr
c.semTryExpr = tryExpr c.semTryExpr = tryExpr
@ -329,14 +329,14 @@ proc myProcess(context: PPassContext, n: PNode): PNode =
var c = PContext(context) var c = PContext(context)
# no need for an expensive 'try' if we stop after the first error anyway: # no need for an expensive 'try' if we stop after the first error anyway:
if msgs.gErrorMax <= 1: if msgs.gErrorMax <= 1:
result = SemStmtAndGenerateGenerics(c, n) result = semStmtAndGenerateGenerics(c, n)
else: else:
let oldContextLen = msgs.getInfoContextLen() let oldContextLen = msgs.getInfoContextLen()
let oldInGenericInst = c.InGenericInst let oldInGenericInst = c.InGenericInst
try: try:
result = SemStmtAndGenerateGenerics(c, n) result = semStmtAndGenerateGenerics(c, n)
except ERecoverableError, ESuggestDone: except ERecoverableError, ESuggestDone:
RecoverContext(c) recoverContext(c)
c.InGenericInst = oldInGenericInst c.InGenericInst = oldInGenericInst
msgs.setInfoContextLen(oldContextLen) msgs.setInfoContextLen(oldContextLen)
if getCurrentException() of ESuggestDone: result = nil if getCurrentException() of ESuggestDone: result = nil
@ -354,7 +354,7 @@ proc myClose(context: PPassContext, n: PNode): PNode =
rawCloseScope(c) # imported symbols; don't check for unused ones! rawCloseScope(c) # imported symbols; don't check for unused ones!
result = newNode(nkStmtList) result = newNode(nkStmtList)
if n != nil: if n != nil:
InternalError(n.info, "n is not nil") #result := n; internalError(n.info, "n is not nil") #result := n;
addCodeForGenerics(c, result) addCodeForGenerics(c, result)
if c.module.ast != nil: if c.module.ast != nil:
result.add(c.module.ast) result.add(c.module.ast)

10
compiler/semcall.nim
View file

@ -150,16 +150,16 @@ proc resolveOverloads(c: PContext, n, orig: PNode,
pickBest(callOp) pickBest(callOp)
if overloadsState == csEmpty and result.state == csEmpty: if overloadsState == csEmpty and result.state == csEmpty:
LocalError(n.info, errUndeclaredIdentifier, considerAcc(f).s) localError(n.info, errUndeclaredIdentifier, considerAcc(f).s)
return return
elif result.state != csMatch: elif result.state != csMatch:
if nfExprCall in n.flags: if nfExprCall in n.flags:
LocalError(n.info, errExprXCannotBeCalled, localError(n.info, errExprXCannotBeCalled,
renderTree(n, {renderNoComments})) renderTree(n, {renderNoComments}))
else: else:
errors = @[] errors = @[]
pickBest(f) pickBest(f)
NotFoundError(c, n, errors) notFoundError(c, n, errors)
return return
if alt.state == csMatch and cmpCandidates(result, alt) == 0 and if alt.state == csMatch and cmpCandidates(result, alt) == 0 and
@ -225,7 +225,7 @@ proc semResolvedCall(c: PContext, n: PNode, x: TCandidate): PNode =
result = x.call result = x.call
result.sons[0] = newSymNode(finalCallee, result.sons[0].info) result.sons[0] = newSymNode(finalCallee, result.sons[0].info)
result.typ = finalCallee.typ.sons[0] result.typ = finalCallee.typ.sons[0]
if ContainsGenericType(result.typ): result.typ = errorType(c) if containsGenericType(result.typ): result.typ = errorType(c)
return return
result = x.call result = x.call
instGenericConvertersSons(c, result, x) instGenericConvertersSons(c, result, x)
@ -260,7 +260,7 @@ proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym): PNode =
# number of generic type parameters: # number of generic type parameters:
if safeLen(s.ast.sons[genericParamsPos]) != n.len-1: if safeLen(s.ast.sons[genericParamsPos]) != n.len-1:
let expected = safeLen(s.ast.sons[genericParamsPos]) let expected = safeLen(s.ast.sons[genericParamsPos])
LocalError(n.info, errGenerated, "cannot instantiate: " & renderTree(n) & localError(n.info, errGenerated, "cannot instantiate: " & renderTree(n) &
"; got " & $(n.len-1) & " type(s) but expected " & $expected) "; got " & $(n.len-1) & " type(s) but expected " & $expected)
return n return n
result = explicitGenericSym(c, n, s) result = explicitGenericSym(c, n, s)

10
compiler/semdata.nim
View file

@ -133,7 +133,7 @@ proc pushOwner(owner: PSym) =
proc popOwner() = proc popOwner() =
var length = len(gOwners) var length = len(gOwners)
if length > 0: setlen(gOwners, length - 1) if length > 0: setLen(gOwners, length - 1)
else: internalError("popOwner") else: internalError("popOwner")
proc lastOptionEntry(c: PContext): POptionEntry = proc lastOptionEntry(c: PContext): POptionEntry =
@ -141,7 +141,7 @@ proc lastOptionEntry(c: PContext): POptionEntry =
proc pushProcCon*(c: PContext, owner: PSym) {.inline.} = proc pushProcCon*(c: PContext, owner: PSym) {.inline.} =
if owner == nil: if owner == nil:
InternalError("owner is nil") internalError("owner is nil")
return return
var x: PProcCon var x: PProcCon
new(x) new(x)
@ -160,7 +160,7 @@ proc newOptionEntry(): POptionEntry =
proc newContext(module: PSym): PContext = proc newContext(module: PSym): PContext =
new(result) new(result)
result.AmbiguousSymbols = initIntset() result.AmbiguousSymbols = initIntSet()
initLinkedList(result.optionStack) initLinkedList(result.optionStack)
initLinkedList(result.libs) initLinkedList(result.libs)
append(result.optionStack, newOptionEntry()) append(result.optionStack, newOptionEntry())
@ -178,7 +178,7 @@ proc inclSym(sq: var TSymSeq, s: PSym) =
var L = len(sq) var L = len(sq)
for i in countup(0, L - 1): for i in countup(0, L - 1):
if sq[i].id == s.id: return if sq[i].id == s.id: return
setlen(sq, L + 1) setLen(sq, L + 1)
sq[L] = s sq[L] = s
proc addConverter*(c: PContext, conv: PSym) = proc addConverter*(c: PContext, conv: PSym) =
@ -234,7 +234,7 @@ proc fillTypeS(dest: PType, kind: TTypeKind, c: PContext) =
dest.owner = getCurrOwner() dest.owner = getCurrOwner()
dest.size = - 1 dest.size = - 1
proc makeRangeType*(c: PContext; first, last: biggestInt; proc makeRangeType*(c: PContext; first, last: BiggestInt;
info: TLineInfo; intType = getSysType(tyInt)): PType = info: TLineInfo; intType = getSysType(tyInt)): PType =
var n = newNodeI(nkRange, info) var n = newNodeI(nkRange, info)
addSon(n, newIntTypeNode(nkIntLit, first, intType)) addSon(n, newIntTypeNode(nkIntLit, first, intType))

10
compiler/semdestruct.nim
View file

@ -22,7 +22,7 @@ new(destructorIsTrivial)
var var
destructorName = getIdent"destroy_" destructorName = getIdent"destroy_"
destructorParam = getIdent"this_" destructorParam = getIdent"this_"
destructorPragma = newIdentNode(getIdent"destructor", UnknownLineInfo()) destructorPragma = newIdentNode(getIdent"destructor", unknownLineInfo())
rangeDestructorProc*: PSym rangeDestructorProc*: PSym
proc instantiateDestructor(c: PContext, typ: PType): bool proc instantiateDestructor(c: PContext, typ: PType): bool
@ -90,7 +90,7 @@ proc generateDestructor(c: PContext, t: PType): PNode =
# Tposix_spawnattr # Tposix_spawnattr
if t.n == nil or t.n.sons == nil: return if t.n == nil or t.n.sons == nil: return
internalAssert t.n.kind == nkRecList internalAssert t.n.kind == nkRecList
let destructedObj = newIdentNode(destructorParam, UnknownLineInfo()) let destructedObj = newIdentNode(destructorParam, unknownLineInfo())
# call the destructods of all fields # call the destructods of all fields
for s in countup(0, t.n.sons.len - 1): for s in countup(0, t.n.sons.len - 1):
case t.n.sons[s].kind case t.n.sons[s].kind
@ -114,7 +114,7 @@ proc instantiateDestructor(c: PContext, typ: PType): bool =
if t.destructor != nil: if t.destructor != nil:
# XXX: This is not entirely correct for recursive types, but we need # XXX: This is not entirely correct for recursive types, but we need
# it temporarily to hide the "destroy is already defined" problem # it temporarily to hide the "destroy is already defined" problem
return t.destructor notin [AnalyzingDestructor, DestructorIsTrivial] return t.destructor notin [analyzingDestructor, destructorIsTrivial]
case t.kind case t.kind
of tySequence, tyArray, tyArrayConstr, tyOpenArray, tyVarargs: of tySequence, tyArray, tyArrayConstr, tyOpenArray, tyVarargs:
@ -126,7 +126,7 @@ proc instantiateDestructor(c: PContext, typ: PType): bool =
else: else:
return false return false
of tyTuple, tyObject: of tyTuple, tyObject:
t.destructor = AnalyzingDestructor t.destructor = analyzingDestructor
let generated = generateDestructor(c, t) let generated = generateDestructor(c, t)
if generated != nil: if generated != nil:
internalAssert t.sym != nil internalAssert t.sym != nil
@ -150,7 +150,7 @@ proc instantiateDestructor(c: PContext, typ: PType): bool =
internalAssert t.destructor != nil internalAssert t.destructor != nil
return true return true
else: else:
t.destructor = DestructorIsTrivial t.destructor = destructorIsTrivial
return false return false
else: else:
return false return false

178
compiler/semexprs.nim
View file

@ -30,7 +30,7 @@ proc semOperand(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
# XXX tyGenericInst here? # XXX tyGenericInst here?
if result.typ.kind == tyVar: result = newDeref(result) if result.typ.kind == tyVar: result = newDeref(result)
else: else:
LocalError(n.info, errExprXHasNoType, localError(n.info, errExprXHasNoType,
renderTree(result, {renderNoComments})) renderTree(result, {renderNoComments}))
result.typ = errorType(c) result.typ = errorType(c)
@ -40,9 +40,9 @@ proc semExprWithType(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
# do not produce another redundant error message: # do not produce another redundant error message:
#raiseRecoverableError("") #raiseRecoverableError("")
result = errorNode(c, n) result = errorNode(c, n)
if result.typ == nil or result.typ == EnforceVoidContext: if result.typ == nil or result.typ == enforceVoidContext:
# we cannot check for 'void' in macros ... # we cannot check for 'void' in macros ...
LocalError(n.info, errExprXHasNoType, localError(n.info, errExprXHasNoType,
renderTree(result, {renderNoComments})) renderTree(result, {renderNoComments}))
result.typ = errorType(c) result.typ = errorType(c)
else: else:
@ -57,7 +57,7 @@ proc semExprNoDeref(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
# do not produce another redundant error message: # do not produce another redundant error message:
result = errorNode(c, n) result = errorNode(c, n)
if result.typ == nil: if result.typ == nil:
LocalError(n.info, errExprXHasNoType, localError(n.info, errExprXHasNoType,
renderTree(result, {renderNoComments})) renderTree(result, {renderNoComments}))
result.typ = errorType(c) result.typ = errorType(c)
else: else:
@ -117,7 +117,7 @@ proc semSym(c: PContext, n: PNode, s: PSym, flags: TExprFlags): PNode =
elif s.ast != nil: elif s.ast != nil:
result = semExpr(c, s.ast) result = semExpr(c, s.ast)
else: else:
InternalError(n.info, "no default for") internalError(n.info, "no default for")
result = emptyNode result = emptyNode
of skType: of skType:
markUsed(n, s) markUsed(n, s)
@ -175,7 +175,7 @@ proc isCastable(dst, src: PType): bool =
# castableTypeKinds = {tyInt, tyPtr, tyRef, tyCstring, tyString, # castableTypeKinds = {tyInt, tyPtr, tyRef, tyCstring, tyString,
# tySequence, tyPointer, tyNil, tyOpenArray, # tySequence, tyPointer, tyNil, tyOpenArray,
# tyProc, tySet, tyEnum, tyBool, tyChar} # tyProc, tySet, tyEnum, tyBool, tyChar}
var ds, ss: biggestInt var ds, ss: BiggestInt
# this is very unrestrictive; cast is allowed if castDest.size >= src.size # this is very unrestrictive; cast is allowed if castDest.size >= src.size
ds = computeSize(dst) ds = computeSize(dst)
ss = computeSize(src) ss = computeSize(src)
@ -193,7 +193,7 @@ proc isSymChoice(n: PNode): bool {.inline.} =
proc semConv(c: PContext, n: PNode): PNode = proc semConv(c: PContext, n: PNode): PNode =
if sonsLen(n) != 2: if sonsLen(n) != 2:
LocalError(n.info, errConvNeedsOneArg) localError(n.info, errConvNeedsOneArg)
return n return n
result = newNodeI(nkConv, n.info) result = newNodeI(nkConv, n.info)
result.typ = semTypeNode(c, n.sons[0], nil).skipTypes({tyGenericInst}) result.typ = semTypeNode(c, n.sons[0], nil).skipTypes({tyGenericInst})
@ -206,9 +206,9 @@ proc semConv(c: PContext, n: PNode): PNode =
case status case status
of convOK: nil of convOK: nil
of convNotNeedeed: of convNotNeedeed:
Message(n.info, hintConvFromXtoItselfNotNeeded, result.typ.typeToString) message(n.info, hintConvFromXtoItselfNotNeeded, result.typ.typeToString)
of convNotLegal: of convNotLegal:
LocalError(n.info, errGenerated, MsgKindToString(errIllegalConvFromXtoY)% localError(n.info, errGenerated, msgKindToString(errIllegalConvFromXtoY)%
[op.typ.typeToString, result.typ.typeToString]) [op.typ.typeToString, result.typ.typeToString])
else: else:
for i in countup(0, sonsLen(op) - 1): for i in countup(0, sonsLen(op) - 1):
@ -229,14 +229,14 @@ proc semCast(c: PContext, n: PNode): PNode =
addSon(result, copyTree(n.sons[0])) addSon(result, copyTree(n.sons[0]))
addSon(result, semExprWithType(c, n.sons[1])) addSon(result, semExprWithType(c, n.sons[1]))
if not isCastable(result.typ, result.sons[1].Typ): if not isCastable(result.typ, result.sons[1].Typ):
LocalError(result.info, errExprCannotBeCastedToX, localError(result.info, errExprCannotBeCastedToX,
typeToString(result.Typ)) typeToString(result.Typ))
proc semLowHigh(c: PContext, n: PNode, m: TMagic): PNode = proc semLowHigh(c: PContext, n: PNode, m: TMagic): PNode =
const const
opToStr: array[mLow..mHigh, string] = ["low", "high"] opToStr: array[mLow..mHigh, string] = ["low", "high"]
if sonsLen(n) != 2: if sonsLen(n) != 2:
LocalError(n.info, errXExpectsTypeOrValue, opToStr[m]) localError(n.info, errXExpectsTypeOrValue, opToStr[m])
else: else:
n.sons[1] = semExprWithType(c, n.sons[1], {efDetermineType}) n.sons[1] = semExprWithType(c, n.sons[1], {efDetermineType})
var typ = skipTypes(n.sons[1].typ, abstractVarRange) var typ = skipTypes(n.sons[1].typ, abstractVarRange)
@ -252,12 +252,12 @@ proc semLowHigh(c: PContext, n: PNode, m: TMagic): PNode =
# leave it for now, it will be resolved in semtypinst # leave it for now, it will be resolved in semtypinst
n.typ = getSysType(tyInt) n.typ = getSysType(tyInt)
else: else:
LocalError(n.info, errInvalidArgForX, opToStr[m]) localError(n.info, errInvalidArgForX, opToStr[m])
result = n result = n
proc semSizeof(c: PContext, n: PNode): PNode = proc semSizeof(c: PContext, n: PNode): PNode =
if sonsLen(n) != 2: if sonsLen(n) != 2:
LocalError(n.info, errXExpectsTypeOrValue, "sizeof") localError(n.info, errXExpectsTypeOrValue, "sizeof")
else: else:
n.sons[1] = semExprWithType(c, n.sons[1], {efDetermineType}) n.sons[1] = semExprWithType(c, n.sons[1], {efDetermineType})
#restoreOldStyleType(n.sons[1]) #restoreOldStyleType(n.sons[1])
@ -276,9 +276,9 @@ proc semOf(c: PContext, n: PNode): PNode =
let y = skipTypes(n.sons[2].typ, abstractPtrs-{tyTypeDesc}) let y = skipTypes(n.sons[2].typ, abstractPtrs-{tyTypeDesc})
if x.kind == tyTypeDesc or y.kind != tyTypeDesc: if x.kind == tyTypeDesc or y.kind != tyTypeDesc:
LocalError(n.info, errXExpectsObjectTypes, "of") localError(n.info, errXExpectsObjectTypes, "of")
elif b.kind != tyObject or a.kind != tyObject: elif b.kind != tyObject or a.kind != tyObject:
LocalError(n.info, errXExpectsObjectTypes, "of") localError(n.info, errXExpectsObjectTypes, "of")
else: else:
let diff = inheritanceDiff(a, b) let diff = inheritanceDiff(a, b)
# | returns: 0 iff `a` == `b` # | returns: 0 iff `a` == `b`
@ -287,15 +287,15 @@ proc semOf(c: PContext, n: PNode): PNode =
# | returns: `maxint` iff `a` and `b` are not compatible at all # | returns: `maxint` iff `a` and `b` are not compatible at all
if diff <= 0: if diff <= 0:
# optimize to true: # optimize to true:
Message(n.info, hintConditionAlwaysTrue, renderTree(n)) message(n.info, hintConditionAlwaysTrue, renderTree(n))
result = newIntNode(nkIntLit, 1) result = newIntNode(nkIntLit, 1)
result.info = n.info result.info = n.info
result.typ = getSysType(tyBool) result.typ = getSysType(tyBool)
return result return result
elif diff == high(int): elif diff == high(int):
LocalError(n.info, errXcanNeverBeOfThisSubtype, typeToString(a)) localError(n.info, errXcanNeverBeOfThisSubtype, typeToString(a))
else: else:
LocalError(n.info, errXExpectsTwoArguments, "of") localError(n.info, errXExpectsTwoArguments, "of")
n.typ = getSysType(tyBool) n.typ = getSysType(tyBool)
result = n result = n
@ -324,15 +324,15 @@ proc isOpImpl(c: PContext, n: PNode): PNode =
case t2.kind case t2.kind
of tyTypeClasses: of tyTypeClasses:
var m: TCandidate var m: TCandidate
InitCandidate(m, t2) initCandidate(m, t2)
match = matchUserTypeClass(c, m, emptyNode, t2, t1) != nil match = matchUserTypeClass(c, m, emptyNode, t2, t1) != nil
of tyOrdinal: of tyOrdinal:
var m: TCandidate var m: TCandidate
InitCandidate(m, t2) initCandidate(m, t2)
match = isOrdinalType(t1) match = isOrdinalType(t1)
of tySequence, tyArray, tySet: of tySequence, tyArray, tySet:
var m: TCandidate var m: TCandidate
InitCandidate(m, t2) initCandidate(m, t2)
match = typeRel(m, t2, t1) != isNone match = typeRel(m, t2, t1) != isNone
else: else:
match = sameType(t1, t2) match = sameType(t1, t2)
@ -343,7 +343,7 @@ proc isOpImpl(c: PContext, n: PNode): PNode =
proc semIs(c: PContext, n: PNode): PNode = proc semIs(c: PContext, n: PNode): PNode =
if sonsLen(n) != 3: if sonsLen(n) != 3:
LocalError(n.info, errXExpectsTwoArguments, "is") localError(n.info, errXExpectsTwoArguments, "is")
result = n result = n
n.typ = getSysType(tyBool) n.typ = getSysType(tyBool)
@ -394,7 +394,7 @@ proc changeType(n: PNode, newType: PType, check: bool) =
changeType(n.sons[i], elemType(newType), check) changeType(n.sons[i], elemType(newType), check)
of nkPar: of nkPar:
if newType.kind != tyTuple: if newType.kind != tyTuple:
InternalError(n.info, "changeType: no tuple type for constructor") internalError(n.info, "changeType: no tuple type for constructor")
elif newType.n == nil: nil elif newType.n == nil: nil
elif sonsLen(n) > 0 and n.sons[0].kind == nkExprColonExpr: elif sonsLen(n) > 0 and n.sons[0].kind == nkExprColonExpr:
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
@ -419,7 +419,7 @@ proc changeType(n: PNode, newType: PType, check: bool) =
if check: if check:
let value = n.intVal let value = n.intVal
if value < firstOrd(newType) or value > lastOrd(newType): if value < firstOrd(newType) or value > lastOrd(newType):
LocalError(n.info, errGenerated, "cannot convert " & $value & localError(n.info, errGenerated, "cannot convert " & $value &
" to " & typeToString(newType)) " to " & typeToString(newType))
else: nil else: nil
n.typ = newType n.typ = newType
@ -431,7 +431,7 @@ proc arrayConstrType(c: PContext, n: PNode): PType =
rawAddSon(typ, newTypeS(tyEmpty, c)) # needs an empty basetype! rawAddSon(typ, newTypeS(tyEmpty, c)) # needs an empty basetype!
else: else:
var x = n.sons[0] var x = n.sons[0]
var lastIndex: biggestInt = sonsLen(n) - 1 var lastIndex: BiggestInt = sonsLen(n) - 1
var t = skipTypes(n.sons[0].typ, {tyGenericInst, tyVar, tyOrdinal}) var t = skipTypes(n.sons[0].typ, {tyGenericInst, tyVar, tyOrdinal})
addSonSkipIntLit(typ, t) addSonSkipIntLit(typ, t)
typ.sons[0] = makeRangeType(c, 0, sonsLen(n) - 1, n.info) typ.sons[0] = makeRangeType(c, 0, sonsLen(n) - 1, n.info)
@ -445,7 +445,7 @@ proc semArrayConstr(c: PContext, n: PNode, flags: TExprFlags): PNode =
rawAddSon(result.typ, newTypeS(tyEmpty, c)) # needs an empty basetype! rawAddSon(result.typ, newTypeS(tyEmpty, c)) # needs an empty basetype!
else: else:
var x = n.sons[0] var x = n.sons[0]
var lastIndex: biggestInt = 0 var lastIndex: BiggestInt = 0
var indexType = getSysType(tyInt) var indexType = getSysType(tyInt)
if x.kind == nkExprColonExpr and sonsLen(x) == 2: if x.kind == nkExprColonExpr and sonsLen(x) == 2:
var idx = semConstExpr(c, x.sons[0]) var idx = semConstExpr(c, x.sons[0])
@ -582,7 +582,7 @@ proc analyseIfAddressTakenInCall(c: PContext, n: PNode) =
skipTypes(t.sons[i], abstractInst-{tyTypeDesc}).kind == tyVar: skipTypes(t.sons[i], abstractInst-{tyTypeDesc}).kind == tyVar:
if isAssignable(c, n.sons[i]) notin {arLValue, arLocalLValue}: if isAssignable(c, n.sons[i]) notin {arLValue, arLocalLValue}:
if n.sons[i].kind != nkHiddenAddr: if n.sons[i].kind != nkHiddenAddr:
LocalError(n.sons[i].info, errVarForOutParamNeeded) localError(n.sons[i].info, errVarForOutParamNeeded)
return return
for i in countup(1, sonsLen(n) - 1): for i in countup(1, sonsLen(n) - 1):
if n.sons[i].kind == nkHiddenCallConv: if n.sons[i].kind == nkHiddenCallConv:
@ -642,7 +642,7 @@ proc evalAtCompileTime(c: PContext, n: PNode): PNode =
if sfCompileTime in callee.flags: if sfCompileTime in callee.flags:
result = evalStaticExpr(c.module, call, c.p.owner) result = evalStaticExpr(c.module, call, c.p.owner)
if result.isNil: if result.isNil:
LocalError(n.info, errCannotInterpretNodeX, renderTree(call)) localError(n.info, errCannotInterpretNodeX, renderTree(call))
else: else:
result = evalConstExpr(c.module, call) result = evalConstExpr(c.module, call)
if result.isNil: result = n if result.isNil: result = n
@ -653,7 +653,7 @@ proc semStaticExpr(c: PContext, n: PNode): PNode =
let a = semExpr(c, n.sons[0]) let a = semExpr(c, n.sons[0])
result = evalStaticExpr(c.module, a, c.p.owner) result = evalStaticExpr(c.module, a, c.p.owner)
if result.isNil: if result.isNil:
LocalError(n.info, errCannotInterpretNodeX, renderTree(n)) localError(n.info, errCannotInterpretNodeX, renderTree(n))
result = emptyNode result = emptyNode
proc semOverloadedCallAnalyseEffects(c: PContext, n: PNode, nOrig: PNode, proc semOverloadedCallAnalyseEffects(c: PContext, n: PNode, nOrig: PNode,
@ -670,14 +670,14 @@ proc semOverloadedCallAnalyseEffects(c: PContext, n: PNode, nOrig: PNode,
{skProc, skMethod, skConverter, skMacro, skTemplate}) {skProc, skMethod, skConverter, skMacro, skTemplate})
if result != nil: if result != nil:
if result.sons[0].kind != nkSym: if result.sons[0].kind != nkSym:
InternalError("semOverloadedCallAnalyseEffects") internalError("semOverloadedCallAnalyseEffects")
return return
let callee = result.sons[0].sym let callee = result.sons[0].sym
case callee.kind case callee.kind
of skMacro, skTemplate: nil of skMacro, skTemplate: nil
else: else:
if (callee.kind == skIterator) and (callee.id == c.p.owner.id): if (callee.kind == skIterator) and (callee.id == c.p.owner.id):
LocalError(n.info, errRecursiveDependencyX, callee.name.s) localError(n.info, errRecursiveDependencyX, callee.name.s)
if sfNoSideEffect notin callee.flags: if sfNoSideEffect notin callee.flags:
if {sfImportc, sfSideEffect} * callee.flags != {}: if {sfImportc, sfSideEffect} * callee.flags != {}:
incl(c.p.owner.flags, sfSideEffect) incl(c.p.owner.flags, sfSideEffect)
@ -711,7 +711,7 @@ proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags): PNode =
if m.state != csMatch: if m.state != csMatch:
if c.inCompilesContext > 0: if c.inCompilesContext > 0:
# speed up error generation: # speed up error generation:
GlobalError(n.Info, errTypeMismatch, "") globalError(n.Info, errTypeMismatch, "")
return emptyNode return emptyNode
else: else:
var hasErrorType = false var hasErrorType = false
@ -726,7 +726,7 @@ proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags): PNode =
if not hasErrorType: if not hasErrorType:
add(msg, ")\n" & msgKindToString(errButExpected) & "\n" & add(msg, ")\n" & msgKindToString(errButExpected) & "\n" &
typeToString(n.sons[0].typ)) typeToString(n.sons[0].typ))
LocalError(n.Info, errGenerated, msg) localError(n.Info, errGenerated, msg)
return errorNode(c, n) return errorNode(c, n)
result = nil result = nil
else: else:
@ -801,7 +801,7 @@ proc semEcho(c: PContext, n: PNode): PNode =
let t = arg.typ let t = arg.typ
if (t == nil or t.skipTypes(abstractInst).kind != tyString) and if (t == nil or t.skipTypes(abstractInst).kind != tyString) and
arg.kind != nkEmpty: arg.kind != nkEmpty:
LocalError(n.info, errGenerated, localError(n.info, errGenerated,
"implicitly invoked '$' does not return string") "implicitly invoked '$' does not return string")
let t = n.sons[0].typ let t = n.sons[0].typ
if tfNoSideEffect notin t.flags: incl(c.p.owner.flags, sfSideEffect) if tfNoSideEffect notin t.flags: incl(c.p.owner.flags, sfSideEffect)
@ -810,11 +810,11 @@ proc semEcho(c: PContext, n: PNode): PNode =
proc buildEchoStmt(c: PContext, n: PNode): PNode = proc buildEchoStmt(c: PContext, n: PNode): PNode =
# we MUST not check 'n' for semantics again here! # we MUST not check 'n' for semantics again here!
result = newNodeI(nkCall, n.info) result = newNodeI(nkCall, n.info)
var e = StrTableGet(magicsys.systemModule.Tab, getIdent"echo") var e = strTableGet(magicsys.systemModule.Tab, getIdent"echo")
if e != nil: if e != nil:
addSon(result, newSymNode(e)) addSon(result, newSymNode(e))
else: else:
LocalError(n.info, errSystemNeeds, "echo") localError(n.info, errSystemNeeds, "echo")
addSon(result, errorNode(c, n)) addSon(result, errorNode(c, n))
var arg = buildStringify(c, n) var arg = buildStringify(c, n)
# problem is: implicit '$' is not checked for semantics yet. So we give up # problem is: implicit '$' is not checked for semantics yet. So we give up
@ -844,7 +844,7 @@ proc lookupInRecordAndBuildCheck(c: PContext, n, r: PNode, field: PIdent,
if result != nil: return if result != nil: return
of nkRecCase: of nkRecCase:
checkMinSonsLen(r, 2) checkMinSonsLen(r, 2)
if (r.sons[0].kind != nkSym): IllFormedAst(r) if (r.sons[0].kind != nkSym): illFormedAst(r)
result = lookupInRecordAndBuildCheck(c, n, r.sons[0], field, check) result = lookupInRecordAndBuildCheck(c, n, r.sons[0], field, check)
if result != nil: return if result != nil: return
var s = newNodeI(nkCurly, r.info) var s = newNodeI(nkCurly, r.info)
@ -906,7 +906,7 @@ proc builtinFieldAccess(c: PContext, n: PNode, flags: TExprFlags): PNode =
# early exit for this; see tests/compile/tbindoverload.nim: # early exit for this; see tests/compile/tbindoverload.nim:
if isSymChoice(n.sons[1]): return if isSymChoice(n.sons[1]): return
var s = qualifiedLookup(c, n, {checkAmbiguity, checkUndeclared}) var s = qualifiedLookUp(c, n, {checkAmbiguity, checkUndeclared})
if s != nil: if s != nil:
return semSym(c, n, s, flags) return semSym(c, n, s, flags)
@ -1038,7 +1038,7 @@ proc semSubscript(c: PContext, n: PNode, flags: TExprFlags): PNode =
n.sons[i] = semExprWithType(c, n.sons[i], n.sons[i] = semExprWithType(c, n.sons[i],
flags*{efInTypeof, efDetermineType}) flags*{efInTypeof, efDetermineType})
var indexType = if arr.kind == tyArray: arr.sons[0] else: getSysType(tyInt) var indexType = if arr.kind == tyArray: arr.sons[0] else: getSysType(tyInt)
var arg = IndexTypesMatch(c, indexType, n.sons[1].typ, n.sons[1]) var arg = indexTypesMatch(c, indexType, n.sons[1].typ, n.sons[1])
if arg != nil: if arg != nil:
n.sons[1] = arg n.sons[1] = arg
result = n result = n
@ -1060,9 +1060,9 @@ proc semSubscript(c: PContext, n: PNode, flags: TExprFlags): PNode =
{tyInt..tyInt64}: {tyInt..tyInt64}:
var idx = getOrdValue(n.sons[1]) var idx = getOrdValue(n.sons[1])
if idx >= 0 and idx < sonsLen(arr): n.typ = arr.sons[int(idx)] if idx >= 0 and idx < sonsLen(arr): n.typ = arr.sons[int(idx)]
else: LocalError(n.info, errInvalidIndexValueForTuple) else: localError(n.info, errInvalidIndexValueForTuple)
else: else:
LocalError(n.info, errIndexTypesDoNotMatch) localError(n.info, errIndexTypesDoNotMatch)
result = n result = n
else: nil else: nil
@ -1098,9 +1098,9 @@ proc takeImplicitAddr(c: PContext, n: PNode): PNode =
var valid = isAssignable(c, n) var valid = isAssignable(c, n)
if valid != arLValue: if valid != arLValue:
if valid == arLocalLValue: if valid == arLocalLValue:
LocalError(n.info, errXStackEscape, renderTree(n, {renderNoComments})) localError(n.info, errXStackEscape, renderTree(n, {renderNoComments}))
else: else:
LocalError(n.info, errExprHasNoAddress) localError(n.info, errExprHasNoAddress)
result = newNodeIT(nkHiddenAddr, n.info, makePtrType(c, n.typ)) result = newNodeIT(nkHiddenAddr, n.info, makePtrType(c, n.typ))
result.add(n) result.add(n)
@ -1149,7 +1149,7 @@ proc semAsgn(c: PContext, n: PNode): PNode =
# a = b # b no 'var T' means: a = addr(b) # a = b # b no 'var T' means: a = addr(b)
var le = a.typ var le = a.typ
if skipTypes(le, {tyGenericInst}).kind != tyVar and if skipTypes(le, {tyGenericInst}).kind != tyVar and
IsAssignable(c, a) == arNone: isAssignable(c, a) == arNone:
# Direct assignment to a discriminant is allowed! # Direct assignment to a discriminant is allowed!
localError(a.info, errXCannotBeAssignedTo, localError(a.info, errXCannotBeAssignedTo,
renderTree(a, {renderNoComments})) renderTree(a, {renderNoComments}))
@ -1161,7 +1161,7 @@ proc semAsgn(c: PContext, n: PNode): PNode =
rhs = semExprWithType(c, n.sons[1], rhs = semExprWithType(c, n.sons[1],
if lhsIsResult: {efAllowDestructor} else: {}) if lhsIsResult: {efAllowDestructor} else: {})
if lhsIsResult: if lhsIsResult:
n.typ = EnforceVoidContext n.typ = enforceVoidContext
if lhs.sym.typ.kind == tyGenericParam: if lhs.sym.typ.kind == tyGenericParam:
if matchTypeClass(lhs.typ, rhs.typ): if matchTypeClass(lhs.typ, rhs.typ):
InternalAssert c.p.resultSym != nil InternalAssert c.p.resultSym != nil
@ -1192,9 +1192,9 @@ proc semReturn(c: PContext, n: PNode): PNode =
if n[0][1].kind == nkSym and n[0][1].sym == c.p.resultSym: if n[0][1].kind == nkSym and n[0][1].sym == c.p.resultSym:
n.sons[0] = ast.emptyNode n.sons[0] = ast.emptyNode
else: else:
LocalError(n.info, errNoReturnTypeDeclared) localError(n.info, errNoReturnTypeDeclared)
else: else:
LocalError(n.info, errXNotAllowedHere, "\'return\'") localError(n.info, errXNotAllowedHere, "\'return\'")
proc semProcBody(c: PContext, n: PNode): PNode = proc semProcBody(c: PContext, n: PNode): PNode =
openScope(c) openScope(c)
@ -1246,16 +1246,16 @@ proc semYield(c: PContext, n: PNode): PNode =
result = n result = n
checkSonsLen(n, 1) checkSonsLen(n, 1)
if c.p.owner == nil or c.p.owner.kind != skIterator: if c.p.owner == nil or c.p.owner.kind != skIterator:
LocalError(n.info, errYieldNotAllowedHere) localError(n.info, errYieldNotAllowedHere)
elif c.p.inTryStmt > 0 and c.p.owner.typ.callConv != ccInline: elif c.p.inTryStmt > 0 and c.p.owner.typ.callConv != ccInline:
LocalError(n.info, errYieldNotAllowedInTryStmt) localError(n.info, errYieldNotAllowedInTryStmt)
elif n.sons[0].kind != nkEmpty: elif n.sons[0].kind != nkEmpty:
n.sons[0] = SemExprWithType(c, n.sons[0]) # check for type compatibility: n.sons[0] = semExprWithType(c, n.sons[0]) # check for type compatibility:
var restype = c.p.owner.typ.sons[0] var restype = c.p.owner.typ.sons[0]
if restype != nil: if restype != nil:
n.sons[0] = fitNode(c, restype, n.sons[0]) n.sons[0] = fitNode(c, restype, n.sons[0])
if n.sons[0].typ == nil: InternalError(n.info, "semYield") if n.sons[0].typ == nil: internalError(n.info, "semYield")
SemYieldVarResult(c, n, restype) semYieldVarResult(c, n, restype)
else: else:
localError(n.info, errCannotReturnExpr) localError(n.info, errCannotReturnExpr)
elif c.p.owner.typ.sons[0] != nil: elif c.p.owner.typ.sons[0] != nil:
@ -1270,12 +1270,12 @@ proc lookUpForDefined(c: PContext, i: PIdent, onlyCurrentScope: bool): PSym =
proc lookUpForDefined(c: PContext, n: PNode, onlyCurrentScope: bool): PSym = proc lookUpForDefined(c: PContext, n: PNode, onlyCurrentScope: bool): PSym =
case n.kind case n.kind
of nkIdent: of nkIdent:
result = lookupForDefined(c, n.ident, onlyCurrentScope) result = lookUpForDefined(c, n.ident, onlyCurrentScope)
of nkDotExpr: of nkDotExpr:
result = nil result = nil
if onlyCurrentScope: return if onlyCurrentScope: return
checkSonsLen(n, 2) checkSonsLen(n, 2)
var m = lookupForDefined(c, n.sons[0], onlyCurrentScope) var m = lookUpForDefined(c, n.sons[0], onlyCurrentScope)
if (m != nil) and (m.kind == skModule): if (m != nil) and (m.kind == skModule):
if (n.sons[1].kind == nkIdent): if (n.sons[1].kind == nkIdent):
var ident = n.sons[1].ident var ident = n.sons[1].ident
@ -1286,7 +1286,7 @@ proc lookUpForDefined(c: PContext, n: PNode, onlyCurrentScope: bool): PSym =
else: else:
localError(n.sons[1].info, errIdentifierExpected, "") localError(n.sons[1].info, errIdentifierExpected, "")
of nkAccQuoted: of nkAccQuoted:
result = lookupForDefined(c, considerAcc(n), onlyCurrentScope) result = lookUpForDefined(c, considerAcc(n), onlyCurrentScope)
of nkSym: of nkSym:
result = n.sym result = n.sym
else: else:
@ -1297,7 +1297,7 @@ proc semDefined(c: PContext, n: PNode, onlyCurrentScope: bool): PNode =
checkSonsLen(n, 2) checkSonsLen(n, 2)
# we replace this node by a 'true' or 'false' node: # we replace this node by a 'true' or 'false' node:
result = newIntNode(nkIntLit, 0) result = newIntNode(nkIntLit, 0)
if LookUpForDefined(c, n.sons[1], onlyCurrentScope) != nil: if lookUpForDefined(c, n.sons[1], onlyCurrentScope) != nil:
result.intVal = 1 result.intVal = 1
elif not onlyCurrentScope and (n.sons[1].kind == nkIdent) and elif not onlyCurrentScope and (n.sons[1].kind == nkIdent) and
condsyms.isDefined(n.sons[1].ident): condsyms.isDefined(n.sons[1].ident):
@ -1314,18 +1314,18 @@ proc expectMacroOrTemplateCall(c: PContext, n: PNode): PSym =
## The argument to the proc should be nkCall(...) or similar ## The argument to the proc should be nkCall(...) or similar
## Returns the macro/template symbol ## Returns the macro/template symbol
if isCallExpr(n): if isCallExpr(n):
var expandedSym = qualifiedLookup(c, n[0], {checkUndeclared}) var expandedSym = qualifiedLookUp(c, n[0], {checkUndeclared})
if expandedSym == nil: if expandedSym == nil:
LocalError(n.info, errUndeclaredIdentifier, n[0].renderTree) localError(n.info, errUndeclaredIdentifier, n[0].renderTree)
return errorSym(c, n[0]) return errorSym(c, n[0])
if expandedSym.kind notin {skMacro, skTemplate}: if expandedSym.kind notin {skMacro, skTemplate}:
LocalError(n.info, errXisNoMacroOrTemplate, expandedSym.name.s) localError(n.info, errXisNoMacroOrTemplate, expandedSym.name.s)
return errorSym(c, n[0]) return errorSym(c, n[0])
result = expandedSym result = expandedSym
else: else:
LocalError(n.info, errXisNoMacroOrTemplate, n.renderTree) localError(n.info, errXisNoMacroOrTemplate, n.renderTree)
result = errorSym(c, n) result = errorSym(c, n)
proc expectString(c: PContext, n: PNode): string = proc expectString(c: PContext, n: PNode): string =
@ -1333,10 +1333,10 @@ proc expectString(c: PContext, n: PNode): string =
if n.kind in nkStrKinds: if n.kind in nkStrKinds:
return n.strVal return n.strVal
else: else:
LocalError(n.info, errStringLiteralExpected) localError(n.info, errStringLiteralExpected)
proc getMagicSym(magic: TMagic): PSym = proc getMagicSym(magic: TMagic): PSym =
result = newSym(skProc, getIdent($magic), GetCurrOwner(), gCodegenLineInfo) result = newSym(skProc, getIdent($magic), getCurrOwner(), gCodegenLineInfo)
result.magic = magic result.magic = magic
proc newAnonSym(kind: TSymKind, info: TLineInfo, proc newAnonSym(kind: TSymKind, info: TLineInfo,
@ -1358,7 +1358,7 @@ proc semUsing(c: PContext, n: PNode): PNode =
continue continue
else: nil else: nil
LocalError(e.info, errUsingNoSymbol, e.renderTree) localError(e.info, errUsingNoSymbol, e.renderTree)
proc semExpandToAst(c: PContext, n: PNode): PNode = proc semExpandToAst(c: PContext, n: PNode): PNode =
var macroCall = n[1] var macroCall = n[1]
@ -1422,7 +1422,7 @@ proc semQuoteAst(c: PContext, n: PNode): PNode =
# this will store the generated param names # this will store the generated param names
if doBlk.kind != nkDo: if doBlk.kind != nkDo:
LocalError(n.info, errXExpected, "block") localError(n.info, errXExpected, "block")
processQuotations(doBlk.sons[bodyPos], op, quotes, ids) processQuotations(doBlk.sons[bodyPos], op, quotes, ids)
@ -1476,7 +1476,7 @@ proc tryExpr(c: PContext, n: PNode,
c.InGenericInst = oldInGenericInst c.InGenericInst = oldInGenericInst
c.p = oldProcCon c.p = oldProcCon
msgs.setInfoContextLen(oldContextLen) msgs.setInfoContextLen(oldContextLen)
setlen(gOwners, oldOwnerLen) setLen(gOwners, oldOwnerLen)
c.currentScope = oldScope c.currentScope = oldScope
dec c.InCompilesContext dec c.InCompilesContext
errorOutputs = oldErrorOutputs errorOutputs = oldErrorOutputs
@ -1556,7 +1556,7 @@ proc semWhen(c: PContext, n: PNode, semCheck = true): PNode =
# The ``when`` statement implements the mechanism for platform dependent # The ``when`` statement implements the mechanism for platform dependent
# code. Thus we try to ensure here consistent ID allocation after the # code. Thus we try to ensure here consistent ID allocation after the
# ``when`` statement. # ``when`` statement.
IDsynchronizationPoint(200) idSynchronizationPoint(200)
proc semSetConstr(c: PContext, n: PNode): PNode = proc semSetConstr(c: PContext, n: PNode): PNode =
result = newNodeI(nkCurly, n.info) result = newNodeI(nkCurly, n.info)
@ -1585,7 +1585,7 @@ proc semSetConstr(c: PContext, n: PNode): PNode =
if typ == nil: if typ == nil:
typ = skipTypes(n.sons[i].typ, {tyGenericInst, tyVar, tyOrdinal}) typ = skipTypes(n.sons[i].typ, {tyGenericInst, tyVar, tyOrdinal})
if not isOrdinalType(typ): if not isOrdinalType(typ):
LocalError(n.info, errOrdinalTypeExpected) localError(n.info, errOrdinalTypeExpected)
typ = makeRangeType(c, 0, MaxSetElements - 1, n.info) typ = makeRangeType(c, 0, MaxSetElements - 1, n.info)
elif lengthOrd(typ) > MaxSetElements: elif lengthOrd(typ) > MaxSetElements:
typ = makeRangeType(c, 0, MaxSetElements - 1, n.info) typ = makeRangeType(c, 0, MaxSetElements - 1, n.info)
@ -1642,11 +1642,11 @@ proc checkPar(n: PNode): TParKind =
if result == paTupleFields: if result == paTupleFields:
if (n.sons[i].kind != nkExprColonExpr) or if (n.sons[i].kind != nkExprColonExpr) or
not (n.sons[i].sons[0].kind in {nkSym, nkIdent}): not (n.sons[i].sons[0].kind in {nkSym, nkIdent}):
LocalError(n.sons[i].info, errNamedExprExpected) localError(n.sons[i].info, errNamedExprExpected)
return paNone return paNone
else: else:
if n.sons[i].kind == nkExprColonExpr: if n.sons[i].kind == nkExprColonExpr:
LocalError(n.sons[i].info, errNamedExprNotAllowed) localError(n.sons[i].info, errNamedExprNotAllowed)
return paNone return paNone
proc semTupleFieldsConstr(c: PContext, n: PNode, flags: TExprFlags): PNode = proc semTupleFieldsConstr(c: PContext, n: PNode, flags: TExprFlags): PNode =
@ -1661,7 +1661,7 @@ proc semTupleFieldsConstr(c: PContext, n: PNode, flags: TExprFlags): PNode =
var id: PIdent var id: PIdent
if n.sons[i].sons[0].kind == nkIdent: id = n.sons[i].sons[0].ident if n.sons[i].sons[0].kind == nkIdent: id = n.sons[i].sons[0].ident
else: id = n.sons[i].sons[0].sym.name else: id = n.sons[i].sons[0].sym.name
if ContainsOrIncl(ids, id.id): if containsOrIncl(ids, id.id):
localError(n.sons[i].info, errFieldInitTwice, id.s) localError(n.sons[i].info, errFieldInitTwice, id.s)
n.sons[i].sons[1] = semExprWithType(c, n.sons[i].sons[1], n.sons[i].sons[1] = semExprWithType(c, n.sons[i].sons[1],
flags*{efAllowDestructor}) flags*{efAllowDestructor})
@ -1688,7 +1688,7 @@ proc checkInitialized(n: PNode, ids: TIntSet, info: TLineInfo) =
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
checkInitialized(n.sons[i], ids, info) checkInitialized(n.sons[i], ids, info)
of nkRecCase: of nkRecCase:
if (n.sons[0].kind != nkSym): InternalError(info, "checkInitialized") if (n.sons[0].kind != nkSym): internalError(info, "checkInitialized")
checkInitialized(n.sons[0], ids, info) checkInitialized(n.sons[0], ids, info)
when false: when false:
# XXX we cannot check here, as we don't know the branch! # XXX we cannot check here, as we don't know the branch!
@ -1698,7 +1698,7 @@ proc checkInitialized(n: PNode, ids: TIntSet, info: TLineInfo) =
else: internalError(info, "checkInitialized") else: internalError(info, "checkInitialized")
of nkSym: of nkSym:
if tfNeedsInit in n.sym.typ.flags and n.sym.name.id notin ids: if tfNeedsInit in n.sym.typ.flags and n.sym.name.id notin ids:
Message(info, errGenerated, "field not initialized: " & n.sym.name.s) message(info, errGenerated, "field not initialized: " & n.sym.name.s)
else: internalError(info, "checkInitialized") else: internalError(info, "checkInitialized")
proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags): PNode = proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags): PNode =
@ -1721,7 +1721,7 @@ proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags): PNode =
var id: PIdent var id: PIdent
if it.sons[0].kind == nkIdent: id = it.sons[0].ident if it.sons[0].kind == nkIdent: id = it.sons[0].ident
else: id = it.sons[0].sym.name else: id = it.sons[0].sym.name
if ContainsOrIncl(ids, id.id): if containsOrIncl(ids, id.id):
localError(it.info, errFieldInitTwice, id.s) localError(it.info, errFieldInitTwice, id.s)
var e = semExprWithType(c, it.sons[1], flags*{efAllowDestructor}) var e = semExprWithType(c, it.sons[1], flags*{efAllowDestructor})
var var
@ -1754,7 +1754,7 @@ proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags): PNode =
proc semBlock(c: PContext, n: PNode): PNode = proc semBlock(c: PContext, n: PNode): PNode =
result = n result = n
Inc(c.p.nestedBlockCounter) inc(c.p.nestedBlockCounter)
checkSonsLen(n, 2) checkSonsLen(n, 2)
openScope(c) # BUGFIX: label is in the scope of block! openScope(c) # BUGFIX: label is in the scope of block!
if n.sons[0].kind != nkEmpty: if n.sons[0].kind != nkEmpty:
@ -1768,7 +1768,7 @@ proc semBlock(c: PContext, n: PNode): PNode =
if isEmptyType(n.typ): n.kind = nkBlockStmt if isEmptyType(n.typ): n.kind = nkBlockStmt
else: n.kind = nkBlockExpr else: n.kind = nkBlockExpr
closeScope(c) closeScope(c)
Dec(c.p.nestedBlockCounter) dec(c.p.nestedBlockCounter)
proc buildCall(n: PNode): PNode = proc buildCall(n: PNode): PNode =
if n.kind == nkDotExpr and n.len == 2: if n.kind == nkDotExpr and n.len == 2:
@ -1834,7 +1834,7 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
if result.kind == nkSym: if result.kind == nkSym:
markIndirect(c, result.sym) markIndirect(c, result.sym)
if isGenericRoutine(result.sym): if isGenericRoutine(result.sym):
LocalError(n.info, errInstantiateXExplicitely, s.name.s) localError(n.info, errInstantiateXExplicitely, s.name.s)
of nkSym: of nkSym:
# because of the changed symbol binding, this does not mean that we # because of the changed symbol binding, this does not mean that we
# don't have to check the symbol for semantics here again! # don't have to check the symbol for semantics here again!
@ -1881,7 +1881,7 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
result.kind = nkCall result.kind = nkCall
result = semExpr(c, result, flags) result = semExpr(c, result, flags)
of nkBind: of nkBind:
Message(n.info, warnDeprecated, "bind") message(n.info, warnDeprecated, "bind")
result = semExpr(c, n.sons[0], flags) result = semExpr(c, n.sons[0], flags)
of nkTypeOfExpr, nkTupleTy, nkRefTy..nkEnumTy: of nkTypeOfExpr, nkTupleTy, nkRefTy..nkEnumTy:
var typ = semTypeNode(c, n, nil).skipTypes({tyTypeDesc}) var typ = semTypeNode(c, n, nil).skipTypes({tyTypeDesc})
@ -1891,7 +1891,7 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
# check if it is an expression macro: # check if it is an expression macro:
checkMinSonsLen(n, 1) checkMinSonsLen(n, 1)
let mode = if nfDelegate in n.flags: {} else: {checkUndeclared} let mode = if nfDelegate in n.flags: {} else: {checkUndeclared}
var s = qualifiedLookup(c, n.sons[0], mode) var s = qualifiedLookUp(c, n.sons[0], mode)
if s != nil: if s != nil:
case s.kind case s.kind
of skMacro: of skMacro:
@ -1912,8 +1912,8 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
result = semConv(c, n) result = semConv(c, n)
elif n.len == 1: elif n.len == 1:
result = semObjConstr(c, n, flags) result = semObjConstr(c, n, flags)
elif Contains(c.AmbiguousSymbols, s.id): elif contains(c.AmbiguousSymbols, s.id):
LocalError(n.info, errUseQualifier, s.name.s) localError(n.info, errUseQualifier, s.name.s)
elif s.magic == mNone: result = semDirectOp(c, n, flags) elif s.magic == mNone: result = semDirectOp(c, n, flags)
else: result = semMagic(c, n, s, flags) else: result = semMagic(c, n, s, flags)
of skProc, skMethod, skConverter, skIterator: of skProc, skMethod, skConverter, skIterator:
@ -1937,7 +1937,7 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
result = semExpr(c, result, flags) result = semExpr(c, result, flags)
of nkBracketExpr: of nkBracketExpr:
checkMinSonsLen(n, 1) checkMinSonsLen(n, 1)
var s = qualifiedLookup(c, n.sons[0], {checkUndeclared}) var s = qualifiedLookUp(c, n.sons[0], {checkUndeclared})
if s != nil and s.kind in {skProc, skMethod, skConverter, skIterator}: if s != nil and s.kind in {skProc, skMethod, skConverter, skIterator}:
# type parameters: partial generic specialization # type parameters: partial generic specialization
n.sons[0] = semSymGenericInstantiation(c, n.sons[0], s) n.sons[0] = semSymGenericInstantiation(c, n.sons[0], s)
@ -1965,7 +1965,7 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
checkSonsLen(n, 1) checkSonsLen(n, 1)
n.sons[0] = semExprWithType(c, n.sons[0]) n.sons[0] = semExprWithType(c, n.sons[0])
if isAssignable(c, n.sons[0]) notin {arLValue, arLocalLValue}: if isAssignable(c, n.sons[0]) notin {arLValue, arLocalLValue}:
LocalError(n.info, errExprHasNoAddress) localError(n.info, errExprHasNoAddress)
n.typ = makePtrType(c, n.sons[0].typ) n.typ = makePtrType(c, n.sons[0].typ)
of nkHiddenAddr, nkHiddenDeref: of nkHiddenAddr, nkHiddenDeref:
checkSonsLen(n, 1) checkSonsLen(n, 1)
@ -1994,7 +1994,7 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
of nkVarSection: result = semVarOrLet(c, n, skVar) of nkVarSection: result = semVarOrLet(c, n, skVar)
of nkLetSection: result = semVarOrLet(c, n, skLet) of nkLetSection: result = semVarOrLet(c, n, skLet)
of nkConstSection: result = semConst(c, n) of nkConstSection: result = semConst(c, n)
of nkTypeSection: result = SemTypeSection(c, n) of nkTypeSection: result = semTypeSection(c, n)
of nkDiscardStmt: result = semDiscard(c, n) of nkDiscardStmt: result = semDiscard(c, n)
of nkWhileStmt: result = semWhile(c, n) of nkWhileStmt: result = semWhile(c, n)
of nkTryStmt: result = semTry(c, n) of nkTryStmt: result = semTry(c, n)
@ -2013,25 +2013,25 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
of nkMacroDef: result = semMacroDef(c, n) of nkMacroDef: result = semMacroDef(c, n)
of nkTemplateDef: result = semTemplateDef(c, n) of nkTemplateDef: result = semTemplateDef(c, n)
of nkImportStmt: of nkImportStmt:
if not isTopLevel(c): LocalError(n.info, errXOnlyAtModuleScope, "import") if not isTopLevel(c): localError(n.info, errXOnlyAtModuleScope, "import")
result = evalImport(c, n) result = evalImport(c, n)
of nkImportExceptStmt: of nkImportExceptStmt:
if not isTopLevel(c): LocalError(n.info, errXOnlyAtModuleScope, "import") if not isTopLevel(c): localError(n.info, errXOnlyAtModuleScope, "import")
result = evalImportExcept(c, n) result = evalImportExcept(c, n)
of nkFromStmt: of nkFromStmt:
if not isTopLevel(c): LocalError(n.info, errXOnlyAtModuleScope, "from") if not isTopLevel(c): localError(n.info, errXOnlyAtModuleScope, "from")
result = evalFrom(c, n) result = evalFrom(c, n)
of nkIncludeStmt: of nkIncludeStmt:
if not isTopLevel(c): LocalError(n.info, errXOnlyAtModuleScope, "include") if not isTopLevel(c): localError(n.info, errXOnlyAtModuleScope, "include")
result = evalInclude(c, n) result = evalInclude(c, n)
of nkExportStmt, nkExportExceptStmt: of nkExportStmt, nkExportExceptStmt:
if not isTopLevel(c): LocalError(n.info, errXOnlyAtModuleScope, "export") if not isTopLevel(c): localError(n.info, errXOnlyAtModuleScope, "export")
result = semExport(c, n) result = semExport(c, n)
of nkPragmaBlock: of nkPragmaBlock:
result = semPragmaBlock(c, n) result = semPragmaBlock(c, n)
of nkStaticStmt: of nkStaticStmt:
result = semStaticStmt(c, n) result = semStaticStmt(c, n)
else: else:
LocalError(n.info, errInvalidExpressionX, localError(n.info, errInvalidExpressionX,
renderTree(n, {renderNoComments})) renderTree(n, {renderNoComments}))
if result != nil: incl(result.flags, nfSem) if result != nil: incl(result.flags, nfSem)

58
compiler/semfold.nim
View file

@ -66,14 +66,14 @@ proc ordinalValToString*(a: PNode): string =
of tyEnum: of tyEnum:
var n = t.n var n = t.n
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
if n.sons[i].kind != nkSym: InternalError(a.info, "ordinalValToString") if n.sons[i].kind != nkSym: internalError(a.info, "ordinalValToString")
var field = n.sons[i].sym var field = n.sons[i].sym
if field.position == x: if field.position == x:
if field.ast == nil: if field.ast == nil:
return field.name.s return field.name.s
else: else:
return field.ast.strVal return field.ast.strVal
InternalError(a.info, "no symbol for ordinal value: " & $x) internalError(a.info, "no symbol for ordinal value: " & $x)
else: else:
result = $x result = $x
@ -92,7 +92,7 @@ proc pickIntRange(a, b: PType): PType =
proc isIntRangeOrLit(t: PType): bool = proc isIntRangeOrLit(t: PType): bool =
result = isIntRange(t) or isIntLit(t) result = isIntRange(t) or isIntLit(t)
proc pickMinInt(n: PNode): biggestInt = proc pickMinInt(n: PNode): BiggestInt =
if n.kind in {nkIntLit..nkUInt64Lit}: if n.kind in {nkIntLit..nkUInt64Lit}:
result = n.intVal result = n.intVal
elif isIntLit(n.typ): elif isIntLit(n.typ):
@ -100,9 +100,9 @@ proc pickMinInt(n: PNode): biggestInt =
elif isIntRange(n.typ): elif isIntRange(n.typ):
result = firstOrd(n.typ) result = firstOrd(n.typ)
else: else:
InternalError(n.info, "pickMinInt") internalError(n.info, "pickMinInt")
proc pickMaxInt(n: PNode): biggestInt = proc pickMaxInt(n: PNode): BiggestInt =
if n.kind in {nkIntLit..nkUInt64Lit}: if n.kind in {nkIntLit..nkUInt64Lit}:
result = n.intVal result = n.intVal
elif isIntLit(n.typ): elif isIntLit(n.typ):
@ -110,9 +110,9 @@ proc pickMaxInt(n: PNode): biggestInt =
elif isIntRange(n.typ): elif isIntRange(n.typ):
result = lastOrd(n.typ) result = lastOrd(n.typ)
else: else:
InternalError(n.info, "pickMaxInt") internalError(n.info, "pickMaxInt")
proc makeRange(typ: PType, first, last: biggestInt): PType = proc makeRange(typ: PType, first, last: BiggestInt): PType =
var n = newNode(nkRange) var n = newNode(nkRange)
addSon(n, newIntNode(nkIntLit, min(first, last))) addSon(n, newIntNode(nkIntLit, min(first, last)))
addSon(n, newIntNode(nkIntLit, max(first, last))) addSon(n, newIntNode(nkIntLit, max(first, last)))
@ -120,7 +120,7 @@ proc makeRange(typ: PType, first, last: biggestInt): PType =
result.n = n result.n = n
addSonSkipIntLit(result, skipTypes(typ, {tyRange})) addSonSkipIntLit(result, skipTypes(typ, {tyRange}))
proc makeRangeF(typ: PType, first, last: biggestFloat): PType = proc makeRangeF(typ: PType, first, last: BiggestFloat): PType =
var n = newNode(nkRange) var n = newNode(nkRange)
addSon(n, newFloatNode(nkFloatLit, min(first.float, last.float))) addSon(n, newFloatNode(nkFloatLit, min(first.float, last.float)))
addSon(n, newFloatNode(nkFloatLit, max(first.float, last.float))) addSon(n, newFloatNode(nkFloatLit, max(first.float, last.float)))
@ -303,7 +303,7 @@ proc evalOp(m: TMagic, n, a, b, c: PNode): PNode =
of tyInt32: result = newIntNodeT(int32(getInt(a)) shl int32(getInt(b)), n) of tyInt32: result = newIntNodeT(int32(getInt(a)) shl int32(getInt(b)), n)
of tyInt64, tyInt, tyUInt..tyUInt64: of tyInt64, tyInt, tyUInt..tyUInt64:
result = newIntNodeT(`shl`(getInt(a), getInt(b)), n) result = newIntNodeT(`shl`(getInt(a), getInt(b)), n)
else: InternalError(n.info, "constant folding for shl") else: internalError(n.info, "constant folding for shl")
of mShrI, mShrI64: of mShrI, mShrI64:
case skipTypes(n.typ, abstractRange).kind case skipTypes(n.typ, abstractRange).kind
of tyInt8: result = newIntNodeT(int8(getInt(a)) shr int8(getInt(b)), n) of tyInt8: result = newIntNodeT(int8(getInt(a)) shr int8(getInt(b)), n)
@ -311,7 +311,7 @@ proc evalOp(m: TMagic, n, a, b, c: PNode): PNode =
of tyInt32: result = newIntNodeT(int32(getInt(a)) shr int32(getInt(b)), n) of tyInt32: result = newIntNodeT(int32(getInt(a)) shr int32(getInt(b)), n)
of tyInt64, tyInt, tyUInt..tyUInt64: of tyInt64, tyInt, tyUInt..tyUInt64:
result = newIntNodeT(`shr`(getInt(a), getInt(b)), n) result = newIntNodeT(`shr`(getInt(a), getInt(b)), n)
else: InternalError(n.info, "constant folding for shr") else: internalError(n.info, "constant folding for shr")
of mDivI, mDivI64: result = newIntNodeT(getInt(a) div getInt(b), n) of mDivI, mDivI64: result = newIntNodeT(getInt(a) div getInt(b), n)
of mModI, mModI64: result = newIntNodeT(getInt(a) mod getInt(b), n) of mModI, mModI64: result = newIntNodeT(getInt(a) mod getInt(b), n)
of mAddF64: result = newFloatNodeT(getFloat(a) + getFloat(b), n) of mAddF64: result = newFloatNodeT(getFloat(a) + getFloat(b), n)
@ -354,10 +354,10 @@ proc evalOp(m: TMagic, n, a, b, c: PNode): PNode =
of mMulU: result = newIntNodeT(`*%`(getInt(a), getInt(b)), n) of mMulU: result = newIntNodeT(`*%`(getInt(a), getInt(b)), n)
of mModU: result = newIntNodeT(`%%`(getInt(a), getInt(b)), n) of mModU: result = newIntNodeT(`%%`(getInt(a), getInt(b)), n)
of mDivU: result = newIntNodeT(`/%`(getInt(a), getInt(b)), n) of mDivU: result = newIntNodeT(`/%`(getInt(a), getInt(b)), n)
of mLeSet: result = newIntNodeT(Ord(containsSets(a, b)), n) of mLeSet: result = newIntNodeT(ord(containsSets(a, b)), n)
of mEqSet: result = newIntNodeT(Ord(equalSets(a, b)), n) of mEqSet: result = newIntNodeT(ord(equalSets(a, b)), n)
of mLtSet: of mLtSet:
result = newIntNodeT(Ord(containsSets(a, b) and not equalSets(a, b)), n) result = newIntNodeT(ord(containsSets(a, b) and not equalSets(a, b)), n)
of mMulSet: of mMulSet:
result = nimsets.intersectSets(a, b) result = nimsets.intersectSets(a, b)
result.info = n.info result.info = n.info
@ -371,7 +371,7 @@ proc evalOp(m: TMagic, n, a, b, c: PNode): PNode =
result = nimsets.symdiffSets(a, b) result = nimsets.symdiffSets(a, b)
result.info = n.info result.info = n.info
of mConStrStr: result = newStrNodeT(getStrOrChar(a) & getStrOrChar(b), n) of mConStrStr: result = newStrNodeT(getStrOrChar(a) & getStrOrChar(b), n)
of mInSet: result = newIntNodeT(Ord(inSet(a, b)), n) of mInSet: result = newIntNodeT(ord(inSet(a, b)), n)
of mRepr: of mRepr:
# BUGFIX: we cannot eval mRepr here for reasons that I forgot. # BUGFIX: we cannot eval mRepr here for reasons that I forgot.
of mIntToStr, mInt64ToStr: result = newStrNodeT($(getOrdValue(a)), n) of mIntToStr, mInt64ToStr: result = newStrNodeT($(getOrdValue(a)), n)
@ -390,9 +390,9 @@ proc evalOp(m: TMagic, n, a, b, c: PNode): PNode =
result = copyTree(a) result = copyTree(a)
result.typ = n.typ result.typ = n.typ
of mCompileOption: of mCompileOption:
result = newIntNodeT(Ord(commands.testCompileOption(a.getStr, n.info)), n) result = newIntNodeT(ord(commands.testCompileOption(a.getStr, n.info)), n)
of mCompileOptionArg: of mCompileOptionArg:
result = newIntNodeT(Ord( result = newIntNodeT(ord(
testCompileOptionArg(getStr(a), getStr(b), n.info)), n) testCompileOptionArg(getStr(a), getStr(b), n.info)), n)
of mNewString, mNewStringOfCap, of mNewString, mNewStringOfCap,
mExit, mInc, ast.mDec, mEcho, mSwap, mAppendStrCh, mExit, mInc, ast.mDec, mEcho, mSwap, mAppendStrCh,
@ -402,7 +402,7 @@ proc evalOp(m: TMagic, n, a, b, c: PNode): PNode =
discard discard
of mRand: of mRand:
result = newIntNodeT(math.random(a.getInt.int), n) result = newIntNodeT(math.random(a.getInt.int), n)
else: InternalError(a.info, "evalOp(" & $m & ')') else: internalError(a.info, "evalOp(" & $m & ')')
proc getConstIfExpr(c: PSym, n: PNode): PNode = proc getConstIfExpr(c: PSym, n: PNode): PNode =
result = nil result = nil
@ -452,13 +452,13 @@ proc leValueConv(a, b: PNode): bool =
case b.kind case b.kind
of nkCharLit..nkUInt64Lit: result = a.intVal <= b.intVal of nkCharLit..nkUInt64Lit: result = a.intVal <= b.intVal
of nkFloatLit..nkFloat128Lit: result = a.intVal <= round(b.floatVal) of nkFloatLit..nkFloat128Lit: result = a.intVal <= round(b.floatVal)
else: InternalError(a.info, "leValueConv") else: internalError(a.info, "leValueConv")
of nkFloatLit..nkFloat128Lit: of nkFloatLit..nkFloat128Lit:
case b.kind case b.kind
of nkFloatLit..nkFloat128Lit: result = a.floatVal <= b.floatVal of nkFloatLit..nkFloat128Lit: result = a.floatVal <= b.floatVal
of nkCharLit..nkUInt64Lit: result = a.floatVal <= toFloat(int(b.intVal)) of nkCharLit..nkUInt64Lit: result = a.floatVal <= toFloat(int(b.intVal))
else: InternalError(a.info, "leValueConv") else: internalError(a.info, "leValueConv")
else: InternalError(a.info, "leValueConv") else: internalError(a.info, "leValueConv")
proc magicCall(m: PSym, n: PNode): PNode = proc magicCall(m: PSym, n: PNode): PNode =
if sonsLen(n) <= 1: return if sonsLen(n) <= 1: return
@ -485,9 +485,9 @@ proc getAppType(n: PNode): PNode =
else: else:
result = newStrNodeT("console", n) result = newStrNodeT("console", n)
proc rangeCheck(n: PNode, value: biggestInt) = proc rangeCheck(n: PNode, value: BiggestInt) =
if value < firstOrd(n.typ) or value > lastOrd(n.typ): if value < firstOrd(n.typ) or value > lastOrd(n.typ):
LocalError(n.info, errGenerated, "cannot convert " & $value & localError(n.info, errGenerated, "cannot convert " & $value &
" to " & typeToString(n.typ)) " to " & typeToString(n.typ))
proc foldConv*(n, a: PNode; check = false): PNode = proc foldConv*(n, a: PNode; check = false): PNode =
@ -536,10 +536,10 @@ proc foldArrayAccess(m: PSym, n: PNode): PNode =
result = x.sons[int(idx)] result = x.sons[int(idx)]
if result.kind == nkExprColonExpr: result = result.sons[1] if result.kind == nkExprColonExpr: result = result.sons[1]
else: else:
LocalError(n.info, errIndexOutOfBounds) localError(n.info, errIndexOutOfBounds)
of nkBracket, nkMetaNode: of nkBracket, nkMetaNode:
if (idx >= 0) and (idx < sonsLen(x)): result = x.sons[int(idx)] if (idx >= 0) and (idx < sonsLen(x)): result = x.sons[int(idx)]
else: LocalError(n.info, errIndexOutOfBounds) else: localError(n.info, errIndexOutOfBounds)
of nkStrLit..nkTripleStrLit: of nkStrLit..nkTripleStrLit:
result = newNodeIT(nkCharLit, x.info, n.typ) result = newNodeIT(nkCharLit, x.info, n.typ)
if (idx >= 0) and (idx < len(x.strVal)): if (idx >= 0) and (idx < len(x.strVal)):
@ -547,7 +547,7 @@ proc foldArrayAccess(m: PSym, n: PNode): PNode =
elif idx == len(x.strVal): elif idx == len(x.strVal):
nil nil
else: else:
LocalError(n.info, errIndexOutOfBounds) localError(n.info, errIndexOutOfBounds)
else: discard else: discard
proc foldFieldAccess(m: PSym, n: PNode): PNode = proc foldFieldAccess(m: PSym, n: PNode): PNode =
@ -634,7 +634,7 @@ proc getConstExpr(m: PSym, n: PNode): PNode =
of mSizeOf: of mSizeOf:
var a = n.sons[1] var a = n.sons[1]
if computeSize(a.typ) < 0: if computeSize(a.typ) < 0:
LocalError(a.info, errCannotEvalXBecauseIncompletelyDefined, localError(a.info, errCannotEvalXBecauseIncompletelyDefined,
"sizeof") "sizeof")
result = nil result = nil
elif skipTypes(a.typ, typedescInst).kind in elif skipTypes(a.typ, typedescInst).kind in
@ -677,9 +677,9 @@ proc getConstExpr(m: PSym, n: PNode): PNode =
else: else:
result = magicCall(m, n) result = magicCall(m, n)
except EOverflow: except EOverflow:
LocalError(n.info, errOverOrUnderflow) localError(n.info, errOverOrUnderflow)
except EDivByZero: except EDivByZero:
LocalError(n.info, errConstantDivisionByZero) localError(n.info, errConstantDivisionByZero)
of nkAddr: of nkAddr:
var a = getConstExpr(m, n.sons[0]) var a = getConstExpr(m, n.sons[0])
if a != nil: if a != nil:
@ -735,7 +735,7 @@ proc getConstExpr(m: PSym, n: PNode): PNode =
result = a # a <= x and x <= b result = a # a <= x and x <= b
result.typ = n.typ result.typ = n.typ
else: else:
LocalError(n.info, errGenerated, `%`( localError(n.info, errGenerated, `%`(
msgKindToString(errIllegalConvFromXtoY), msgKindToString(errIllegalConvFromXtoY),
[typeToString(n.sons[0].typ), typeToString(n.typ)])) [typeToString(n.sons[0].typ), typeToString(n.typ)]))
of nkStringToCString, nkCStringToString: of nkStringToCString, nkCStringToString:

18
compiler/semgnrc.nim
View file

@ -96,10 +96,10 @@ proc semGenericStmt(c: PContext, n: PNode,
if gCmd == cmdIdeTools: suggestStmt(c, n) if gCmd == cmdIdeTools: suggestStmt(c, n)
case n.kind case n.kind
of nkIdent, nkAccQuoted: of nkIdent, nkAccQuoted:
result = Lookup(c, n, flags, ctx) result = lookup(c, n, flags, ctx)
of nkDotExpr: of nkDotExpr:
let luf = if withinMixin notin flags: {checkUndeclared} else: {} let luf = if withinMixin notin flags: {checkUndeclared} else: {}
var s = QualifiedLookUp(c, n, luf) var s = qualifiedLookUp(c, n, luf)
if s != nil: result = semGenericStmtSymbol(c, n, s) if s != nil: result = semGenericStmtSymbol(c, n, s)
# XXX for example: ``result.add`` -- ``add`` needs to be looked up here... # XXX for example: ``result.add`` -- ``add`` needs to be looked up here...
of nkEmpty, nkSym..nkNilLit: of nkEmpty, nkSym..nkNilLit:
@ -119,7 +119,7 @@ proc semGenericStmt(c: PContext, n: PNode,
# check if it is an expression macro: # check if it is an expression macro:
checkMinSonsLen(n, 1) checkMinSonsLen(n, 1)
let fn = n.sons[0] let fn = n.sons[0]
var s = qualifiedLookup(c, fn, {}) var s = qualifiedLookUp(c, fn, {})
if s == nil and withinMixin notin flags and if s == nil and withinMixin notin flags and
fn.kind in {nkIdent, nkAccQuoted} and considerAcc(fn).id notin ctx: fn.kind in {nkIdent, nkAccQuoted} and considerAcc(fn).id notin ctx:
localError(n.info, errUndeclaredIdentifier, fn.renderTree) localError(n.info, errUndeclaredIdentifier, fn.renderTree)
@ -219,7 +219,7 @@ proc semGenericStmt(c: PContext, n: PNode,
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
var a = n.sons[i] var a = n.sons[i]
if a.kind == nkCommentStmt: continue if a.kind == nkCommentStmt: continue
if (a.kind != nkIdentDefs) and (a.kind != nkVarTuple): IllFormedAst(a) if (a.kind != nkIdentDefs) and (a.kind != nkVarTuple): illFormedAst(a)
checkMinSonsLen(a, 3) checkMinSonsLen(a, 3)
var L = sonsLen(a) var L = sonsLen(a)
a.sons[L-2] = semGenericStmt(c, a.sons[L-2], flags+{withinTypeDesc}, a.sons[L-2] = semGenericStmt(c, a.sons[L-2], flags+{withinTypeDesc},
@ -230,7 +230,7 @@ proc semGenericStmt(c: PContext, n: PNode,
of nkGenericParams: of nkGenericParams:
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
var a = n.sons[i] var a = n.sons[i]
if (a.kind != nkIdentDefs): IllFormedAst(a) if (a.kind != nkIdentDefs): illFormedAst(a)
checkMinSonsLen(a, 3) checkMinSonsLen(a, 3)
var L = sonsLen(a) var L = sonsLen(a)
a.sons[L-2] = semGenericStmt(c, a.sons[L-2], flags+{withinTypeDesc}, a.sons[L-2] = semGenericStmt(c, a.sons[L-2], flags+{withinTypeDesc},
@ -242,7 +242,7 @@ proc semGenericStmt(c: PContext, n: PNode,
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
var a = n.sons[i] var a = n.sons[i]
if a.kind == nkCommentStmt: continue if a.kind == nkCommentStmt: continue
if (a.kind != nkConstDef): IllFormedAst(a) if (a.kind != nkConstDef): illFormedAst(a)
checkSonsLen(a, 3) checkSonsLen(a, 3)
addPrelimDecl(c, newSymS(skUnknown, getIdentNode(a.sons[0]), c)) addPrelimDecl(c, newSymS(skUnknown, getIdentNode(a.sons[0]), c))
a.sons[1] = semGenericStmt(c, a.sons[1], flags+{withinTypeDesc}, ctx) a.sons[1] = semGenericStmt(c, a.sons[1], flags+{withinTypeDesc}, ctx)
@ -251,13 +251,13 @@ proc semGenericStmt(c: PContext, n: PNode,
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
var a = n.sons[i] var a = n.sons[i]
if a.kind == nkCommentStmt: continue if a.kind == nkCommentStmt: continue
if (a.kind != nkTypeDef): IllFormedAst(a) if (a.kind != nkTypeDef): illFormedAst(a)
checkSonsLen(a, 3) checkSonsLen(a, 3)
addPrelimDecl(c, newSymS(skUnknown, getIdentNode(a.sons[0]), c)) addPrelimDecl(c, newSymS(skUnknown, getIdentNode(a.sons[0]), c))
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
var a = n.sons[i] var a = n.sons[i]
if a.kind == nkCommentStmt: continue if a.kind == nkCommentStmt: continue
if (a.kind != nkTypeDef): IllFormedAst(a) if (a.kind != nkTypeDef): illFormedAst(a)
checkSonsLen(a, 3) checkSonsLen(a, 3)
if a.sons[1].kind != nkEmpty: if a.sons[1].kind != nkEmpty:
openScope(c) openScope(c)
@ -285,7 +285,7 @@ proc semGenericStmt(c: PContext, n: PNode,
n.sons[0] = semGenericStmt(c, n.sons[0], flags+{withinTypeDesc}, ctx) n.sons[0] = semGenericStmt(c, n.sons[0], flags+{withinTypeDesc}, ctx)
for i in countup(1, sonsLen(n) - 1): for i in countup(1, sonsLen(n) - 1):
var a = n.sons[i] var a = n.sons[i]
if (a.kind != nkIdentDefs): IllFormedAst(a) if (a.kind != nkIdentDefs): illFormedAst(a)
checkMinSonsLen(a, 3) checkMinSonsLen(a, 3)
var L = sonsLen(a) var L = sonsLen(a)
a.sons[L-2] = semGenericStmt(c, a.sons[L-2], flags+{withinTypeDesc}, a.sons[L-2] = semGenericStmt(c, a.sons[L-2], flags+{withinTypeDesc},

32
compiler/seminst.nim
View file

@ -13,28 +13,28 @@
proc instantiateGenericParamList(c: PContext, n: PNode, pt: TIdTable, proc instantiateGenericParamList(c: PContext, n: PNode, pt: TIdTable,
entry: var TInstantiation) = entry: var TInstantiation) =
if n.kind != nkGenericParams: if n.kind != nkGenericParams:
InternalError(n.info, "instantiateGenericParamList; no generic params") internalError(n.info, "instantiateGenericParamList; no generic params")
newSeq(entry.concreteTypes, n.len) newSeq(entry.concreteTypes, n.len)
for i in countup(0, n.len - 1): for i in countup(0, n.len - 1):
var a = n.sons[i] var a = n.sons[i]
if a.kind != nkSym: if a.kind != nkSym:
InternalError(a.info, "instantiateGenericParamList; no symbol") internalError(a.info, "instantiateGenericParamList; no symbol")
var q = a.sym var q = a.sym
if q.typ.kind notin {tyTypeDesc, tyGenericParam, tyExpr}+tyTypeClasses: if q.typ.kind notin {tyTypeDesc, tyGenericParam, tyExpr}+tyTypeClasses:
continue continue
var s = newSym(skType, q.name, getCurrOwner(), q.info) var s = newSym(skType, q.name, getCurrOwner(), q.info)
s.flags = s.flags + {sfUsed, sfFromGeneric} s.flags = s.flags + {sfUsed, sfFromGeneric}
var t = PType(IdTableGet(pt, q.typ)) var t = PType(idTableGet(pt, q.typ))
if t == nil: if t == nil:
if tfRetType in q.typ.flags: if tfRetType in q.typ.flags:
# keep the generic type and allow the return type to be bound # keep the generic type and allow the return type to be bound
# later by semAsgn in return type inference scenario # later by semAsgn in return type inference scenario
t = q.typ t = q.typ
else: else:
LocalError(a.info, errCannotInstantiateX, s.name.s) localError(a.info, errCannotInstantiateX, s.name.s)
t = errorType(c) t = errorType(c)
elif t.kind == tyGenericParam: elif t.kind == tyGenericParam:
InternalError(a.info, "instantiateGenericParamList: " & q.name.s) internalError(a.info, "instantiateGenericParamList: " & q.name.s)
elif t.kind == tyGenericInvokation: elif t.kind == tyGenericInvokation:
#t = instGenericContainer(c, a, t) #t = instGenericContainer(c, a, t)
t = generateTypeInstance(c, pt, a, t) t = generateTypeInstance(c, pt, a, t)
@ -50,7 +50,7 @@ proc sameInstantiation(a, b: TInstantiation): bool =
flags = {TypeDescExactMatch}): return flags = {TypeDescExactMatch}): return
result = true result = true
proc genericCacheGet(genericSym: Psym, entry: TInstantiation): PSym = proc genericCacheGet(genericSym: PSym, entry: TInstantiation): PSym =
if genericSym.procInstCache != nil: if genericSym.procInstCache != nil:
for inst in genericSym.procInstCache: for inst in genericSym.procInstCache:
if sameInstantiation(entry, inst[]): if sameInstantiation(entry, inst[]):
@ -75,11 +75,11 @@ proc removeDefaultParamValues(n: PNode) =
proc freshGenSyms(n: PNode, owner: PSym, symMap: var TIdTable) = proc freshGenSyms(n: PNode, owner: PSym, symMap: var TIdTable) =
# we need to create a fresh set of gensym'ed symbols: # we need to create a fresh set of gensym'ed symbols:
if n.kind == nkSym and sfGenSym in n.sym.flags: if n.kind == nkSym and sfGenSym in n.sym.flags:
var x = PSym(IdTableGet(symMap, n.sym)) var x = PSym(idTableGet(symMap, n.sym))
if x == nil: if x == nil:
x = copySym(n.sym, false) x = copySym(n.sym, false)
x.owner = owner x.owner = owner
IdTablePut(symMap, n.sym, x) idTablePut(symMap, n.sym, x)
n.sym = x n.sym = x
else: else:
for i in 0 .. <safeLen(n): freshGenSyms(n.sons[i], owner, symMap) for i in 0 .. <safeLen(n): freshGenSyms(n.sons[i], owner, symMap)
@ -101,7 +101,7 @@ proc instantiateBody(c: PContext, n: PNode, result: PSym) =
maybeAddResult(c, result, n) maybeAddResult(c, result, n)
var b = n.sons[bodyPos] var b = n.sons[bodyPos]
var symMap: TIdTable var symMap: TIdTable
InitIdTable symMap initIdTable symMap
freshGenSyms(b, result, symMap) freshGenSyms(b, result, symMap)
b = semProcBody(c, b) b = semProcBody(c, b)
b = hloBody(c, b) b = hloBody(c, b)
@ -126,7 +126,7 @@ proc fixupInstantiatedSymbols(c: PContext, s: PSym) =
proc sideEffectsCheck(c: PContext, s: PSym) = proc sideEffectsCheck(c: PContext, s: PSym) =
if {sfNoSideEffect, sfSideEffect} * s.flags == if {sfNoSideEffect, sfSideEffect} * s.flags ==
{sfNoSideEffect, sfSideEffect}: {sfNoSideEffect, sfSideEffect}:
LocalError(s.info, errXhasSideEffects, s.name.s) localError(s.info, errXhasSideEffects, s.name.s)
elif sfThread in s.flags and semthreads.needsGlobalAnalysis() and elif sfThread in s.flags and semthreads.needsGlobalAnalysis() and
s.ast.sons[genericParamsPos].kind == nkEmpty: s.ast.sons[genericParamsPos].kind == nkEmpty:
c.threadEntries.add(s) c.threadEntries.add(s)
@ -170,11 +170,11 @@ proc instGenericContainer(c: PContext, info: TLineInfo, header: PType): PType =
lateInstantiateGeneric(c, header, info) lateInstantiateGeneric(c, header, info)
else: else:
var cl: TReplTypeVars var cl: TReplTypeVars
InitIdTable(cl.symMap) initIdTable(cl.symMap)
InitIdTable(cl.typeMap) initIdTable(cl.typeMap)
cl.info = info cl.info = info
cl.c = c cl.c = c
result = ReplaceTypeVarsT(cl, header) result = replaceTypeVarsT(cl, header)
proc instGenericContainer(c: PContext, n: PNode, header: PType): PType = proc instGenericContainer(c: PContext, n: PNode, header: PType): PType =
result = instGenericContainer(c, n.info, header) result = instGenericContainer(c, n.info, header)
@ -265,7 +265,7 @@ proc generateInstance(c: PContext, fn: PSym, pt: TIdTable,
if fn.kind in {skTemplate, skMacro}: return fn if fn.kind in {skTemplate, skMacro}: return fn
# generates an instantiated proc # generates an instantiated proc
if c.InstCounter > 1000: InternalError(fn.ast.info, "nesting too deep") if c.InstCounter > 1000: internalError(fn.ast.info, "nesting too deep")
inc(c.InstCounter) inc(c.InstCounter)
# careful! we copy the whole AST including the possibly nil body! # careful! we copy the whole AST including the possibly nil body!
var n = copyTree(fn.ast) var n = copyTree(fn.ast)
@ -282,7 +282,7 @@ proc generateInstance(c: PContext, fn: PSym, pt: TIdTable,
pushOwner(result) pushOwner(result)
openScope(c) openScope(c)
if n.sons[genericParamsPos].kind == nkEmpty: if n.sons[genericParamsPos].kind == nkEmpty:
InternalError(n.info, "generateInstance") internalError(n.info, "generateInstance")
n.sons[namePos] = newSymNode(result) n.sons[namePos] = newSymNode(result)
pushInfoContext(info) pushInfoContext(info)
var entry = TInstantiation.new var entry = TInstantiation.new
@ -301,7 +301,7 @@ proc generateInstance(c: PContext, fn: PSym, pt: TIdTable,
if fn.kind != skTemplate: if fn.kind != skTemplate:
instantiateBody(c, n, result) instantiateBody(c, n, result)
sideEffectsCheck(c, result) sideEffectsCheck(c, result)
ParamsTypeCheck(c, result.typ) paramsTypeCheck(c, result.typ)
else: else:
result = oldPrc result = oldPrc
popInfoContext() popInfoContext()

14
compiler/semmagic.nim
View file

@ -18,7 +18,7 @@ proc expectIntLit(c: PContext, n: PNode): int =
let x = c.semConstExpr(c, n) let x = c.semConstExpr(c, n)
case x.kind case x.kind
of nkIntLit..nkInt64Lit: result = int(x.intVal) of nkIntLit..nkInt64Lit: result = int(x.intVal)
else: LocalError(n.info, errIntLiteralExpected) else: localError(n.info, errIntLiteralExpected)
proc semInstantiationInfo(c: PContext, n: PNode): PNode = proc semInstantiationInfo(c: PContext, n: PNode): PNode =
result = newNodeIT(nkPar, n.info, n.typ) result = newNodeIT(nkPar, n.info, n.typ)
@ -28,7 +28,7 @@ proc semInstantiationInfo(c: PContext, n: PNode): PNode =
var filename = newNodeIT(nkStrLit, n.info, getSysType(tyString)) var filename = newNodeIT(nkStrLit, n.info, getSysType(tyString))
filename.strVal = if useFullPaths != 0: info.toFullPath else: info.ToFilename filename.strVal = if useFullPaths != 0: info.toFullPath else: info.ToFilename
var line = newNodeIT(nkIntLit, n.info, getSysType(tyInt)) var line = newNodeIT(nkIntLit, n.info, getSysType(tyInt))
line.intVal = ToLinenumber(info) line.intVal = toLinenumber(info)
result.add(filename) result.add(filename)
result.add(line) result.add(line)
@ -54,7 +54,7 @@ proc semTypeTraits(c: PContext, n: PNode): PNode =
if t.kind == tyTypeDesc and t.len == 0: if t.kind == tyTypeDesc and t.len == 0:
result = n result = n
elif not containsGenericType(t): elif not containsGenericType(t):
result = evalTypeTrait(n[0], t, GetCurrOwner()) result = evalTypeTrait(n[0], t, getCurrOwner())
else: else:
# a typedesc variable, pass unmodified to evals # a typedesc variable, pass unmodified to evals
result = n result = n
@ -70,23 +70,23 @@ proc semBindSym(c: PContext, n: PNode): PNode =
let sl = semConstExpr(c, n.sons[1]) let sl = semConstExpr(c, n.sons[1])
if sl.kind notin {nkStrLit, nkRStrLit, nkTripleStrLit}: if sl.kind notin {nkStrLit, nkRStrLit, nkTripleStrLit}:
LocalError(n.sons[1].info, errStringLiteralExpected) localError(n.sons[1].info, errStringLiteralExpected)
return errorNode(c, n) return errorNode(c, n)
let isMixin = semConstExpr(c, n.sons[2]) let isMixin = semConstExpr(c, n.sons[2])
if isMixin.kind != nkIntLit or isMixin.intVal < 0 or if isMixin.kind != nkIntLit or isMixin.intVal < 0 or
isMixin.intVal > high(TSymChoiceRule).int: isMixin.intVal > high(TSymChoiceRule).int:
LocalError(n.sons[2].info, errConstExprExpected) localError(n.sons[2].info, errConstExprExpected)
return errorNode(c, n) return errorNode(c, n)
let id = newIdentNode(getIdent(sl.strVal), n.info) let id = newIdentNode(getIdent(sl.strVal), n.info)
let s = QualifiedLookUp(c, id) let s = qualifiedLookUp(c, id)
if s != nil: if s != nil:
# we need to mark all symbols: # we need to mark all symbols:
var sc = symChoice(c, id, s, TSymChoiceRule(isMixin.intVal)) var sc = symChoice(c, id, s, TSymChoiceRule(isMixin.intVal))
result.add(sc) result.add(sc)
else: else:
LocalError(n.sons[1].info, errUndeclaredIdentifier, sl.strVal) localError(n.sons[1].info, errUndeclaredIdentifier, sl.strVal)
proc semLocals(c: PContext, n: PNode): PNode = proc semLocals(c: PContext, n: PNode): PNode =
var counter = 0 var counter = 0

18
compiler/sempass2.nim
View file

@ -95,12 +95,12 @@ proc useVar(a: PEffects, n: PNode) =
if s.id notin a.init: if s.id notin a.init:
if {tfNeedsInit, tfNotNil} * s.typ.flags != {}: if {tfNeedsInit, tfNotNil} * s.typ.flags != {}:
when true: when true:
Message(n.info, warnProveInit, s.name.s) message(n.info, warnProveInit, s.name.s)
else: else:
Message(n.info, errGenerated, Message(n.info, errGenerated,
"'$1' might not have been initialized" % s.name.s) "'$1' might not have been initialized" % s.name.s)
else: else:
Message(n.info, warnUninit, s.name.s) message(n.info, warnUninit, s.name.s)
# prevent superfluous warnings about the same variable: # prevent superfluous warnings about the same variable:
a.init.add s.id a.init.add s.id
@ -162,8 +162,8 @@ proc mergeTags(a: PEffects, b, comesFrom: PNode) =
for effect in items(b): addTag(a, effect, useLineInfo=comesFrom != nil) for effect in items(b): addTag(a, effect, useLineInfo=comesFrom != nil)
proc listEffects(a: PEffects) = proc listEffects(a: PEffects) =
for e in items(a.exc): Message(e.info, hintUser, typeToString(e.typ)) for e in items(a.exc): message(e.info, hintUser, typeToString(e.typ))
for e in items(a.tags): Message(e.info, hintUser, typeToString(e.typ)) for e in items(a.tags): message(e.info, hintUser, typeToString(e.typ))
proc catches(tracked: PEffects, e: PType) = proc catches(tracked: PEffects, e: PType) =
let e = skipTypes(e, skipPtrs) let e = skipTypes(e, skipPtrs)
@ -310,10 +310,10 @@ proc notNilCheck(tracked: PEffects, n: PNode, paramType: PType) =
return return
case impliesNotNil(tracked.guards, n) case impliesNotNil(tracked.guards, n)
of impUnknown: of impUnknown:
Message(n.info, errGenerated, message(n.info, errGenerated,
"cannot prove '$1' is not nil" % n.renderTree) "cannot prove '$1' is not nil" % n.renderTree)
of impNo: of impNo:
Message(n.info, errGenerated, "'$1' is provably nil" % n.renderTree) message(n.info, errGenerated, "'$1' is provably nil" % n.renderTree)
of impYes: discard of impYes: discard
proc trackOperand(tracked: PEffects, n: PNode, paramType: PType) = proc trackOperand(tracked: PEffects, n: PNode, paramType: PType) =
@ -549,7 +549,7 @@ proc checkRaisesSpec(spec, real: PNode, msg: string, hints: bool) =
if hints: if hints:
for s in 0 .. <spec.len: for s in 0 .. <spec.len:
if not used.contains(s): if not used.contains(s):
Message(spec[s].info, hintXDeclaredButNotUsed, renderTree(spec[s])) message(spec[s].info, hintXDeclaredButNotUsed, renderTree(spec[s]))
proc checkMethodEffects*(disp, branch: PSym) = proc checkMethodEffects*(disp, branch: PSym) =
## checks for consistent effects for multi methods. ## checks for consistent effects for multi methods.
@ -603,7 +603,7 @@ proc trackProc*(s: PSym, body: PNode) =
s.kind in {skProc, skConverter, skMethod}: s.kind in {skProc, skConverter, skMethod}:
var res = s.ast.sons[resultPos].sym # get result symbol var res = s.ast.sons[resultPos].sym # get result symbol
if res.id notin t.init: if res.id notin t.init:
Message(body.info, warnProveInit, "result") message(body.info, warnProveInit, "result")
let p = s.ast.sons[pragmasPos] let p = s.ast.sons[pragmasPos]
let raisesSpec = effectSpec(p, wRaises) let raisesSpec = effectSpec(p, wRaises)
if not isNil(raisesSpec): if not isNil(raisesSpec):
@ -618,4 +618,4 @@ proc trackProc*(s: PSym, body: PNode) =
hints=off) hints=off)
# after the check, use the formal spec: # after the check, use the formal spec:
effects.sons[tagEffects] = tagsSpec effects.sons[tagEffects] = tagsSpec

152
compiler/semstmts.nim
View file

@ -58,10 +58,10 @@ proc semWhile(c: PContext, n: PNode): PNode =
n.sons[1] = semStmt(c, n.sons[1]) n.sons[1] = semStmt(c, n.sons[1])
dec(c.p.nestedLoopCounter) dec(c.p.nestedLoopCounter)
closeScope(c) closeScope(c)
if n.sons[1].typ == EnforceVoidContext: if n.sons[1].typ == enforceVoidContext:
result.typ = EnforceVoidContext result.typ = enforceVoidContext
proc toCover(t: PType): biggestInt = proc toCover(t: PType): BiggestInt =
var t2 = skipTypes(t, abstractVarRange-{tyTypeDesc}) var t2 = skipTypes(t, abstractVarRange-{tyTypeDesc})
if t2.kind == tyEnum and enumHasHoles(t2): if t2.kind == tyEnum and enumHasHoles(t2):
result = sonsLen(t2.n) result = sonsLen(t2.n)
@ -72,7 +72,7 @@ proc performProcvarCheck(c: PContext, n: PNode, s: PSym) =
var smoduleId = getModule(s).id var smoduleId = getModule(s).id
if sfProcVar notin s.flags and s.typ.callConv == ccDefault and if sfProcVar notin s.flags and s.typ.callConv == ccDefault and
smoduleId != c.module.id and smoduleId != c.friendModule.id: smoduleId != c.module.id and smoduleId != c.friendModule.id:
LocalError(n.info, errXCannotBePassedToProcVar, s.name.s) localError(n.info, errXCannotBePassedToProcVar, s.name.s)
proc semProcvarCheck(c: PContext, n: PNode) = proc semProcvarCheck(c: PContext, n: PNode) =
let n = n.skipConv let n = n.skipConv
@ -87,7 +87,7 @@ include semdestruct
proc semDestructorCheck(c: PContext, n: PNode, flags: TExprFlags) {.inline.} = proc semDestructorCheck(c: PContext, n: PNode, flags: TExprFlags) {.inline.} =
if efAllowDestructor notin flags and n.kind in nkCallKinds+{nkObjConstr}: if efAllowDestructor notin flags and n.kind in nkCallKinds+{nkObjConstr}:
if instantiateDestructor(c, n.typ): if instantiateDestructor(c, n.typ):
LocalError(n.info, errGenerated, localError(n.info, errGenerated,
"usage of a type with a destructor in a non destructible context") "usage of a type with a destructor in a non destructible context")
# This still breaks too many things: # This still breaks too many things:
when false: when false:
@ -136,7 +136,7 @@ proc discardCheck(c: PContext, result: PNode) =
if result.typ != nil and result.typ.kind notin {tyStmt, tyEmpty}: if result.typ != nil and result.typ.kind notin {tyStmt, tyEmpty}:
if result.kind == nkNilLit: if result.kind == nkNilLit:
result.typ = nil result.typ = nil
elif ImplicitlyDiscardable(result): elif implicitlyDiscardable(result):
var n = result var n = result
result.typ = nil result.typ = nil
while n.kind in skipForDiscardable: while n.kind in skipForDiscardable:
@ -156,7 +156,7 @@ proc discardCheck(c: PContext, result: PNode) =
proc semIf(c: PContext, n: PNode): PNode = proc semIf(c: PContext, n: PNode): PNode =
result = n result = n
var typ = CommonTypeBegin var typ = commonTypeBegin
var hasElse = false var hasElse = false
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
var it = n.sons[i] var it = n.sons[i]
@ -176,7 +176,7 @@ proc semIf(c: PContext, n: PNode): PNode =
for it in n: discardCheck(c, it.lastSon) for it in n: discardCheck(c, it.lastSon)
result.kind = nkIfStmt result.kind = nkIfStmt
# propagate any enforced VoidContext: # propagate any enforced VoidContext:
if typ == EnforceVoidContext: result.typ = EnforceVoidContext if typ == enforceVoidContext: result.typ = enforceVoidContext
else: else:
for it in n: for it in n:
let j = it.len-1 let j = it.len-1
@ -190,8 +190,8 @@ proc semCase(c: PContext, n: PNode): PNode =
openScope(c) openScope(c)
n.sons[0] = semExprWithType(c, n.sons[0]) n.sons[0] = semExprWithType(c, n.sons[0])
var chckCovered = false var chckCovered = false
var covered: biggestint = 0 var covered: BiggestInt = 0
var typ = CommonTypeBegin var typ = commonTypeBegin
var hasElse = false var hasElse = false
case skipTypes(n.sons[0].Typ, abstractVarRange-{tyTypeDesc}).Kind case skipTypes(n.sons[0].Typ, abstractVarRange-{tyTypeDesc}).Kind
of tyInt..tyInt64, tyChar, tyEnum, tyUInt..tyUInt32: of tyInt..tyInt64, tyChar, tyEnum, tyUInt..tyUInt32:
@ -199,7 +199,7 @@ proc semCase(c: PContext, n: PNode): PNode =
of tyFloat..tyFloat128, tyString, tyError: of tyFloat..tyFloat128, tyString, tyError:
discard discard
else: else:
LocalError(n.info, errSelectorMustBeOfCertainTypes) localError(n.info, errSelectorMustBeOfCertainTypes)
return return
for i in countup(1, sonsLen(n) - 1): for i in countup(1, sonsLen(n) - 1):
var x = n.sons[i] var x = n.sons[i]
@ -236,8 +236,8 @@ proc semCase(c: PContext, n: PNode): PNode =
if isEmptyType(typ) or typ.kind == tyNil or not hasElse: if isEmptyType(typ) or typ.kind == tyNil or not hasElse:
for i in 1..n.len-1: discardCheck(c, n.sons[i].lastSon) for i in 1..n.len-1: discardCheck(c, n.sons[i].lastSon)
# propagate any enforced VoidContext: # propagate any enforced VoidContext:
if typ == EnforceVoidContext: if typ == enforceVoidContext:
result.typ = EnforceVoidContext result.typ = enforceVoidContext
else: else:
for i in 1..n.len-1: for i in 1..n.len-1:
var it = n.sons[i] var it = n.sons[i]
@ -249,7 +249,7 @@ proc semTry(c: PContext, n: PNode): PNode =
result = n result = n
inc c.p.inTryStmt inc c.p.inTryStmt
checkMinSonsLen(n, 2) checkMinSonsLen(n, 2)
var typ = CommonTypeBegin var typ = commonTypeBegin
n.sons[0] = semExprBranchScope(c, n.sons[0]) n.sons[0] = semExprBranchScope(c, n.sons[0])
typ = commonType(typ, n.sons[0].typ) typ = commonType(typ, n.sons[0].typ)
var check = initIntSet() var check = initIntSet()
@ -267,10 +267,10 @@ proc semTry(c: PContext, n: PNode): PNode =
var typ = semTypeNode(c, a.sons[j], nil) var typ = semTypeNode(c, a.sons[j], nil)
if typ.kind == tyRef: typ = typ.sons[0] if typ.kind == tyRef: typ = typ.sons[0]
if typ.kind != tyObject: if typ.kind != tyObject:
LocalError(a.sons[j].info, errExprCannotBeRaised) localError(a.sons[j].info, errExprCannotBeRaised)
a.sons[j] = newNodeI(nkType, a.sons[j].info) a.sons[j] = newNodeI(nkType, a.sons[j].info)
a.sons[j].typ = typ a.sons[j].typ = typ
if ContainsOrIncl(check, typ.id): if containsOrIncl(check, typ.id):
localError(a.sons[j].info, errExceptionAlreadyHandled) localError(a.sons[j].info, errExceptionAlreadyHandled)
elif a.kind != nkFinally: elif a.kind != nkFinally:
illFormedAst(n) illFormedAst(n)
@ -281,8 +281,8 @@ proc semTry(c: PContext, n: PNode): PNode =
if isEmptyType(typ) or typ.kind == tyNil: if isEmptyType(typ) or typ.kind == tyNil:
discardCheck(c, n.sons[0]) discardCheck(c, n.sons[0])
for i in 1..n.len-1: discardCheck(c, n.sons[i].lastSon) for i in 1..n.len-1: discardCheck(c, n.sons[i].lastSon)
if typ == EnforceVoidContext: if typ == enforceVoidContext:
result.typ = EnforceVoidContext result.typ = enforceVoidContext
else: else:
n.sons[0] = fitNode(c, typ, n.sons[0]) n.sons[0] = fitNode(c, typ, n.sons[0])
for i in 1..n.len-1: for i in 1..n.len-1:
@ -291,7 +291,7 @@ proc semTry(c: PContext, n: PNode): PNode =
it.sons[j] = fitNode(c, typ, it.sons[j]) it.sons[j] = fitNode(c, typ, it.sons[j])
result.typ = typ result.typ = typ
proc fitRemoveHiddenConv(c: PContext, typ: Ptype, n: PNode): PNode = proc fitRemoveHiddenConv(c: PContext, typ: PType, n: PNode): PNode =
result = fitNode(c, typ, n) result = fitNode(c, typ, n)
if result.kind in {nkHiddenStdConv, nkHiddenSubConv}: if result.kind in {nkHiddenStdConv, nkHiddenSubConv}:
changeType(result.sons[1], typ, check=true) changeType(result.sons[1], typ, check=true)
@ -302,7 +302,7 @@ proc fitRemoveHiddenConv(c: PContext, typ: Ptype, n: PNode): PNode =
proc findShadowedVar(c: PContext, v: PSym): PSym = proc findShadowedVar(c: PContext, v: PSym): PSym =
for scope in walkScopes(c.currentScope.parent): for scope in walkScopes(c.currentScope.parent):
if scope == c.topLevelScope: break if scope == c.topLevelScope: break
let shadowed = StrTableGet(scope.symbols, v.name) let shadowed = strTableGet(scope.symbols, v.name)
if shadowed != nil and shadowed.kind in skLocalVars: if shadowed != nil and shadowed.kind in skLocalVars:
return shadowed return shadowed
@ -322,9 +322,9 @@ proc semIdentDef(c: PContext, n: PNode, kind: TSymKind): PSym =
proc checkNilable(v: PSym) = proc checkNilable(v: PSym) =
if sfGlobal in v.flags and {tfNotNil, tfNeedsInit} * v.typ.flags != {}: if sfGlobal in v.flags and {tfNotNil, tfNeedsInit} * v.typ.flags != {}:
if v.ast.isNil: if v.ast.isNil:
Message(v.info, warnProveInit, v.name.s) message(v.info, warnProveInit, v.name.s)
elif tfNotNil in v.typ.flags and tfNotNil notin v.ast.typ.flags: elif tfNotNil in v.typ.flags and tfNotNil notin v.ast.typ.flags:
Message(v.info, warnProveInit, v.name.s) message(v.info, warnProveInit, v.name.s)
proc semVarOrLet(c: PContext, n: PNode, symkind: TSymKind): PNode = proc semVarOrLet(c: PContext, n: PNode, symkind: TSymKind): PNode =
var b: PNode var b: PNode
@ -333,7 +333,7 @@ proc semVarOrLet(c: PContext, n: PNode, symkind: TSymKind): PNode =
var a = n.sons[i] var a = n.sons[i]
if gCmd == cmdIdeTools: suggestStmt(c, a) if gCmd == cmdIdeTools: suggestStmt(c, a)
if a.kind == nkCommentStmt: continue if a.kind == nkCommentStmt: continue
if a.kind notin {nkIdentDefs, nkVarTuple, nkConstDef}: IllFormedAst(a) if a.kind notin {nkIdentDefs, nkVarTuple, nkConstDef}: illFormedAst(a)
checkMinSonsLen(a, 3) checkMinSonsLen(a, 3)
var length = sonsLen(a) var length = sonsLen(a)
var typ: PType var typ: PType
@ -350,12 +350,12 @@ proc semVarOrLet(c: PContext, n: PNode, symkind: TSymKind): PNode =
else: typ = skipIntLit(def.typ) else: typ = skipIntLit(def.typ)
else: else:
def = ast.emptyNode def = ast.emptyNode
if symkind == skLet: LocalError(a.info, errLetNeedsInit) if symkind == skLet: localError(a.info, errLetNeedsInit)
# this can only happen for errornous var statements: # this can only happen for errornous var statements:
if typ == nil: continue if typ == nil: continue
if not typeAllowed(typ, symkind): if not typeAllowed(typ, symkind):
LocalError(a.info, errXisNoType, typeToString(typ)) localError(a.info, errXisNoType, typeToString(typ))
var tup = skipTypes(typ, {tyGenericInst}) var tup = skipTypes(typ, {tyGenericInst})
if a.kind == nkVarTuple: if a.kind == nkVarTuple:
if tup.kind != tyTuple: if tup.kind != tyTuple:
@ -370,7 +370,7 @@ proc semVarOrLet(c: PContext, n: PNode, symkind: TSymKind): PNode =
addSon(result, b) addSon(result, b)
elif tup.kind == tyTuple and def.kind == nkPar and elif tup.kind == tyTuple and def.kind == nkPar and
a.kind == nkIdentDefs and a.len > 3: a.kind == nkIdentDefs and a.len > 3:
Message(a.info, warnEachIdentIsTuple) message(a.info, warnEachIdentIsTuple)
for j in countup(0, length-3): for j in countup(0, length-3):
var v = semIdentDef(c, a.sons[j], symkind) var v = semIdentDef(c, a.sons[j], symkind)
if sfGenSym notin v.flags: addInterfaceDecl(c, v) if sfGenSym notin v.flags: addInterfaceDecl(c, v)
@ -383,12 +383,12 @@ proc semVarOrLet(c: PContext, n: PNode, symkind: TSymKind): PNode =
# a shadowed variable is an error unless it appears on the right # a shadowed variable is an error unless it appears on the right
# side of the '=': # side of the '=':
if warnShadowIdent in gNotes and not identWithin(def, v.name): if warnShadowIdent in gNotes and not identWithin(def, v.name):
Message(a.info, warnShadowIdent, v.name.s) message(a.info, warnShadowIdent, v.name.s)
if a.kind != nkVarTuple: if a.kind != nkVarTuple:
if def != nil and def.kind != nkEmpty: if def != nil and def.kind != nkEmpty:
# this is needed for the evaluation pass and for the guard checking: # this is needed for the evaluation pass and for the guard checking:
v.ast = def v.ast = def
if sfThread in v.flags: LocalError(def.info, errThreadvarCannotInit) if sfThread in v.flags: localError(def.info, errThreadvarCannotInit)
v.typ = typ v.typ = typ
b = newNodeI(nkIdentDefs, a.info) b = newNodeI(nkIdentDefs, a.info)
if importantComments(): if importantComments():
@ -410,7 +410,7 @@ proc semConst(c: PContext, n: PNode): PNode =
var a = n.sons[i] var a = n.sons[i]
if gCmd == cmdIdeTools: suggestStmt(c, a) if gCmd == cmdIdeTools: suggestStmt(c, a)
if a.kind == nkCommentStmt: continue if a.kind == nkCommentStmt: continue
if (a.kind != nkConstDef): IllFormedAst(a) if (a.kind != nkConstDef): illFormedAst(a)
checkSonsLen(a, 3) checkSonsLen(a, 3)
var v = semIdentDef(c, a.sons[0], skConst) var v = semIdentDef(c, a.sons[0], skConst)
var typ: PType = nil var typ: PType = nil
@ -418,7 +418,7 @@ proc semConst(c: PContext, n: PNode): PNode =
var def = semConstExpr(c, a.sons[2]) var def = semConstExpr(c, a.sons[2])
if def == nil: if def == nil:
LocalError(a.sons[2].info, errConstExprExpected) localError(a.sons[2].info, errConstExprExpected)
continue continue
# check type compatibility between def.typ and typ: # check type compatibility between def.typ and typ:
if typ != nil: if typ != nil:
@ -426,10 +426,10 @@ proc semConst(c: PContext, n: PNode): PNode =
else: else:
typ = def.typ typ = def.typ
if typ == nil: if typ == nil:
LocalError(a.sons[2].info, errConstExprExpected) localError(a.sons[2].info, errConstExprExpected)
continue continue
if not typeAllowed(typ, skConst): if not typeAllowed(typ, skConst):
LocalError(a.info, errXisNoType, typeToString(typ)) localError(a.info, errXisNoType, typeToString(typ))
continue continue
v.typ = typ v.typ = typ
v.ast = def # no need to copy v.ast = def # no need to copy
@ -498,7 +498,7 @@ proc semForObjectFields(c: TFieldsCtx, typ, forLoop, father: PNode) =
openScope(c.c) openScope(c.c)
inc c.c.InUnrolledContext inc c.c.InUnrolledContext
let body = instFieldLoopBody(fc, lastSon(forLoop), forLoop) let body = instFieldLoopBody(fc, lastSon(forLoop), forLoop)
father.add(SemStmt(c.c, body)) father.add(semStmt(c.c, body))
dec c.c.InUnrolledContext dec c.c.InUnrolledContext
closeScope(c.c) closeScope(c.c)
of nkNilLit: discard of nkNilLit: discard
@ -506,7 +506,7 @@ proc semForObjectFields(c: TFieldsCtx, typ, forLoop, father: PNode) =
let L = forLoop.len let L = forLoop.len
let call = forLoop.sons[L-2] let call = forLoop.sons[L-2]
if call.len > 2: if call.len > 2:
LocalError(forLoop.info, errGenerated, localError(forLoop.info, errGenerated,
"parallel 'fields' iterator does not work for 'case' objects") "parallel 'fields' iterator does not work for 'case' objects")
return return
# iterate over the selector: # iterate over the selector:
@ -535,9 +535,9 @@ proc semForFields(c: PContext, n: PNode, m: TMagic): PNode =
# so that 'break' etc. work as expected, we produce # so that 'break' etc. work as expected, we produce
# a 'while true: stmt; break' loop ... # a 'while true: stmt; break' loop ...
result = newNodeI(nkWhileStmt, n.info, 2) result = newNodeI(nkWhileStmt, n.info, 2)
var trueSymbol = StrTableGet(magicsys.systemModule.Tab, getIdent"true") var trueSymbol = strTableGet(magicsys.systemModule.Tab, getIdent"true")
if trueSymbol == nil: if trueSymbol == nil:
LocalError(n.info, errSystemNeeds, "true") localError(n.info, errSystemNeeds, "true")
trueSymbol = newSym(skUnknown, getIdent"true", getCurrOwner(), n.info) trueSymbol = newSym(skUnknown, getIdent"true", getCurrOwner(), n.info)
trueSymbol.typ = getSysType(tyBool) trueSymbol.typ = getSysType(tyBool)
@ -548,7 +548,7 @@ proc semForFields(c: PContext, n: PNode, m: TMagic): PNode =
var length = sonsLen(n) var length = sonsLen(n)
var call = n.sons[length-2] var call = n.sons[length-2]
if length-2 != sonsLen(call)-1 + ord(m==mFieldPairs): if length-2 != sonsLen(call)-1 + ord(m==mFieldPairs):
LocalError(n.info, errWrongNumberOfVariables) localError(n.info, errWrongNumberOfVariables)
return result return result
var tupleTypeA = skipTypes(call.sons[1].typ, abstractVar-{tyTypeDesc}) var tupleTypeA = skipTypes(call.sons[1].typ, abstractVar-{tyTypeDesc})
@ -557,10 +557,10 @@ proc semForFields(c: PContext, n: PNode, m: TMagic): PNode =
return result return result
for i in 1..call.len-1: for i in 1..call.len-1:
var tupleTypeB = skipTypes(call.sons[i].typ, abstractVar-{tyTypeDesc}) var tupleTypeB = skipTypes(call.sons[i].typ, abstractVar-{tyTypeDesc})
if not SameType(tupleTypeA, tupleTypeB): if not sameType(tupleTypeA, tupleTypeB):
typeMismatch(call.sons[i], tupleTypeA, tupleTypeB) typeMismatch(call.sons[i], tupleTypeA, tupleTypeB)
Inc(c.p.nestedLoopCounter) inc(c.p.nestedLoopCounter)
if tupleTypeA.kind == tyTuple: if tupleTypeA.kind == tyTuple:
var loopBody = n.sons[length-1] var loopBody = n.sons[length-1]
for i in 0..sonsLen(tupleTypeA)-1: for i in 0..sonsLen(tupleTypeA)-1:
@ -571,7 +571,7 @@ proc semForFields(c: PContext, n: PNode, m: TMagic): PNode =
fc.replaceByFieldName = m == mFieldPairs fc.replaceByFieldName = m == mFieldPairs
var body = instFieldLoopBody(fc, loopBody, n) var body = instFieldLoopBody(fc, loopBody, n)
inc c.InUnrolledContext inc c.InUnrolledContext
stmts.add(SemStmt(c, body)) stmts.add(semStmt(c, body))
dec c.InUnrolledContext dec c.InUnrolledContext
closeScope(c) closeScope(c)
else: else:
@ -579,7 +579,7 @@ proc semForFields(c: PContext, n: PNode, m: TMagic): PNode =
fc.m = m fc.m = m
fc.c = c fc.c = c
semForObjectFields(fc, tupleTypeA.n, n, stmts) semForObjectFields(fc, tupleTypeA.n, n, stmts)
Dec(c.p.nestedLoopCounter) dec(c.p.nestedLoopCounter)
# for TR macros this 'while true: ...; break' loop is pretty bad, so # for TR macros this 'while true: ...; break' loop is pretty bad, so
# we avoid it now if we can: # we avoid it now if we can:
if hasSonWith(stmts, nkBreakStmt): if hasSonWith(stmts, nkBreakStmt):
@ -595,7 +595,7 @@ proc addForVarDecl(c: PContext, v: PSym) =
if shadowed != nil: if shadowed != nil:
# XXX should we do this here? # XXX should we do this here?
#shadowed.flags.incl(sfShadowed) #shadowed.flags.incl(sfShadowed)
Message(v.info, warnShadowIdent, v.name.s) message(v.info, warnShadowIdent, v.name.s)
addDecl(c, v) addDecl(c, v)
proc symForVar(c: PContext, n: PNode): PSym = proc symForVar(c: PContext, n: PNode): PSym =
@ -619,9 +619,9 @@ proc semForVars(c: PContext, n: PNode): PNode =
n.sons[0] = newSymNode(v) n.sons[0] = newSymNode(v)
if sfGenSym notin v.flags: addForVarDecl(c, v) if sfGenSym notin v.flags: addForVarDecl(c, v)
else: else:
LocalError(n.info, errWrongNumberOfVariables) localError(n.info, errWrongNumberOfVariables)
elif length-2 != sonsLen(iter): elif length-2 != sonsLen(iter):
LocalError(n.info, errWrongNumberOfVariables) localError(n.info, errWrongNumberOfVariables)
else: else:
for i in countup(0, length - 3): for i in countup(0, length - 3):
var v = symForVar(c, n.sons[i]) var v = symForVar(c, n.sons[i])
@ -629,9 +629,9 @@ proc semForVars(c: PContext, n: PNode): PNode =
v.typ = iter.sons[i] v.typ = iter.sons[i]
n.sons[i] = newSymNode(v) n.sons[i] = newSymNode(v)
if sfGenSym notin v.flags: addForVarDecl(c, v) if sfGenSym notin v.flags: addForVarDecl(c, v)
Inc(c.p.nestedLoopCounter) inc(c.p.nestedLoopCounter)
n.sons[length-1] = SemStmt(c, n.sons[length-1]) n.sons[length-1] = semStmt(c, n.sons[length-1])
Dec(c.p.nestedLoopCounter) dec(c.p.nestedLoopCounter)
proc implicitIterator(c: PContext, it: string, arg: PNode): PNode = proc implicitIterator(c: PContext, it: string, arg: PNode): PNode =
result = newNodeI(nkCall, arg.info) result = newNodeI(nkCall, arg.info)
@ -659,7 +659,7 @@ proc semFor(c: PContext, n: PNode): PNode =
elif length == 4: elif length == 4:
n.sons[length-2] = implicitIterator(c, "pairs", n.sons[length-2]) n.sons[length-2] = implicitIterator(c, "pairs", n.sons[length-2])
else: else:
LocalError(n.sons[length-2].info, errIteratorExpected) localError(n.sons[length-2].info, errIteratorExpected)
result = semForVars(c, n) result = semForVars(c, n)
elif call.sons[0].sym.magic != mNone: elif call.sons[0].sym.magic != mNone:
if call.sons[0].sym.magic == mOmpParFor: if call.sons[0].sym.magic == mOmpParFor:
@ -670,8 +670,8 @@ proc semFor(c: PContext, n: PNode): PNode =
else: else:
result = semForVars(c, n) result = semForVars(c, n)
# propagate any enforced VoidContext: # propagate any enforced VoidContext:
if n.sons[length-1].typ == EnforceVoidContext: if n.sons[length-1].typ == enforceVoidContext:
result.typ = EnforceVoidContext result.typ = enforceVoidContext
closeScope(c) closeScope(c)
proc semRaise(c: PContext, n: PNode): PNode = proc semRaise(c: PContext, n: PNode): PNode =
@ -697,7 +697,7 @@ proc typeSectionLeftSidePass(c: PContext, n: PNode) =
var a = n.sons[i] var a = n.sons[i]
if gCmd == cmdIdeTools: suggestStmt(c, a) if gCmd == cmdIdeTools: suggestStmt(c, a)
if a.kind == nkCommentStmt: continue if a.kind == nkCommentStmt: continue
if a.kind != nkTypeDef: IllFormedAst(a) if a.kind != nkTypeDef: illFormedAst(a)
checkSonsLen(a, 3) checkSonsLen(a, 3)
var s = semIdentDef(c, a.sons[0], skType) var s = semIdentDef(c, a.sons[0], skType)
s.typ = newTypeS(tyForward, c) s.typ = newTypeS(tyForward, c)
@ -712,12 +712,12 @@ proc typeSectionRightSidePass(c: PContext, n: PNode) =
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
var a = n.sons[i] var a = n.sons[i]
if a.kind == nkCommentStmt: continue if a.kind == nkCommentStmt: continue
if (a.kind != nkTypeDef): IllFormedAst(a) if (a.kind != nkTypeDef): illFormedAst(a)
checkSonsLen(a, 3) checkSonsLen(a, 3)
if (a.sons[0].kind != nkSym): IllFormedAst(a) if (a.sons[0].kind != nkSym): illFormedAst(a)
var s = a.sons[0].sym var s = a.sons[0].sym
if s.magic == mNone and a.sons[2].kind == nkEmpty: if s.magic == mNone and a.sons[2].kind == nkEmpty:
LocalError(a.info, errImplOfXexpected, s.name.s) localError(a.info, errImplOfXexpected, s.name.s)
if s.magic != mNone: processMagicType(c, s) if s.magic != mNone: processMagicType(c, s)
if a.sons[1].kind != nkEmpty: if a.sons[1].kind != nkEmpty:
# We have a generic type declaration here. In generic types, # We have a generic type declaration here. In generic types,
@ -770,7 +770,7 @@ proc typeSectionFinalPass(c: PContext, n: PNode) =
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
var a = n.sons[i] var a = n.sons[i]
if a.kind == nkCommentStmt: continue if a.kind == nkCommentStmt: continue
if a.sons[0].kind != nkSym: IllFormedAst(a) if a.sons[0].kind != nkSym: illFormedAst(a)
var s = a.sons[0].sym var s = a.sons[0].sym
# compute the type's size and check for illegal recursions: # compute the type's size and check for illegal recursions:
if a.sons[1].kind == nkEmpty: if a.sons[1].kind == nkEmpty:
@ -812,12 +812,12 @@ proc addParams(c: PContext, n: PNode, kind: TSymKind) =
proc semBorrow(c: PContext, n: PNode, s: PSym) = proc semBorrow(c: PContext, n: PNode, s: PSym) =
# search for the correct alias: # search for the correct alias:
var b = SearchForBorrowProc(c, c.currentScope.parent, s) var b = searchForBorrowProc(c, c.currentScope.parent, s)
if b != nil: if b != nil:
# store the alias: # store the alias:
n.sons[bodyPos] = newSymNode(b) n.sons[bodyPos] = newSymNode(b)
else: else:
LocalError(n.info, errNoSymbolToBorrowFromFound) localError(n.info, errNoSymbolToBorrowFromFound)
proc addResult(c: PContext, t: PType, info: TLineInfo, owner: TSymKind) = proc addResult(c: PContext, t: PType, info: TLineInfo, owner: TSymKind) =
if t != nil: if t != nil:
@ -855,7 +855,7 @@ proc semProcAnnotation(c: PContext, prc: PNode): PNode =
prc.sons[namePos] = newIdentNode(idDelegator, prc.info) prc.sons[namePos] = newIdentNode(idDelegator, prc.info)
prc.sons[pragmasPos] = copyExcept(n, i) prc.sons[pragmasPos] = copyExcept(n, i)
else: else:
LocalError(prc.info, errOnlyACallOpCanBeDelegator) localError(prc.info, errOnlyACallOpCanBeDelegator)
continue continue
# we transform ``proc p {.m, rest.}`` into ``m(do: proc p {.rest.})`` and # we transform ``proc p {.m, rest.}`` into ``m(do: proc p {.rest.})`` and
# let the semantic checker deal with it: # let the semantic checker deal with it:
@ -888,7 +888,7 @@ proc semLambda(c: PContext, n: PNode, flags: TExprFlags): PNode =
if n.sons[paramsPos].kind != nkEmpty: if n.sons[paramsPos].kind != nkEmpty:
var gp = newNodeI(nkGenericParams, n.info) var gp = newNodeI(nkGenericParams, n.info)
semParamList(c, n.sons[ParamsPos], gp, s) semParamList(c, n.sons[ParamsPos], gp, s)
ParamsTypeCheck(c, s.typ) paramsTypeCheck(c, s.typ)
else: else:
s.typ = newTypeS(tyProc, c) s.typ = newTypeS(tyProc, c)
rawAddSon(s.typ, nil) rawAddSon(s.typ, nil)
@ -897,7 +897,7 @@ proc semLambda(c: PContext, n: PNode, flags: TExprFlags): PNode =
s.options = gOptions s.options = gOptions
if n.sons[bodyPos].kind != nkEmpty: if n.sons[bodyPos].kind != nkEmpty:
if sfImportc in s.flags: if sfImportc in s.flags:
LocalError(n.sons[bodyPos].info, errImplOfXNotAllowed, s.name.s) localError(n.sons[bodyPos].info, errImplOfXNotAllowed, s.name.s)
#if efDetermineType notin flags: #if efDetermineType notin flags:
# XXX not good enough; see tnamedparamanonproc.nim # XXX not good enough; see tnamedparamanonproc.nim
pushProcCon(c, s) pushProcCon(c, s)
@ -908,7 +908,7 @@ proc semLambda(c: PContext, n: PNode, flags: TExprFlags): PNode =
popProcCon(c) popProcCon(c)
sideEffectsCheck(c, s) sideEffectsCheck(c, s)
else: else:
LocalError(n.info, errImplOfXexpected, s.name.s) localError(n.info, errImplOfXexpected, s.name.s)
closeScope(c) # close scope for parameters closeScope(c) # close scope for parameters
popOwner() popOwner()
result.typ = s.typ result.typ = s.typ
@ -996,7 +996,7 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
n.sons[patternPos] = semPattern(c, n.sons[patternPos]) n.sons[patternPos] = semPattern(c, n.sons[patternPos])
if s.kind == skIterator: s.typ.flags.incl(tfIterator) if s.kind == skIterator: s.typ.flags.incl(tfIterator)
var proto = SearchForProc(c, s.scope, s) var proto = searchForProc(c, s.scope, s)
if proto == nil: if proto == nil:
s.typ.callConv = lastOptionEntry(c).defaultCC s.typ.callConv = lastOptionEntry(c).defaultCC
# add it here, so that recursive procs are possible: # add it here, so that recursive procs are possible:
@ -1013,9 +1013,9 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
implictPragmas(c, s, n, validPragmas) implictPragmas(c, s, n, validPragmas)
else: else:
if n.sons[pragmasPos].kind != nkEmpty: if n.sons[pragmasPos].kind != nkEmpty:
LocalError(n.sons[pragmasPos].info, errPragmaOnlyInHeaderOfProc) localError(n.sons[pragmasPos].info, errPragmaOnlyInHeaderOfProc)
if sfForward notin proto.flags: if sfForward notin proto.flags:
WrongRedefinition(n.info, proto.name.s) wrongRedefinition(n.info, proto.name.s)
excl(proto.flags, sfForward) excl(proto.flags, sfForward)
closeScope(c) # close scope with wrong parameter symbols closeScope(c) # close scope with wrong parameter symbols
openScope(c) # open scope for old (correct) parameter symbols openScope(c) # open scope for old (correct) parameter symbols
@ -1028,7 +1028,7 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
n.sons[genericParamsPos] = proto.ast.sons[genericParamsPos] n.sons[genericParamsPos] = proto.ast.sons[genericParamsPos]
n.sons[paramsPos] = proto.ast.sons[paramsPos] n.sons[paramsPos] = proto.ast.sons[paramsPos]
n.sons[pragmasPos] = proto.ast.sons[pragmasPos] n.sons[pragmasPos] = proto.ast.sons[pragmasPos]
if n.sons[namePos].kind != nkSym: InternalError(n.info, "semProcAux") if n.sons[namePos].kind != nkSym: internalError(n.info, "semProcAux")
n.sons[namePos].sym = proto n.sons[namePos].sym = proto
if importantComments() and not isNil(proto.ast.comment): if importantComments() and not isNil(proto.ast.comment):
n.comment = proto.ast.comment n.comment = proto.ast.comment
@ -1040,9 +1040,9 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
if n.sons[bodyPos].kind != nkEmpty: if n.sons[bodyPos].kind != nkEmpty:
# for DLL generation it is annoying to check for sfImportc! # for DLL generation it is annoying to check for sfImportc!
if sfBorrow in s.flags: if sfBorrow in s.flags:
LocalError(n.sons[bodyPos].info, errImplOfXNotAllowed, s.name.s) localError(n.sons[bodyPos].info, errImplOfXNotAllowed, s.name.s)
if n.sons[genericParamsPos].kind == nkEmpty: if n.sons[genericParamsPos].kind == nkEmpty:
ParamsTypeCheck(c, s.typ) paramsTypeCheck(c, s.typ)
pushProcCon(c, s) pushProcCon(c, s)
maybeAddResult(c, s, n) maybeAddResult(c, s, n)
if sfImportc notin s.flags: if sfImportc notin s.flags:
@ -1062,7 +1062,7 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
# so we just ignore the body after semantic checking for importc: # so we just ignore the body after semantic checking for importc:
n.sons[bodyPos] = ast.emptyNode n.sons[bodyPos] = ast.emptyNode
else: else:
if proto != nil: LocalError(n.info, errImplOfXexpected, proto.name.s) if proto != nil: localError(n.info, errImplOfXexpected, proto.name.s)
if {sfImportc, sfBorrow} * s.flags == {} and s.magic == mNone: if {sfImportc, sfBorrow} * s.flags == {} and s.magic == mNone:
incl(s.flags, sfForward) incl(s.flags, sfForward)
elif sfBorrow in s.flags: semBorrow(c, n, s) elif sfBorrow in s.flags: semBorrow(c, n, s)
@ -1083,7 +1083,7 @@ proc semIterator(c: PContext, n: PNode): PNode =
var s = result.sons[namePos].sym var s = result.sons[namePos].sym
var t = s.typ var t = s.typ
if t.sons[0] == nil and s.typ.callConv != ccClosure: if t.sons[0] == nil and s.typ.callConv != ccClosure:
LocalError(n.info, errXNeedsReturnType, "iterator") localError(n.info, errXNeedsReturnType, "iterator")
# iterators are either 'inline' or 'closure'; for backwards compatibility, # iterators are either 'inline' or 'closure'; for backwards compatibility,
# we require first class iterators to be marked with 'closure' explicitly # we require first class iterators to be marked with 'closure' explicitly
# -- at least for 0.9.2. # -- at least for 0.9.2.
@ -1097,7 +1097,7 @@ proc semIterator(c: PContext, n: PNode): PNode =
# and they always at least use the 'env' for the state field: # and they always at least use the 'env' for the state field:
incl(s.typ.flags, tfCapturesEnv) incl(s.typ.flags, tfCapturesEnv)
if n.sons[bodyPos].kind == nkEmpty and s.magic == mNone: if n.sons[bodyPos].kind == nkEmpty and s.magic == mNone:
LocalError(n.info, errImplOfXexpected, s.name.s) localError(n.info, errImplOfXexpected, s.name.s)
proc semProc(c: PContext, n: PNode): PNode = proc semProc(c: PContext, n: PNode): PNode =
result = semProcAux(c, n, skProc, procPragmas) result = semProcAux(c, n, skProc, procPragmas)
@ -1148,11 +1148,11 @@ proc evalInclude(c: PContext, n: PNode): PNode =
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
var f = checkModuleName(n.sons[i]) var f = checkModuleName(n.sons[i])
if f != InvalidFileIDX: if f != InvalidFileIDX:
if ContainsOrIncl(c.includedFiles, f): if containsOrIncl(c.includedFiles, f):
LocalError(n.info, errRecursiveDependencyX, f.toFilename) localError(n.info, errRecursiveDependencyX, f.toFilename)
else: else:
addSon(result, semStmt(c, gIncludeFile(c.module, f))) addSon(result, semStmt(c, gIncludeFile(c.module, f)))
Excl(c.includedFiles, f) excl(c.includedFiles, f)
proc setLine(n: PNode, info: TLineInfo) = proc setLine(n: PNode, info: TLineInfo) =
for i in 0 .. <safeLen(n): setLine(n.sons[i], info) for i in 0 .. <safeLen(n): setLine(n.sons[i], info)
@ -1231,9 +1231,9 @@ proc semStmtList(c: PContext, n: PNode): PNode =
return return
else: else:
n.sons[i] = semExpr(c, n.sons[i]) n.sons[i] = semExpr(c, n.sons[i])
if n.sons[i].typ == EnforceVoidContext or usesResult(n.sons[i]): if n.sons[i].typ == enforceVoidContext or usesResult(n.sons[i]):
voidContext = true voidContext = true
n.typ = EnforceVoidContext n.typ = enforceVoidContext
if i != last or voidContext: if i != last or voidContext:
discardCheck(c, n.sons[i]) discardCheck(c, n.sons[i])
else: else:
@ -1246,7 +1246,7 @@ proc semStmtList(c: PContext, n: PNode): PNode =
if outer != nil: if outer != nil:
n.sons[i] = outer n.sons[i] = outer
for j in countup(i+1, length-1): for j in countup(i+1, length-1):
inner.addSon(SemStmt(c, n.sons[j])) inner.addSon(semStmt(c, n.sons[j]))
n.sons.setLen(i+1) n.sons.setLen(i+1)
return return
of LastBlockStmts: of LastBlockStmts:

54
compiler/semtempl.nim
View file

@ -79,7 +79,7 @@ proc semBindStmt(c: PContext, n: PNode, toBind: var TIntSet): PNode =
# the same symbol! # the same symbol!
# This is however not true anymore for hygienic templates as semantic # This is however not true anymore for hygienic templates as semantic
# processing for them changes the symbol table... # processing for them changes the symbol table...
let s = QualifiedLookUp(c, a) let s = qualifiedLookUp(c, a)
if s != nil: if s != nil:
# we need to mark all symbols: # we need to mark all symbols:
let sc = symChoice(c, n, s, scClosed) let sc = symChoice(c, n, s, scClosed)
@ -115,7 +115,7 @@ proc getIdentNode(c: var TemplCtx, n: PNode): PNode =
of nkPragmaExpr: result = getIdentNode(c, n.sons[0]) of nkPragmaExpr: result = getIdentNode(c, n.sons[0])
of nkIdent: of nkIdent:
result = n result = n
let s = QualifiedLookUp(c.c, n, {}) let s = qualifiedLookUp(c.c, n, {})
if s != nil: if s != nil:
if s.owner == c.owner and s.kind == skParam: if s.owner == c.owner and s.kind == skParam:
result = newSymNode(s, n.info) result = newSymNode(s, n.info)
@ -178,7 +178,7 @@ proc semTemplSymbol(c: PContext, n: PNode, s: PSym): PNode =
proc semRoutineInTemplName(c: var TemplCtx, n: PNode): PNode = proc semRoutineInTemplName(c: var TemplCtx, n: PNode): PNode =
result = n result = n
if n.kind == nkIdent: if n.kind == nkIdent:
let s = QualifiedLookUp(c.c, n, {}) let s = qualifiedLookUp(c.c, n, {})
if s != nil: if s != nil:
if s.owner == c.owner and (s.kind == skParam or sfGenSym in s.flags): if s.owner == c.owner and (s.kind == skParam or sfGenSym in s.flags):
incl(s.flags, sfUsed) incl(s.flags, sfUsed)
@ -211,7 +211,7 @@ proc semTemplSomeDecl(c: var TemplCtx, n: PNode, symKind: TSymKind) =
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
var a = n.sons[i] var a = n.sons[i]
if a.kind == nkCommentStmt: continue if a.kind == nkCommentStmt: continue
if (a.kind != nkIdentDefs) and (a.kind != nkVarTuple): IllFormedAst(a) if (a.kind != nkIdentDefs) and (a.kind != nkVarTuple): illFormedAst(a)
checkMinSonsLen(a, 3) checkMinSonsLen(a, 3)
var L = sonsLen(a) var L = sonsLen(a)
a.sons[L-2] = semTemplBody(c, a.sons[L-2]) a.sons[L-2] = semTemplBody(c, a.sons[L-2])
@ -224,14 +224,14 @@ proc semTemplBody(c: var TemplCtx, n: PNode): PNode =
result = n result = n
case n.kind case n.kind
of nkIdent: of nkIdent:
let s = QualifiedLookUp(c.c, n, {}) let s = qualifiedLookUp(c.c, n, {})
if s != nil: if s != nil:
if s.owner == c.owner and s.kind == skParam: if s.owner == c.owner and s.kind == skParam:
incl(s.flags, sfUsed) incl(s.flags, sfUsed)
result = newSymNode(s, n.info) result = newSymNode(s, n.info)
elif Contains(c.toBind, s.id): elif contains(c.toBind, s.id):
result = symChoice(c.c, n, s, scClosed) result = symChoice(c.c, n, s, scClosed)
elif Contains(c.toMixin, s.name.id): elif contains(c.toMixin, s.name.id):
result = symChoice(c.c, n, s, scForceOpen) result = symChoice(c.c, n, s, scForceOpen)
elif s.owner == c.owner and sfGenSym in s.flags: elif s.owner == c.owner and sfGenSym in s.flags:
# template tmp[T](x: var seq[T]) = # template tmp[T](x: var seq[T]) =
@ -309,7 +309,7 @@ proc semTemplBody(c: var TemplCtx, n: PNode): PNode =
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
var a = n.sons[i] var a = n.sons[i]
if a.kind == nkCommentStmt: continue if a.kind == nkCommentStmt: continue
if (a.kind != nkConstDef): IllFormedAst(a) if (a.kind != nkConstDef): illFormedAst(a)
checkSonsLen(a, 3) checkSonsLen(a, 3)
addLocalDecl(c, a.sons[0], skConst) addLocalDecl(c, a.sons[0], skConst)
a.sons[1] = semTemplBody(c, a.sons[1]) a.sons[1] = semTemplBody(c, a.sons[1])
@ -318,13 +318,13 @@ proc semTemplBody(c: var TemplCtx, n: PNode): PNode =
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
var a = n.sons[i] var a = n.sons[i]
if a.kind == nkCommentStmt: continue if a.kind == nkCommentStmt: continue
if (a.kind != nkTypeDef): IllFormedAst(a) if (a.kind != nkTypeDef): illFormedAst(a)
checkSonsLen(a, 3) checkSonsLen(a, 3)
addLocalDecl(c, a.sons[0], skType) addLocalDecl(c, a.sons[0], skType)
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
var a = n.sons[i] var a = n.sons[i]
if a.kind == nkCommentStmt: continue if a.kind == nkCommentStmt: continue
if (a.kind != nkTypeDef): IllFormedAst(a) if (a.kind != nkTypeDef): illFormedAst(a)
checkSonsLen(a, 3) checkSonsLen(a, 3)
if a.sons[1].kind != nkEmpty: if a.sons[1].kind != nkEmpty:
openScope(c) openScope(c)
@ -353,11 +353,11 @@ proc semTemplBody(c: var TemplCtx, n: PNode): PNode =
# dotExpr is ambiguous: note that we explicitely allow 'x.TemplateParam', # dotExpr is ambiguous: note that we explicitely allow 'x.TemplateParam',
# so we use the generic code for nkDotExpr too # so we use the generic code for nkDotExpr too
if n.kind == nkDotExpr or n.kind == nkAccQuoted: if n.kind == nkDotExpr or n.kind == nkAccQuoted:
let s = QualifiedLookUp(c.c, n, {}) let s = qualifiedLookUp(c.c, n, {})
if s != nil: if s != nil:
if Contains(c.toBind, s.id): if contains(c.toBind, s.id):
return symChoice(c.c, n, s, scClosed) return symChoice(c.c, n, s, scClosed)
elif Contains(c.toMixin, s.name.id): elif contains(c.toMixin, s.name.id):
return symChoice(c.c, n, s, scForceOpen) return symChoice(c.c, n, s, scForceOpen)
else: else:
return symChoice(c.c, n, s, scOpen) return symChoice(c.c, n, s, scOpen)
@ -369,11 +369,11 @@ proc semTemplBodyDirty(c: var TemplCtx, n: PNode): PNode =
result = n result = n
case n.kind case n.kind
of nkIdent: of nkIdent:
let s = QualifiedLookUp(c.c, n, {}) let s = qualifiedLookUp(c.c, n, {})
if s != nil: if s != nil:
if s.owner == c.owner and s.kind == skParam: if s.owner == c.owner and s.kind == skParam:
result = newSymNode(s, n.info) result = newSymNode(s, n.info)
elif Contains(c.toBind, s.id): elif contains(c.toBind, s.id):
result = symChoice(c.c, n, s, scClosed) result = symChoice(c.c, n, s, scClosed)
of nkBind: of nkBind:
result = semTemplBodyDirty(c, n.sons[0]) result = semTemplBodyDirty(c, n.sons[0])
@ -385,8 +385,8 @@ proc semTemplBodyDirty(c: var TemplCtx, n: PNode): PNode =
# dotExpr is ambiguous: note that we explicitely allow 'x.TemplateParam', # dotExpr is ambiguous: note that we explicitely allow 'x.TemplateParam',
# so we use the generic code for nkDotExpr too # so we use the generic code for nkDotExpr too
if n.kind == nkDotExpr or n.kind == nkAccQuoted: if n.kind == nkDotExpr or n.kind == nkAccQuoted:
let s = QualifiedLookUp(c.c, n, {}) let s = qualifiedLookUp(c.c, n, {})
if s != nil and Contains(c.toBind, s.id): if s != nil and contains(c.toBind, s.id):
return symChoice(c.c, n, s, scClosed) return symChoice(c.c, n, s, scClosed)
result = n result = n
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
@ -470,12 +470,12 @@ proc semTemplateDef(c: PContext, n: PNode): PNode =
s.ast = n s.ast = n
result = n result = n
if n.sons[bodyPos].kind == nkEmpty: if n.sons[bodyPos].kind == nkEmpty:
LocalError(n.info, errImplOfXexpected, s.name.s) localError(n.info, errImplOfXexpected, s.name.s)
var proto = SearchForProc(c, c.currentScope, s) var proto = searchForProc(c, c.currentScope, s)
if proto == nil: if proto == nil:
addInterfaceOverloadableSymAt(c, c.currentScope, s) addInterfaceOverloadableSymAt(c, c.currentScope, s)
else: else:
SymTabReplace(c.currentScope.symbols, proto, s) symTabReplace(c.currentScope.symbols, proto, s)
if n.sons[patternPos].kind != nkEmpty: if n.sons[patternPos].kind != nkEmpty:
c.patterns.add(s) c.patterns.add(s)
@ -498,7 +498,7 @@ proc semPatternBody(c: var TemplCtx, n: PNode): PNode =
if s != nil: if s != nil:
if s.owner == c.owner and s.kind == skParam: if s.owner == c.owner and s.kind == skParam:
result = newParam(c, n, s) result = newParam(c, n, s)
elif Contains(c.toBind, s.id): elif contains(c.toBind, s.id):
result = symChoice(c.c, n, s, scClosed) result = symChoice(c.c, n, s, scClosed)
elif templToExpand(s): elif templToExpand(s):
result = semPatternBody(c, semTemplateExpr(c.c, n, s, false)) result = semPatternBody(c, semTemplateExpr(c.c, n, s, false))
@ -508,7 +508,7 @@ proc semPatternBody(c: var TemplCtx, n: PNode): PNode =
# more flexibility # more flexibility
proc expectParam(c: var TemplCtx, n: PNode): PNode = proc expectParam(c: var TemplCtx, n: PNode): PNode =
let s = QualifiedLookUp(c.c, n, {}) let s = qualifiedLookUp(c.c, n, {})
if s != nil and s.owner == c.owner and s.kind == skParam: if s != nil and s.owner == c.owner and s.kind == skParam:
result = newParam(c, n, s) result = newParam(c, n, s)
else: else:
@ -518,7 +518,7 @@ proc semPatternBody(c: var TemplCtx, n: PNode): PNode =
result = n result = n
case n.kind case n.kind
of nkIdent: of nkIdent:
let s = QualifiedLookUp(c.c, n, {}) let s = qualifiedLookUp(c.c, n, {})
result = handleSym(c, n, s) result = handleSym(c, n, s)
of nkBindStmt: of nkBindStmt:
result = semBindStmt(c.c, n, c.toBind) result = semBindStmt(c.c, n, c.toBind)
@ -541,10 +541,10 @@ proc semPatternBody(c: var TemplCtx, n: PNode): PNode =
else: else:
localError(n.info, errInvalidExpression) localError(n.info, errInvalidExpression)
of nkCallKinds: of nkCallKinds:
let s = QualifiedLookUp(c.c, n.sons[0], {}) let s = qualifiedLookUp(c.c, n.sons[0], {})
if s != nil: if s != nil:
if s.owner == c.owner and s.kind == skParam: discard if s.owner == c.owner and s.kind == skParam: discard
elif Contains(c.toBind, s.id): discard elif contains(c.toBind, s.id): discard
elif templToExpand(s): elif templToExpand(s):
return semPatternBody(c, semTemplateExpr(c.c, n, s, false)) return semPatternBody(c, semTemplateExpr(c.c, n, s, false))
@ -580,9 +580,9 @@ proc semPatternBody(c: var TemplCtx, n: PNode): PNode =
# so we use the generic code for nkDotExpr too # so we use the generic code for nkDotExpr too
case n.kind case n.kind
of nkDotExpr, nkAccQuoted: of nkDotExpr, nkAccQuoted:
let s = QualifiedLookUp(c.c, n, {}) let s = qualifiedLookUp(c.c, n, {})
if s != nil: if s != nil:
if Contains(c.toBind, s.id): if contains(c.toBind, s.id):
return symChoice(c.c, n, s, scClosed) return symChoice(c.c, n, s, scClosed)
else: else:
return newIdentNode(s.name, n.info) return newIdentNode(s.name, n.info)

36
compiler/semthreads.nim
View file

@ -97,7 +97,7 @@ proc `==`(a, b: TCall): bool =
proc newProcCtx(owner: PSym): PProcCtx = proc newProcCtx(owner: PSym): PProcCtx =
assert owner != nil assert owner != nil
new(result) new(result)
result.mapping = tables.InitTable[int, TThreadOwner]() result.mapping = tables.initTable[int, TThreadOwner]()
result.owner = owner result.owner = owner
proc analyse(c: PProcCtx, n: PNode): TThreadOwner proc analyse(c: PProcCtx, n: PNode): TThreadOwner
@ -119,7 +119,7 @@ proc analyseSym(c: PProcCtx, n: PNode): TThreadOwner =
of skParam: of skParam:
result = c.mapping[v.id] result = c.mapping[v.id]
if result == toUndefined: if result == toUndefined:
InternalError(n.info, "param not set: " & v.name.s) internalError(n.info, "param not set: " & v.name.s)
else: else:
result = toNil result = toNil
c.mapping[v.id] = result c.mapping[v.id] = result
@ -132,7 +132,7 @@ proc lvalueSym(n: PNode): PNode =
proc writeAccess(c: PProcCtx, n: PNode, owner: TThreadOwner) = proc writeAccess(c: PProcCtx, n: PNode, owner: TThreadOwner) =
if owner notin {toNil, toMine, toTheirs}: if owner notin {toNil, toMine, toTheirs}:
InternalError(n.info, "writeAccess: " & $owner) internalError(n.info, "writeAccess: " & $owner)
var a = lvalueSym(n) var a = lvalueSym(n)
if a.kind == nkSym: if a.kind == nkSym:
var v = a.sym var v = a.sym
@ -151,21 +151,21 @@ proc writeAccess(c: PProcCtx, n: PNode, owner: TThreadOwner) =
newOwner = toMine newOwner = toMine
# XXX BUG what if the tuple contains both ``tyRef`` and ``tyString``? # XXX BUG what if the tuple contains both ``tyRef`` and ``tyString``?
c.mapping[v.id] = newOwner c.mapping[v.id] = newOwner
of toVoid, toUndefined: InternalError(n.info, "writeAccess") of toVoid, toUndefined: internalError(n.info, "writeAccess")
of toTheirs: Message(n.info, warnWriteToForeignHeap) of toTheirs: message(n.info, warnWriteToForeignHeap)
of toMine: of toMine:
if lastOwner != owner and owner != toNil: if lastOwner != owner and owner != toNil:
Message(n.info, warnDifferentHeaps) message(n.info, warnDifferentHeaps)
else: else:
# we could not backtrack to a concrete symbol, but that's fine: # we could not backtrack to a concrete symbol, but that's fine:
var lastOwner = analyse(c, n) var lastOwner = analyse(c, n)
case lastOwner case lastOwner
of toNil: nil # fine, toNil can be overwritten of toNil: nil # fine, toNil can be overwritten
of toVoid, toUndefined: InternalError(n.info, "writeAccess") of toVoid, toUndefined: internalError(n.info, "writeAccess")
of toTheirs: Message(n.info, warnWriteToForeignHeap) of toTheirs: message(n.info, warnWriteToForeignHeap)
of toMine: of toMine:
if lastOwner != owner and owner != toNil: if lastOwner != owner and owner != toNil:
Message(n.info, warnDifferentHeaps) message(n.info, warnDifferentHeaps)
proc analyseAssign(c: PProcCtx, le, ri: PNode) = proc analyseAssign(c: PProcCtx, le, ri: PNode) =
var y = analyse(c, ri) # read access; ok var y = analyse(c, ri) # read access; ok
@ -192,7 +192,7 @@ proc analyseCall(c: PProcCtx, n: PNode): TThreadOwner =
result = analyse(newCtx, prc.getBody) result = analyse(newCtx, prc.getBody)
if prc.ast.sons[bodyPos].kind == nkEmpty and if prc.ast.sons[bodyPos].kind == nkEmpty and
{sfNoSideEffect, sfThread, sfImportc} * prc.flags == {}: {sfNoSideEffect, sfThread, sfImportc} * prc.flags == {}:
Message(n.info, warnAnalysisLoophole, renderTree(n)) message(n.info, warnAnalysisLoophole, renderTree(n))
if result == toUndefined: result = toNil if result == toUndefined: result = toNil
if prc.typ.sons[0] != nil: if prc.typ.sons[0] != nil:
if prc.ast.len > resultPos: if prc.ast.len > resultPos:
@ -215,12 +215,12 @@ proc analyseCall(c: PProcCtx, n: PNode): TThreadOwner =
else: result = toNil else: result = toNil
proc analyseVarTuple(c: PProcCtx, n: PNode) = proc analyseVarTuple(c: PProcCtx, n: PNode) =
if n.kind != nkVarTuple: InternalError(n.info, "analyseVarTuple") if n.kind != nkVarTuple: internalError(n.info, "analyseVarTuple")
var L = n.len var L = n.len
for i in countup(0, L-3): AnalyseAssign(c, n.sons[i], n.sons[L-1]) for i in countup(0, L-3): analyseAssign(c, n.sons[i], n.sons[L-1])
proc analyseSingleVar(c: PProcCtx, a: PNode) = proc analyseSingleVar(c: PProcCtx, a: PNode) =
if a.sons[2].kind != nkEmpty: AnalyseAssign(c, a.sons[0], a.sons[2]) if a.sons[2].kind != nkEmpty: analyseAssign(c, a.sons[0], a.sons[2])
proc analyseVarSection(c: PProcCtx, n: PNode): TThreadOwner = proc analyseVarSection(c: PProcCtx, n: PNode): TThreadOwner =
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
@ -238,7 +238,7 @@ proc analyseConstSection(c: PProcCtx, t: PNode): TThreadOwner =
for i in countup(0, sonsLen(t) - 1): for i in countup(0, sonsLen(t) - 1):
var it = t.sons[i] var it = t.sons[i]
if it.kind == nkCommentStmt: continue if it.kind == nkCommentStmt: continue
if it.kind != nkConstDef: InternalError(t.info, "analyseConstSection") if it.kind != nkConstDef: internalError(t.info, "analyseConstSection")
if sfFakeConst in it.sons[0].sym.flags: analyseSingleVar(c, it) if sfFakeConst in it.sons[0].sym.flags: analyseSingleVar(c, it)
result = toVoid result = toVoid
@ -246,7 +246,7 @@ template aggregateOwner(result, ana: expr) =
var a = ana # eval once var a = ana # eval once
if result != a: if result != a:
if result == toNil: result = a if result == toNil: result = a
elif a != toNil: Message(n.info, warnDifferentHeaps) elif a != toNil: message(n.info, warnDifferentHeaps)
proc analyseArgs(c: PProcCtx, n: PNode, start = 1) = proc analyseArgs(c: PProcCtx, n: PNode, start = 1) =
for i in start..n.len-1: discard analyse(c, n[i]) for i in start..n.len-1: discard analyse(c, n[i])
@ -254,7 +254,7 @@ proc analyseArgs(c: PProcCtx, n: PNode, start = 1) =
proc analyseOp(c: PProcCtx, n: PNode): TThreadOwner = proc analyseOp(c: PProcCtx, n: PNode): TThreadOwner =
if n[0].kind != nkSym or n[0].sym.kind != skProc: if n[0].kind != nkSym or n[0].sym.kind != skProc:
if {tfNoSideEffect, tfThread} * n[0].typ.flags == {}: if {tfNoSideEffect, tfThread} * n[0].typ.flags == {}:
Message(n.info, warnAnalysisLoophole, renderTree(n)) message(n.info, warnAnalysisLoophole, renderTree(n))
result = toNil result = toNil
else: else:
var prc = n[0].sym var prc = n[0].sym
@ -352,7 +352,7 @@ proc analyse(c: PProcCtx, n: PNode): TThreadOwner =
result = analyse(c, n.sons[0]) result = analyse(c, n.sons[0])
of nkRaiseStmt: of nkRaiseStmt:
var a = analyse(c, n.sons[0]) var a = analyse(c, n.sons[0])
if a != toMine: Message(n.info, warnDifferentHeaps) if a != toMine: message(n.info, warnDifferentHeaps)
result = toVoid result = toVoid
of nkVarSection, nkLetSection: result = analyseVarSection(c, n) of nkVarSection, nkLetSection: result = analyseVarSection(c, n)
of nkConstSection: result = analyseConstSection(c, n) of nkConstSection: result = analyseConstSection(c, n)
@ -373,7 +373,7 @@ proc analyse(c: PProcCtx, n: PNode): TThreadOwner =
result = toVoid result = toVoid
of nkExprColonExpr: of nkExprColonExpr:
result = analyse(c, n.sons[1]) result = analyse(c, n.sons[1])
else: InternalError(n.info, "analysis not implemented for: " & $n.kind) else: internalError(n.info, "analysis not implemented for: " & $n.kind)
proc analyseThreadProc*(prc: PSym) = proc analyseThreadProc*(prc: PSym) =
var c = newProcCtx(prc) var c = newProcCtx(prc)

140
compiler/semtypes.nim
View file

@ -53,9 +53,9 @@ proc semEnum(c: PContext, n: PNode, prev: PType): PType =
if skipTypes(strVal.typ, abstractInst).kind in {tyString, tyCstring}: if skipTypes(strVal.typ, abstractInst).kind in {tyString, tyCstring}:
x = getOrdValue(v.sons[0]) # first tuple part is the ordinal x = getOrdValue(v.sons[0]) # first tuple part is the ordinal
else: else:
LocalError(strVal.info, errStringLiteralExpected) localError(strVal.info, errStringLiteralExpected)
else: else:
LocalError(v.info, errWrongNumberOfVariables) localError(v.info, errWrongNumberOfVariables)
of tyString, tyCstring: of tyString, tyCstring:
strVal = v strVal = v
x = counter x = counter
@ -64,7 +64,7 @@ proc semEnum(c: PContext, n: PNode, prev: PType): PType =
if i != 1: if i != 1:
if x != counter: incl(result.flags, tfEnumHasHoles) if x != counter: incl(result.flags, tfEnumHasHoles)
if x < counter: if x < counter:
LocalError(n.sons[i].info, errInvalidOrderInEnumX, e.name.s) localError(n.sons[i].info, errInvalidOrderInEnumX, e.name.s)
x = counter x = counter
e.ast = strVal # might be nil e.ast = strVal # might be nil
counter = x counter = x
@ -79,7 +79,7 @@ proc semEnum(c: PContext, n: PNode, prev: PType): PType =
if result.sym != nil and sfExported in result.sym.flags: if result.sym != nil and sfExported in result.sym.flags:
incl(e.flags, sfUsed) incl(e.flags, sfUsed)
incl(e.flags, sfExported) incl(e.flags, sfExported)
if not isPure: StrTableAdd(c.module.tab, e) if not isPure: strTableAdd(c.module.tab, e)
addSon(result.n, newSymNode(e)) addSon(result.n, newSymNode(e))
if sfGenSym notin e.flags and not isPure: addDecl(c, e) if sfGenSym notin e.flags and not isPure: addDecl(c, e)
inc(counter) inc(counter)
@ -93,11 +93,11 @@ proc semSet(c: PContext, n: PNode, prev: PType): PType =
if base.kind == tyGenericInst: base = lastSon(base) if base.kind == tyGenericInst: base = lastSon(base)
if base.kind != tyGenericParam: if base.kind != tyGenericParam:
if not isOrdinalType(base): if not isOrdinalType(base):
LocalError(n.info, errOrdinalTypeExpected) localError(n.info, errOrdinalTypeExpected)
elif lengthOrd(base) > MaxSetElements: elif lengthOrd(base) > MaxSetElements:
LocalError(n.info, errSetTooBig) localError(n.info, errSetTooBig)
else: else:
LocalError(n.info, errXExpectsOneTypeParam, "set") localError(n.info, errXExpectsOneTypeParam, "set")
addSonSkipIntLit(result, errorType(c)) addSonSkipIntLit(result, errorType(c))
proc semContainer(c: PContext, n: PNode, kind: TTypeKind, kindStr: string, proc semContainer(c: PContext, n: PNode, kind: TTypeKind, kindStr: string,
@ -107,7 +107,7 @@ proc semContainer(c: PContext, n: PNode, kind: TTypeKind, kindStr: string,
var base = semTypeNode(c, n.sons[1], nil) var base = semTypeNode(c, n.sons[1], nil)
addSonSkipIntLit(result, base) addSonSkipIntLit(result, base)
else: else:
LocalError(n.info, errXExpectsOneTypeParam, kindStr) localError(n.info, errXExpectsOneTypeParam, kindStr)
addSonSkipIntLit(result, errorType(c)) addSonSkipIntLit(result, errorType(c))
proc semVarargs(c: PContext, n: PNode, prev: PType): PType = proc semVarargs(c: PContext, n: PNode, prev: PType): PType =
@ -118,7 +118,7 @@ proc semVarargs(c: PContext, n: PNode, prev: PType): PType =
if sonsLen(n) == 3: if sonsLen(n) == 3:
result.n = newIdentNode(considerAcc(n.sons[2]), n.sons[2].info) result.n = newIdentNode(considerAcc(n.sons[2]), n.sons[2].info)
else: else:
LocalError(n.info, errXExpectsOneTypeParam, "varargs") localError(n.info, errXExpectsOneTypeParam, "varargs")
addSonSkipIntLit(result, errorType(c)) addSonSkipIntLit(result, errorType(c))
proc semAnyRef(c: PContext, n: PNode, kind: TTypeKind, prev: PType): PType = proc semAnyRef(c: PContext, n: PNode, kind: TTypeKind, prev: PType): PType =
@ -134,7 +134,7 @@ proc semVarType(c: PContext, n: PNode, prev: PType): PType =
result = newOrPrevType(tyVar, prev, c) result = newOrPrevType(tyVar, prev, c)
var base = semTypeNode(c, n.sons[0], nil) var base = semTypeNode(c, n.sons[0], nil)
if base.kind == tyVar: if base.kind == tyVar:
LocalError(n.info, errVarVarTypeNotAllowed) localError(n.info, errVarVarTypeNotAllowed)
base = base.sons[0] base = base.sons[0]
addSonSkipIntLit(result, base) addSonSkipIntLit(result, base)
else: else:
@ -153,17 +153,17 @@ proc semRangeAux(c: PContext, n: PNode, prev: PType): PType =
result = newOrPrevType(tyRange, prev, c) result = newOrPrevType(tyRange, prev, c)
result.n = newNodeI(nkRange, n.info) result.n = newNodeI(nkRange, n.info)
if (n[1].kind == nkEmpty) or (n[2].kind == nkEmpty): if (n[1].kind == nkEmpty) or (n[2].kind == nkEmpty):
LocalError(n.Info, errRangeIsEmpty) localError(n.Info, errRangeIsEmpty)
var a = semConstExpr(c, n[1]) var a = semConstExpr(c, n[1])
var b = semConstExpr(c, n[2]) var b = semConstExpr(c, n[2])
if not sameType(a.typ, b.typ): if not sameType(a.typ, b.typ):
LocalError(n.info, errPureTypeMismatch) localError(n.info, errPureTypeMismatch)
elif a.typ.kind notin {tyInt..tyInt64,tyEnum,tyBool,tyChar, elif a.typ.kind notin {tyInt..tyInt64,tyEnum,tyBool,tyChar,
tyFloat..tyFloat128,tyUInt8..tyUInt32}: tyFloat..tyFloat128,tyUInt8..tyUInt32}:
LocalError(n.info, errOrdinalTypeExpected) localError(n.info, errOrdinalTypeExpected)
elif enumHasHoles(a.typ): elif enumHasHoles(a.typ):
LocalError(n.info, errEnumXHasHoles, a.typ.sym.name.s) localError(n.info, errEnumXHasHoles, a.typ.sym.name.s)
elif not leValue(a, b): LocalError(n.Info, errRangeIsEmpty) elif not leValue(a, b): localError(n.Info, errRangeIsEmpty)
addSon(result.n, a) addSon(result.n, a)
addSon(result.n, b) addSon(result.n, b)
addSonSkipIntLit(result, b.typ) addSonSkipIntLit(result, b.typ)
@ -180,10 +180,10 @@ proc semRange(c: PContext, n: PNode, prev: PType): PType =
elif n.sons[0].floatVal > 0.0 or n.sons[1].floatVal < 0.0: elif n.sons[0].floatVal > 0.0 or n.sons[1].floatVal < 0.0:
incl(result.flags, tfNeedsInit) incl(result.flags, tfNeedsInit)
else: else:
LocalError(n.sons[0].info, errRangeExpected) localError(n.sons[0].info, errRangeExpected)
result = newOrPrevType(tyError, prev, c) result = newOrPrevType(tyError, prev, c)
else: else:
LocalError(n.info, errXExpectsOneTypeParam, "range") localError(n.info, errXExpectsOneTypeParam, "range")
result = newOrPrevType(tyError, prev, c) result = newOrPrevType(tyError, prev, c)
proc semArray(c: PContext, n: PNode, prev: PType): PType = proc semArray(c: PContext, n: PNode, prev: PType): PType =
@ -208,13 +208,13 @@ proc semArray(c: PContext, n: PNode, prev: PType): PType =
if indx.kind == tyGenericInst: indx = lastSon(indx) if indx.kind == tyGenericInst: indx = lastSon(indx)
if indx.kind notin {tyGenericParam, tyExpr}: if indx.kind notin {tyGenericParam, tyExpr}:
if not isOrdinalType(indx): if not isOrdinalType(indx):
LocalError(n.sons[1].info, errOrdinalTypeExpected) localError(n.sons[1].info, errOrdinalTypeExpected)
elif enumHasHoles(indx): elif enumHasHoles(indx):
LocalError(n.sons[1].info, errEnumXHasHoles, indx.sym.name.s) localError(n.sons[1].info, errEnumXHasHoles, indx.sym.name.s)
base = semTypeNode(c, n.sons[2], nil) base = semTypeNode(c, n.sons[2], nil)
addSonSkipIntLit(result, base) addSonSkipIntLit(result, base)
else: else:
LocalError(n.info, errArrayExpectsTwoTypeParams) localError(n.info, errArrayExpectsTwoTypeParams)
result = newOrPrevType(tyError, prev, c) result = newOrPrevType(tyError, prev, c)
proc semOrdinal(c: PContext, n: PNode, prev: PType): PType = proc semOrdinal(c: PContext, n: PNode, prev: PType): PType =
@ -223,17 +223,17 @@ proc semOrdinal(c: PContext, n: PNode, prev: PType): PType =
var base = semTypeNode(c, n.sons[1], nil) var base = semTypeNode(c, n.sons[1], nil)
if base.kind != tyGenericParam: if base.kind != tyGenericParam:
if not isOrdinalType(base): if not isOrdinalType(base):
LocalError(n.sons[1].info, errOrdinalTypeExpected) localError(n.sons[1].info, errOrdinalTypeExpected)
addSonSkipIntLit(result, base) addSonSkipIntLit(result, base)
else: else:
LocalError(n.info, errXExpectsOneTypeParam, "ordinal") localError(n.info, errXExpectsOneTypeParam, "ordinal")
result = newOrPrevType(tyError, prev, c) result = newOrPrevType(tyError, prev, c)
proc semTypeIdent(c: PContext, n: PNode): PSym = proc semTypeIdent(c: PContext, n: PNode): PSym =
if n.kind == nkSym: if n.kind == nkSym:
result = n.sym result = n.sym
else: else:
result = qualifiedLookup(c, n, {checkAmbiguity, checkUndeclared}) result = qualifiedLookUp(c, n, {checkAmbiguity, checkUndeclared})
if result != nil: if result != nil:
markUsed(n, result) markUsed(n, result)
if result.kind == skParam and result.typ.kind == tyTypeDesc: if result.kind == skParam and result.typ.kind == tyTypeDesc:
@ -245,7 +245,7 @@ proc semTypeIdent(c: PContext, n: PNode): PSym =
if bound != nil: return bound if bound != nil: return bound
return result return result
if result.typ.sym == nil: if result.typ.sym == nil:
LocalError(n.info, errTypeExpected) localError(n.info, errTypeExpected)
return errorSym(c, n) return errorSym(c, n)
result = result.typ.sym.copySym result = result.typ.sym.copySym
result.typ = copyType(result.typ, result.typ.owner, true) result.typ = copyType(result.typ, result.typ.owner, true)
@ -253,12 +253,12 @@ proc semTypeIdent(c: PContext, n: PNode): PSym =
if result.kind != skType: if result.kind != skType:
# this implements the wanted ``var v: V, x: V`` feature ... # this implements the wanted ``var v: V, x: V`` feature ...
var ov: TOverloadIter var ov: TOverloadIter
var amb = InitOverloadIter(ov, c, n) var amb = initOverloadIter(ov, c, n)
while amb != nil and amb.kind != skType: while amb != nil and amb.kind != skType:
amb = nextOverloadIter(ov, c, n) amb = nextOverloadIter(ov, c, n)
if amb != nil: result = amb if amb != nil: result = amb
else: else:
if result.kind != skError: LocalError(n.info, errTypeExpected) if result.kind != skError: localError(n.info, errTypeExpected)
return errorSym(c, n) return errorSym(c, n)
if result.typ.kind != tyGenericParam: if result.typ.kind != tyGenericParam:
# XXX get rid of this hack! # XXX get rid of this hack!
@ -268,7 +268,7 @@ proc semTypeIdent(c: PContext, n: PNode): PSym =
n.sym = result n.sym = result
n.info = oldInfo n.info = oldInfo
else: else:
LocalError(n.info, errIdentifierExpected) localError(n.info, errIdentifierExpected)
result = errorSym(c, n) result = errorSym(c, n)
proc semTuple(c: PContext, n: PNode, prev: PType): PType = proc semTuple(c: PContext, n: PNode, prev: PType): PType =
@ -280,23 +280,23 @@ proc semTuple(c: PContext, n: PNode, prev: PType): PType =
var counter = 0 var counter = 0
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
var a = n.sons[i] var a = n.sons[i]
if (a.kind != nkIdentDefs): IllFormedAst(a) if (a.kind != nkIdentDefs): illFormedAst(a)
checkMinSonsLen(a, 3) checkMinSonsLen(a, 3)
var length = sonsLen(a) var length = sonsLen(a)
if a.sons[length - 2].kind != nkEmpty: if a.sons[length - 2].kind != nkEmpty:
typ = semTypeNode(c, a.sons[length - 2], nil) typ = semTypeNode(c, a.sons[length - 2], nil)
else: else:
LocalError(a.info, errTypeExpected) localError(a.info, errTypeExpected)
typ = errorType(c) typ = errorType(c)
if a.sons[length - 1].kind != nkEmpty: if a.sons[length - 1].kind != nkEmpty:
LocalError(a.sons[length - 1].info, errInitHereNotAllowed) localError(a.sons[length - 1].info, errInitHereNotAllowed)
for j in countup(0, length - 3): for j in countup(0, length - 3):
var field = newSymG(skField, a.sons[j], c) var field = newSymG(skField, a.sons[j], c)
field.typ = typ field.typ = typ
field.position = counter field.position = counter
inc(counter) inc(counter)
if ContainsOrIncl(check, field.name.id): if containsOrIncl(check, field.name.id):
LocalError(a.sons[j].info, errAttemptToRedefine, field.name.s) localError(a.sons[j].info, errAttemptToRedefine, field.name.s)
else: else:
addSon(result.n, newSymNode(field)) addSon(result.n, newSymNode(field))
addSonSkipIntLit(result, typ) addSonSkipIntLit(result, typ)
@ -313,7 +313,7 @@ proc semIdentVis(c: PContext, kind: TSymKind, n: PNode,
if sfExported in allowed and v.id == ord(wStar): if sfExported in allowed and v.id == ord(wStar):
incl(result.flags, sfExported) incl(result.flags, sfExported)
else: else:
LocalError(n.sons[0].info, errInvalidVisibilityX, v.s) localError(n.sons[0].info, errInvalidVisibilityX, v.s)
else: else:
illFormedAst(n) illFormedAst(n)
else: else:
@ -341,9 +341,9 @@ proc checkForOverlap(c: PContext, t: PNode, currentEx, branchIndex: int) =
for j in countup(0, sonsLen(t.sons[i]) - 2): for j in countup(0, sonsLen(t.sons[i]) - 2):
if i == branchIndex and j == currentEx: break if i == branchIndex and j == currentEx: break
if overlap(t.sons[i].sons[j].skipConv, ex): if overlap(t.sons[i].sons[j].skipConv, ex):
LocalError(ex.info, errDuplicateCaseLabel) localError(ex.info, errDuplicateCaseLabel)
proc semBranchRange(c: PContext, t, a, b: PNode, covered: var biggestInt): PNode = proc semBranchRange(c: PContext, t, a, b: PNode, covered: var BiggestInt): PNode =
checkMinSonsLen(t, 1) checkMinSonsLen(t, 1)
let ac = semConstExpr(c, a) let ac = semConstExpr(c, a)
let bc = semConstExpr(c, b) let bc = semConstExpr(c, b)
@ -353,16 +353,16 @@ proc semBranchRange(c: PContext, t, a, b: PNode, covered: var biggestInt): PNode
result = newNodeI(nkRange, a.info) result = newNodeI(nkRange, a.info)
result.add(at) result.add(at)
result.add(bt) result.add(bt)
if emptyRange(ac, bc): LocalError(b.info, errRangeIsEmpty) if emptyRange(ac, bc): localError(b.info, errRangeIsEmpty)
else: covered = covered + getOrdValue(bc) - getOrdValue(ac) + 1 else: covered = covered + getOrdValue(bc) - getOrdValue(ac) + 1
proc semCaseBranchRange(c: PContext, t, b: PNode, proc semCaseBranchRange(c: PContext, t, b: PNode,
covered: var biggestInt): PNode = covered: var BiggestInt): PNode =
checkSonsLen(b, 3) checkSonsLen(b, 3)
result = semBranchRange(c, t, b.sons[1], b.sons[2], covered) result = semBranchRange(c, t, b.sons[1], b.sons[2], covered)
proc semCaseBranchSetElem(c: PContext, t, b: PNode, proc semCaseBranchSetElem(c: PContext, t, b: PNode,
covered: var biggestInt): PNode = covered: var BiggestInt): PNode =
if isRange(b): if isRange(b):
checkSonsLen(b, 3) checkSonsLen(b, 3)
result = semBranchRange(c, t, b.sons[1], b.sons[2], covered) result = semBranchRange(c, t, b.sons[1], b.sons[2], covered)
@ -374,7 +374,7 @@ proc semCaseBranchSetElem(c: PContext, t, b: PNode,
inc(covered) inc(covered)
proc semCaseBranch(c: PContext, t, branch: PNode, branchIndex: int, proc semCaseBranch(c: PContext, t, branch: PNode, branchIndex: int,
covered: var biggestInt) = covered: var BiggestInt) =
for i in countup(0, sonsLen(branch) - 2): for i in countup(0, sonsLen(branch) - 2):
var b = branch.sons[i] var b = branch.sons[i]
if b.kind == nkRange: if b.kind == nkRange:
@ -411,14 +411,14 @@ proc semRecordCase(c: PContext, n: PNode, check: var TIntSet, pos: var int,
internalError("semRecordCase: discriminant is no symbol") internalError("semRecordCase: discriminant is no symbol")
return return
incl(a.sons[0].sym.flags, sfDiscriminant) incl(a.sons[0].sym.flags, sfDiscriminant)
var covered: biggestInt = 0 var covered: BiggestInt = 0
var typ = skipTypes(a.sons[0].Typ, abstractVar-{tyTypeDesc}) var typ = skipTypes(a.sons[0].Typ, abstractVar-{tyTypeDesc})
if not isOrdinalType(typ): if not isOrdinalType(typ):
LocalError(n.info, errSelectorMustBeOrdinal) localError(n.info, errSelectorMustBeOrdinal)
elif firstOrd(typ) < 0: elif firstOrd(typ) < 0:
LocalError(n.info, errOrdXMustNotBeNegative, a.sons[0].sym.name.s) localError(n.info, errOrdXMustNotBeNegative, a.sons[0].sym.name.s)
elif lengthOrd(typ) > 0x00007FFF: elif lengthOrd(typ) > 0x00007FFF:
LocalError(n.info, errLenXinvalid, a.sons[0].sym.name.s) localError(n.info, errLenXinvalid, a.sons[0].sym.name.s)
var chckCovered = true var chckCovered = true
for i in countup(1, sonsLen(n) - 1): for i in countup(1, sonsLen(n) - 1):
var b = copyTree(n.sons[i]) var b = copyTree(n.sons[i])
@ -452,7 +452,7 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var TIntSet, pos: var int,
checkSonsLen(it, 2) checkSonsLen(it, 2)
if c.InGenericContext == 0: if c.InGenericContext == 0:
var e = semConstBoolExpr(c, it.sons[0]) var e = semConstBoolExpr(c, it.sons[0])
if e.kind != nkIntLit: InternalError(e.info, "semRecordNodeAux") if e.kind != nkIntLit: internalError(e.info, "semRecordNodeAux")
elif e.intVal != 0 and branch == nil: branch = it.sons[1] elif e.intVal != 0 and branch == nil: branch = it.sons[1]
else: else:
it.sons[0] = forceBool(c, semExprWithType(c, it.sons[0])) it.sons[0] = forceBool(c, semExprWithType(c, it.sons[0]))
@ -467,7 +467,7 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var TIntSet, pos: var int,
assign(newCheck, check) assign(newCheck, check)
var newPos = pos var newPos = pos
var newf = newNodeI(nkRecList, n.info) var newf = newNodeI(nkRecList, n.info)
semRecordNodeAux(c, it.sons[idx], newcheck, newpos, newf, rectype) semRecordNodeAux(c, it.sons[idx], newCheck, newPos, newf, rectype)
it.sons[idx] = if newf.len == 1: newf[0] else: newf it.sons[idx] = if newf.len == 1: newf[0] else: newf
if c.InGenericContext > 0: if c.InGenericContext > 0:
addSon(father, n) addSon(father, n)
@ -493,7 +493,7 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var TIntSet, pos: var int,
localError(n.sons[length-1].info, errInitHereNotAllowed) localError(n.sons[length-1].info, errInitHereNotAllowed)
var typ: PType var typ: PType
if n.sons[length-2].kind == nkEmpty: if n.sons[length-2].kind == nkEmpty:
LocalError(n.info, errTypeExpected) localError(n.info, errTypeExpected)
typ = errorType(c) typ = errorType(c)
else: else:
typ = semTypeNode(c, n.sons[length-2], nil) typ = semTypeNode(c, n.sons[length-2], nil)
@ -509,7 +509,7 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var TIntSet, pos: var int,
f.loc.r = toRope(f.name.s) f.loc.r = toRope(f.name.s)
f.flags = f.flags + ({sfImportc, sfExportc} * rec.flags) f.flags = f.flags + ({sfImportc, sfExportc} * rec.flags)
inc(pos) inc(pos)
if ContainsOrIncl(check, f.name.id): if containsOrIncl(check, f.name.id):
localError(n.sons[i].info, errAttemptToRedefine, f.name.s) localError(n.sons[i].info, errAttemptToRedefine, f.name.s)
if a.kind == nkEmpty: addSon(father, newSymNode(f)) if a.kind == nkEmpty: addSon(father, newSymNode(f))
else: addSon(a, newSymNode(f)) else: addSon(a, newSymNode(f))
@ -521,7 +521,7 @@ proc addInheritedFieldsAux(c: PContext, check: var TIntSet, pos: var int,
n: PNode) = n: PNode) =
case n.kind case n.kind
of nkRecCase: of nkRecCase:
if (n.sons[0].kind != nkSym): InternalError(n.info, "addInheritedFieldsAux") if (n.sons[0].kind != nkSym): internalError(n.info, "addInheritedFieldsAux")
addInheritedFieldsAux(c, check, pos, n.sons[0]) addInheritedFieldsAux(c, check, pos, n.sons[0])
for i in countup(1, sonsLen(n) - 1): for i in countup(1, sonsLen(n) - 1):
case n.sons[i].kind case n.sons[i].kind
@ -532,9 +532,9 @@ proc addInheritedFieldsAux(c: PContext, check: var TIntSet, pos: var int,
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
addInheritedFieldsAux(c, check, pos, n.sons[i]) addInheritedFieldsAux(c, check, pos, n.sons[i])
of nkSym: of nkSym:
Incl(check, n.sym.name.id) incl(check, n.sym.name.id)
inc(pos) inc(pos)
else: InternalError(n.info, "addInheritedFieldsAux()") else: internalError(n.info, "addInheritedFieldsAux()")
proc addInheritedFields(c: PContext, check: var TIntSet, pos: var int, proc addInheritedFields(c: PContext, check: var TIntSet, pos: var int,
obj: PType) = obj: PType) =
@ -565,7 +565,7 @@ proc semObjectNode(c: PContext, n: PNode, prev: PType): PType =
if concreteBase.kind != tyError: if concreteBase.kind != tyError:
localError(n.sons[1].info, errInheritanceOnlyWithNonFinalObjects) localError(n.sons[1].info, errInheritanceOnlyWithNonFinalObjects)
base = nil base = nil
if n.kind != nkObjectTy: InternalError(n.info, "semObjectNode") if n.kind != nkObjectTy: internalError(n.info, "semObjectNode")
result = newOrPrevType(tyObject, prev, c) result = newOrPrevType(tyObject, prev, c)
rawAddSon(result, base) rawAddSon(result, base)
result.n = newNodeI(nkRecList, n.info) result.n = newNodeI(nkRecList, n.info)
@ -719,7 +719,7 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
var counter = 0 var counter = 0
for i in countup(1, n.len - 1): for i in countup(1, n.len - 1):
var a = n.sons[i] var a = n.sons[i]
if a.kind != nkIdentDefs: IllFormedAst(a) if a.kind != nkIdentDefs: illFormedAst(a)
checkMinSonsLen(a, 3) checkMinSonsLen(a, 3)
var var
typ: PType = nil typ: PType = nil
@ -756,8 +756,8 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
arg.constraint = constraint arg.constraint = constraint
inc(counter) inc(counter)
if def != nil and def.kind != nkEmpty: arg.ast = copyTree(def) if def != nil and def.kind != nkEmpty: arg.ast = copyTree(def)
if ContainsOrIncl(check, arg.name.id): if containsOrIncl(check, arg.name.id):
LocalError(a.sons[j].info, errAttemptToRedefine, arg.name.s) localError(a.sons[j].info, errAttemptToRedefine, arg.name.s)
addSon(result.n, newSymNode(arg)) addSon(result.n, newSymNode(arg))
rawAddSon(result, finalType) rawAddSon(result, finalType)
addParamOrResult(c, arg, kind) addParamOrResult(c, arg, kind)
@ -788,7 +788,7 @@ proc semStmtListType(c: PContext, n: PNode, prev: PType): PType =
result = nil result = nil
proc semBlockType(c: PContext, n: PNode, prev: PType): PType = proc semBlockType(c: PContext, n: PNode, prev: PType): PType =
Inc(c.p.nestedBlockCounter) inc(c.p.nestedBlockCounter)
checkSonsLen(n, 2) checkSonsLen(n, 2)
openScope(c) openScope(c)
if n.sons[0].kind notin {nkEmpty, nkSym}: if n.sons[0].kind notin {nkEmpty, nkSym}:
@ -797,7 +797,7 @@ proc semBlockType(c: PContext, n: PNode, prev: PType): PType =
n.sons[1].typ = result n.sons[1].typ = result
n.typ = result n.typ = result
closeScope(c) closeScope(c)
Dec(c.p.nestedBlockCounter) dec(c.p.nestedBlockCounter)
proc semGenericParamInInvokation(c: PContext, n: PNode): PType = proc semGenericParamInInvokation(c: PContext, n: PNode): PType =
# XXX hack 1022 for generics ... would have been nice if the compiler had # XXX hack 1022 for generics ... would have been nice if the compiler had
@ -824,12 +824,12 @@ proc semGeneric(c: PContext, n: PNode, s: PSym, prev: PType): PType =
template addToResult(typ) = template addToResult(typ) =
if typ.isNil: if typ.isNil:
InternalAssert false internalAssert false
rawAddSon(result, typ) rawAddSon(result, typ)
else: addSonSkipIntLit(result, typ) else: addSonSkipIntLit(result, typ)
if s.typ == nil: if s.typ == nil:
LocalError(n.info, errCannotInstantiateX, s.name.s) localError(n.info, errCannotInstantiateX, s.name.s)
return newOrPrevType(tyError, prev, c) return newOrPrevType(tyError, prev, c)
elif s.typ.kind == tyForward: elif s.typ.kind == tyForward:
for i in countup(1, sonsLen(n)-1): for i in countup(1, sonsLen(n)-1):
@ -845,7 +845,7 @@ proc semGeneric(c: PContext, n: PNode, s: PSym, prev: PType): PType =
var err = "cannot instantiate " & typeToString(s.typ) & "\n" & var err = "cannot instantiate " & typeToString(s.typ) & "\n" &
"got: (" & describeArgs(c, n) & ")\n" & "got: (" & describeArgs(c, n) & ")\n" &
"but expected: (" & describeArgs(c, s.typ.n, 0) & ")" "but expected: (" & describeArgs(c, s.typ.n, 0) & ")"
LocalError(n.info, errGenerated, err) localError(n.info, errGenerated, err)
return newOrPrevType(tyError, prev, c) return newOrPrevType(tyError, prev, c)
var isConcrete = true var isConcrete = true
@ -857,7 +857,7 @@ proc semGeneric(c: PContext, n: PNode, s: PSym, prev: PType): PType =
if isConcrete: if isConcrete:
if s.ast == nil: if s.ast == nil:
LocalError(n.info, errCannotInstantiateX, s.name.s) localError(n.info, errCannotInstantiateX, s.name.s)
result = newOrPrevType(tyError, prev, c) result = newOrPrevType(tyError, prev, c)
else: else:
when oUseLateInstantiation: when oUseLateInstantiation:
@ -870,7 +870,7 @@ proc semTypeExpr(c: PContext, n: PNode): PType =
if n.kind == nkSym and n.sym.kind == skType: if n.kind == nkSym and n.sym.kind == skType:
result = n.sym.typ result = n.sym.typ
else: else:
LocalError(n.info, errTypeExpected, n.renderTree) localError(n.info, errTypeExpected, n.renderTree)
proc freshType(res, prev: PType): PType {.inline.} = proc freshType(res, prev: PType): PType {.inline.} =
if prev.isNil: if prev.isNil:
@ -905,7 +905,7 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
if sonsLen(n) == 1: result = semTypeNode(c, n.sons[0], prev) if sonsLen(n) == 1: result = semTypeNode(c, n.sons[0], prev)
else: else:
# XXX support anon tuple here # XXX support anon tuple here
LocalError(n.info, errTypeExpected) localError(n.info, errTypeExpected)
result = newOrPrevType(tyError, prev, c) result = newOrPrevType(tyError, prev, c)
of nkCallKinds: of nkCallKinds:
if isRange(n): if isRange(n):
@ -918,10 +918,10 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
t1 = semTypeNode(c, n.sons[1], nil) t1 = semTypeNode(c, n.sons[1], nil)
t2 = semTypeNode(c, n.sons[2], nil) t2 = semTypeNode(c, n.sons[2], nil)
if t1 == nil: if t1 == nil:
LocalError(n.sons[1].info, errTypeExpected) localError(n.sons[1].info, errTypeExpected)
result = newOrPrevType(tyError, prev, c) result = newOrPrevType(tyError, prev, c)
elif t2 == nil: elif t2 == nil:
LocalError(n.sons[2].info, errTypeExpected) localError(n.sons[2].info, errTypeExpected)
result = newOrPrevType(tyError, prev, c) result = newOrPrevType(tyError, prev, c)
else: else:
result = newTypeS(tyTypeClass, c) result = newTypeS(tyTypeClass, c)
@ -936,7 +936,7 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
result = freshType(result, prev) result = freshType(result, prev)
result.flags.incl(tfNotNil) result.flags.incl(tfNotNil)
else: else:
LocalError(n.info, errGenerated, "invalid type") localError(n.info, errGenerated, "invalid type")
else: else:
result = semTypeExpr(c, n) result = semTypeExpr(c, n)
else: else:
@ -966,7 +966,7 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
of nkIdent, nkDotExpr, nkAccQuoted: of nkIdent, nkDotExpr, nkAccQuoted:
var s = semTypeIdent(c, n) var s = semTypeIdent(c, n)
if s.typ == nil: if s.typ == nil:
if s.kind != skError: LocalError(n.info, errTypeExpected) if s.kind != skError: localError(n.info, errTypeExpected)
result = newOrPrevType(tyError, prev, c) result = newOrPrevType(tyError, prev, c)
elif s.kind == skParam and s.typ.kind == tyTypeDesc: elif s.kind == skParam and s.typ.kind == tyTypeDesc:
assert s.typ.len > 0 assert s.typ.len > 0
@ -991,7 +991,7 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
result = prev result = prev
markUsed(n, n.sym) markUsed(n, n.sym)
else: else:
if n.sym.kind != skError: LocalError(n.info, errTypeExpected) if n.sym.kind != skError: localError(n.info, errTypeExpected)
result = newOrPrevType(tyError, prev, c) result = newOrPrevType(tyError, prev, c)
of nkObjectTy: result = semObjectNode(c, n, prev) of nkObjectTy: result = semObjectNode(c, n, prev)
of nkTupleTy: result = semTuple(c, n, prev) of nkTupleTy: result = semTuple(c, n, prev)
@ -1016,7 +1016,7 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
#Message(n.info, warnImplicitClosure, renderTree(n)) #Message(n.info, warnImplicitClosure, renderTree(n))
else: else:
pragma(c, s, n.sons[1], procTypePragmas) pragma(c, s, n.sons[1], procTypePragmas)
when useEffectSystem: SetEffectsForProcType(result, n.sons[1]) when useEffectSystem: setEffectsForProcType(result, n.sons[1])
closeScope(c) closeScope(c)
if n.kind == nkIteratorTy: if n.kind == nkIteratorTy:
result.flags.incl(tfIterator) result.flags.incl(tfIterator)
@ -1031,7 +1031,7 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
result = freshType(result, prev) result = freshType(result, prev)
result.flags.incl(tfShared) result.flags.incl(tfShared)
else: else:
LocalError(n.info, errTypeExpected) localError(n.info, errTypeExpected)
result = newOrPrevType(tyError, prev, c) result = newOrPrevType(tyError, prev, c)
proc setMagicType(m: PSym, kind: TTypeKind, size: int) = proc setMagicType(m: PSym, kind: TTypeKind, size: int) =
@ -1081,7 +1081,7 @@ proc processMagicType(c: PContext, m: PSym) =
of mSeq: setMagicType(m, tySequence, 0) of mSeq: setMagicType(m, tySequence, 0)
of mOrdinal: setMagicType(m, tyOrdinal, 0) of mOrdinal: setMagicType(m, tyOrdinal, 0)
of mPNimrodNode: nil of mPNimrodNode: nil
else: LocalError(m.info, errTypeExpected) else: localError(m.info, errTypeExpected)
proc semGenericConstraints(c: PContext, x: PType): PType = proc semGenericConstraints(c: PContext, x: PType): PType =
if x.kind in StructuralEquivTypes and ( if x.kind in StructuralEquivTypes and (

48
compiler/semtypinst.nim
View file

@ -13,19 +13,19 @@ import ast, astalgo, msgs, types, magicsys, semdata, renderer
proc checkPartialConstructedType(info: TLineInfo, t: PType) = proc checkPartialConstructedType(info: TLineInfo, t: PType) =
if tfAcyclic in t.flags and skipTypes(t, abstractInst).kind != tyObject: if tfAcyclic in t.flags and skipTypes(t, abstractInst).kind != tyObject:
LocalError(info, errInvalidPragmaX, "acyclic") localError(info, errInvalidPragmaX, "acyclic")
elif t.kind == tyVar and t.sons[0].kind == tyVar: elif t.kind == tyVar and t.sons[0].kind == tyVar:
LocalError(info, errVarVarTypeNotAllowed) localError(info, errVarVarTypeNotAllowed)
proc checkConstructedType*(info: TLineInfo, typ: PType) = proc checkConstructedType*(info: TLineInfo, typ: PType) =
var t = typ.skipTypes({tyDistinct}) var t = typ.skipTypes({tyDistinct})
if t.kind in {tyTypeClass}: nil if t.kind in {tyTypeClass}: nil
elif tfAcyclic in t.flags and skipTypes(t, abstractInst).kind != tyObject: elif tfAcyclic in t.flags and skipTypes(t, abstractInst).kind != tyObject:
LocalError(info, errInvalidPragmaX, "acyclic") localError(info, errInvalidPragmaX, "acyclic")
elif t.kind == tyVar and t.sons[0].kind == tyVar: elif t.kind == tyVar and t.sons[0].kind == tyVar:
LocalError(info, errVarVarTypeNotAllowed) localError(info, errVarVarTypeNotAllowed)
elif computeSize(t) < 0: elif computeSize(t) < 0:
LocalError(info, errIllegalRecursionInTypeX, typeToString(t)) localError(info, errIllegalRecursionInTypeX, typeToString(t))
when false: when false:
if t.kind == tyObject and t.sons[0] != nil: if t.kind == tyObject and t.sons[0] != nil:
if t.sons[0].kind != tyObject or tfFinal in t.sons[0].flags: if t.sons[0].kind != tyObject or tfFinal in t.sons[0].flags:
@ -74,8 +74,8 @@ proc replaceTypeVarsN(cl: var TReplTypeVars, n: PNode): PNode
proc prepareNode(cl: var TReplTypeVars, n: PNode): PNode = proc prepareNode(cl: var TReplTypeVars, n: PNode): PNode =
result = copyNode(n) result = copyNode(n)
result.typ = ReplaceTypeVarsT(cl, n.typ) result.typ = replaceTypeVarsT(cl, n.typ)
if result.kind == nkSym: result.sym = ReplaceTypeVarsS(cl, n.sym) if result.kind == nkSym: result.sym = replaceTypeVarsS(cl, n.sym)
for i in 0 .. safeLen(n)-1: for i in 0 .. safeLen(n)-1:
# XXX HACK: ``f(a, b)``, avoid to instantiate `f` # XXX HACK: ``f(a, b)``, avoid to instantiate `f`
if i == 0: result.add(n[i]) if i == 0: result.add(n[i])
@ -84,12 +84,12 @@ proc prepareNode(cl: var TReplTypeVars, n: PNode): PNode =
proc replaceTypeVarsN(cl: var TReplTypeVars, n: PNode): PNode = proc replaceTypeVarsN(cl: var TReplTypeVars, n: PNode): PNode =
if n == nil: return if n == nil: return
result = copyNode(n) result = copyNode(n)
result.typ = ReplaceTypeVarsT(cl, n.typ) result.typ = replaceTypeVarsT(cl, n.typ)
case n.kind case n.kind
of nkNone..pred(nkSym), succ(nkSym)..nkNilLit: of nkNone..pred(nkSym), succ(nkSym)..nkNilLit:
discard discard
of nkSym: of nkSym:
result.sym = ReplaceTypeVarsS(cl, n.sym) result.sym = replaceTypeVarsS(cl, n.sym)
of nkRecWhen: of nkRecWhen:
var branch: PNode = nil # the branch to take var branch: PNode = nil # the branch to take
for i in countup(0, sonsLen(n) - 1): for i in countup(0, sonsLen(n) - 1):
@ -101,14 +101,14 @@ proc replaceTypeVarsN(cl: var TReplTypeVars, n: PNode): PNode =
var cond = prepareNode(cl, it.sons[0]) var cond = prepareNode(cl, it.sons[0])
var e = cl.c.semConstExpr(cl.c, cond) var e = cl.c.semConstExpr(cl.c, cond)
if e.kind != nkIntLit: if e.kind != nkIntLit:
InternalError(e.info, "ReplaceTypeVarsN: when condition not a bool") internalError(e.info, "ReplaceTypeVarsN: when condition not a bool")
if e.intVal != 0 and branch == nil: branch = it.sons[1] if e.intVal != 0 and branch == nil: branch = it.sons[1]
of nkElse: of nkElse:
checkSonsLen(it, 1) checkSonsLen(it, 1)
if branch == nil: branch = it.sons[0] if branch == nil: branch = it.sons[0]
else: illFormedAst(n) else: illFormedAst(n)
if branch != nil: if branch != nil:
result = ReplaceTypeVarsN(cl, branch) result = replaceTypeVarsN(cl, branch)
else: else:
result = newNodeI(nkRecList, n.info) result = newNodeI(nkRecList, n.info)
else: else:
@ -116,7 +116,7 @@ proc replaceTypeVarsN(cl: var TReplTypeVars, n: PNode): PNode =
if length > 0: if length > 0:
newSons(result, length) newSons(result, length)
for i in countup(0, length - 1): for i in countup(0, length - 1):
result.sons[i] = ReplaceTypeVarsN(cl, n.sons[i]) result.sons[i] = replaceTypeVarsN(cl, n.sons[i])
proc replaceTypeVarsS(cl: var TReplTypeVars, s: PSym): PSym = proc replaceTypeVarsS(cl: var TReplTypeVars, s: PSym): PSym =
if s == nil: return nil if s == nil: return nil
@ -125,23 +125,23 @@ proc replaceTypeVarsS(cl: var TReplTypeVars, s: PSym): PSym =
result = copySym(s, false) result = copySym(s, false)
incl(result.flags, sfFromGeneric) incl(result.flags, sfFromGeneric)
idTablePut(cl.symMap, s, result) idTablePut(cl.symMap, s, result)
result.typ = ReplaceTypeVarsT(cl, s.typ) result.typ = replaceTypeVarsT(cl, s.typ)
result.owner = s.owner result.owner = s.owner
result.ast = ReplaceTypeVarsN(cl, s.ast) result.ast = replaceTypeVarsN(cl, s.ast)
proc lookupTypeVar(cl: TReplTypeVars, t: PType): PType = proc lookupTypeVar(cl: TReplTypeVars, t: PType): PType =
result = PType(idTableGet(cl.typeMap, t)) result = PType(idTableGet(cl.typeMap, t))
if result == nil: if result == nil:
LocalError(t.sym.info, errCannotInstantiateX, typeToString(t)) localError(t.sym.info, errCannotInstantiateX, typeToString(t))
result = errorType(cl.c) result = errorType(cl.c)
elif result.kind == tyGenericParam: elif result.kind == tyGenericParam:
InternalError(cl.info, "substitution with generic parameter") internalError(cl.info, "substitution with generic parameter")
proc handleGenericInvokation(cl: var TReplTypeVars, t: PType): PType = proc handleGenericInvokation(cl: var TReplTypeVars, t: PType): PType =
# tyGenericInvokation[A, tyGenericInvokation[A, B]] # tyGenericInvokation[A, tyGenericInvokation[A, B]]
# is difficult to handle: # is difficult to handle:
var body = t.sons[0] var body = t.sons[0]
if body.kind != tyGenericBody: InternalError(cl.info, "no generic body") if body.kind != tyGenericBody: internalError(cl.info, "no generic body")
var header: PType = nil var header: PType = nil
# search for some instantiation here: # search for some instantiation here:
result = searchInstTypes(t) result = searchInstTypes(t)
@ -180,11 +180,11 @@ proc handleGenericInvokation(cl: var TReplTypeVars, t: PType): PType =
# but we already raised an error! # but we already raised an error!
rawAddSon(result, header.sons[i]) rawAddSon(result, header.sons[i])
var newbody = ReplaceTypeVarsT(cl, lastSon(body)) var newbody = replaceTypeVarsT(cl, lastSon(body))
newbody.flags = newbody.flags + t.flags + body.flags newbody.flags = newbody.flags + t.flags + body.flags
result.flags = result.flags + newbody.flags result.flags = result.flags + newbody.flags
newbody.callConv = body.callConv newbody.callConv = body.callConv
newbody.n = ReplaceTypeVarsN(cl, lastSon(body).n) newbody.n = replaceTypeVarsN(cl, lastSon(body).n)
# This type may be a generic alias and we want to resolve it here. # This type may be a generic alias and we want to resolve it here.
# One step is enough, because the recursive nature of # One step is enough, because the recursive nature of
# handleGenericInvokation will handle the alias-to-alias-to-alias case # handleGenericInvokation will handle the alias-to-alias-to-alias case
@ -207,8 +207,8 @@ proc replaceTypeVarsT*(cl: var TReplTypeVars, t: PType): PType =
of tyGenericInvokation: of tyGenericInvokation:
result = handleGenericInvokation(cl, t) result = handleGenericInvokation(cl, t)
of tyGenericBody: of tyGenericBody:
InternalError(cl.info, "ReplaceTypeVarsT: tyGenericBody") internalError(cl.info, "ReplaceTypeVarsT: tyGenericBody")
result = ReplaceTypeVarsT(cl, lastSon(t)) result = replaceTypeVarsT(cl, lastSon(t))
of tyInt: of tyInt:
result = skipIntLit(t) result = skipIntLit(t)
# XXX now there are also float literals # XXX now there are also float literals
@ -224,10 +224,10 @@ proc replaceTypeVarsT*(cl: var TReplTypeVars, t: PType): PType =
incl(result.flags, tfFromGeneric) incl(result.flags, tfFromGeneric)
result.size = -1 # needs to be recomputed result.size = -1 # needs to be recomputed
for i in countup(0, sonsLen(result) - 1): for i in countup(0, sonsLen(result) - 1):
result.sons[i] = ReplaceTypeVarsT(cl, result.sons[i]) result.sons[i] = replaceTypeVarsT(cl, result.sons[i])
result.n = ReplaceTypeVarsN(cl, result.n) result.n = replaceTypeVarsN(cl, result.n)
if result.Kind in GenericTypes: if result.Kind in GenericTypes:
LocalError(cl.info, errCannotInstantiateX, TypeToString(t, preferName)) localError(cl.info, errCannotInstantiateX, typeToString(t, preferName))
if result.kind == tyProc and result.sons[0] != nil: if result.kind == tyProc and result.sons[0] != nil:
if result.sons[0].kind == tyEmpty: if result.sons[0].kind == tyEmpty:
result.sons[0] = nil result.sons[0] = nil

8
compiler/service.nim
View file

@ -43,9 +43,9 @@ proc processCmdLine*(pass: TCmdLinePass, cmd: string) =
if bracketLe >= 0: if bracketLe >= 0:
var key = substr(p.key, 0, bracketLe - 1) var key = substr(p.key, 0, bracketLe - 1)
var val = substr(p.key, bracketLe + 1) & ':' & p.val var val = substr(p.key, bracketLe + 1) & ':' & p.val
ProcessSwitch(key, val, pass, gCmdLineInfo) processSwitch(key, val, pass, gCmdLineInfo)
else: else:
ProcessSwitch(p.key, p.val, pass, gCmdLineInfo) processSwitch(p.key, p.val, pass, gCmdLineInfo)
of cmdArgument: of cmdArgument:
if argsCount == 0: if argsCount == 0:
options.command = p.key options.command = p.key
@ -79,11 +79,11 @@ proc serve*(action: proc (){.nimcall.}) =
if line == "quit": quit() if line == "quit": quit()
execute line execute line
echo "" echo ""
FlushFile(stdout) flushFile(stdout)
of "tcp", "": of "tcp", "":
when useCaas: when useCaas:
var server = Socket() var server = socket()
let p = getConfigVar("server.port") let p = getConfigVar("server.port")
let port = if p.len > 0: parseInt(p).TPort else: 6000.TPort let port = if p.len > 0: parseInt(p).TPort else: 6000.TPort
server.bindAddr(port, getConfigVar("server.address")) server.bindAddr(port, getConfigVar("server.address"))

50
compiler/sigmatch.nim
View file

@ -77,7 +77,7 @@ proc initCandidate*(c: var TCandidate, callee: PType) =
initIdTable(c.bindings) initIdTable(c.bindings)
proc put(t: var TIdTable, key, val: PType) {.inline.} = proc put(t: var TIdTable, key, val: PType) {.inline.} =
IdTablePut(t, key, val) idTablePut(t, key, val)
proc initCandidate*(c: var TCandidate, callee: PSym, binding: PNode, proc initCandidate*(c: var TCandidate, callee: PSym, binding: PNode,
calleeScope = -1) = calleeScope = -1) =
@ -169,11 +169,11 @@ proc cmpCandidates*(a, b: TCandidate): int =
result = complexDisambiguation(a.callee, b.callee) result = complexDisambiguation(a.callee, b.callee)
proc writeMatches*(c: TCandidate) = proc writeMatches*(c: TCandidate) =
Writeln(stdout, "exact matches: " & $c.exactMatches) writeln(stdout, "exact matches: " & $c.exactMatches)
Writeln(stdout, "subtype matches: " & $c.subtypeMatches) writeln(stdout, "subtype matches: " & $c.subtypeMatches)
Writeln(stdout, "conv matches: " & $c.convMatches) writeln(stdout, "conv matches: " & $c.convMatches)
Writeln(stdout, "intconv matches: " & $c.intConvMatches) writeln(stdout, "intconv matches: " & $c.intConvMatches)
Writeln(stdout, "generic matches: " & $c.genericMatches) writeln(stdout, "generic matches: " & $c.genericMatches)
proc argTypeToString(arg: PNode): string = proc argTypeToString(arg: PNode): string =
if arg.kind in nkSymChoices: if arg.kind in nkSymChoices:
@ -223,7 +223,7 @@ proc concreteType(c: TCandidate, t: PType): PType =
# proc sort[T](cmp: proc(a, b: T): int = cmp) # proc sort[T](cmp: proc(a, b: T): int = cmp)
if result.kind != tyGenericParam: break if result.kind != tyGenericParam: break
of tyGenericInvokation: of tyGenericInvokation:
InternalError("cannot resolve type: " & typeToString(t)) internalError("cannot resolve type: " & typeToString(t))
result = t result = t
else: else:
result = t # Note: empty is valid here result = t # Note: empty is valid here
@ -309,8 +309,8 @@ proc tupleRel(c: var TCandidate, f, a: PType): TTypeRelation =
if f.n != nil and a.n != nil: if f.n != nil and a.n != nil:
for i in countup(0, sonsLen(f.n) - 1): for i in countup(0, sonsLen(f.n) - 1):
# check field names: # check field names:
if f.n.sons[i].kind != nkSym: InternalError(f.n.info, "tupleRel") if f.n.sons[i].kind != nkSym: internalError(f.n.info, "tupleRel")
elif a.n.sons[i].kind != nkSym: InternalError(a.n.info, "tupleRel") elif a.n.sons[i].kind != nkSym: internalError(a.n.info, "tupleRel")
else: else:
var x = f.n.sons[i].sym var x = f.n.sons[i].sym
var y = a.n.sons[i].sym var y = a.n.sons[i].sym
@ -552,7 +552,7 @@ proc typeRel(c: var TCandidate, f, a: PType, doBind = true): TTypeRelation =
if result < isGeneric: result = isNone if result < isGeneric: result = isNone
elif a.kind == tyGenericParam: elif a.kind == tyGenericParam:
result = isGeneric result = isGeneric
of tyForward: InternalError("forward type in typeRel()") of tyForward: internalError("forward type in typeRel()")
of tyNil: of tyNil:
if a.kind == f.kind: result = isEqual if a.kind == f.kind: result = isEqual
of tyTuple: of tyTuple:
@ -658,7 +658,7 @@ proc typeRel(c: var TCandidate, f, a: PType, doBind = true): TTypeRelation =
(sonsLen(x) - 1 == sonsLen(f)): (sonsLen(x) - 1 == sonsLen(f)):
for i in countup(1, sonsLen(f) - 1): for i in countup(1, sonsLen(f) - 1):
if x.sons[i].kind == tyGenericParam: if x.sons[i].kind == tyGenericParam:
InternalError("wrong instantiated type!") internalError("wrong instantiated type!")
elif typeRel(c, f.sons[i], x.sons[i]) <= isSubtype: return elif typeRel(c, f.sons[i], x.sons[i]) <= isSubtype: return
result = isGeneric result = isGeneric
else: else:
@ -668,7 +668,7 @@ proc typeRel(c: var TCandidate, f, a: PType, doBind = true): TTypeRelation =
for i in countup(1, sonsLen(f) - 1): for i in countup(1, sonsLen(f) - 1):
var x = PType(idTableGet(c.bindings, f.sons[0].sons[i - 1])) var x = PType(idTableGet(c.bindings, f.sons[0].sons[i - 1]))
if x == nil or x.kind in {tyGenericInvokation, tyGenericParam}: if x == nil or x.kind in {tyGenericInvokation, tyGenericParam}:
InternalError("wrong instantiated type!") internalError("wrong instantiated type!")
put(c.bindings, f.sons[i], x) put(c.bindings, f.sons[i], x)
of tyAnd: of tyAnd:
@ -764,7 +764,7 @@ proc typeRel(c: var TCandidate, f, a: PType, doBind = true): TTypeRelation =
proc cmpTypes*(f, a: PType): TTypeRelation = proc cmpTypes*(f, a: PType): TTypeRelation =
var c: TCandidate var c: TCandidate
InitCandidate(c, f) initCandidate(c, f)
result = typeRel(c, f, a) result = typeRel(c, f, a)
proc getInstantiatedType(c: PContext, arg: PNode, m: TCandidate, proc getInstantiatedType(c: PContext, arg: PNode, m: TCandidate,
@ -773,7 +773,7 @@ proc getInstantiatedType(c: PContext, arg: PNode, m: TCandidate,
if result == nil: if result == nil:
result = generateTypeInstance(c, m.bindings, arg, f) result = generateTypeInstance(c, m.bindings, arg, f)
if result == nil: if result == nil:
InternalError(arg.info, "getInstantiatedType") internalError(arg.info, "getInstantiatedType")
result = errorType(c) result = errorType(c)
proc implicitConv(kind: TNodeKind, f: PType, arg: PNode, m: TCandidate, proc implicitConv(kind: TNodeKind, f: PType, arg: PNode, m: TCandidate,
@ -786,7 +786,7 @@ proc implicitConv(kind: TNodeKind, f: PType, arg: PNode, m: TCandidate,
result.typ = errorType(c) result.typ = errorType(c)
else: else:
result.typ = f result.typ = f
if result.typ == nil: InternalError(arg.info, "implicitConv") if result.typ == nil: internalError(arg.info, "implicitConv")
addSon(result, ast.emptyNode) addSon(result, ast.emptyNode)
addSon(result, arg) addSon(result, arg)
@ -1006,7 +1006,7 @@ proc paramTypesMatchAux(c: PContext, m: var TCandidate, f, argType: PType,
proc paramTypesMatch*(c: PContext, m: var TCandidate, f, a: PType, proc paramTypesMatch*(c: PContext, m: var TCandidate, f, a: PType,
arg, argOrig: PNode): PNode = arg, argOrig: PNode): PNode =
if arg == nil or arg.kind notin nkSymChoices: if arg == nil or arg.kind notin nkSymChoices:
result = ParamTypesMatchAux(c, m, f, a, arg, argOrig) result = paramTypesMatchAux(c, m, f, a, arg, argOrig)
else: else:
# CAUTION: The order depends on the used hashing scheme. Thus it is # CAUTION: The order depends on the used hashing scheme. Thus it is
# incorrect to simply use the first fitting match. However, to implement # incorrect to simply use the first fitting match. However, to implement
@ -1041,17 +1041,17 @@ proc paramTypesMatch*(c: PContext, m: var TCandidate, f, a: PType,
result = nil result = nil
elif (y.state == csMatch) and (cmpCandidates(x, y) == 0): elif (y.state == csMatch) and (cmpCandidates(x, y) == 0):
if x.state != csMatch: if x.state != csMatch:
InternalError(arg.info, "x.state is not csMatch") internalError(arg.info, "x.state is not csMatch")
# ambiguous: more than one symbol fits # ambiguous: more than one symbol fits
result = nil result = nil
else: else:
# only one valid interpretation found: # only one valid interpretation found:
markUsed(arg, arg.sons[best].sym) markUsed(arg, arg.sons[best].sym)
result = ParamTypesMatchAux(c, m, f, arg.sons[best].typ, arg.sons[best], result = paramTypesMatchAux(c, m, f, arg.sons[best].typ, arg.sons[best],
argOrig) argOrig)
proc setSon(father: PNode, at: int, son: PNode) = proc setSon(father: PNode, at: int, son: PNode) =
if sonsLen(father) <= at: setlen(father.sons, at + 1) if sonsLen(father) <= at: setLen(father.sons, at + 1)
father.sons[at] = son father.sons[at] = son
# we are allowed to modify the calling node in the 'prepare*' procs: # we are allowed to modify the calling node in the 'prepare*' procs:
@ -1122,7 +1122,7 @@ proc matchesAux(c: PContext, n, nOrig: PNode,
# check if m.callee has such a param: # check if m.callee has such a param:
prepareNamedParam(n.sons[a]) prepareNamedParam(n.sons[a])
if n.sons[a].sons[0].kind != nkIdent: if n.sons[a].sons[0].kind != nkIdent:
LocalError(n.sons[a].info, errNamedParamHasToBeIdent) localError(n.sons[a].info, errNamedParamHasToBeIdent)
m.state = csNoMatch m.state = csNoMatch
return return
formal = getSymFromList(m.callee.n, n.sons[a].sons[0].ident, 1) formal = getSymFromList(m.callee.n, n.sons[a].sons[0].ident, 1)
@ -1130,15 +1130,15 @@ proc matchesAux(c: PContext, n, nOrig: PNode,
# no error message! # no error message!
m.state = csNoMatch m.state = csNoMatch
return return
if ContainsOrIncl(marker, formal.position): if containsOrIncl(marker, formal.position):
# already in namedParams: # already in namedParams:
LocalError(n.sons[a].info, errCannotBindXTwice, formal.name.s) localError(n.sons[a].info, errCannotBindXTwice, formal.name.s)
m.state = csNoMatch m.state = csNoMatch
return return
m.baseTypeMatch = false m.baseTypeMatch = false
n.sons[a].sons[1] = prepareOperand(c, formal.typ, n.sons[a].sons[1]) n.sons[a].sons[1] = prepareOperand(c, formal.typ, n.sons[a].sons[1])
n.sons[a].typ = n.sons[a].sons[1].typ n.sons[a].typ = n.sons[a].sons[1].typ
var arg = ParamTypesMatch(c, m, formal.typ, n.sons[a].typ, var arg = paramTypesMatch(c, m, formal.typ, n.sons[a].typ,
n.sons[a].sons[1], nOrig.sons[a].sons[1]) n.sons[a].sons[1], nOrig.sons[a].sons[1])
if arg == nil: if arg == nil:
m.state = csNoMatch m.state = csNoMatch
@ -1168,7 +1168,7 @@ proc matchesAux(c: PContext, n, nOrig: PNode,
elif formal != nil: elif formal != nil:
m.baseTypeMatch = false m.baseTypeMatch = false
n.sons[a] = prepareOperand(c, formal.typ, n.sons[a]) n.sons[a] = prepareOperand(c, formal.typ, n.sons[a])
var arg = ParamTypesMatch(c, m, formal.typ, n.sons[a].typ, var arg = paramTypesMatch(c, m, formal.typ, n.sons[a].typ,
n.sons[a], nOrig.sons[a]) n.sons[a], nOrig.sons[a])
if (arg != nil) and m.baseTypeMatch and (container != nil): if (arg != nil) and m.baseTypeMatch and (container != nil):
addSon(container, arg) addSon(container, arg)
@ -1181,7 +1181,7 @@ proc matchesAux(c: PContext, n, nOrig: PNode,
return return
else: else:
if m.callee.n.sons[f].kind != nkSym: if m.callee.n.sons[f].kind != nkSym:
InternalError(n.sons[a].info, "matches") internalError(n.sons[a].info, "matches")
return return
formal = m.callee.n.sons[f].sym formal = m.callee.n.sons[f].sym
if containsOrIncl(marker, formal.position): if containsOrIncl(marker, formal.position):

34
compiler/suggest.nim
View file

@ -48,15 +48,15 @@ proc symToStr(s: PSym, isLocal: bool, section: string, li: TLineInfo): string =
result.add(sep) result.add(sep)
result.add(toFullPath(li)) result.add(toFullPath(li))
result.add(sep) result.add(sep)
result.add($ToLinenumber(li)) result.add($toLinenumber(li))
result.add(sep) result.add(sep)
result.add($ToColumn(li)) result.add($toColumn(li))
result.add(sep) result.add(sep)
when not defined(noDocgen): when not defined(noDocgen):
result.add(s.extractDocComment.escape) result.add(s.extractDocComment.escape)
proc symToStr(s: PSym, isLocal: bool, section: string): string = proc symToStr(s: PSym, isLocal: bool, section: string): string =
result = SymToStr(s, isLocal, section, s.info) result = symToStr(s, isLocal, section, s.info)
proc filterSym(s: PSym): bool {.inline.} = proc filterSym(s: PSym): bool {.inline.} =
result = s.name.s[0] in lexer.SymChars and s.kind != skModule result = s.name.s[0] in lexer.SymChars and s.kind != skModule
@ -68,7 +68,7 @@ proc fieldVisible*(c: PContext, f: PSym): bool {.inline.} =
proc suggestField(c: PContext, s: PSym, outputs: var int) = proc suggestField(c: PContext, s: PSym, outputs: var int) =
if filterSym(s) and fieldVisible(c, s): if filterSym(s) and fieldVisible(c, s):
SuggestWriteln(SymToStr(s, isLocal=true, sectionSuggest)) suggestWriteln(symToStr(s, isLocal=true, sectionSuggest))
inc outputs inc outputs
when not defined(nimhygiene): when not defined(nimhygiene):
@ -84,7 +84,7 @@ template wholeSymTab(cond, section: expr) {.immediate.} =
for item in entries: for item in entries:
let it {.inject.} = item let it {.inject.} = item
if cond: if cond:
SuggestWriteln(SymToStr(it, isLocal = isLocal, section)) suggestWriteln(symToStr(it, isLocal = isLocal, section))
inc outputs inc outputs
proc suggestSymList(c: PContext, list: PNode, outputs: var int) = proc suggestSymList(c: PContext, list: PNode, outputs: var int) =
@ -144,7 +144,7 @@ proc suggestEverything(c: PContext, n: PNode, outputs: var int) =
if scope == c.topLevelScope: isLocal = false if scope == c.topLevelScope: isLocal = false
for it in items(scope.symbols): for it in items(scope.symbols):
if filterSym(it): if filterSym(it):
SuggestWriteln(SymToStr(it, isLocal = isLocal, sectionSuggest)) suggestWriteln(symToStr(it, isLocal = isLocal, sectionSuggest))
inc outputs inc outputs
if scope == c.topLevelScope: break if scope == c.topLevelScope: break
@ -159,12 +159,12 @@ proc suggestFieldAccess(c: PContext, n: PNode, outputs: var int) =
# all symbols accessible, because we are in the current module: # all symbols accessible, because we are in the current module:
for it in items(c.topLevelScope.symbols): for it in items(c.topLevelScope.symbols):
if filterSym(it): if filterSym(it):
SuggestWriteln(SymToStr(it, isLocal=false, sectionSuggest)) suggestWriteln(symToStr(it, isLocal=false, sectionSuggest))
inc outputs inc outputs
else: else:
for it in items(n.sym.tab): for it in items(n.sym.tab):
if filterSym(it): if filterSym(it):
SuggestWriteln(SymToStr(it, isLocal=false, sectionSuggest)) suggestWriteln(symToStr(it, isLocal=false, sectionSuggest))
inc outputs inc outputs
else: else:
# fallback: # fallback:
@ -246,16 +246,16 @@ var
proc findUsages(node: PNode, s: PSym) = proc findUsages(node: PNode, s: PSym) =
if usageSym == nil and isTracked(node.info, s.name.s.len): if usageSym == nil and isTracked(node.info, s.name.s.len):
usageSym = s usageSym = s
SuggestWriteln(SymToStr(s, isLocal=false, sectionUsage)) suggestWriteln(symToStr(s, isLocal=false, sectionUsage))
elif s == usageSym: elif s == usageSym:
if lastLineInfo != node.info: if lastLineInfo != node.info:
SuggestWriteln(SymToStr(s, isLocal=false, sectionUsage, node.info)) suggestWriteln(symToStr(s, isLocal=false, sectionUsage, node.info))
lastLineInfo = node.info lastLineInfo = node.info
proc findDefinition(node: PNode, s: PSym) = proc findDefinition(node: PNode, s: PSym) =
if isTracked(node.info, s.name.s.len): if isTracked(node.info, s.name.s.len):
SuggestWriteln(SymToStr(s, isLocal=false, sectionDef)) suggestWriteln(symToStr(s, isLocal=false, sectionDef))
SuggestQuit() suggestQuit()
type type
TSourceMap = object TSourceMap = object
@ -281,7 +281,7 @@ proc resetSourceMap*(fileIdx: int32) =
ensureIdx(gSourceMaps, fileIdx) ensureIdx(gSourceMaps, fileIdx)
gSourceMaps[fileIdx].lines = @[] gSourceMaps[fileIdx].lines = @[]
proc addToSourceMap(sym: Psym, info: TLineInfo) = proc addToSourceMap(sym: PSym, info: TLineInfo) =
ensureIdx(gSourceMaps, info.fileIndex) ensureIdx(gSourceMaps, info.fileIndex)
ensureSeq(gSourceMaps[info.fileIndex].lines) ensureSeq(gSourceMaps[info.fileIndex].lines)
ensureIdx(gSourceMaps[info.fileIndex].lines, info.line) ensureIdx(gSourceMaps[info.fileIndex].lines, info.line)
@ -302,7 +302,7 @@ proc defFromLine(entries: var seq[TEntry], col: int32) =
# that the first expr that ends after the cursor column is # that the first expr that ends after the cursor column is
# the one we are looking for. # the one we are looking for.
if e.pos >= col: if e.pos >= col:
SuggestWriteln(SymToStr(e.sym, isLocal=false, sectionDef)) suggestWriteln(symToStr(e.sym, isLocal=false, sectionDef))
return return
proc defFromSourceMap*(i: TLineInfo) = proc defFromSourceMap*(i: TLineInfo) =
@ -324,8 +324,8 @@ proc suggestSym*(n: PNode, s: PSym) {.inline.} =
proc markUsed(n: PNode, s: PSym) = proc markUsed(n: PNode, s: PSym) =
incl(s.flags, sfUsed) incl(s.flags, sfUsed)
if {sfDeprecated, sfError} * s.flags != {}: if {sfDeprecated, sfError} * s.flags != {}:
if sfDeprecated in s.flags: Message(n.info, warnDeprecated, s.name.s) if sfDeprecated in s.flags: message(n.info, warnDeprecated, s.name.s)
if sfError in s.flags: LocalError(n.info, errWrongSymbolX, s.name.s) if sfError in s.flags: localError(n.info, errWrongSymbolX, s.name.s)
suggestSym(n, s) suggestSym(n, s)
proc useSym*(sym: PSym): PNode = proc useSym*(sym: PSym): PNode =
@ -369,7 +369,7 @@ proc suggestExpr*(c: PContext, node: PNode) =
suggestCall(c, a, n, outputs) suggestCall(c, a, n, outputs)
dec(c.InCompilesContext) dec(c.InCompilesContext)
if outputs > 0 and optUsages notin gGlobalOptions: SuggestQuit() if outputs > 0 and optUsages notin gGlobalOptions: suggestQuit()
proc suggestStmt*(c: PContext, n: PNode) = proc suggestStmt*(c: PContext, n: PNode) =
suggestExpr(c, n) suggestExpr(c, n)

28
compiler/syntaxes.nim
View file

@ -43,14 +43,14 @@ proc parseTopLevelStmt*(p: var TParsers): PNode
proc parseFile(fileIdx: int32): PNode = proc parseFile(fileIdx: int32): PNode =
var var
p: TParsers p: TParsers
f: tfile f: TFile
let filename = fileIdx.toFullPath let filename = fileIdx.toFullPath
if not open(f, filename): if not open(f, filename):
rawMessage(errCannotOpenFile, filename) rawMessage(errCannotOpenFile, filename)
return return
OpenParsers(p, fileIdx, LLStreamOpen(f)) openParsers(p, fileIdx, llStreamOpen(f))
result = ParseAll(p) result = parseAll(p)
CloseParsers(p) closeParsers(p)
proc parseAll(p: var TParsers): PNode = proc parseAll(p: var TParsers): PNode =
case p.skin case p.skin
@ -59,7 +59,7 @@ proc parseAll(p: var TParsers): PNode =
of skinBraces: of skinBraces:
result = pbraces.parseAll(p.parser) result = pbraces.parseAll(p.parser)
of skinEndX: of skinEndX:
InternalError("parser to implement") internalError("parser to implement")
result = ast.emptyNode result = ast.emptyNode
# skinEndX: result := pendx.parseAll(p.parser); # skinEndX: result := pendx.parseAll(p.parser);
@ -70,7 +70,7 @@ proc parseTopLevelStmt(p: var TParsers): PNode =
of skinBraces: of skinBraces:
result = pbraces.parseTopLevelStmt(p.parser) result = pbraces.parseTopLevelStmt(p.parser)
of skinEndX: of skinEndX:
InternalError("parser to implement") internalError("parser to implement")
result = ast.emptyNode result = ast.emptyNode
#skinEndX: result := pendx.parseTopLevelStmt(p.parser); #skinEndX: result := pendx.parseTopLevelStmt(p.parser);
@ -88,22 +88,22 @@ proc containsShebang(s: string, i: int): bool =
proc parsePipe(filename: string, inputStream: PLLStream): PNode = proc parsePipe(filename: string, inputStream: PLLStream): PNode =
result = ast.emptyNode result = ast.emptyNode
var s = LLStreamOpen(filename, fmRead) var s = llStreamOpen(filename, fmRead)
if s != nil: if s != nil:
var line = newStringOfCap(80) var line = newStringOfCap(80)
discard LLStreamReadLine(s, line) discard llStreamReadLine(s, line)
var i = utf8Bom(line) var i = utf8Bom(line)
if containsShebang(line, i): if containsShebang(line, i):
discard LLStreamReadLine(s, line) discard llStreamReadLine(s, line)
i = 0 i = 0
if line[i] == '#' and line[i+1] == '!': if line[i] == '#' and line[i+1] == '!':
inc(i, 2) inc(i, 2)
while line[i] in WhiteSpace: inc(i) while line[i] in WhiteSpace: inc(i)
var q: TParser var q: TParser
openParser(q, filename, LLStreamOpen(substr(line, i))) openParser(q, filename, llStreamOpen(substr(line, i)))
result = parser.parseAll(q) result = parser.parseAll(q)
closeParser(q) closeParser(q)
LLStreamClose(s) llStreamClose(s)
proc getFilter(ident: PIdent): TFilterKind = proc getFilter(ident: PIdent): TFilterKind =
for i in countup(low(TFilterKind), high(TFilterKind)): for i in countup(low(TFilterKind), high(TFilterKind)):
@ -165,9 +165,9 @@ proc openParsers(p: var TParsers, fileIdx: int32, inputstream: PLLStream) =
var s: PLLStream var s: PLLStream
p.skin = skinStandard p.skin = skinStandard
let filename = fileIdx.toFullPath let filename = fileIdx.toFullPath
var pipe = parsePipe(filename, inputStream) var pipe = parsePipe(filename, inputstream)
if pipe != nil: s = evalPipe(p, pipe, filename, inputStream) if pipe != nil: s = evalPipe(p, pipe, filename, inputstream)
else: s = inputStream else: s = inputstream
case p.skin case p.skin
of skinStandard, skinBraces, skinEndX: of skinStandard, skinBraces, skinEndX:
parser.openParser(p.parser, fileIdx, s) parser.openParser(p.parser, fileIdx, s)

26
compiler/transf.nim
View file

@ -88,7 +88,7 @@ proc pushTransCon(c: PTransf, t: PTransCon) =
c.transCon = t c.transCon = t
proc popTransCon(c: PTransf) = proc popTransCon(c: PTransf) =
if (c.transCon == nil): InternalError("popTransCon") if (c.transCon == nil): internalError("popTransCon")
c.transCon = c.transCon.next c.transCon = c.transCon.next
proc getCurrOwner(c: PTransf): PSym = proc getCurrOwner(c: PTransf): PSym =
@ -126,7 +126,7 @@ proc transformSymAux(c: PTransf, n: PNode): PNode =
else: else:
b = n b = n
while tc != nil: while tc != nil:
result = IdNodeTableGet(tc.mapping, b.sym) result = idNodeTableGet(tc.mapping, b.sym)
if result != nil: return if result != nil: return
tc = tc.next tc = tc.next
result = b result = b
@ -141,14 +141,14 @@ proc transformVarSection(c: PTransf, v: PNode): PTransNode =
if it.kind == nkCommentStmt: if it.kind == nkCommentStmt:
result[i] = PTransNode(it) result[i] = PTransNode(it)
elif it.kind == nkIdentDefs: elif it.kind == nkIdentDefs:
if it.sons[0].kind != nkSym: InternalError(it.info, "transformVarSection") if it.sons[0].kind != nkSym: internalError(it.info, "transformVarSection")
InternalAssert(it.len == 3) InternalAssert(it.len == 3)
var newVar = copySym(it.sons[0].sym) var newVar = copySym(it.sons[0].sym)
incl(newVar.flags, sfFromGeneric) incl(newVar.flags, sfFromGeneric)
# fixes a strange bug for rodgen: # fixes a strange bug for rodgen:
#include(it.sons[0].sym.flags, sfFromGeneric); #include(it.sons[0].sym.flags, sfFromGeneric);
newVar.owner = getCurrOwner(c) newVar.owner = getCurrOwner(c)
IdNodeTablePut(c.transCon.mapping, it.sons[0].sym, newSymNode(newVar)) idNodeTablePut(c.transCon.mapping, it.sons[0].sym, newSymNode(newVar))
var defs = newTransNode(nkIdentDefs, it.info, 3) var defs = newTransNode(nkIdentDefs, it.info, 3)
if importantComments(): if importantComments():
# keep documentation information: # keep documentation information:
@ -159,14 +159,14 @@ proc transformVarSection(c: PTransf, v: PNode): PTransNode =
result[i] = defs result[i] = defs
else: else:
if it.kind != nkVarTuple: if it.kind != nkVarTuple:
InternalError(it.info, "transformVarSection: not nkVarTuple") internalError(it.info, "transformVarSection: not nkVarTuple")
var L = sonsLen(it) var L = sonsLen(it)
var defs = newTransNode(it.kind, it.info, L) var defs = newTransNode(it.kind, it.info, L)
for j in countup(0, L-3): for j in countup(0, L-3):
var newVar = copySym(it.sons[j].sym) var newVar = copySym(it.sons[j].sym)
incl(newVar.flags, sfFromGeneric) incl(newVar.flags, sfFromGeneric)
newVar.owner = getCurrOwner(c) newVar.owner = getCurrOwner(c)
IdNodeTablePut(c.transCon.mapping, it.sons[j].sym, newSymNode(newVar)) idNodeTablePut(c.transCon.mapping, it.sons[j].sym, newSymNode(newVar))
defs[j] = newSymNode(newVar).PTransNode defs[j] = newSymNode(newVar).PTransNode
assert(it.sons[L-2].kind == nkEmpty) assert(it.sons[L-2].kind == nkEmpty)
defs[L-1] = transform(c, it.sons[L-1]) defs[L-1] = transform(c, it.sons[L-1])
@ -179,9 +179,9 @@ proc transformConstSection(c: PTransf, v: PNode): PTransNode =
if it.kind == nkCommentStmt: if it.kind == nkCommentStmt:
result[i] = PTransNode(it) result[i] = PTransNode(it)
else: else:
if it.kind != nkConstDef: InternalError(it.info, "transformConstSection") if it.kind != nkConstDef: internalError(it.info, "transformConstSection")
if it.sons[0].kind != nkSym: if it.sons[0].kind != nkSym:
InternalError(it.info, "transformConstSection") internalError(it.info, "transformConstSection")
if sfFakeConst in it[0].sym.flags: if sfFakeConst in it[0].sym.flags:
var b = newNodeI(nkConstDef, it.info) var b = newNodeI(nkConstDef, it.info)
addSon(b, it[0]) addSon(b, it[0])
@ -429,7 +429,7 @@ proc findWrongOwners(c: PTransf, n: PNode) =
proc transformFor(c: PTransf, n: PNode): PTransNode = proc transformFor(c: PTransf, n: PNode): PTransNode =
# generate access statements for the parameters (unless they are constant) # generate access statements for the parameters (unless they are constant)
# put mapping from formal parameters to actual parameters # put mapping from formal parameters to actual parameters
if n.kind != nkForStmt: InternalError(n.info, "transformFor") if n.kind != nkForStmt: internalError(n.info, "transformFor")
var length = sonsLen(n) var length = sonsLen(n)
var call = n.sons[length - 2] var call = n.sons[length - 2]
@ -454,7 +454,7 @@ proc transformFor(c: PTransf, n: PNode): PTransNode =
var newC = newTransCon(getCurrOwner(c)) var newC = newTransCon(getCurrOwner(c))
newC.forStmt = n newC.forStmt = n
newC.forLoopBody = loopBody newC.forLoopBody = loopBody
if iter.kind != skIterator: InternalError(call.info, "transformFor") if iter.kind != skIterator: internalError(call.info, "transformFor")
# generate access statements for the parameters (unless they are constant) # generate access statements for the parameters (unless they are constant)
pushTransCon(c, newC) pushTransCon(c, newC)
for i in countup(1, sonsLen(call) - 1): for i in countup(1, sonsLen(call) - 1):
@ -462,16 +462,16 @@ proc transformFor(c: PTransf, n: PNode): PTransNode =
var formal = skipTypes(iter.typ, abstractInst).n.sons[i].sym var formal = skipTypes(iter.typ, abstractInst).n.sons[i].sym
case putArgInto(arg, formal.typ) case putArgInto(arg, formal.typ)
of paDirectMapping: of paDirectMapping:
IdNodeTablePut(newC.mapping, formal, arg) idNodeTablePut(newC.mapping, formal, arg)
of paFastAsgn: of paFastAsgn:
# generate a temporary and produce an assignment statement: # generate a temporary and produce an assignment statement:
var temp = newTemp(c, formal.typ, formal.info) var temp = newTemp(c, formal.typ, formal.info)
addVar(v, newSymNode(temp)) addVar(v, newSymNode(temp))
add(result, newAsgnStmt(c, newSymNode(temp), arg.ptransNode)) add(result, newAsgnStmt(c, newSymNode(temp), arg.ptransNode))
IdNodeTablePut(newC.mapping, formal, newSymNode(temp)) idNodeTablePut(newC.mapping, formal, newSymNode(temp))
of paVarAsgn: of paVarAsgn:
assert(skipTypes(formal.typ, abstractInst).kind == tyVar) assert(skipTypes(formal.typ, abstractInst).kind == tyVar)
IdNodeTablePut(newC.mapping, formal, arg) idNodeTablePut(newC.mapping, formal, arg)
# XXX BUG still not correct if the arg has a side effect! # XXX BUG still not correct if the arg has a side effect!
var body = iter.getBody var body = iter.getBody
pushInfoContext(n.info) pushInfoContext(n.info)

2
compiler/treetab.nim
View file

@ -77,7 +77,7 @@ proc nodeTableRawInsert(data: var TNodePairSeq, k: THash, key: PNode,
proc nodeTablePut*(t: var TNodeTable, key: PNode, val: int) = proc nodeTablePut*(t: var TNodeTable, key: PNode, val: int) =
var n: TNodePairSeq var n: TNodePairSeq
var k: THash = hashTree(key) var k: THash = hashTree(key)
var index = NodeTableRawGet(t, k, key) var index = nodeTableRawGet(t, k, key)
if index >= 0: if index >= 0:
assert(t.data[index].key != nil) assert(t.data[index].key != nil)
t.data[index].val = val t.data[index].val = val

94
compiler/types.nim
View file

@ -12,9 +12,9 @@
import import
intsets, ast, astalgo, trees, msgs, strutils, platform intsets, ast, astalgo, trees, msgs, strutils, platform
proc firstOrd*(t: PType): biggestInt proc firstOrd*(t: PType): BiggestInt
proc lastOrd*(t: PType): biggestInt proc lastOrd*(t: PType): BiggestInt
proc lengthOrd*(t: PType): biggestInt proc lengthOrd*(t: PType): BiggestInt
type type
TPreferedDesc* = enum TPreferedDesc* = enum
preferName, preferDesc, preferExported preferName, preferDesc, preferExported
@ -70,9 +70,9 @@ proc containsGarbageCollectedRef*(typ: PType): bool
proc containsHiddenPointer*(typ: PType): bool proc containsHiddenPointer*(typ: PType): bool
proc canFormAcycle*(typ: PType): bool proc canFormAcycle*(typ: PType): bool
proc isCompatibleToCString*(a: PType): bool proc isCompatibleToCString*(a: PType): bool
proc getOrdValue*(n: PNode): biggestInt proc getOrdValue*(n: PNode): BiggestInt
proc computeSize*(typ: PType): biggestInt proc computeSize*(typ: PType): BiggestInt
proc getSize*(typ: PType): biggestInt proc getSize*(typ: PType): BiggestInt
proc isPureObject*(typ: PType): bool proc isPureObject*(typ: PType): bool
proc invalidGenericInst*(f: PType): bool proc invalidGenericInst*(f: PType): bool
# for debugging # for debugging
@ -103,7 +103,7 @@ proc getOrdValue(n: PNode): biggestInt =
of nkNilLit: result = 0 of nkNilLit: result = 0
of nkHiddenStdConv: result = getOrdValue(n.sons[1]) of nkHiddenStdConv: result = getOrdValue(n.sons[1])
else: else:
LocalError(n.info, errOrdinalTypeExpected) localError(n.info, errOrdinalTypeExpected)
result = 0 result = 0
proc isIntLit*(t: PType): bool {.inline.} = proc isIntLit*(t: PType): bool {.inline.} =
@ -184,7 +184,7 @@ proc iterOverTypeAux(marker: var TIntSet, t: PType, iter: TTypeIter,
if t == nil: return if t == nil: return
result = iter(t, closure) result = iter(t, closure)
if result: return if result: return
if not ContainsOrIncl(marker, t.id): if not containsOrIncl(marker, t.id):
case t.kind case t.kind
of tyGenericInst, tyGenericBody: of tyGenericInst, tyGenericBody:
result = iterOverTypeAux(marker, lastSon(t), iter, closure) result = iterOverTypeAux(marker, lastSon(t), iter, closure)
@ -195,7 +195,7 @@ proc iterOverTypeAux(marker: var TIntSet, t: PType, iter: TTypeIter,
if t.n != nil: result = iterOverNode(marker, t.n, iter, closure) if t.n != nil: result = iterOverNode(marker, t.n, iter, closure)
proc iterOverType(t: PType, iter: TTypeIter, closure: PObject): bool = proc iterOverType(t: PType, iter: TTypeIter, closure: PObject): bool =
var marker = InitIntSet() var marker = initIntSet()
result = iterOverTypeAux(marker, t, iter, closure) result = iterOverTypeAux(marker, t, iter, closure)
proc searchTypeForAux(t: PType, predicate: TTypePredicate, proc searchTypeForAux(t: PType, predicate: TTypePredicate,
@ -228,8 +228,8 @@ proc searchTypeForAux(t: PType, predicate: TTypePredicate,
# iterates over VALUE types! # iterates over VALUE types!
result = false result = false
if t == nil: return if t == nil: return
if ContainsOrIncl(marker, t.id): return if containsOrIncl(marker, t.id): return
result = Predicate(t) result = predicate(t)
if result: return if result: return
case t.kind case t.kind
of tyObject: of tyObject:
@ -245,7 +245,7 @@ proc searchTypeForAux(t: PType, predicate: TTypePredicate,
discard discard
proc searchTypeFor(t: PType, predicate: TTypePredicate): bool = proc searchTypeFor(t: PType, predicate: TTypePredicate): bool =
var marker = InitIntSet() var marker = initIntSet()
result = searchTypeForAux(t, predicate, marker) result = searchTypeForAux(t, predicate, marker)
proc isObjectPredicate(t: PType): bool = proc isObjectPredicate(t: PType): bool =
@ -287,7 +287,7 @@ proc analyseObjectWithTypeFieldAux(t: PType,
discard discard
proc analyseObjectWithTypeField(t: PType): TTypeFieldResult = proc analyseObjectWithTypeField(t: PType): TTypeFieldResult =
var marker = InitIntSet() var marker = initIntSet()
result = analyseObjectWithTypeFieldAux(t, marker) result = analyseObjectWithTypeFieldAux(t, marker)
proc isGCRef(t: PType): bool = proc isGCRef(t: PType): bool =
@ -337,7 +337,7 @@ proc canFormAcycleAux(marker: var TIntSet, typ: PType, startId: int): bool =
case t.kind case t.kind
of tyTuple, tyObject, tyRef, tySequence, tyArray, tyArrayConstr, tyOpenArray, of tyTuple, tyObject, tyRef, tySequence, tyArray, tyArrayConstr, tyOpenArray,
tyVarargs: tyVarargs:
if not ContainsOrIncl(marker, t.id): if not containsOrIncl(marker, t.id):
for i in countup(0, sonsLen(t) - 1): for i in countup(0, sonsLen(t) - 1):
result = canFormAcycleAux(marker, t.sons[i], startId) result = canFormAcycleAux(marker, t.sons[i], startId)
if result: return if result: return
@ -353,7 +353,7 @@ proc canFormAcycleAux(marker: var TIntSet, typ: PType, startId: int): bool =
else: nil else: nil
proc canFormAcycle(typ: PType): bool = proc canFormAcycle(typ: PType): bool =
var marker = InitIntSet() var marker = initIntSet()
result = canFormAcycleAux(marker, typ, typ.id) result = canFormAcycleAux(marker, typ, typ.id)
proc mutateTypeAux(marker: var TIntSet, t: PType, iter: TTypeMutator, proc mutateTypeAux(marker: var TIntSet, t: PType, iter: TTypeMutator,
@ -377,14 +377,14 @@ proc mutateTypeAux(marker: var TIntSet, t: PType, iter: TTypeMutator,
result = nil result = nil
if t == nil: return if t == nil: return
result = iter(t, closure) result = iter(t, closure)
if not ContainsOrIncl(marker, t.id): if not containsOrIncl(marker, t.id):
for i in countup(0, sonsLen(t) - 1): for i in countup(0, sonsLen(t) - 1):
result.sons[i] = mutateTypeAux(marker, result.sons[i], iter, closure) result.sons[i] = mutateTypeAux(marker, result.sons[i], iter, closure)
if t.n != nil: result.n = mutateNode(marker, t.n, iter, closure) if t.n != nil: result.n = mutateNode(marker, t.n, iter, closure)
assert(result != nil) assert(result != nil)
proc mutateType(t: PType, iter: TTypeMutator, closure: PObject): PType = proc mutateType(t: PType, iter: TTypeMutator, closure: PObject): PType =
var marker = InitIntSet() var marker = initIntSet()
result = mutateTypeAux(marker, t, iter, closure) result = mutateTypeAux(marker, t, iter, closure)
proc valueToString(a: PNode): string = proc valueToString(a: PNode): string =
@ -396,7 +396,7 @@ proc valueToString(a: PNode): string =
proc rangeToStr(n: PNode): string = proc rangeToStr(n: PNode): string =
assert(n.kind == nkRange) assert(n.kind == nkRange)
result = ValueToString(n.sons[0]) & ".." & ValueToString(n.sons[1]) result = valueToString(n.sons[0]) & ".." & valueToString(n.sons[1])
const const
typeToStr: array[TTypeKind, string] = ["None", "bool", "Char", "empty", typeToStr: array[TTypeKind, string] = ["None", "bool", "Char", "empty",
@ -501,7 +501,7 @@ proc typeToString(typ: PType, prefer: TPreferedDesc = preferName): string =
add(result, typeToString(t.sons[i])) add(result, typeToString(t.sons[i]))
if i < sonsLen(t) - 1: add(result, ", ") if i < sonsLen(t) - 1: add(result, ", ")
add(result, ')') add(result, ')')
if t.sons[0] != nil: add(result, ": " & TypeToString(t.sons[0])) if t.sons[0] != nil: add(result, ": " & typeToString(t.sons[0]))
var prag: string var prag: string
if t.callConv != ccDefault: prag = CallingConvToStr[t.callConv] if t.callConv != ccDefault: prag = CallingConvToStr[t.callConv]
else: prag = "" else: prag = ""
@ -625,9 +625,9 @@ proc initSameTypeClosure: TSameTypeClosure =
discard discard
proc containsOrIncl(c: var TSameTypeClosure, a, b: PType): bool = proc containsOrIncl(c: var TSameTypeClosure, a, b: PType): bool =
result = not IsNil(c.s) and c.s.contains((a.id, b.id)) result = not isNil(c.s) and c.s.contains((a.id, b.id))
if not result: if not result:
if IsNil(c.s): c.s = @[] if isNil(c.s): c.s = @[]
c.s.add((a.id, b.id)) c.s.add((a.id, b.id))
proc sameTypeAux(x, y: PType, c: var TSameTypeClosure): bool proc sameTypeAux(x, y: PType, c: var TSameTypeClosure): bool
@ -636,7 +636,7 @@ proc sameTypeOrNilAux(a, b: PType, c: var TSameTypeClosure): bool =
result = true result = true
else: else:
if a == nil or b == nil: result = false if a == nil or b == nil: result = false
else: result = SameTypeAux(a, b, c) else: result = sameTypeAux(a, b, c)
proc sameTypeOrNil*(a, b: PType, flags: TTypeCmpFlags = {}): bool = proc sameTypeOrNil*(a, b: PType, flags: TTypeCmpFlags = {}): bool =
if a == b: if a == b:
@ -646,15 +646,15 @@ proc sameTypeOrNil*(a, b: PType, flags: TTypeCmpFlags = {}): bool =
else: else:
var c = initSameTypeClosure() var c = initSameTypeClosure()
c.flags = flags c.flags = flags
result = SameTypeAux(a, b, c) result = sameTypeAux(a, b, c)
proc equalParam(a, b: PSym): TParamsEquality = proc equalParam(a, b: PSym): TParamsEquality =
if SameTypeOrNil(a.typ, b.typ, {TypeDescExactMatch}) and if sameTypeOrNil(a.typ, b.typ, {TypeDescExactMatch}) and
ExprStructuralEquivalent(a.constraint, b.constraint): exprStructuralEquivalent(a.constraint, b.constraint):
if a.ast == b.ast: if a.ast == b.ast:
result = paramsEqual result = paramsEqual
elif a.ast != nil and b.ast != nil: elif a.ast != nil and b.ast != nil:
if ExprStructuralEquivalent(a.ast, b.ast): result = paramsEqual if exprStructuralEquivalent(a.ast, b.ast): result = paramsEqual
else: result = paramsIncompatible else: result = paramsIncompatible
elif a.ast != nil: elif a.ast != nil:
result = paramsEqual result = paramsEqual
@ -685,7 +685,7 @@ proc equalParams(a, b: PNode): TParamsEquality =
return paramsNotEqual # paramsIncompatible; return paramsNotEqual # paramsIncompatible;
# continue traversal! If not equal, we can return immediately; else # continue traversal! If not equal, we can return immediately; else
# it stays incompatible # it stays incompatible
if not SameTypeOrNil(a.sons[0].typ, b.sons[0].typ, {TypeDescExactMatch}): if not sameTypeOrNil(a.sons[0].typ, b.sons[0].typ, {TypeDescExactMatch}):
if (a.sons[0].typ == nil) or (b.sons[0].typ == nil): if (a.sons[0].typ == nil) or (b.sons[0].typ == nil):
result = paramsNotEqual # one proc has a result, the other not is OK result = paramsNotEqual # one proc has a result, the other not is OK
else: else:
@ -701,8 +701,8 @@ proc sameLiteral(x, y: PNode): bool =
else: assert(false) else: assert(false)
proc sameRanges(a, b: PNode): bool = proc sameRanges(a, b: PNode): bool =
result = SameLiteral(a.sons[0], b.sons[0]) and result = sameLiteral(a.sons[0], b.sons[0]) and
SameLiteral(a.sons[1], b.sons[1]) sameLiteral(a.sons[1], b.sons[1])
proc sameTuple(a, b: PType, c: var TSameTypeClosure): bool = proc sameTuple(a, b: PType, c: var TSameTypeClosure): bool =
# two tuples are equivalent iff the names, types and positions are the same; # two tuples are equivalent iff the names, types and positions are the same;
@ -717,7 +717,7 @@ proc sameTuple(a, b: PType, c: var TSameTypeClosure): bool =
x = skipTypes(x, {tyRange}) x = skipTypes(x, {tyRange})
y = skipTypes(y, {tyRange}) y = skipTypes(y, {tyRange})
result = SameTypeAux(x, y, c) result = sameTypeAux(x, y, c)
if not result: return if not result: return
if a.n != nil and b.n != nil and IgnoreTupleFields notin c.flags: if a.n != nil and b.n != nil and IgnoreTupleFields notin c.flags:
for i in countup(0, sonsLen(a.n) - 1): for i in countup(0, sonsLen(a.n) - 1):
@ -727,12 +727,12 @@ proc sameTuple(a, b: PType, c: var TSameTypeClosure): bool =
var y = b.n.sons[i].sym var y = b.n.sons[i].sym
result = x.name.id == y.name.id result = x.name.id == y.name.id
if not result: break if not result: break
else: InternalError(a.n.info, "sameTuple") else: internalError(a.n.info, "sameTuple")
else: else:
result = false result = false
template ifFastObjectTypeCheckFailed(a, b: PType, body: stmt) {.immediate.} = template ifFastObjectTypeCheckFailed(a, b: PType, body: stmt) {.immediate.} =
if tfFromGeneric notin a.flags + b.flags: if tfFromGeneric not_in a.flags + b.flags:
# fast case: id comparison suffices: # fast case: id comparison suffices:
result = a.id == b.id result = a.id == b.id
else: else:
@ -966,7 +966,7 @@ proc matchType*(a: PType, pattern: openArray[tuple[k:TTypeKind, i:int]],
var a = a var a = a
for k, i in pattern.items: for k, i in pattern.items:
if a.kind != k: return false if a.kind != k: return false
if i >= a.sonslen or a.sons[i] == nil: return false if i >= a.sonsLen or a.sons[i] == nil: return false
a = a.sons[i] a = a.sons[i]
result = a.kind == last result = a.kind == last
@ -986,7 +986,7 @@ proc matchTypeClass*(bindings: var TIdTable, typeClass, t: PType): bool =
of tyGenericBody: of tyGenericBody:
if t.kind == tyGenericInst and t.sons[0] == req: if t.kind == tyGenericInst and t.sons[0] == req:
match = true match = true
IdTablePut(bindings, typeClass, t) idTablePut(bindings, typeClass, t)
of tyTypeClass: of tyTypeClass:
match = matchTypeClass(bindings, req, t) match = matchTypeClass(bindings, req, t)
elif t.kind == tyTypeClass: elif t.kind == tyTypeClass:
@ -1005,7 +1005,7 @@ proc matchTypeClass*(bindings: var TIdTable, typeClass, t: PType): bool =
# or none of them matched. # or none of them matched.
result = if tfAny in typeClass.flags: false else: true result = if tfAny in typeClass.flags: false else: true
if result == true: if result == true:
IdTablePut(bindings, typeClass, t) idTablePut(bindings, typeClass, t)
proc matchTypeClass*(typeClass, typ: PType): bool = proc matchTypeClass*(typeClass, typ: PType): bool =
var bindings: TIdTable var bindings: TIdTable
@ -1019,7 +1019,7 @@ proc typeAllowedAux(marker: var TIntSet, typ: PType, kind: TSymKind,
# evaluation if something is wrong: # evaluation if something is wrong:
result = true result = true
if typ == nil: return if typ == nil: return
if ContainsOrIncl(marker, typ.id): return if containsOrIncl(marker, typ.id): return
var t = skipTypes(typ, abstractInst-{tyTypeDesc}) var t = skipTypes(typ, abstractInst-{tyTypeDesc})
case t.kind case t.kind
of tyVar: of tyVar:
@ -1089,15 +1089,15 @@ proc typeAllowedAux(marker: var TIntSet, typ: PType, kind: TSymKind,
result = true result = true
proc typeAllowed(t: PType, kind: TSymKind): bool = proc typeAllowed(t: PType, kind: TSymKind): bool =
var marker = InitIntSet() var marker = initIntSet()
result = typeAllowedAux(marker, t, kind, {}) result = typeAllowedAux(marker, t, kind, {})
proc align(address, alignment: biggestInt): biggestInt = proc align(address, alignment: BiggestInt): BiggestInt =
result = (address + (alignment - 1)) and not (alignment - 1) result = (address + (alignment - 1)) and not (alignment - 1)
proc computeSizeAux(typ: PType, a: var biggestInt): biggestInt proc computeSizeAux(typ: PType, a: var BiggestInt): BiggestInt
proc computeRecSizeAux(n: PNode, a, currOffset: var biggestInt): biggestInt = proc computeRecSizeAux(n: PNode, a, currOffset: var BiggestInt): BiggestInt =
var maxAlign, maxSize, b, res: biggestInt var maxAlign, maxSize, b, res: BiggestInt
case n.kind case n.kind
of nkRecCase: of nkRecCase:
assert(n.sons[0].kind == nkSym) assert(n.sons[0].kind == nkSym)
@ -1129,12 +1129,12 @@ proc computeRecSizeAux(n: PNode, a, currOffset: var biggestInt): biggestInt =
result = computeSizeAux(n.sym.typ, a) result = computeSizeAux(n.sym.typ, a)
n.sym.offset = int(currOffset) n.sym.offset = int(currOffset)
else: else:
InternalError("computeRecSizeAux()") internalError("computeRecSizeAux()")
a = 1 a = 1
result = - 1 result = - 1
proc computeSizeAux(typ: PType, a: var biggestInt): biggestInt = proc computeSizeAux(typ: PType, a: var biggestInt): biggestInt =
var res, maxAlign, length, currOffset: biggestInt var res, maxAlign, length, currOffset: BiggestInt
if typ.size == - 2: if typ.size == - 2:
# we are already computing the size of the type # we are already computing the size of the type
# --> illegal recursion in type # --> illegal recursion in type
@ -1147,7 +1147,7 @@ proc computeSizeAux(typ: PType, a: var biggestInt): biggestInt =
typ.size = - 2 # mark as being computed typ.size = - 2 # mark as being computed
case typ.kind case typ.kind
of tyInt, tyUInt: of tyInt, tyUInt:
result = IntSize result = intSize
a = result a = result
of tyInt8, tyUInt8, tyBool, tyChar: of tyInt8, tyUInt8, tyBool, tyChar:
result = 1 result = 1
@ -1236,7 +1236,7 @@ proc computeSizeAux(typ: PType, a: var biggestInt): biggestInt =
typ.align = int(a) typ.align = int(a)
proc computeSize(typ: PType): biggestInt = proc computeSize(typ: PType): biggestInt =
var a: biggestInt = 1 var a: BiggestInt = 1
result = computeSizeAux(typ, a) result = computeSizeAux(typ, a)
proc getReturnType*(s: PSym): PType = proc getReturnType*(s: PSym): PType =
@ -1246,7 +1246,7 @@ proc getReturnType*(s: PSym): PType =
proc getSize(typ: PType): biggestInt = proc getSize(typ: PType): biggestInt =
result = computeSize(typ) result = computeSize(typ)
if result < 0: InternalError("getSize: " & $typ.kind) if result < 0: internalError("getSize: " & $typ.kind)
proc containsGenericTypeIter(t: PType, closure: PObject): bool = proc containsGenericTypeIter(t: PType, closure: PObject): bool =
@ -1300,7 +1300,7 @@ proc compatibleEffects*(formal, actual: PType): bool =
# if 'se.kind == nkArgList' it is no formal type really, but a # if 'se.kind == nkArgList' it is no formal type really, but a
# computed effect and as such no spec: # computed effect and as such no spec:
# 'r.msgHandler = if isNil(msgHandler): defaultMsgHandler else: msgHandler' # 'r.msgHandler = if isNil(msgHandler): defaultMsgHandler else: msgHandler'
if not IsNil(se) and se.kind != nkArgList: if not isNil(se) and se.kind != nkArgList:
# spec requires some exception or tag, but we don't know anything: # spec requires some exception or tag, but we don't know anything:
if real.len == 0: return false if real.len == 0: return false
result = compatibleEffectsAux(se, real.sons[exceptionEffects]) result = compatibleEffectsAux(se, real.sons[exceptionEffects])

22
compiler/vm.nim
View file

@ -40,7 +40,7 @@ proc stackTraceAux(c: PCtx; x: PStackFrame; pc: int) =
var info = c.debug[pc] var info = c.debug[pc]
# we now use the same format as in system/except.nim # we now use the same format as in system/except.nim
var s = toFilename(info) var s = toFilename(info)
var line = toLineNumber(info) var line = toLinenumber(info)
if line > 0: if line > 0:
add(s, '(') add(s, '(')
add(s, $line) add(s, $line)
@ -48,7 +48,7 @@ proc stackTraceAux(c: PCtx; x: PStackFrame; pc: int) =
if x.prc != nil: if x.prc != nil:
for k in 1..max(1, 25-s.len): add(s, ' ') for k in 1..max(1, 25-s.len): add(s, ' ')
add(s, x.prc.name.s) add(s, x.prc.name.s)
MsgWriteln(s) msgWriteln(s)
proc stackTrace(c: PCtx, tos: PStackFrame, pc: int, proc stackTrace(c: PCtx, tos: PStackFrame, pc: int,
msg: TMsgKind, arg = "") = msg: TMsgKind, arg = "") =
@ -716,7 +716,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): PNode =
of opcFinallyEnd: of opcFinallyEnd:
if c.currentExceptionA != nil: if c.currentExceptionA != nil:
# we are in a cleanup run: # we are in a cleanup run:
pc = cleanupOnException(c, tos, regs)-1 pc = cleanUpOnException(c, tos, regs)-1
if pc < 0: if pc < 0:
bailOut(c, tos) bailOut(c, tos)
return return
@ -725,7 +725,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): PNode =
c.currentExceptionA = raised c.currentExceptionA = raised
c.exceptionInstr = pc c.exceptionInstr = pc
# -1 because of the following 'inc' # -1 because of the following 'inc'
pc = cleanupOnException(c, tos, regs) - 1 pc = cleanUpOnException(c, tos, regs) - 1
if pc < 0: if pc < 0:
bailOut(c, tos) bailOut(c, tos)
return return
@ -776,7 +776,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): PNode =
regs[ra].strVal = renderTree(regs[rb].skipMeta, {renderNoComments}) regs[ra].strVal = renderTree(regs[rb].skipMeta, {renderNoComments})
of opcQuit: of opcQuit:
if c.mode in {emRepl, emStaticExpr, emStaticStmt}: if c.mode in {emRepl, emStaticExpr, emStaticStmt}:
Message(c.debug[pc], hintQuitCalled) message(c.debug[pc], hintQuitCalled)
quit(int(getOrdValue(regs[ra]))) quit(int(getOrdValue(regs[ra])))
else: else:
return nil return nil
@ -866,7 +866,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): PNode =
else: else:
stackTrace(c, tos, pc, errFieldXNotFound, "ident") stackTrace(c, tos, pc, errFieldXNotFound, "ident")
of opcNGetType: of opcNGetType:
InternalError(c.debug[pc], "unknown opcode " & $instr.opcode) internalError(c.debug[pc], "unknown opcode " & $instr.opcode)
of opcNStrVal: of opcNStrVal:
decodeB(nkStrLit) decodeB(nkStrLit)
let a = regs[rb].uast let a = regs[rb].uast
@ -882,16 +882,16 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): PNode =
of opcNError: of opcNError:
stackTrace(c, tos, pc, errUser, regs[ra].strVal) stackTrace(c, tos, pc, errUser, regs[ra].strVal)
of opcNWarning: of opcNWarning:
Message(c.debug[pc], warnUser, regs[ra].strVal) message(c.debug[pc], warnUser, regs[ra].strVal)
of opcNHint: of opcNHint:
Message(c.debug[pc], hintUser, regs[ra].strVal) message(c.debug[pc], hintUser, regs[ra].strVal)
of opcParseExprToAst: of opcParseExprToAst:
decodeB(nkMetaNode) decodeB(nkMetaNode)
# c.debug[pc].line.int - countLines(regs[rb].strVal) ? # c.debug[pc].line.int - countLines(regs[rb].strVal) ?
let ast = parseString(regs[rb].strVal, c.debug[pc].toFilename, let ast = parseString(regs[rb].strVal, c.debug[pc].toFilename,
c.debug[pc].line.int) c.debug[pc].line.int)
if sonsLen(ast) != 1: if sonsLen(ast) != 1:
GlobalError(c.debug[pc], errExprExpected, "multiple statements") globalError(c.debug[pc], errExprExpected, "multiple statements")
setMeta(regs[ra], ast.sons[0]) setMeta(regs[ra], ast.sons[0])
of opcParseStmtToAst: of opcParseStmtToAst:
decodeB(nkMetaNode) decodeB(nkMetaNode)
@ -1137,7 +1137,7 @@ proc evalMacroCall*(module: PSym, n, nOrig: PNode, sym: PSym): PNode =
# XXX GlobalError() is ugly here, but I don't know a better solution for now # XXX GlobalError() is ugly here, but I don't know a better solution for now
inc(evalMacroCounter) inc(evalMacroCounter)
if evalMacroCounter > 100: if evalMacroCounter > 100:
GlobalError(n.info, errTemplateInstantiationTooNested) globalError(n.info, errTemplateInstantiationTooNested)
setupGlobalCtx(module) setupGlobalCtx(module)
var c = globalCtx var c = globalCtx
@ -1161,7 +1161,7 @@ proc evalMacroCall*(module: PSym, n, nOrig: PNode, sym: PSym): PNode =
# temporary storage: # temporary storage:
for i in L .. <maxSlots: tos.slots[i] = newNode(nkEmpty) for i in L .. <maxSlots: tos.slots[i] = newNode(nkEmpty)
result = rawExecute(c, start, tos) result = rawExecute(c, start, tos)
if cyclicTree(result): GlobalError(n.info, errCyclicTree) if cyclicTree(result): globalError(n.info, errCyclicTree)
dec(evalMacroCounter) dec(evalMacroCounter)
if result != nil: if result != nil:
result = result.skipMeta result = result.skipMeta

4
compiler/vmdeps.nim
View file

@ -25,12 +25,12 @@ proc opGorge*(cmd, input: string): string =
proc opSlurp*(file: string, info: TLineInfo, module: PSym): string = proc opSlurp*(file: string, info: TLineInfo, module: PSym): string =
try: try:
let filename = file.FindFile let filename = file.findFile
result = readFile(filename) result = readFile(filename)
# we produce a fake include statement for every slurped filename, so that # we produce a fake include statement for every slurped filename, so that
# the module dependencies are accurate: # the module dependencies are accurate:
appendToModule(module, newNode(nkIncludeStmt, info, @[ appendToModule(module, newNode(nkIncludeStmt, info, @[
newStrNode(nkStrLit, filename)])) newStrNode(nkStrLit, filename)]))
except EIO: except EIO:
LocalError(info, errCannotOpenFile, file) localError(info, errCannotOpenFile, file)
result = "" result = ""

24
compiler/vmgen.nim
View file

@ -61,7 +61,7 @@ proc gABC(ctx: PCtx; n: PNode; opc: TOpcode; a, b, c: TRegister = 0) =
ctx.code.add(ins) ctx.code.add(ins)
ctx.debug.add(n.info) ctx.debug.add(n.info)
proc gABI(c: PCtx; n: PNode; opc: TOpcode; a, b: TRegister; imm: biggestInt) = proc gABI(c: PCtx; n: PNode; opc: TOpcode; a, b: TRegister; imm: BiggestInt) =
let ins = (opc.uint32 or (a.uint32 shl 8'u32) or let ins = (opc.uint32 or (a.uint32 shl 8'u32) or
(b.uint32 shl 16'u32) or (b.uint32 shl 16'u32) or
(imm+byteExcess).uint32 shl 24'u32).TInstr (imm+byteExcess).uint32 shl 24'u32).TInstr
@ -166,7 +166,7 @@ proc getTempRange(c: PCtx; n: int; kind: TSlotKind): TRegister =
for k in result .. result+n-1: c.slots[k] = (inUse: true, kind: kind) for k in result .. result+n-1: c.slots[k] = (inUse: true, kind: kind)
return return
if c.maxSlots+n >= high(TRegister): if c.maxSlots+n >= high(TRegister):
InternalError("cannot generate code; too many registers required") internalError("cannot generate code; too many registers required")
result = TRegister(c.maxSlots) result = TRegister(c.maxSlots)
inc c.maxSlots, n inc c.maxSlots, n
for k in result .. result+n-1: c.slots[k] = (inUse: true, kind: kind) for k in result .. result+n-1: c.slots[k] = (inUse: true, kind: kind)
@ -257,7 +257,7 @@ proc genBreak(c: PCtx; n: PNode) =
if c.prc.blocks[i].label == n.sons[0].sym: if c.prc.blocks[i].label == n.sons[0].sym:
c.prc.blocks[i].fixups.add L1 c.prc.blocks[i].fixups.add L1
return return
InternalError(n.info, "cannot find 'break' target") internalError(n.info, "cannot find 'break' target")
else: else:
c.prc.blocks[c.prc.blocks.high].fixups.add L1 c.prc.blocks[c.prc.blocks.high].fixups.add L1
@ -338,7 +338,7 @@ proc genLiteral(c: PCtx; n: PNode): int =
proc unused(n: PNode; x: TDest) {.inline.} = proc unused(n: PNode; x: TDest) {.inline.} =
if x >= 0: if x >= 0:
#debug(n) #debug(n)
InternalError(n.info, "not unused") internalError(n.info, "not unused")
proc genCase(c: PCtx; n: PNode; dest: var TDest) = proc genCase(c: PCtx; n: PNode; dest: var TDest) =
# if (!expr1) goto L1; # if (!expr1) goto L1;
@ -709,7 +709,7 @@ proc genMagic(c: PCtx; n: PNode; dest: var TDest) =
c.freeTemp(tmp) c.freeTemp(tmp)
c.freeTemp(idx) c.freeTemp(idx)
of mSizeOf: of mSizeOf:
GlobalError(n.info, errCannotInterpretNodeX, renderTree(n)) globalError(n.info, errCannotInterpretNodeX, renderTree(n))
of mHigh: of mHigh:
if dest < 0: dest = c.getTemp(n.typ) if dest < 0: dest = c.getTemp(n.typ)
let tmp = c.genx(n.sons[1]) let tmp = c.genx(n.sons[1])
@ -828,7 +828,7 @@ proc genMagic(c: PCtx; n: PNode; dest: var TDest) =
globalError(n.info, "expandToAst requires a call expression") globalError(n.info, "expandToAst requires a call expression")
else: else:
# mGCref, mGCunref, # mGCref, mGCunref,
InternalError(n.info, "cannot generate code for: " & $m) internalError(n.info, "cannot generate code for: " & $m)
const const
atomicTypes = {tyBool, tyChar, atomicTypes = {tyBool, tyChar,
@ -1027,7 +1027,7 @@ proc getNullValueAux(obj: PNode, result: PNode) =
getNullValueAux(lastSon(obj.sons[i]), result) getNullValueAux(lastSon(obj.sons[i]), result)
of nkSym: of nkSym:
addSon(result, getNullValue(obj.sym.typ, result.info)) addSon(result, getNullValue(obj.sym.typ, result.info))
else: InternalError(result.info, "getNullValueAux") else: internalError(result.info, "getNullValueAux")
proc getNullValue(typ: PType, info: TLineInfo): PNode = proc getNullValue(typ: PType, info: TLineInfo): PNode =
var t = skipTypes(typ, abstractRange-{tyTypeDesc}) var t = skipTypes(typ, abstractRange-{tyTypeDesc})
@ -1038,7 +1038,7 @@ proc getNullValue(typ: PType, info: TLineInfo): PNode =
of tyUInt..tyUInt64: of tyUInt..tyUInt64:
result = newNodeIT(nkUIntLit, info, t) result = newNodeIT(nkUIntLit, info, t)
of tyFloat..tyFloat128: of tyFloat..tyFloat128:
result = newNodeIt(nkFloatLit, info, t) result = newNodeIT(nkFloatLit, info, t)
of tyVar, tyPointer, tyPtr, tyCString, tySequence, tyString, tyExpr, of tyVar, tyPointer, tyPtr, tyCString, tySequence, tyString, tyExpr,
tyStmt, tyTypeDesc, tyRef: tyStmt, tyTypeDesc, tyRef:
result = newNodeIT(nkNilLit, info, t) result = newNodeIT(nkNilLit, info, t)
@ -1067,7 +1067,7 @@ proc getNullValue(typ: PType, info: TLineInfo): PNode =
addSon(result, getNullValue(t.sons[i], info)) addSon(result, getNullValue(t.sons[i], info))
of tySet: of tySet:
result = newNodeIT(nkCurly, info, t) result = newNodeIT(nkCurly, info, t)
else: InternalError("getNullValue: " & $t.kind) else: internalError("getNullValue: " & $t.kind)
proc setSlot(c: PCtx; v: PSym) = proc setSlot(c: PCtx; v: PSym) =
# XXX generate type initialization here? # XXX generate type initialization here?
@ -1214,13 +1214,13 @@ proc gen(c: PCtx; n: PNode; dest: var TDest) =
of skField: of skField:
InternalAssert dest < 0 InternalAssert dest < 0
if s.position > high(dest): if s.position > high(dest):
InternalError(n.info, internalError(n.info,
"too large offset! cannot generate code for: " & s.name.s) "too large offset! cannot generate code for: " & s.name.s)
dest = s.position dest = s.position
of skType: of skType:
genTypeLit(c, s.typ, dest) genTypeLit(c, s.typ, dest)
else: else:
InternalError(n.info, "cannot generate code for: " & s.name.s) internalError(n.info, "cannot generate code for: " & s.name.s)
of nkCallKinds: of nkCallKinds:
if n.sons[0].kind == nkSym and n.sons[0].sym.magic != mNone: if n.sons[0].kind == nkSym and n.sons[0].sym.magic != mNone:
genMagic(c, n, dest) genMagic(c, n, dest)
@ -1309,7 +1309,7 @@ proc gen(c: PCtx; n: PNode; dest: var TDest) =
else: else:
localError(n.info, errGenerated, "VM is not allowed to 'cast'") localError(n.info, errGenerated, "VM is not allowed to 'cast'")
else: else:
InternalError n.info, "too implement " & $n.kind internalError n.info, "too implement " & $n.kind
proc removeLastEof(c: PCtx) = proc removeLastEof(c: PCtx) =
let last = c.code.len-1 let last = c.code.len-1

4
compiler/wordrecg.nim
View file

@ -166,7 +166,7 @@ const
"inout", "bycopy", "byref", "oneway", "inout", "bycopy", "byref", "oneway",
] ]
proc findStr*(a: openarray[string], s: string): int = proc findStr*(a: openArray[string], s: string): int =
for i in countup(low(a), high(a)): for i in countup(low(a), high(a)):
if cmpIgnoreStyle(a[i], s) == 0: if cmpIgnoreStyle(a[i], s) == 0:
return i return i
@ -176,7 +176,7 @@ proc whichKeyword*(id: PIdent): TSpecialWord =
if id.id < 0: result = wInvalid if id.id < 0: result = wInvalid
else: result = TSpecialWord(id.id) else: result = TSpecialWord(id.id)
proc whichKeyword*(id: String): TSpecialWord = proc whichKeyword*(id: string): TSpecialWord =
result = whichKeyword(getIdent(id)) result = whichKeyword(getIdent(id))
proc initSpecials() = proc initSpecials() =

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

@ -321,7 +321,7 @@ proc generalStrLit(g: var TGeneralTokenizer, position: int): int =
inc(pos) inc(pos)
result = pos result = pos
proc isKeyword(x: openarray[string], y: string): int = proc isKeyword(x: openArray[string], y: string): int =
var a = 0 var a = 0
var b = len(x) - 1 var b = len(x) - 1
while a <= b: while a <= b:
@ -335,7 +335,7 @@ proc isKeyword(x: openarray[string], y: string): int =
return mid return mid
result = - 1 result = - 1
proc isKeywordIgnoreCase(x: openarray[string], y: string): int = proc isKeywordIgnoreCase(x: openArray[string], y: string): int =
var a = 0 var a = 0
var b = len(x) - 1 var b = len(x) - 1
while a <= b: while a <= b:
@ -354,7 +354,7 @@ type
hasPreprocessor, hasNestedComments hasPreprocessor, hasNestedComments
TTokenizerFlags = set[TTokenizerFlag] TTokenizerFlags = set[TTokenizerFlag]
proc clikeNextToken(g: var TGeneralTokenizer, keywords: openarray[string], proc clikeNextToken(g: var TGeneralTokenizer, keywords: openArray[string],
flags: TTokenizerFlags) = flags: TTokenizerFlags) =
const const
hexChars = {'0'..'9', 'A'..'F', 'a'..'f'} hexChars = {'0'..'9', 'A'..'F', 'a'..'f'}

168
lib/packages/docutils/rst.nim
View file

@ -58,10 +58,10 @@ const
mwUnsupportedLanguage: "language '$1' not supported" mwUnsupportedLanguage: "language '$1' not supported"
] ]
proc rstnodeToRefname*(n: PRstNode): string proc rstnodeToRefname*(n: PRSTNode): string
proc addNodes*(n: PRstNode): string proc addNodes*(n: PRSTNode): string
proc getFieldValue*(n: PRstNode, fieldname: string): string proc getFieldValue*(n: PRSTNode, fieldname: string): string
proc getArgument*(n: PRstNode): string proc getArgument*(n: PRSTNode): string
# ----------------------------- scanner part -------------------------------- # ----------------------------- scanner part --------------------------------
@ -242,7 +242,7 @@ proc getTokens(buffer: string, skipPounds: bool, tokens: var TTokenSeq): int =
inc(result) inc(result)
while true: while true:
inc(length) inc(length)
setlen(tokens, length) setLen(tokens, length)
rawGetTok(L, tokens[length - 1]) rawGetTok(L, tokens[length - 1])
if tokens[length - 1].kind == tkEof: break if tokens[length - 1].kind == tkEof: break
if tokens[0].kind == tkWhite: if tokens[0].kind == tkWhite:
@ -254,7 +254,7 @@ type
TLevelMap = array[Char, int] TLevelMap = array[Char, int]
TSubstitution{.final.} = object TSubstitution{.final.} = object
key*: string key*: string
value*: PRstNode value*: PRSTNode
TSharedState {.final.} = object TSharedState {.final.} = object
options: TRstParseOptions # parsing options options: TRstParseOptions # parsing options
@ -294,11 +294,11 @@ proc whichMsgClass*(k: TMsgKind): TMsgClass =
proc defaultMsgHandler*(filename: string, line, col: int, msgkind: TMsgKind, proc defaultMsgHandler*(filename: string, line, col: int, msgkind: TMsgKind,
arg: string) {.procvar.} = arg: string) {.procvar.} =
let mc = msgKind.whichMsgClass let mc = msgkind.whichMsgClass
let a = messages[msgKind] % arg let a = messages[msgkind] % arg
let message = "$1($2, $3) $4: $5" % [filename, $line, $col, $mc, a] let message = "$1($2, $3) $4: $5" % [filename, $line, $col, $mc, a]
if mc == mcError: raise newException(EParseError, message) if mc == mcError: raise newException(EParseError, message)
else: Writeln(stdout, message) else: writeln(stdout, message)
proc defaultFindFile*(filename: string): string {.procvar.} = proc defaultFindFile*(filename: string): string {.procvar.} =
if existsFile(filename): result = filename if existsFile(filename): result = filename
@ -339,7 +339,7 @@ proc pushInd(p: var TRstParser, ind: int) =
add(p.indentStack, ind) add(p.indentStack, ind)
proc popInd(p: var TRstParser) = proc popInd(p: var TRstParser) =
if len(p.indentStack) > 1: setlen(p.indentStack, len(p.indentStack) - 1) if len(p.indentStack) > 1: setLen(p.indentStack, len(p.indentStack) - 1)
proc initParser(p: var TRstParser, sharedState: PSharedState) = proc initParser(p: var TRstParser, sharedState: PSharedState) =
p.indentStack = @[0] p.indentStack = @[0]
@ -351,7 +351,7 @@ proc initParser(p: var TRstParser, sharedState: PSharedState) =
p.line = 1 p.line = 1
p.s = sharedState p.s = sharedState
proc addNodesAux(n: PRstNode, result: var string) = proc addNodesAux(n: PRSTNode, result: var string) =
if n.kind == rnLeaf: if n.kind == rnLeaf:
add(result, n.text) add(result, n.text)
else: else:
@ -361,7 +361,7 @@ proc addNodes(n: PRstNode): string =
result = "" result = ""
addNodesAux(n, result) addNodesAux(n, result)
proc rstnodeToRefnameAux(n: PRstNode, r: var string, b: var bool) = proc rstnodeToRefnameAux(n: PRSTNode, r: var string, b: var bool) =
if n.kind == rnLeaf: if n.kind == rnLeaf:
for i in countup(0, len(n.text) - 1): for i in countup(0, len(n.text) - 1):
case n.text[i] case n.text[i]
@ -391,7 +391,7 @@ proc rstnodeToRefname(n: PRstNode): string =
var b = false var b = false
rstnodeToRefnameAux(n, result, b) rstnodeToRefnameAux(n, result, b)
proc findSub(p: var TRstParser, n: PRstNode): int = proc findSub(p: var TRstParser, n: PRSTNode): int =
var key = addNodes(n) var key = addNodes(n)
# the spec says: if no exact match, try one without case distinction: # the spec says: if no exact match, try one without case distinction:
for i in countup(0, high(p.s.subs)): for i in countup(0, high(p.s.subs)):
@ -402,17 +402,17 @@ proc findSub(p: var TRstParser, n: PRstNode): int =
return i return i
result = -1 result = -1
proc setSub(p: var TRstParser, key: string, value: PRstNode) = proc setSub(p: var TRstParser, key: string, value: PRSTNode) =
var length = len(p.s.subs) var length = len(p.s.subs)
for i in countup(0, length - 1): for i in countup(0, length - 1):
if key == p.s.subs[i].key: if key == p.s.subs[i].key:
p.s.subs[i].value = value p.s.subs[i].value = value
return return
setlen(p.s.subs, length + 1) setLen(p.s.subs, length + 1)
p.s.subs[length].key = key p.s.subs[length].key = key
p.s.subs[length].value = value p.s.subs[length].value = value
proc setRef(p: var TRstParser, key: string, value: PRstNode) = proc setRef(p: var TRstParser, key: string, value: PRSTNode) =
var length = len(p.s.refs) var length = len(p.s.refs)
for i in countup(0, length - 1): for i in countup(0, length - 1):
if key == p.s.refs[i].key: if key == p.s.refs[i].key:
@ -421,19 +421,19 @@ proc setRef(p: var TRstParser, key: string, value: PRstNode) =
p.s.refs[i].value = value p.s.refs[i].value = value
return return
setlen(p.s.refs, length + 1) setLen(p.s.refs, length + 1)
p.s.refs[length].key = key p.s.refs[length].key = key
p.s.refs[length].value = value p.s.refs[length].value = value
proc findRef(p: var TRstParser, key: string): PRstNode = proc findRef(p: var TRstParser, key: string): PRSTNode =
for i in countup(0, high(p.s.refs)): for i in countup(0, high(p.s.refs)):
if key == p.s.refs[i].key: if key == p.s.refs[i].key:
return p.s.refs[i].value return p.s.refs[i].value
proc newLeaf(p: var TRstParser): PRstNode = proc newLeaf(p: var TRstParser): PRSTNode =
result = newRstNode(rnLeaf, p.tok[p.idx].symbol) result = newRstNode(rnLeaf, p.tok[p.idx].symbol)
proc getReferenceName(p: var TRstParser, endStr: string): PRstNode = proc getReferenceName(p: var TRstParser, endStr: string): PRSTNode =
var res = newRstNode(rnInner) var res = newRstNode(rnInner)
while true: while true:
case p.tok[p.idx].kind case p.tok[p.idx].kind
@ -451,7 +451,7 @@ proc getReferenceName(p: var TRstParser, endStr: string): PRstNode =
inc(p.idx) inc(p.idx)
result = res result = res
proc untilEol(p: var TRstParser): PRstNode = proc untilEol(p: var TRstParser): PRSTNode =
result = newRstNode(rnInner) result = newRstNode(rnInner)
while not (p.tok[p.idx].kind in {tkIndent, tkEof}): while not (p.tok[p.idx].kind in {tkIndent, tkEof}):
add(result, newLeaf(p)) add(result, newLeaf(p))
@ -479,7 +479,7 @@ proc isInlineMarkupEnd(p: TRstParser, markup: string): bool =
result = false result = false
proc isInlineMarkupStart(p: TRstParser, markup: string): bool = proc isInlineMarkupStart(p: TRstParser, markup: string): bool =
var d: Char var d: char
result = p.tok[p.idx].symbol == markup result = p.tok[p.idx].symbol == markup
if not result: if not result:
return # Rule 1: return # Rule 1:
@ -550,7 +550,7 @@ proc match(p: TRstParser, start: int, expr: string): bool =
inc(i) inc(i)
result = true result = true
proc fixupEmbeddedRef(n, a, b: PRstNode) = proc fixupEmbeddedRef(n, a, b: PRSTNode) =
var sep = - 1 var sep = - 1
for i in countdown(len(n) - 2, 0): for i in countdown(len(n) - 2, 0):
if n.sons[i].text == "<": if n.sons[i].text == "<":
@ -560,7 +560,7 @@ proc fixupEmbeddedRef(n, a, b: PRstNode) =
for i in countup(0, sep - incr): add(a, n.sons[i]) for i in countup(0, sep - incr): add(a, n.sons[i])
for i in countup(sep + 1, len(n) - 2): add(b, n.sons[i]) for i in countup(sep + 1, len(n) - 2): add(b, n.sons[i])
proc parsePostfix(p: var TRstParser, n: PRstNode): PRstNode = proc parsePostfix(p: var TRstParser, n: PRSTNode): PRSTNode =
result = n result = n
if isInlineMarkupEnd(p, "_"): if isInlineMarkupEnd(p, "_"):
inc(p.idx) inc(p.idx)
@ -613,9 +613,9 @@ proc matchVerbatim(p: TRstParser, start: int, expr: string): int =
inc result inc result
if j < expr.len: result = 0 if j < expr.len: result = 0
proc parseSmiley(p: var TRstParser): PRstNode = proc parseSmiley(p: var TRstParser): PRSTNode =
if p.tok[p.idx].symbol[0] notin SmileyStartChars: return if p.tok[p.idx].symbol[0] notin SmileyStartChars: return
for key, val in items(smilies): for key, val in items(Smilies):
let m = matchVerbatim(p, p.idx, key) let m = matchVerbatim(p, p.idx, key)
if m > 0: if m > 0:
p.idx = m p.idx = m
@ -634,7 +634,7 @@ proc isURL(p: TRstParser, i: int): bool =
(p.tok[i+3].kind == tkWord) and (p.tok[i+3].kind == tkWord) and
(p.tok[i].symbol in ["http", "https", "ftp", "telnet", "file"]) (p.tok[i].symbol in ["http", "https", "ftp", "telnet", "file"])
proc parseURL(p: var TRstParser, father: PRstNode) = proc parseURL(p: var TRstParser, father: PRSTNode) =
#if p.tok[p.idx].symbol[strStart] == '<': #if p.tok[p.idx].symbol[strStart] == '<':
if isURL(p, p.idx): if isURL(p, p.idx):
var n = newRstNode(rnStandaloneHyperlink) var n = newRstNode(rnStandaloneHyperlink)
@ -654,7 +654,7 @@ proc parseURL(p: var TRstParser, father: PRstNode) =
if p.tok[p.idx].symbol == "_": n = parsePostfix(p, n) if p.tok[p.idx].symbol == "_": n = parsePostfix(p, n)
add(father, n) add(father, n)
proc parseBackslash(p: var TRstParser, father: PRstNode) = proc parseBackslash(p: var TRstParser, father: PRSTNode) =
assert(p.tok[p.idx].kind == tkPunct) assert(p.tok[p.idx].kind == tkPunct)
if p.tok[p.idx].symbol == "\\\\": if p.tok[p.idx].symbol == "\\\\":
add(father, newRstNode(rnLeaf, "\\")) add(father, newRstNode(rnLeaf, "\\"))
@ -692,7 +692,7 @@ when false:
if p.tok[p.idx].symbol == "_": n = parsePostfix(p, n) if p.tok[p.idx].symbol == "_": n = parsePostfix(p, n)
add(father, n) add(father, n)
proc parseUntil(p: var TRstParser, father: PRstNode, postfix: string, proc parseUntil(p: var TRstParser, father: PRSTNode, postfix: string,
interpretBackslash: bool) = interpretBackslash: bool) =
let let
line = p.tok[p.idx].line line = p.tok[p.idx].line
@ -723,7 +723,7 @@ proc parseUntil(p: var TRstParser, father: PRstNode, postfix: string,
inc(p.idx) inc(p.idx)
else: rstMessage(p, meExpected, postfix, line, col) else: rstMessage(p, meExpected, postfix, line, col)
proc parseMarkdownCodeblock(p: var TRstParser): PRstNode = proc parseMarkdownCodeblock(p: var TRstParser): PRSTNode =
var args = newRstNode(rnDirArg) var args = newRstNode(rnDirArg)
if p.tok[p.idx].kind == tkWord: if p.tok[p.idx].kind == tkWord:
add(args, newLeaf(p)) add(args, newLeaf(p))
@ -753,7 +753,7 @@ proc parseMarkdownCodeblock(p: var TRstParser): PRstNode =
add(result, nil) add(result, nil)
add(result, lb) add(result, lb)
proc parseInline(p: var TRstParser, father: PRstNode) = proc parseInline(p: var TRstParser, father: PRSTNode) =
case p.tok[p.idx].kind case p.tok[p.idx].kind
of tkPunct: of tkPunct:
if isInlineMarkupStart(p, "***"): if isInlineMarkupStart(p, "***"):
@ -797,7 +797,7 @@ proc parseInline(p: var TRstParser, father: PRstNode) =
if n != nil: if n != nil:
add(father, n) add(father, n)
return return
parseUrl(p, father) parseURL(p, father)
of tkAdornment, tkOther, tkWhite: of tkAdornment, tkOther, tkWhite:
if roSupportSmilies in p.s.options: if roSupportSmilies in p.s.options:
let n = parseSmiley(p) let n = parseSmiley(p)
@ -828,7 +828,7 @@ proc getDirective(p: var TRstParser): string =
else: else:
result = "" result = ""
proc parseComment(p: var TRstParser): PRstNode = proc parseComment(p: var TRstParser): PRSTNode =
case p.tok[p.idx].kind case p.tok[p.idx].kind
of tkIndent, tkEof: of tkIndent, tkEof:
if p.tok[p.idx].kind != tkEof and p.tok[p.idx + 1].kind == tkIndent: if p.tok[p.idx].kind != tkEof and p.tok[p.idx + 1].kind == tkIndent:
@ -863,20 +863,20 @@ proc getDirKind(s: string): TDirKind =
if i >= 0: result = TDirKind(i) if i >= 0: result = TDirKind(i)
else: result = dkNone else: result = dkNone
proc parseLine(p: var TRstParser, father: PRstNode) = proc parseLine(p: var TRstParser, father: PRSTNode) =
while True: while True:
case p.tok[p.idx].kind case p.tok[p.idx].kind
of tkWhite, tkWord, tkOther, tkPunct: parseInline(p, father) of tkWhite, tkWord, tkOther, tkPunct: parseInline(p, father)
else: break else: break
proc parseUntilNewline(p: var TRstParser, father: PRstNode) = proc parseUntilNewline(p: var TRstParser, father: PRSTNode) =
while True: while True:
case p.tok[p.idx].kind case p.tok[p.idx].kind
of tkWhite, tkWord, tkAdornment, tkOther, tkPunct: parseInline(p, father) of tkWhite, tkWord, tkAdornment, tkOther, tkPunct: parseInline(p, father)
of tkEof, tkIndent: break of tkEof, tkIndent: break
proc parseSection(p: var TRstParser, result: PRstNode) proc parseSection(p: var TRstParser, result: PRSTNode)
proc parseField(p: var TRstParser): PRstNode = proc parseField(p: var TRstParser): PRSTNode =
result = newRstNode(rnField) result = newRstNode(rnField)
var col = p.tok[p.idx].col var col = p.tok[p.idx].col
var fieldname = newRstNode(rnFieldname) var fieldname = newRstNode(rnFieldname)
@ -892,7 +892,7 @@ proc parseField(p: var TRstParser): PRstNode =
add(result, fieldname) add(result, fieldname)
add(result, fieldbody) add(result, fieldbody)
proc parseFields(p: var TRstParser): PRstNode = proc parseFields(p: var TRstParser): PRSTNode =
result = nil result = nil
var atStart = p.idx == 0 and p.tok[0].symbol == ":" var atStart = p.idx == 0 and p.tok[0].symbol == ":"
if (p.tok[p.idx].kind == tkIndent) and (p.tok[p.idx + 1].symbol == ":") or if (p.tok[p.idx].kind == tkIndent) and (p.tok[p.idx + 1].symbol == ":") or
@ -926,8 +926,8 @@ proc getArgument(n: PRstNode): string =
if n.sons[0] == nil: result = "" if n.sons[0] == nil: result = ""
else: result = addNodes(n.sons[0]) else: result = addNodes(n.sons[0])
proc parseDotDot(p: var TRstParser): PRstNode proc parseDotDot(p: var TRstParser): PRSTNode
proc parseLiteralBlock(p: var TRstParser): PRstNode = proc parseLiteralBlock(p: var TRstParser): PRSTNode =
result = newRstNode(rnLiteralBlock) result = newRstNode(rnLiteralBlock)
var n = newRstNode(rnLeaf, "") var n = newRstNode(rnLeaf, "")
if p.tok[p.idx].kind == tkIndent: if p.tok[p.idx].kind == tkIndent:
@ -953,7 +953,7 @@ proc parseLiteralBlock(p: var TRstParser): PRstNode =
inc(p.idx) inc(p.idx)
add(result, n) add(result, n)
proc getLevel(map: var TLevelMap, lvl: var int, c: Char): int = proc getLevel(map: var TLevelMap, lvl: var int, c: char): int =
if map[c] == 0: if map[c] == 0:
inc(lvl) inc(lvl)
map[c] = lvl map[c] = lvl
@ -999,7 +999,7 @@ proc whichSection(p: TRstParser): TRstNodeKind =
elif match(p, p.idx + 1, "i"): result = rnOverline elif match(p, p.idx + 1, "i"): result = rnOverline
else: result = rnLeaf else: result = rnLeaf
of tkPunct: of tkPunct:
if match(p, tokenAfterNewLine(p), "ai"): if match(p, tokenAfterNewline(p), "ai"):
result = rnHeadline result = rnHeadline
elif p.tok[p.idx].symbol == "::": elif p.tok[p.idx].symbol == "::":
result = rnLiteralBlock result = rnLiteralBlock
@ -1026,13 +1026,13 @@ proc whichSection(p: TRstParser): TRstNodeKind =
else: else:
result = rnParagraph result = rnParagraph
of tkWord, tkOther, tkWhite: of tkWord, tkOther, tkWhite:
if match(p, tokenAfterNewLine(p), "ai"): result = rnHeadline if match(p, tokenAfterNewline(p), "ai"): result = rnHeadline
elif match(p, p.idx, "e) ") or match(p, p.idx, "e. "): result = rnEnumList elif match(p, p.idx, "e) ") or match(p, p.idx, "e. "): result = rnEnumList
elif isDefList(p): result = rnDefList elif isDefList(p): result = rnDefList
else: result = rnParagraph else: result = rnParagraph
else: result = rnLeaf else: result = rnLeaf
proc parseLineBlock(p: var TRstParser): PRstNode = proc parseLineBlock(p: var TRstParser): PRSTNode =
result = nil result = nil
if p.tok[p.idx + 1].kind == tkWhite: if p.tok[p.idx + 1].kind == tkWhite:
var col = p.tok[p.idx].col var col = p.tok[p.idx].col
@ -1051,7 +1051,7 @@ proc parseLineBlock(p: var TRstParser): PRstNode =
break break
popInd(p) popInd(p)
proc parseParagraph(p: var TRstParser, result: PRstNode) = proc parseParagraph(p: var TRstParser, result: PRSTNode) =
while True: while True:
case p.tok[p.idx].kind case p.tok[p.idx].kind
of tkIndent: of tkIndent:
@ -1082,9 +1082,9 @@ proc parseParagraph(p: var TRstParser, result: PRstNode) =
parseInline(p, result) parseInline(p, result)
else: break else: break
proc parseHeadline(p: var TRstParser): PRstNode = proc parseHeadline(p: var TRstParser): PRSTNode =
result = newRstNode(rnHeadline) result = newRstNode(rnHeadline)
parseUntilNewLine(p, result) parseUntilNewline(p, result)
assert(p.tok[p.idx].kind == tkIndent) assert(p.tok[p.idx].kind == tkIndent)
assert(p.tok[p.idx + 1].kind == tkAdornment) assert(p.tok[p.idx + 1].kind == tkAdornment)
var c = p.tok[p.idx + 1].symbol[0] var c = p.tok[p.idx + 1].symbol[0]
@ -1101,7 +1101,7 @@ proc getColumns(p: var TRstParser, cols: var TIntSeq) =
var L = 0 var L = 0
while true: while true:
inc(L) inc(L)
setlen(cols, L) setLen(cols, L)
cols[L - 1] = tokEnd(p) cols[L - 1] = tokEnd(p)
assert(p.tok[p.idx].kind == tkAdornment) assert(p.tok[p.idx].kind == tkAdornment)
inc(p.idx) inc(p.idx)
@ -1112,16 +1112,16 @@ proc getColumns(p: var TRstParser, cols: var TIntSeq) =
# last column has no limit: # last column has no limit:
cols[L - 1] = 32000 cols[L - 1] = 32000
proc parseDoc(p: var TRstParser): PRstNode proc parseDoc(p: var TRstParser): PRSTNode
proc parseSimpleTable(p: var TRstParser): PRstNode = proc parseSimpleTable(p: var TRstParser): PRSTNode =
var var
cols: TIntSeq cols: TIntSeq
row: seq[string] row: seq[string]
i, last, line: int i, last, line: int
c: Char c: char
q: TRstParser q: TRstParser
a, b: PRstNode a, b: PRSTNode
result = newRstNode(rnTable) result = newRstNode(rnTable)
cols = @[] cols = @[]
row = @[] row = @[]
@ -1135,7 +1135,7 @@ proc parseSimpleTable(p: var TRstParser): PRstNode =
p.idx = last p.idx = last
break break
getColumns(p, cols) getColumns(p, cols)
setlen(row, len(cols)) setLen(row, len(cols))
if a != nil: if a != nil:
for j in 0..len(a)-1: a.sons[j].kind = rnTableHeaderCell for j in 0..len(a)-1: a.sons[j].kind = rnTableHeaderCell
if p.tok[p.idx].kind == tkEof: break if p.tok[p.idx].kind == tkEof: break
@ -1167,13 +1167,13 @@ proc parseSimpleTable(p: var TRstParser): PRstNode =
add(a, b) add(a, b)
add(result, a) add(result, a)
proc parseTransition(p: var TRstParser): PRstNode = proc parseTransition(p: var TRstParser): PRSTNode =
result = newRstNode(rnTransition) result = newRstNode(rnTransition)
inc(p.idx) inc(p.idx)
if p.tok[p.idx].kind == tkIndent: inc(p.idx) if p.tok[p.idx].kind == tkIndent: inc(p.idx)
if p.tok[p.idx].kind == tkIndent: inc(p.idx) if p.tok[p.idx].kind == tkIndent: inc(p.idx)
proc parseOverline(p: var TRstParser): PRstNode = proc parseOverline(p: var TRstParser): PRSTNode =
var c = p.tok[p.idx].symbol[0] var c = p.tok[p.idx].symbol[0]
inc(p.idx, 2) inc(p.idx, 2)
result = newRstNode(rnOverline) result = newRstNode(rnOverline)
@ -1192,7 +1192,7 @@ proc parseOverline(p: var TRstParser): PRstNode =
inc(p.idx) # XXX: check? inc(p.idx) # XXX: check?
if p.tok[p.idx].kind == tkIndent: inc(p.idx) if p.tok[p.idx].kind == tkIndent: inc(p.idx)
proc parseBulletList(p: var TRstParser): PRstNode = proc parseBulletList(p: var TRstParser): PRSTNode =
result = nil result = nil
if p.tok[p.idx + 1].kind == tkWhite: if p.tok[p.idx + 1].kind == tkWhite:
var bullet = p.tok[p.idx].symbol var bullet = p.tok[p.idx].symbol
@ -1212,7 +1212,7 @@ proc parseBulletList(p: var TRstParser): PRstNode =
break break
popInd(p) popInd(p)
proc parseOptionList(p: var TRstParser): PRstNode = proc parseOptionList(p: var TRstParser): PRSTNode =
result = newRstNode(rnOptionList) result = newRstNode(rnOptionList)
while true: while true:
if isOptionList(p): if isOptionList(p):
@ -1241,9 +1241,9 @@ proc parseOptionList(p: var TRstParser): PRstNode =
else: else:
break break
proc parseDefinitionList(p: var TRstParser): PRstNode = proc parseDefinitionList(p: var TRstParser): PRSTNode =
result = nil result = nil
var j = tokenAfterNewLine(p) - 1 var j = tokenAfterNewline(p) - 1
if (j >= 1) and (p.tok[j].kind == tkIndent) and if (j >= 1) and (p.tok[j].kind == tkIndent) and
(p.tok[j].ival > currInd(p)) and (p.tok[j - 1].symbol != "::"): (p.tok[j].ival > currInd(p)) and (p.tok[j - 1].symbol != "::"):
var col = p.tok[p.idx].col var col = p.tok[p.idx].col
@ -1269,7 +1269,7 @@ proc parseDefinitionList(p: var TRstParser): PRstNode =
break break
if (p.tok[p.idx].kind == tkIndent) and (p.tok[p.idx].ival == col): if (p.tok[p.idx].kind == tkIndent) and (p.tok[p.idx].ival == col):
inc(p.idx) inc(p.idx)
j = tokenAfterNewLine(p) - 1 j = tokenAfterNewline(p) - 1
if j >= 1 and p.tok[j].kind == tkIndent and p.tok[j].ival > col and if j >= 1 and p.tok[j].kind == tkIndent and p.tok[j].ival > col and
p.tok[j-1].symbol != "::" and p.tok[j+1].kind != tkIndent: p.tok[j-1].symbol != "::" and p.tok[j+1].kind != tkIndent:
nil nil
@ -1277,7 +1277,7 @@ proc parseDefinitionList(p: var TRstParser): PRstNode =
break break
if len(result) == 0: result = nil if len(result) == 0: result = nil
proc parseEnumList(p: var TRstParser): PRstNode = proc parseEnumList(p: var TRstParser): PRSTNode =
const const
wildcards: array[0..2, string] = ["(e) ", "e) ", "e. "] wildcards: array[0..2, string] = ["(e) ", "e) ", "e. "]
wildpos: array[0..2, int] = [1, 0, 0] wildpos: array[0..2, int] = [1, 0, 0]
@ -1290,7 +1290,7 @@ proc parseEnumList(p: var TRstParser): PRstNode =
var col = p.tok[p.idx].col var col = p.tok[p.idx].col
result = newRstNode(rnEnumList) result = newRstNode(rnEnumList)
inc(p.idx, wildpos[w] + 3) inc(p.idx, wildpos[w] + 3)
var j = tokenAfterNewLine(p) var j = tokenAfterNewline(p)
if (p.tok[j].col == p.tok[p.idx].col) or match(p, j, wildcards[w]): if (p.tok[j].col == p.tok[p.idx].col) or match(p, j, wildcards[w]):
pushInd(p, p.tok[p.idx].col) pushInd(p, p.tok[p.idx].col)
while true: while true:
@ -1307,7 +1307,7 @@ proc parseEnumList(p: var TRstParser): PRstNode =
dec(p.idx, wildpos[w] + 3) dec(p.idx, wildpos[w] + 3)
result = nil result = nil
proc sonKind(father: PRstNode, i: int): TRstNodeKind = proc sonKind(father: PRSTNode, i: int): TRstNodeKind =
result = rnLeaf result = rnLeaf
if i < len(father): result = father.sons[i].kind if i < len(father): result = father.sons[i].kind
@ -1328,7 +1328,7 @@ proc parseSection(p: var TRstParser, result: PRstNode) =
leave = true leave = true
break break
if leave or p.tok[p.idx].kind == tkEof: break if leave or p.tok[p.idx].kind == tkEof: break
var a: PRstNode = nil var a: PRSTNode = nil
var k = whichSection(p) var k = whichSection(p)
case k case k
of rnLiteralBlock: of rnLiteralBlock:
@ -1359,7 +1359,7 @@ proc parseSection(p: var TRstParser, result: PRstNode) =
if sonKind(result, 0) == rnParagraph and sonKind(result, 1) != rnParagraph: if sonKind(result, 0) == rnParagraph and sonKind(result, 1) != rnParagraph:
result.sons[0].kind = rnInner result.sons[0].kind = rnInner
proc parseSectionWrapper(p: var TRstParser): PRstNode = proc parseSectionWrapper(p: var TRstParser): PRSTNode =
result = newRstNode(rnInner) result = newRstNode(rnInner)
parseSection(p, result) parseSection(p, result)
while (result.kind == rnInner) and (len(result) == 1): while (result.kind == rnInner) and (len(result) == 1):
@ -1385,12 +1385,12 @@ type
TDirFlag = enum TDirFlag = enum
hasArg, hasOptions, argIsFile, argIsWord hasArg, hasOptions, argIsFile, argIsWord
TDirFlags = set[TDirFlag] TDirFlags = set[TDirFlag]
TSectionParser = proc (p: var TRstParser): PRstNode {.nimcall.} TSectionParser = proc (p: var TRstParser): PRSTNode {.nimcall.}
proc parseDirective(p: var TRstParser, flags: TDirFlags): PRstNode = proc parseDirective(p: var TRstParser, flags: TDirFlags): PRSTNode =
result = newRstNode(rnDirective) result = newRstNode(rnDirective)
var args: PRstNode = nil var args: PRSTNode = nil
var options: PRstNode = nil var options: PRSTNode = nil
if hasArg in flags: if hasArg in flags:
args = newRstNode(rnDirArg) args = newRstNode(rnDirArg)
if argIsFile in flags: if argIsFile in flags:
@ -1420,7 +1420,7 @@ proc indFollows(p: TRstParser): bool =
result = p.tok[p.idx].kind == tkIndent and p.tok[p.idx].ival > currInd(p) result = p.tok[p.idx].kind == tkIndent and p.tok[p.idx].ival > currInd(p)
proc parseDirective(p: var TRstParser, flags: TDirFlags, proc parseDirective(p: var TRstParser, flags: TDirFlags,
contentParser: TSectionParser): PRstNode = contentParser: TSectionParser): PRSTNode =
result = parseDirective(p, flags) result = parseDirective(p, flags)
if not isNil(contentParser) and indFollows(p): if not isNil(contentParser) and indFollows(p):
pushInd(p, p.tok[p.idx].ival) pushInd(p, p.tok[p.idx].ival)
@ -1430,13 +1430,13 @@ proc parseDirective(p: var TRstParser, flags: TDirFlags,
else: else:
add(result, nil) add(result, nil)
proc parseDirBody(p: var TRstParser, contentParser: TSectionParser): PRstNode = proc parseDirBody(p: var TRstParser, contentParser: TSectionParser): PRSTNode =
if indFollows(p): if indFollows(p):
pushInd(p, p.tok[p.idx].ival) pushInd(p, p.tok[p.idx].ival)
result = contentParser(p) result = contentParser(p)
popInd(p) popInd(p)
proc dirInclude(p: var TRstParser): PRstNode = proc dirInclude(p: var TRstParser): PRSTNode =
# #
#The following options are recognized: #The following options are recognized:
# #
@ -1474,7 +1474,7 @@ proc dirInclude(p: var TRstParser): PRstNode =
# InternalError("Too many binary zeros in include file") # InternalError("Too many binary zeros in include file")
result = parseDoc(q) result = parseDoc(q)
proc dirCodeBlock(p: var TRstParser): PRstNode = proc dirCodeBlock(p: var TRstParser): PRSTNode =
result = parseDirective(p, {hasArg, hasOptions}, parseLiteralBlock) result = parseDirective(p, {hasArg, hasOptions}, parseLiteralBlock)
var filename = strip(getFieldValue(result, "file")) var filename = strip(getFieldValue(result, "file"))
if filename != "": if filename != "":
@ -1485,34 +1485,34 @@ proc dirCodeBlock(p: var TRstParser): PRstNode =
result.sons[2] = n result.sons[2] = n
result.kind = rnCodeBlock result.kind = rnCodeBlock
proc dirContainer(p: var TRstParser): PRstNode = proc dirContainer(p: var TRstParser): PRSTNode =
result = parseDirective(p, {hasArg}, parseSectionWrapper) result = parseDirective(p, {hasArg}, parseSectionWrapper)
assert(result.kind == rnDirective) assert(result.kind == rnDirective)
assert(len(result) == 3) assert(len(result) == 3)
result.kind = rnContainer result.kind = rnContainer
proc dirImage(p: var TRstParser): PRstNode = proc dirImage(p: var TRstParser): PRSTNode =
result = parseDirective(p, {hasOptions, hasArg, argIsFile}, nil) result = parseDirective(p, {hasOptions, hasArg, argIsFile}, nil)
result.kind = rnImage result.kind = rnImage
proc dirFigure(p: var TRstParser): PRstNode = proc dirFigure(p: var TRstParser): PRSTNode =
result = parseDirective(p, {hasOptions, hasArg, argIsFile}, result = parseDirective(p, {hasOptions, hasArg, argIsFile},
parseSectionWrapper) parseSectionWrapper)
result.kind = rnFigure result.kind = rnFigure
proc dirTitle(p: var TRstParser): PRstNode = proc dirTitle(p: var TRstParser): PRSTNode =
result = parseDirective(p, {hasArg}, nil) result = parseDirective(p, {hasArg}, nil)
result.kind = rnTitle result.kind = rnTitle
proc dirContents(p: var TRstParser): PRstNode = proc dirContents(p: var TRstParser): PRSTNode =
result = parseDirective(p, {hasArg}, nil) result = parseDirective(p, {hasArg}, nil)
result.kind = rnContents result.kind = rnContents
proc dirIndex(p: var TRstParser): PRstNode = proc dirIndex(p: var TRstParser): PRSTNode =
result = parseDirective(p, {}, parseSectionWrapper) result = parseDirective(p, {}, parseSectionWrapper)
result.kind = rnIndex result.kind = rnIndex
proc dirRawAux(p: var TRstParser, result: var PRstNode, kind: TRstNodeKind, proc dirRawAux(p: var TRstParser, result: var PRSTNode, kind: TRstNodeKind,
contentParser: TSectionParser) = contentParser: TSectionParser) =
var filename = getFieldValue(result, "file") var filename = getFieldValue(result, "file")
if filename.len > 0: if filename.len > 0:
@ -1527,7 +1527,7 @@ proc dirRawAux(p: var TRstParser, result: var PRstNode, kind: TRstNodeKind,
result.kind = kind result.kind = kind
add(result, parseDirBody(p, contentParser)) add(result, parseDirBody(p, contentParser))
proc dirRaw(p: var TRstParser): PRstNode = proc dirRaw(p: var TRstParser): PRSTNode =
# #
#The following options are recognized: #The following options are recognized:
# #
@ -1581,7 +1581,7 @@ proc parseDotDot(p: var TRstParser): PRstNode =
# substitution definitions: # substitution definitions:
inc(p.idx, 2) inc(p.idx, 2)
var a = getReferenceName(p, "|") var a = getReferenceName(p, "|")
var b: PRstNode var b: PRSTNode
if p.tok[p.idx].kind == tkWhite: inc(p.idx) if p.tok[p.idx].kind == tkWhite: inc(p.idx)
if cmpIgnoreStyle(p.tok[p.idx].symbol, "replace") == 0: if cmpIgnoreStyle(p.tok[p.idx].symbol, "replace") == 0:
inc(p.idx) inc(p.idx)
@ -1603,7 +1603,7 @@ proc parseDotDot(p: var TRstParser): PRstNode =
else: else:
result = parseComment(p) result = parseComment(p)
proc resolveSubs(p: var TRstParser, n: PRstNode): PRstNode = proc resolveSubs(p: var TRstParser, n: PRSTNode): PRSTNode =
result = n result = n
if n == nil: return if n == nil: return
case n.kind case n.kind
@ -1634,7 +1634,7 @@ proc rstParse*(text, filename: string,
line, column: int, hasToc: var bool, line, column: int, hasToc: var bool,
options: TRstParseOptions, options: TRstParseOptions,
findFile: TFindFileHandler = nil, findFile: TFindFileHandler = nil,
msgHandler: TMsgHandler = nil): PRstNode = msgHandler: TMsgHandler = nil): PRSTNode =
var p: TRstParser var p: TRstParser
initParser(p, newSharedState(options, findFile, msgHandler)) initParser(p, newSharedState(options, findFile, msgHandler))
p.filename = filename p.filename = filename

24
lib/packages/docutils/rstast.nim
View file

@ -62,8 +62,8 @@ type
# leaf val # leaf val
PRSTNode* = ref TRstNode ## an RST node PRSTNode* = ref TRSTNode ## an RST node
TRstNodeSeq* = seq[PRstNode] TRstNodeSeq* = seq[PRSTNode]
TRSTNode* {.acyclic, final.} = object ## an RST node's description TRSTNode* {.acyclic, final.} = object ## an RST node's description
kind*: TRstNodeKind ## the node's kind kind*: TRstNodeKind ## the node's kind
text*: string ## valid for leafs in the AST; and the title of text*: string ## valid for leafs in the AST; and the title of
@ -71,25 +71,25 @@ type
level*: int ## valid for some node kinds level*: int ## valid for some node kinds
sons*: TRstNodeSeq ## the node's sons sons*: TRstNodeSeq ## the node's sons
proc len*(n: PRstNode): int = proc len*(n: PRSTNode): int =
result = len(n.sons) result = len(n.sons)
proc newRstNode*(kind: TRstNodeKind): PRstNode = proc newRstNode*(kind: TRstNodeKind): PRSTNode =
new(result) new(result)
result.sons = @[] result.sons = @[]
result.kind = kind result.kind = kind
proc newRstNode*(kind: TRstNodeKind, s: string): PRstNode = proc newRstNode*(kind: TRstNodeKind, s: string): PRSTNode =
result = newRstNode(kind) result = newRstNode(kind)
result.text = s result.text = s
proc lastSon*(n: PRstNode): PRstNode = proc lastSon*(n: PRSTNode): PRSTNode =
result = n.sons[len(n.sons)-1] result = n.sons[len(n.sons)-1]
proc add*(father, son: PRstNode) = proc add*(father, son: PRSTNode) =
add(father.sons, son) add(father.sons, son)
proc addIfNotNil*(father, son: PRstNode) = proc addIfNotNil*(father, son: PRSTNode) =
if son != nil: add(father, son) if son != nil: add(father, son)
@ -98,9 +98,9 @@ type
indent: int indent: int
verbatim: int verbatim: int
proc renderRstToRst(d: var TRenderContext, n: PRstNode, result: var string) proc renderRstToRst(d: var TRenderContext, n: PRSTNode, result: var string)
proc renderRstSons(d: var TRenderContext, n: PRstNode, result: var string) = proc renderRstSons(d: var TRenderContext, n: PRSTNode, result: var string) =
for i in countup(0, len(n) - 1): for i in countup(0, len(n) - 1):
renderRstToRst(d, n.sons[i], result) renderRstToRst(d, n.sons[i], result)
@ -132,7 +132,7 @@ proc renderRstToRst(d: var TRenderContext, n: PRstNode, result: var string) =
var headline = "" var headline = ""
renderRstSons(d, n, headline) renderRstSons(d, n, headline)
let lvl = repeatChar(headline.Len - d.indent, lvlToChar[n.level]) let lvl = repeatChar(headline.len - d.indent, lvlToChar[n.level])
result.add(lvl) result.add(lvl)
result.add("\n") result.add("\n")
result.add(headline) result.add(headline)
@ -281,7 +281,7 @@ proc renderRstToRst(d: var TRenderContext, n: PRstNode, result: var string) =
else: else:
result.add("Error: cannot render: " & $n.kind) result.add("Error: cannot render: " & $n.kind)
proc renderRstToRst*(n: PRstNode, result: var string) = proc renderRstToRst*(n: PRSTNode, result: var string) =
## renders `n` into its string representation and appends to `result`. ## renders `n` into its string representation and appends to `result`.
var d: TRenderContext var d: TRenderContext
renderRstToRst(d, n, result) renderRstToRst(d, n, result)

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

@ -32,7 +32,7 @@ type
outLatex # output is Latex outLatex # output is Latex
TTocEntry{.final.} = object TTocEntry{.final.} = object
n*: PRstNode n*: PRSTNode
refname*, header*: string refname*, header*: string
TMetaEnum* = enum TMetaEnum* = enum
@ -113,7 +113,7 @@ proc initRstGenerator*(g: var TRstGenerator, target: TOutputTarget,
proc writeIndexFile*(g: var TRstGenerator, outfile: string) = proc writeIndexFile*(g: var TRstGenerator, outfile: string) =
if g.theIndex.len > 0: writeFile(outfile, g.theIndex) if g.theIndex.len > 0: writeFile(outfile, g.theIndex)
proc addXmlChar(dest: var string, c: Char) = proc addXmlChar(dest: var string, c: char) =
case c case c
of '&': add(dest, "&amp;") of '&': add(dest, "&amp;")
of '<': add(dest, "&lt;") of '<': add(dest, "&lt;")
@ -121,14 +121,14 @@ proc addXmlChar(dest: var string, c: Char) =
of '\"': add(dest, "&quot;") of '\"': add(dest, "&quot;")
else: add(dest, c) else: add(dest, c)
proc addRtfChar(dest: var string, c: Char) = proc addRtfChar(dest: var string, c: char) =
case c case c
of '{': add(dest, "\\{") of '{': add(dest, "\\{")
of '}': add(dest, "\\}") of '}': add(dest, "\\}")
of '\\': add(dest, "\\\\") of '\\': add(dest, "\\\\")
else: add(dest, c) else: add(dest, c)
proc addTexChar(dest: var string, c: Char) = proc addTexChar(dest: var string, c: char) =
case c case c
of '_': add(dest, "\\_") of '_': add(dest, "\\_")
of '{': add(dest, "\\symbol{123}") of '{': add(dest, "\\symbol{123}")
@ -148,7 +148,7 @@ proc addTexChar(dest: var string, c: Char) =
var splitter*: string = "<wbr />" var splitter*: string = "<wbr />"
proc escChar*(target: TOutputTarget, dest: var string, c: Char) {.inline.} = proc escChar*(target: TOutputTarget, dest: var string, c: char) {.inline.} =
case target case target
of outHtml: addXmlChar(dest, c) of outHtml: addXmlChar(dest, c)
of outLatex: addTexChar(dest, c) of outLatex: addTexChar(dest, c)
@ -196,7 +196,7 @@ proc dispA(target: TOutputTarget, dest: var string,
if target != outLatex: addf(dest, xml, args) if target != outLatex: addf(dest, xml, args)
else: addf(dest, tex, args) else: addf(dest, tex, args)
proc renderRstToOut*(d: var TRstGenerator, n: PRstNode, result: var string) proc renderRstToOut*(d: var TRstGenerator, n: PRSTNode, result: var string)
## Writes into ``result`` the rst ast ``n`` using the ``d`` configuration. ## Writes into ``result`` the rst ast ``n`` using the ``d`` configuration.
## ##
## Before using this proc you need to initialise a ``TRstGenerator`` with ## Before using this proc you need to initialise a ``TRstGenerator`` with
@ -210,10 +210,10 @@ proc renderRstToOut*(d: var TRstGenerator, n: PRstNode, result: var string)
## renderRstToOut(gen, rst, generatedHTML) ## renderRstToOut(gen, rst, generatedHTML)
## echo generatedHTML ## echo generatedHTML
proc renderAux(d: PDoc, n: PRstNode, result: var string) = proc renderAux(d: PDoc, n: PRSTNode, result: var string) =
for i in countup(0, len(n)-1): renderRstToOut(d, n.sons[i], result) for i in countup(0, len(n)-1): renderRstToOut(d, n.sons[i], result)
proc renderAux(d: PDoc, n: PRstNode, frmtA, frmtB: string, result: var string) = proc renderAux(d: PDoc, n: PRSTNode, frmtA, frmtB: string, result: var string) =
var tmp = "" var tmp = ""
for i in countup(0, len(n)-1): renderRstToOut(d, n.sons[i], tmp) for i in countup(0, len(n)-1): renderRstToOut(d, n.sons[i], tmp)
if d.target != outLatex: if d.target != outLatex:
@ -232,7 +232,7 @@ proc setIndexTerm*(d: var TRstGenerator, id, term: string) =
d.theIndex.add(id) d.theIndex.add(id)
d.theIndex.add("\n") d.theIndex.add("\n")
proc hash(n: PRstNode): int = proc hash(n: PRSTNode): int =
if n.kind == rnLeaf: if n.kind == rnLeaf:
result = hash(n.text) result = hash(n.text)
elif n.len > 0: elif n.len > 0:
@ -241,7 +241,7 @@ proc hash(n: PRstNode): int =
result = result !& hash(n.sons[i]) result = result !& hash(n.sons[i])
result = !$result result = !$result
proc renderIndexTerm(d: PDoc, n: PRstNode, result: var string) = proc renderIndexTerm(d: PDoc, n: PRSTNode, result: var string) =
let id = rstnodeToRefname(n) & '_' & $abs(hash(n)) let id = rstnodeToRefname(n) & '_' & $abs(hash(n))
var term = "" var term = ""
renderAux(d, n, term) renderAux(d, n, term)
@ -314,13 +314,13 @@ proc mergeIndexes*(dir: string): string =
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
proc renderHeadline(d: PDoc, n: PRstNode, result: var string) = proc renderHeadline(d: PDoc, n: PRSTNode, result: var string) =
var tmp = "" var tmp = ""
for i in countup(0, len(n) - 1): renderRstToOut(d, n.sons[i], tmp) for i in countup(0, len(n) - 1): renderRstToOut(d, n.sons[i], tmp)
var refname = rstnodeToRefname(n) var refname = rstnodeToRefname(n)
if d.hasToc: if d.hasToc:
var length = len(d.tocPart) var length = len(d.tocPart)
setlen(d.tocPart, length + 1) setLen(d.tocPart, length + 1)
d.tocPart[length].refname = refname d.tocPart[length].refname = refname
d.tocPart[length].n = n d.tocPart[length].n = n
d.tocPart[length].header = tmp d.tocPart[length].header = tmp
@ -336,7 +336,7 @@ proc renderHeadline(d: PDoc, n: PRstNode, result: var string) =
$n.level, refname, tmp, $n.level, refname, tmp,
$chr(n.level - 1 + ord('A'))]) $chr(n.level - 1 + ord('A'))])
proc renderOverline(d: PDoc, n: PRstNode, result: var string) = proc renderOverline(d: PDoc, n: PRSTNode, result: var string) =
if d.meta[metaTitle].len == 0: if d.meta[metaTitle].len == 0:
for i in countup(0, len(n)-1): for i in countup(0, len(n)-1):
renderRstToOut(d, n.sons[i], d.meta[metaTitle]) renderRstToOut(d, n.sons[i], d.meta[metaTitle])
@ -373,7 +373,7 @@ proc renderTocEntries*(d: var TRstGenerator, j: var int, lvl: int, result: var s
else: else:
result.add(tmp) result.add(tmp)
proc renderImage(d: PDoc, n: PRstNode, result: var string) = proc renderImage(d: PDoc, n: PRSTNode, result: var string) =
var options = "" var options = ""
var s = getFieldValue(n, "scale") var s = getFieldValue(n, "scale")
if s != "": dispA(d.target, options, " scale=\"$1\"", " scale=$1", [strip(s)]) if s != "": dispA(d.target, options, " scale=\"$1\"", " scale=$1", [strip(s)])
@ -396,13 +396,13 @@ proc renderImage(d: PDoc, n: PRstNode, result: var string) =
[getArgument(n), options]) [getArgument(n), options])
if len(n) >= 3: renderRstToOut(d, n.sons[2], result) if len(n) >= 3: renderRstToOut(d, n.sons[2], result)
proc renderSmiley(d: PDoc, n: PRstNode, result: var string) = proc renderSmiley(d: PDoc, n: PRSTNode, result: var string) =
dispA(d.target, result, dispA(d.target, result,
"""<img src="/images/smilies/$1.gif" width="15" """<img src="/images/smilies/$1.gif" width="15"
height="17" hspace="2" vspace="2" />""", height="17" hspace="2" vspace="2" />""",
"\\includegraphics{$1}", [n.text]) "\\includegraphics{$1}", [n.text])
proc renderCodeBlock(d: PDoc, n: PRstNode, result: var string) = proc renderCodeBlock(d: PDoc, n: PRSTNode, result: var string) =
if n.sons[2] == nil: return if n.sons[2] == nil: return
var m = n.sons[2].sons[0] var m = n.sons[2].sons[0]
assert m.kind == rnLeaf assert m.kind == rnLeaf
@ -433,7 +433,7 @@ proc renderCodeBlock(d: PDoc, n: PRstNode, result: var string) =
deinitGeneralTokenizer(g) deinitGeneralTokenizer(g)
dispA(d.target, result, "</pre>", "\n\\end{rstpre}\n") dispA(d.target, result, "</pre>", "\n\\end{rstpre}\n")
proc renderContainer(d: PDoc, n: PRstNode, result: var string) = proc renderContainer(d: PDoc, n: PRSTNode, result: var string) =
var tmp = "" var tmp = ""
renderRstToOut(d, n.sons[2], tmp) renderRstToOut(d, n.sons[2], tmp)
var arg = strip(getArgument(n)) var arg = strip(getArgument(n))
@ -442,11 +442,11 @@ proc renderContainer(d: PDoc, n: PRstNode, result: var string) =
else: else:
dispA(d.target, result, "<div class=\"$1\">$2</div>", "$2", [arg, tmp]) dispA(d.target, result, "<div class=\"$1\">$2</div>", "$2", [arg, tmp])
proc texColumns(n: PRstNode): string = proc texColumns(n: PRSTNode): string =
result = "" result = ""
for i in countup(1, len(n)): add(result, "|X") for i in countup(1, len(n)): add(result, "|X")
proc renderField(d: PDoc, n: PRstNode, result: var string) = proc renderField(d: PDoc, n: PRSTNode, result: var string) =
var b = false var b = false
if d.target == outLatex: if d.target == outLatex:
var fieldname = addNodes(n.sons[0]) var fieldname = addNodes(n.sons[0])
@ -456,7 +456,7 @@ proc renderField(d: PDoc, n: PRstNode, result: var string) =
if d.meta[metaAuthor].len == 0: if d.meta[metaAuthor].len == 0:
d.meta[metaAuthor] = fieldval d.meta[metaAuthor] = fieldval
b = true b = true
elif cmpIgnoreStyle(fieldName, "version") == 0: elif cmpIgnoreStyle(fieldname, "version") == 0:
if d.meta[metaVersion].len == 0: if d.meta[metaVersion].len == 0:
d.meta[metaVersion] = fieldval d.meta[metaVersion] = fieldval
b = true b = true
@ -620,14 +620,14 @@ proc renderRstToOut(d: PDoc, n: PRstNode, result: var string) =
# ----------------------------------------------------------------------------- # -----------------------------------------------------------------------------
proc getVarIdx(varnames: openarray[string], id: string): int = proc getVarIdx(varnames: openArray[string], id: string): int =
for i in countup(0, high(varnames)): for i in countup(0, high(varnames)):
if cmpIgnoreStyle(varnames[i], id) == 0: if cmpIgnoreStyle(varnames[i], id) == 0:
return i return i
result = -1 result = -1
proc formatNamedVars*(frmt: string, varnames: openarray[string], proc formatNamedVars*(frmt: string, varnames: openArray[string],
varvalues: openarray[string]): string = varvalues: openArray[string]): string =
var i = 0 var i = 0
var L = len(frmt) var L = len(frmt)
result = "" result = ""
@ -646,7 +646,7 @@ proc formatNamedVars*(frmt: string, varnames: openarray[string],
of '0'..'9': of '0'..'9':
var j = 0 var j = 0
while true: while true:
j = (j * 10) + Ord(frmt[i]) - ord('0') j = (j * 10) + ord(frmt[i]) - ord('0')
inc(i) inc(i)
if i > L-1 or frmt[i] notin {'0'..'9'}: break if i > L-1 or frmt[i] notin {'0'..'9'}: break
if j > high(varvalues) + 1: if j > high(varvalues) + 1:

4
lib/pure/algorithm.nim
View file

@ -34,7 +34,7 @@ proc reverse*[T](a: var openArray[T]) =
## reverses the array `a`. ## reverses the array `a`.
reverse(a, 0, a.high) reverse(a, 0, a.high)
proc binarySearch*[T](a: openarray[T], key: T): int = proc binarySearch*[T](a: openArray[T], key: T): int =
## binary search for `key` in `a`. Returns -1 if not found. ## binary search for `key` in `a`. Returns -1 if not found.
var b = len(a) var b = len(a)
while result < b: while result < b:
@ -79,7 +79,7 @@ proc merge[T](a, b: var openArray[T], lo, m, hi: int,
inc(bb) inc(bb)
inc(j) inc(j)
else: else:
CopyMem(addr(b[0]), addr(a[j]), sizeof(T)*(m-j+1)) copyMem(addr(b[0]), addr(a[j]), sizeof(T)*(m-j+1))
j = m+1 j = m+1
var i = 0 var i = 0
var k = lo var k = lo

14
lib/pure/collections/intsets.nim
View file

@ -71,8 +71,8 @@ proc intSetEnlarge(t: var TIntSet) =
var oldMax = t.max var oldMax = t.max
t.max = ((t.max + 1) * 2) - 1 t.max = ((t.max + 1) * 2) - 1
newSeq(n, t.max + 1) newSeq(n, t.max + 1)
for i in countup(0, oldmax): for i in countup(0, oldMax):
if t.data[i] != nil: IntSetRawInsert(t, n, t.data[i]) if t.data[i] != nil: intSetRawInsert(t, n, t.data[i])
swap(t.data, n) swap(t.data, n)
proc intSetPut(t: var TIntSet, key: int): PTrunk = proc intSetPut(t: var TIntSet, key: int): PTrunk =
@ -81,7 +81,7 @@ proc intSetPut(t: var TIntSet, key: int): PTrunk =
if t.data[h].key == key: if t.data[h].key == key:
return t.data[h] return t.data[h]
h = nextTry(h, t.max) h = nextTry(h, t.max)
if mustRehash(t.max + 1, t.counter): IntSetEnlarge(t) if mustRehash(t.max + 1, t.counter): intSetEnlarge(t)
inc(t.counter) inc(t.counter)
h = key and t.max h = key and t.max
while t.data[h] != nil: h = nextTry(h, t.max) while t.data[h] != nil: h = nextTry(h, t.max)
@ -94,7 +94,7 @@ proc intSetPut(t: var TIntSet, key: int): PTrunk =
proc contains*(s: TIntSet, key: int): bool = proc contains*(s: TIntSet, key: int): bool =
## returns true iff `key` is in `s`. ## returns true iff `key` is in `s`.
var t = IntSetGet(s, `shr`(key, TrunkShift)) var t = intSetGet(s, `shr`(key, TrunkShift))
if t != nil: if t != nil:
var u = key and TrunkMask var u = key and TrunkMask
result = (t.bits[`shr`(u, IntShift)] and `shl`(1, u and IntMask)) != 0 result = (t.bits[`shr`(u, IntShift)] and `shl`(1, u and IntMask)) != 0
@ -103,14 +103,14 @@ proc contains*(s: TIntSet, key: int): bool =
proc incl*(s: var TIntSet, key: int) = proc incl*(s: var TIntSet, key: int) =
## includes an element `key` in `s`. ## includes an element `key` in `s`.
var t = IntSetPut(s, `shr`(key, TrunkShift)) var t = intSetPut(s, `shr`(key, TrunkShift))
var u = key and TrunkMask var u = key and TrunkMask
t.bits[`shr`(u, IntShift)] = t.bits[`shr`(u, IntShift)] or t.bits[`shr`(u, IntShift)] = t.bits[`shr`(u, IntShift)] or
`shl`(1, u and IntMask) `shl`(1, u and IntMask)
proc excl*(s: var TIntSet, key: int) = proc excl*(s: var TIntSet, key: int) =
## excludes `key` from the set `s`. ## excludes `key` from the set `s`.
var t = IntSetGet(s, `shr`(key, TrunkShift)) var t = intSetGet(s, `shr`(key, TrunkShift))
if t != nil: if t != nil:
var u = key and TrunkMask var u = key and TrunkMask
t.bits[`shr`(u, IntShift)] = t.bits[`shr`(u, IntShift)] and t.bits[`shr`(u, IntShift)] = t.bits[`shr`(u, IntShift)] and
@ -119,7 +119,7 @@ proc excl*(s: var TIntSet, key: int) =
proc containsOrIncl*(s: var TIntSet, key: int): bool = proc containsOrIncl*(s: var TIntSet, key: int): bool =
## returns true if `s` contains `key`, otherwise `key` is included in `s` ## returns true if `s` contains `key`, otherwise `key` is included in `s`
## and false is returned. ## and false is returned.
var t = IntSetGet(s, `shr`(key, TrunkShift)) var t = intSetGet(s, `shr`(key, TrunkShift))
if t != nil: if t != nil:
var u = key and TrunkMask var u = key and TrunkMask
result = (t.bits[`shr`(u, IntShift)] and `shl`(1, u and IntMask)) != 0 result = (t.bits[`shr`(u, IntShift)] and `shl`(1, u and IntMask)) != 0

2
lib/pure/collections/sequtils.nim
View file

@ -136,7 +136,7 @@ proc delete*[T](s: var seq[T], first=0, last=0) =
s[i].shallowCopy(s[j]) s[i].shallowCopy(s[j])
inc(i) inc(i)
inc(j) inc(j)
setlen(s, newLen) setLen(s, newLen)
proc insert*[T](dest: var seq[T], src: openArray[T], pos=0) = proc insert*[T](dest: var seq[T], src: openArray[T], pos=0) =
## Inserts items from `src` into `dest` at position `pos`. This modifies ## Inserts items from `src` into `dest` at position `pos`. This modifies

6
lib/pure/collections/tables.nim
View file

@ -168,7 +168,7 @@ proc initTable*[A, B](initialSize=64): TTable[A, B] =
result.counter = 0 result.counter = 0
newSeq(result.data, initialSize) newSeq(result.data, initialSize)
proc toTable*[A, B](pairs: openarray[tuple[key: A, proc toTable*[A, B](pairs: openArray[tuple[key: A,
val: B]]): TTable[A, B] = val: B]]): TTable[A, B] =
## creates a new hash table that contains the given `pairs`. ## creates a new hash table that contains the given `pairs`.
result = initTable[A, B](nextPowerOfTwo(pairs.len+10)) result = initTable[A, B](nextPowerOfTwo(pairs.len+10))
@ -304,7 +304,7 @@ proc initOrderedTable*[A, B](initialSize=64): TOrderedTable[A, B] =
result.last = -1 result.last = -1
newSeq(result.data, initialSize) newSeq(result.data, initialSize)
proc toOrderedTable*[A, B](pairs: openarray[tuple[key: A, proc toOrderedTable*[A, B](pairs: openArray[tuple[key: A,
val: B]]): TOrderedTable[A, B] = val: B]]): TOrderedTable[A, B] =
## creates a new ordered hash table that contains the given `pairs`. ## creates a new ordered hash table that contains the given `pairs`.
result = initOrderedTable[A, B](nextPowerOfTwo(pairs.len+10)) result = initOrderedTable[A, B](nextPowerOfTwo(pairs.len+10))
@ -463,7 +463,7 @@ proc `$`*[A](t: TCountTable[A]): string =
proc inc*[A](t: var TCountTable[A], key: A, val = 1) = proc inc*[A](t: var TCountTable[A], key: A, val = 1) =
## increments `t[key]` by `val`. ## increments `t[key]` by `val`.
var index = RawGet(t, key) var index = rawGet(t, key)
if index >= 0: if index >= 0:
inc(t.data[index].val, val) inc(t.data[index].val, val)
else: else:

12
lib/pure/hashes.nim
View file

@ -32,7 +32,7 @@ proc `!$`*(h: THash): THash {.inline.} =
result = result xor (result shr 11) result = result xor (result shr 11)
result = result +% result shl 15 result = result +% result shl 15
proc hashData*(Data: Pointer, Size: int): THash = proc hashData*(Data: pointer, Size: int): THash =
## hashes an array of bytes of size `size` ## hashes an array of bytes of size `size`
var h: THash = 0 var h: THash = 0
when defined(js): when defined(js):
@ -41,17 +41,17 @@ proc hashData*(Data: Pointer, Size: int): THash =
else: else:
var p = cast[cstring](Data) var p = cast[cstring](Data)
var i = 0 var i = 0
var s = size var s = Size
while s > 0: while s > 0:
h = h !& ord(p[i]) h = h !& ord(p[i])
Inc(i) inc(i)
Dec(s) dec(s)
result = !$h result = !$h
when defined(js): when defined(js):
var objectID = 0 var objectID = 0
proc hash*(x: Pointer): THash {.inline.} = proc hash*(x: pointer): THash {.inline.} =
## efficient hashing of pointers ## efficient hashing of pointers
when defined(js): when defined(js):
asm """ asm """
@ -126,6 +126,6 @@ proc hash*(x: float): THash {.inline.} =
var y = x + 1.0 var y = x + 1.0
result = cast[ptr THash](addr(y))[] result = cast[ptr THash](addr(y))[]
proc hash*[A](x: openarray[A]): THash = proc hash*[A](x: openArray[A]): THash =
for it in items(x): result = result !& hash(it) for it in items(x): result = result !& hash(it)
result = !$result result = !$result

40
lib/pure/json.nim
View file

@ -135,7 +135,7 @@ proc str*(my: TJsonParser): string {.inline.} =
assert(my.kind in {jsonInt, jsonFloat, jsonString}) assert(my.kind in {jsonInt, jsonFloat, jsonString})
return my.a return my.a
proc getInt*(my: TJsonParser): biggestInt {.inline.} = proc getInt*(my: TJsonParser): BiggestInt {.inline.} =
## returns the number for the event: ``jsonInt`` ## returns the number for the event: ``jsonInt``
assert(my.kind == jsonInt) assert(my.kind == jsonInt)
return parseBiggestInt(my.a) return parseBiggestInt(my.a)
@ -173,7 +173,7 @@ proc errorMsgExpected*(my: TJsonParser, e: string): string =
result = "$1($2, $3) Error: $4" % [ result = "$1($2, $3) Error: $4" % [
my.filename, $getLine(my), $getColumn(my), e & " expected"] my.filename, $getLine(my), $getColumn(my), e & " expected"]
proc handleHexChar(c: Char, x: var int): bool = proc handleHexChar(c: char, x: var int): bool =
result = true # Success result = true # Success
case c case c
of '0'..'9': x = (x shl 4) or (ord(c) - ord('0')) of '0'..'9': x = (x shl 4) or (ord(c) - ord('0'))
@ -286,7 +286,7 @@ proc skip(my: var TJsonParser) =
else: else:
break break
of ' ', '\t': of ' ', '\t':
Inc(pos) inc(pos)
of '\c': of '\c':
pos = lexbase.HandleCR(my, pos) pos = lexbase.HandleCR(my, pos)
buf = my.buf buf = my.buf
@ -517,7 +517,7 @@ type
of JString: of JString:
str*: string str*: string
of JInt: of JInt:
num*: biggestInt num*: BiggestInt
of JFloat: of JFloat:
fnum*: float fnum*: float
of JBool: of JBool:
@ -535,30 +535,30 @@ proc raiseParseErr*(p: TJsonParser, msg: string) {.noinline, noreturn.} =
## raises an `EJsonParsingError` exception. ## raises an `EJsonParsingError` exception.
raise newException(EJsonParsingError, errorMsgExpected(p, msg)) raise newException(EJsonParsingError, errorMsgExpected(p, msg))
proc newJString*(s: String): PJsonNode = proc newJString*(s: string): PJsonNode =
## Creates a new `JString PJsonNode`. ## Creates a new `JString PJsonNode`.
new(result) new(result)
result.kind = JString result.kind = JString
result.str = s result.str = s
proc newJStringMove(s: String): PJsonNode = proc newJStringMove(s: string): PJsonNode =
new(result) new(result)
result.kind = JString result.kind = JString
shallowCopy(result.str, s) shallowCopy(result.str, s)
proc newJInt*(n: biggestInt): PJsonNode = proc newJInt*(n: BiggestInt): PJsonNode =
## Creates a new `JInt PJsonNode`. ## Creates a new `JInt PJsonNode`.
new(result) new(result)
result.kind = JInt result.kind = JInt
result.num = n result.num = n
proc newJFloat*(n: Float): PJsonNode = proc newJFloat*(n: float): PJsonNode =
## Creates a new `JFloat PJsonNode`. ## Creates a new `JFloat PJsonNode`.
new(result) new(result)
result.kind = JFloat result.kind = JFloat
result.fnum = n result.fnum = n
proc newJBool*(b: Bool): PJsonNode = proc newJBool*(b: bool): PJsonNode =
## Creates a new `JBool PJsonNode`. ## Creates a new `JBool PJsonNode`.
new(result) new(result)
result.kind = JBool result.kind = JBool
@ -587,7 +587,7 @@ proc `%`*(s: string): PJsonNode =
result.kind = JString result.kind = JString
result.str = s result.str = s
proc `%`*(n: biggestInt): PJsonNode = proc `%`*(n: BiggestInt): PJsonNode =
## Generic constructor for JSON data. Creates a new `JInt PJsonNode`. ## Generic constructor for JSON data. Creates a new `JInt PJsonNode`.
new(result) new(result)
result.kind = JInt result.kind = JInt
@ -612,7 +612,7 @@ proc `%`*(keyVals: openArray[tuple[key: string, val: PJsonNode]]): PJsonNode =
newSeq(result.fields, keyVals.len) newSeq(result.fields, keyVals.len)
for i, p in pairs(keyVals): result.fields[i] = p for i, p in pairs(keyVals): result.fields[i] = p
proc `%`*(elements: openArray[PJSonNode]): PJsonNode = proc `%`*(elements: openArray[PJsonNode]): PJsonNode =
## Generic constructor for JSON data. Creates a new `JArray PJsonNode` ## Generic constructor for JSON data. Creates a new `JArray PJsonNode`
new(result) new(result)
result.kind = JArray result.kind = JArray
@ -628,7 +628,7 @@ proc len*(n: PJsonNode): int =
of JObject: result = n.fields.len of JObject: result = n.fields.len
else: nil else: nil
proc `[]`*(node: PJsonNode, name: String): PJsonNode = proc `[]`*(node: PJsonNode, name: string): PJsonNode =
## Gets a field from a `JObject`. Returns nil if the key is not found. ## Gets a field from a `JObject`. Returns nil if the key is not found.
assert(node.kind == JObject) assert(node.kind == JObject)
for key, item in items(node.fields): for key, item in items(node.fields):
@ -636,17 +636,17 @@ proc `[]`*(node: PJsonNode, name: String): PJsonNode =
return item return item
return nil return nil
proc `[]`*(node: PJsonNode, index: Int): PJsonNode = proc `[]`*(node: PJsonNode, index: int): PJsonNode =
## Gets the node at `index` in an Array. ## Gets the node at `index` in an Array.
assert(node.kind == JArray) assert(node.kind == JArray)
return node.elems[index] return node.elems[index]
proc hasKey*(node: PJsonNode, key: String): Bool = proc hasKey*(node: PJsonNode, key: string): bool =
## Checks if `key` exists in `node`. ## Checks if `key` exists in `node`.
assert(node.kind == JObject) assert(node.kind == JObject)
for k, item in items(node.fields): for k, item in items(node.fields):
if k == key: return True if k == key: return True
proc existsKey*(node: PJsonNode, key: String): Bool {.deprecated.} = node.hasKey(key) proc existsKey*(node: PJsonNode, key: string): bool {.deprecated.} = node.hasKey(key)
## Deprecated for `hasKey` ## Deprecated for `hasKey`
proc add*(father, child: PJsonNode) = proc add*(father, child: PJsonNode) =
@ -661,7 +661,7 @@ proc add*(obj: PJsonNode, key: string, val: PJsonNode) =
assert obj.kind == JObject assert obj.kind == JObject
obj.fields.add((key, val)) obj.fields.add((key, val))
proc `[]=`*(obj: PJsonNode, key: String, val: PJsonNode) = proc `[]=`*(obj: PJsonNode, key: string, val: PJsonNode) =
## Sets a field from a `JObject`. Performs a check for duplicate keys. ## Sets a field from a `JObject`. Performs a check for duplicate keys.
assert(obj.kind == JObject) assert(obj.kind == JObject)
for i in 0..obj.fields.len-1: for i in 0..obj.fields.len-1:
@ -706,7 +706,7 @@ proc copy*(p: PJsonNode): PJsonNode =
proc indent(s: var string, i: int) = proc indent(s: var string, i: int) =
s.add(repeatChar(i)) s.add(repeatChar(i))
proc newIndent(curr, indent: int, ml: bool): Int = proc newIndent(curr, indent: int, ml: bool): int =
if ml: return curr + indent if ml: return curr + indent
else: return indent else: return indent
@ -785,18 +785,18 @@ proc toPretty(result: var string, node: PJsonNode, indent = 2, ml = True,
if lstArr: result.indent(currIndent) if lstArr: result.indent(currIndent)
result.add("null") result.add("null")
proc pretty*(node: PJsonNode, indent = 2): String = proc pretty*(node: PJsonNode, indent = 2): string =
## Converts `node` to its JSON Representation, with indentation and ## Converts `node` to its JSON Representation, with indentation and
## on multiple lines. ## on multiple lines.
result = "" result = ""
toPretty(result, node, indent) toPretty(result, node, indent)
proc `$`*(node: PJsonNode): String = proc `$`*(node: PJsonNode): string =
## Converts `node` to its JSON Representation on one line. ## Converts `node` to its JSON Representation on one line.
result = "" result = ""
toPretty(result, node, 1, False) toPretty(result, node, 1, False)
iterator items*(node: PJsonNode): PJSonNode = iterator items*(node: PJsonNode): PJsonNode =
## Iterator for the items of `node`. `node` has to be a JArray. ## Iterator for the items of `node`. `node` has to be a JArray.
assert node.kind == JArray assert node.kind == JArray
for i in items(node.elems): for i in items(node.elems):

4
lib/pure/lexbase.nim
View file

@ -91,7 +91,7 @@ proc fillBuffer(L: var TBaseLexer) =
dec(s) # BUGFIX (valgrind) dec(s) # BUGFIX (valgrind)
while true: while true:
assert(s < L.bufLen) assert(s < L.bufLen)
while (s >= 0) and not (L.buf[s] in NewLines): Dec(s) while (s >= 0) and not (L.buf[s] in NewLines): dec(s)
if s >= 0: if s >= 0:
# we found an appropriate character for a sentinel: # we found an appropriate character for a sentinel:
L.sentinel = s L.sentinel = s
@ -163,5 +163,5 @@ proc getCurrentLine(L: TBaseLexer, marker: bool = true): string =
inc(i) inc(i)
add(result, "\n") add(result, "\n")
if marker: if marker:
add(result, RepeatChar(getColNumber(L, L.bufpos)) & "^\n") add(result, repeatChar(getColNumber(L, L.bufpos)) & "^\n")

8
lib/pure/math.nim
View file

@ -94,7 +94,7 @@ proc nextPowerOfTwo*(x: int): int =
result = result or (result shr 4) result = result or (result shr 4)
result = result or (result shr 2) result = result or (result shr 2)
result = result or (result shr 1) result = result or (result shr 1)
Inc(result) inc(result)
proc countBits32*(n: int32): int {.noSideEffect.} = proc countBits32*(n: int32): int {.noSideEffect.} =
## counts the set bits in `n`. ## counts the set bits in `n`.
@ -103,17 +103,17 @@ proc countBits32*(n: int32): int {.noSideEffect.} =
v = (v and 0x33333333'i32) +% ((v shr 2'i32) and 0x33333333'i32) v = (v and 0x33333333'i32) +% ((v shr 2'i32) and 0x33333333'i32)
result = ((v +% (v shr 4'i32) and 0xF0F0F0F'i32) *% 0x1010101'i32) shr 24'i32 result = ((v +% (v shr 4'i32) and 0xF0F0F0F'i32) *% 0x1010101'i32) shr 24'i32
proc sum*[T](x: openarray[T]): T {.noSideEffect.} = proc sum*[T](x: openArray[T]): T {.noSideEffect.} =
## computes the sum of the elements in `x`. ## computes the sum of the elements in `x`.
## If `x` is empty, 0 is returned. ## If `x` is empty, 0 is returned.
for i in items(x): result = result + i for i in items(x): result = result + i
proc mean*(x: openarray[float]): float {.noSideEffect.} = proc mean*(x: openArray[float]): float {.noSideEffect.} =
## computes the mean of the elements in `x`. ## computes the mean of the elements in `x`.
## If `x` is empty, NaN is returned. ## If `x` is empty, NaN is returned.
result = sum(x) / toFloat(len(x)) result = sum(x) / toFloat(len(x))
proc variance*(x: openarray[float]): float {.noSideEffect.} = proc variance*(x: openArray[float]): float {.noSideEffect.} =
## computes the variance of the elements in `x`. ## computes the variance of the elements in `x`.
## If `x` is empty, NaN is returned. ## If `x` is empty, NaN is returned.
result = 0.0 result = 0.0

38
lib/pure/memfiles.nim
View file

@ -52,9 +52,9 @@ proc open*(filename: string, mode: TFileMode = fmRead,
when defined(windows): when defined(windows):
template fail(errCode: TOSErrorCode, msg: expr) = template fail(errCode: TOSErrorCode, msg: expr) =
rollback() rollback()
if result.fHandle != 0: discard CloseHandle(result.fHandle) if result.fHandle != 0: discard closeHandle(result.fHandle)
if result.mapHandle != 0: discard CloseHandle(result.mapHandle) if result.mapHandle != 0: discard closeHandle(result.mapHandle)
OSError(errCode) osError(errCode)
# return false # return false
#raise newException(EIO, msg) #raise newException(EIO, msg)
@ -69,36 +69,36 @@ proc open*(filename: string, mode: TFileMode = fmRead,
0) 0)
when useWinUnicode: when useWinUnicode:
result.fHandle = callCreateFile(CreateFileW, newWideCString(filename)) result.fHandle = callCreateFile(createFileW, newWideCString(filename))
else: else:
result.fHandle = callCreateFile(CreateFileA, filename) result.fHandle = callCreateFile(CreateFileA, filename)
if result.fHandle == INVALID_HANDLE_VALUE: if result.fHandle == INVALID_HANDLE_VALUE:
fail(OSLastError(), "error opening file") fail(osLastError(), "error opening file")
if newFileSize != -1: if newFileSize != -1:
var var
sizeHigh = int32(newFileSize shr 32) sizeHigh = int32(newFileSize shr 32)
sizeLow = int32(newFileSize and 0xffffffff) sizeLow = int32(newFileSize and 0xffffffff)
var status = SetFilePointer(result.fHandle, sizeLow, addr(sizeHigh), var status = setFilePointer(result.fHandle, sizeLow, addr(sizeHigh),
FILE_BEGIN) FILE_BEGIN)
let lastErr = OSLastError() let lastErr = osLastError()
if (status == INVALID_SET_FILE_POINTER and lastErr.int32 != NO_ERROR) or if (status == INVALID_SET_FILE_POINTER and lastErr.int32 != NO_ERROR) or
(SetEndOfFile(result.fHandle) == 0): (setEndOfFile(result.fHandle) == 0):
fail(lastErr, "error setting file size") fail(lastErr, "error setting file size")
# since the strings are always 'nil', we simply always call # since the strings are always 'nil', we simply always call
# CreateFileMappingW which should be slightly faster anyway: # CreateFileMappingW which should be slightly faster anyway:
result.mapHandle = CreateFileMappingW( result.mapHandle = createFileMappingW(
result.fHandle, nil, result.fHandle, nil,
if readonly: PAGE_READONLY else: PAGE_READWRITE, if readonly: PAGE_READONLY else: PAGE_READWRITE,
0, 0, nil) 0, 0, nil)
if result.mapHandle == 0: if result.mapHandle == 0:
fail(OSLastError(), "error creating mapping") fail(osLastError(), "error creating mapping")
result.mem = MapViewOfFileEx( result.mem = mapViewOfFileEx(
result.mapHandle, result.mapHandle,
if readonly: FILE_MAP_READ else: FILE_MAP_WRITE, if readonly: FILE_MAP_READ else: FILE_MAP_WRITE,
int32(offset shr 32), int32(offset shr 32),
@ -107,12 +107,12 @@ proc open*(filename: string, mode: TFileMode = fmRead,
nil) nil)
if result.mem == nil: if result.mem == nil:
fail(OSLastError(), "error mapping view") fail(osLastError(), "error mapping view")
var hi, low: int32 var hi, low: int32
low = GetFileSize(result.fHandle, addr(hi)) low = getFileSize(result.fHandle, addr(hi))
if low == INVALID_FILE_SIZE: if low == INVALID_FILE_SIZE:
fail(OSLastError(), "error getting file size") fail(osLastError(), "error getting file size")
else: else:
var fileSize = (int64(hi) shr 32) or low var fileSize = (int64(hi) shr 32) or low
if mappedSize != -1: result.size = min(fileSize, mappedSize).int if mappedSize != -1: result.size = min(fileSize, mappedSize).int
@ -170,10 +170,10 @@ proc close*(f: var TMemFile) =
when defined(windows): when defined(windows):
if f.fHandle != INVALID_HANDLE_VALUE: if f.fHandle != INVALID_HANDLE_VALUE:
lastErr = OSLastError() lastErr = osLastError()
error = UnmapViewOfFile(f.mem) == 0 error = unmapViewOfFile(f.mem) == 0
error = (CloseHandle(f.mapHandle) == 0) or error error = (closeHandle(f.mapHandle) == 0) or error
error = (CloseHandle(f.fHandle) == 0) or error error = (closeHandle(f.fHandle) == 0) or error
else: else:
if f.handle != 0: if f.handle != 0:
lastErr = OSLastError() lastErr = OSLastError()
@ -189,5 +189,5 @@ proc close*(f: var TMemFile) =
else: else:
f.handle = 0 f.handle = 0
if error: OSError(lastErr) if error: osError(lastErr)

56
lib/pure/os.nim
View file

@ -189,7 +189,7 @@ proc osErrorMsg*(): string {.rtl, extern: "nos$1", deprecated.} =
var err = getLastError() var err = getLastError()
if err != 0'i32: if err != 0'i32:
when useWinUnicode: when useWinUnicode:
var msgbuf: widecstring var msgbuf: WideCString
if formatMessageW(0x00000100 or 0x00001000 or 0x00000200, if formatMessageW(0x00000100 or 0x00001000 or 0x00000200,
nil, err, 0, addr(msgbuf), 0, nil) != 0'i32: nil, err, 0, addr(msgbuf), 0, nil) != 0'i32:
result = $msgbuf result = $msgbuf
@ -237,7 +237,7 @@ proc osErrorMsg*(errorCode: TOSErrorCode): string =
when defined(Windows): when defined(Windows):
if errorCode != TOSErrorCode(0'i32): if errorCode != TOSErrorCode(0'i32):
when useWinUnicode: when useWinUnicode:
var msgbuf: widecstring var msgbuf: WideCString
if formatMessageW(0x00000100 or 0x00001000 or 0x00000200, if formatMessageW(0x00000100 or 0x00001000 or 0x00000200,
nil, errorCode.int32, 0, addr(msgbuf), 0, nil) != 0'i32: nil, errorCode.int32, 0, addr(msgbuf), 0, nil) != 0'i32:
result = $msgbuf result = $msgbuf
@ -282,7 +282,7 @@ proc osLastError*(): TOSErrorCode =
## immediately after an OS call fails. On POSIX systems this is not a problem. ## immediately after an OS call fails. On POSIX systems this is not a problem.
when defined(windows): when defined(windows):
result = TOSErrorCode(GetLastError()) result = TOSErrorCode(getLastError())
else: else:
result = TOSErrorCode(errno) result = TOSErrorCode(errno)
{.pop.} {.pop.}
@ -394,11 +394,11 @@ proc getLastModificationTime*(file: string): TTime {.rtl, extern: "nos$1".} =
if stat(file, res) < 0'i32: osError(osLastError()) if stat(file, res) < 0'i32: osError(osLastError())
return res.st_mtime return res.st_mtime
else: else:
var f: TWIN32_Find_Data var f: TWIN32_FIND_DATA
var h = findFirstFile(file, f) var h = findFirstFile(file, f)
if h == -1'i32: osError(osLastError()) if h == -1'i32: osError(osLastError())
result = winTimeToUnixTime(rdFileTime(f.ftLastWriteTime)) result = winTimeToUnixTime(rdFileTime(f.ftLastWriteTime))
findclose(h) findClose(h)
proc getLastAccessTime*(file: string): TTime {.rtl, extern: "nos$1".} = proc getLastAccessTime*(file: string): TTime {.rtl, extern: "nos$1".} =
## Returns the `file`'s last read or write access time. ## Returns the `file`'s last read or write access time.
@ -407,11 +407,11 @@ proc getLastAccessTime*(file: string): TTime {.rtl, extern: "nos$1".} =
if stat(file, res) < 0'i32: osError(osLastError()) if stat(file, res) < 0'i32: osError(osLastError())
return res.st_atime return res.st_atime
else: else:
var f: TWIN32_Find_Data var f: TWIN32_FIND_DATA
var h = findFirstFile(file, f) var h = findFirstFile(file, f)
if h == -1'i32: osError(osLastError()) if h == -1'i32: osError(osLastError())
result = winTimeToUnixTime(rdFileTime(f.ftLastAccessTime)) result = winTimeToUnixTime(rdFileTime(f.ftLastAccessTime))
findclose(h) findClose(h)
proc getCreationTime*(file: string): TTime {.rtl, extern: "nos$1".} = proc getCreationTime*(file: string): TTime {.rtl, extern: "nos$1".} =
## Returns the `file`'s creation time. ## Returns the `file`'s creation time.
@ -420,11 +420,11 @@ proc getCreationTime*(file: string): TTime {.rtl, extern: "nos$1".} =
if stat(file, res) < 0'i32: osError(osLastError()) if stat(file, res) < 0'i32: osError(osLastError())
return res.st_ctime return res.st_ctime
else: else:
var f: TWIN32_Find_Data var f: TWIN32_FIND_DATA
var h = findFirstFile(file, f) var h = findFirstFile(file, f)
if h == -1'i32: osError(osLastError()) if h == -1'i32: osError(osLastError())
result = winTimeToUnixTime(rdFileTime(f.ftCreationTime)) result = winTimeToUnixTime(rdFileTime(f.ftCreationTime))
findclose(h) findClose(h)
proc fileNewer*(a, b: string): bool {.rtl, extern: "nos$1".} = proc fileNewer*(a, b: string): bool {.rtl, extern: "nos$1".} =
## Returns true if the file `a` is newer than file `b`, i.e. if `a`'s ## Returns true if the file `a` is newer than file `b`, i.e. if `a`'s
@ -670,7 +670,7 @@ proc expandFilename*(filename: string): string {.rtl, extern: "nos$1",
when defined(windows): when defined(windows):
const bufsize = 3072'i32 const bufsize = 3072'i32
when useWinUnicode: when useWinUnicode:
var unused: widecstring var unused: WideCString
var res = newWideCString("", bufsize div 2) var res = newWideCString("", bufsize div 2)
var L = getFullPathNameW(newWideCString(filename), bufsize, res, unused) var L = getFullPathNameW(newWideCString(filename), bufsize, res, unused)
if L <= 0'i32 or L >= bufsize: if L <= 0'i32 or L >= bufsize:
@ -957,7 +957,7 @@ proc copyFile*(source, dest: string) {.rtl, extern: "nos$1",
proc moveFile*(source, dest: string) {.rtl, extern: "nos$1", proc moveFile*(source, dest: string) {.rtl, extern: "nos$1",
tags: [FReadIO, FWriteIO].} = tags: [FReadIO, FWriteIO].} =
## Moves a file from `source` to `dest`. If this fails, `EOS` is raised. ## Moves a file from `source` to `dest`. If this fails, `EOS` is raised.
if crename(source, dest) != 0'i32: if c_rename(source, dest) != 0'i32:
raise newException(EOS, $strerror(errno)) raise newException(EOS, $strerror(errno))
when not defined(ENOENT) and not defined(Windows): when not defined(ENOENT) and not defined(Windows):
@ -1005,7 +1005,7 @@ proc execShellCmd*(command: string): int {.rtl, extern: "nos$1",
## the process has finished. To execute a program without having a ## the process has finished. To execute a program without having a
## shell involved, use the `execProcess` proc of the `osproc` ## shell involved, use the `execProcess` proc of the `osproc`
## module. ## module.
result = csystem(command) result = c_system(command)
# Environment handling cannot be put into RTL, because the ``envPairs`` # Environment handling cannot be put into RTL, because the ``envPairs``
# iterator depends on ``environment``. # iterator depends on ``environment``.
@ -1018,7 +1018,7 @@ when defined(windows):
# because we support Windows GUI applications, things get really # because we support Windows GUI applications, things get really
# messy here... # messy here...
when useWinUnicode: when useWinUnicode:
proc strEnd(cstr: wideCString, c = 0'i32): wideCString {. proc strEnd(cstr: WideCString, c = 0'i32): WideCString {.
importc: "wcschr", header: "<string.h>".} importc: "wcschr", header: "<string.h>".}
else: else:
proc strEnd(cstr: cstring, c = 0'i32): cstring {. proc strEnd(cstr: cstring, c = 0'i32): cstring {.
@ -1035,9 +1035,9 @@ when defined(windows):
while True: while True:
var eend = strEnd(e) var eend = strEnd(e)
add(environment, $e) add(environment, $e)
e = cast[wideCString](cast[TAddress](eend)+2) e = cast[WideCString](cast[TAddress](eend)+2)
if eend[1].int == 0: break if eend[1].int == 0: break
discard FreeEnvironmentStringsW(env) discard freeEnvironmentStringsW(env)
else: else:
var var
env = getEnvironmentStringsA() env = getEnvironmentStringsA()
@ -1099,14 +1099,14 @@ proc getEnv*(key: string): TaintedString {.tags: [FReadEnv].} =
if i >= 0: if i >= 0:
return TaintedString(substr(environment[i], find(environment[i], '=')+1)) return TaintedString(substr(environment[i], find(environment[i], '=')+1))
else: else:
var env = cgetenv(key) var env = c_getenv(key)
if env == nil: return TaintedString("") if env == nil: return TaintedString("")
result = TaintedString($env) result = TaintedString($env)
proc existsEnv*(key: string): bool {.tags: [FReadEnv].} = proc existsEnv*(key: string): bool {.tags: [FReadEnv].} =
## Checks whether the environment variable named `key` exists. ## Checks whether the environment variable named `key` exists.
## Returns true if it exists, false otherwise. ## Returns true if it exists, false otherwise.
if cgetenv(key) != nil: return true if c_getenv(key) != nil: return true
else: return findEnvVar(key) >= 0 else: return findEnvVar(key) >= 0
proc putEnv*(key, val: string) {.tags: [FWriteEnv].} = proc putEnv*(key, val: string) {.tags: [FWriteEnv].} =
@ -1152,15 +1152,15 @@ iterator walkFiles*(pattern: string): string {.tags: [FReadDir].} =
## notation is supported. ## notation is supported.
when defined(windows): when defined(windows):
var var
f: TWin32FindData f: TWIN32_FIND_DATA
res: int res: int
res = findfirstFile(pattern, f) res = findFirstFile(pattern, f)
if res != -1: if res != -1:
while true: while true:
if not skipFindData(f): if not skipFindData(f):
yield splitFile(pattern).dir / extractFilename(getFilename(f)) yield splitFile(pattern).dir / extractFilename(getFilename(f))
if findnextFile(res, f) == 0'i32: break if findnextFile(res, f) == 0'i32: break
findclose(res) findClose(res)
else: # here we use glob else: # here we use glob
var var
f: TGlob f: TGlob
@ -1205,8 +1205,8 @@ iterator walkDir*(dir: string): tuple[kind: TPathComponent, path: string] {.
## dirA/fileA1.txt ## dirA/fileA1.txt
## dirA/fileA2.txt ## dirA/fileA2.txt
when defined(windows): when defined(windows):
var f: TWIN32_Find_Data var f: TWIN32_FIND_DATA
var h = findfirstFile(dir / "*", f) var h = findFirstFile(dir / "*", f)
if h != -1: if h != -1:
while true: while true:
var k = pcFile var k = pcFile
@ -1215,7 +1215,7 @@ iterator walkDir*(dir: string): tuple[kind: TPathComponent, path: string] {.
k = pcDir k = pcDir
yield (k, dir / extractFilename(getFilename(f))) yield (k, dir / extractFilename(getFilename(f)))
if findnextFile(h, f) == 0'i32: break if findnextFile(h, f) == 0'i32: break
findclose(h) findClose(h)
else: else:
var d = openDir(dir) var d = openDir(dir)
if d != nil: if d != nil:
@ -1553,7 +1553,7 @@ proc getAppFilename*(): string {.rtl, extern: "nos$1", tags: [FReadIO].} =
# /proc/<pid>/file # /proc/<pid>/file
when defined(windows): when defined(windows):
when useWinUnicode: when useWinUnicode:
var buf = cast[wideCString](alloc(256*2)) var buf = cast[WideCString](alloc(256*2))
var len = getModuleFileNameW(0, buf, 256) var len = getModuleFileNameW(0, buf, 256)
result = buf$len result = buf$len
else: else:
@ -1614,15 +1614,15 @@ proc sleep*(milsecs: int) {.rtl, extern: "nos$1", tags: [FTime].} =
a.tv_nsec = (milsecs mod 1000) * 1000 * 1000 a.tv_nsec = (milsecs mod 1000) * 1000 * 1000
discard posix.nanosleep(a, b) discard posix.nanosleep(a, b)
proc getFileSize*(file: string): biggestInt {.rtl, extern: "nos$1", proc getFileSize*(file: string): BiggestInt {.rtl, extern: "nos$1",
tags: [FReadIO].} = tags: [FReadIO].} =
## returns the file size of `file`. Can raise ``EOS``. ## returns the file size of `file`. Can raise ``EOS``.
when defined(windows): when defined(windows):
var a: TWin32FindData var a: TWIN32_FIND_DATA
var resA = findfirstFile(file, a) var resA = findFirstFile(file, a)
if resA == -1: osError(osLastError()) if resA == -1: osError(osLastError())
result = rdFileSize(a) result = rdFileSize(a)
findclose(resA) findClose(resA)
else: else:
var f: TFile var f: TFile
if open(f, file): if open(f, file):

84
lib/pure/osproc.nim
View file

@ -23,7 +23,7 @@ else:
type type
TProcess = object of TObject TProcess = object of TObject
when defined(windows): when defined(windows):
FProcessHandle: Thandle FProcessHandle: THandle
inHandle, outHandle, errHandle: TFileHandle inHandle, outHandle, errHandle: TFileHandle
id: THandle id: THandle
else: else:
@ -108,7 +108,7 @@ proc execCmd*(command: string): int {.rtl, extern: "nosp$1", tags: [FExecIO].}
proc startProcess*(command: string, proc startProcess*(command: string,
workingDir: string = "", workingDir: string = "",
args: openarray[string] = [], args: openArray[string] = [],
env: PStringTable = nil, env: PStringTable = nil,
options: set[TProcessOption] = {poStdErrToStdOut}): options: set[TProcessOption] = {poStdErrToStdOut}):
PProcess {.rtl, extern: "nosp$1", tags: [FExecIO, FReadEnv].} PProcess {.rtl, extern: "nosp$1", tags: [FExecIO, FReadEnv].}
@ -219,7 +219,7 @@ proc countProcessors*(): int {.rtl, extern: "nosp$1".} =
## returns the numer of the processors/cores the machine has. ## returns the numer of the processors/cores the machine has.
## Returns 0 if it cannot be detected. ## Returns 0 if it cannot be detected.
when defined(windows): when defined(windows):
var x = getenv("NUMBER_OF_PROCESSORS") var x = getEnv("NUMBER_OF_PROCESSORS")
if x.len > 0: result = parseInt(x.string) if x.len > 0: result = parseInt(x.string)
elif defined(macosx) or defined(bsd): elif defined(macosx) or defined(bsd):
var var
@ -358,7 +358,7 @@ when defined(Windows) and not defined(useNimRtl):
result.readDataImpl = hsReadData result.readDataImpl = hsReadData
result.writeDataImpl = hsWriteData result.writeDataImpl = hsWriteData
proc buildCommandLine(a: string, args: openarray[string]): cstring = proc buildCommandLine(a: string, args: openArray[string]): cstring =
var res = quoteShell(a) var res = quoteShell(a)
for i in 0..high(args): for i in 0..high(args):
res.add(' ') res.add(' ')
@ -384,11 +384,11 @@ when defined(Windows) and not defined(useNimRtl):
# O_RDONLY {.importc: "_O_RDONLY", header: "<fcntl.h>".}: int # O_RDONLY {.importc: "_O_RDONLY", header: "<fcntl.h>".}: int
proc createPipeHandles(Rdhandle, WrHandle: var THandle) = proc createPipeHandles(Rdhandle, WrHandle: var THandle) =
var piInheritablePipe: TSecurityAttributes var piInheritablePipe: TSECURITY_ATTRIBUTES
piInheritablePipe.nlength = SizeOf(TSecurityAttributes).cint piInheritablePipe.nlength = sizeof(TSECURITY_ATTRIBUTES).cint
piInheritablePipe.lpSecurityDescriptor = nil piInheritablePipe.lpSecurityDescriptor = nil
piInheritablePipe.Binherithandle = 1 piInheritablePipe.Binherithandle = 1
if createPipe(Rdhandle, Wrhandle, piInheritablePipe, 1024) == 0'i32: if createPipe(Rdhandle, WrHandle, piInheritablePipe, 1024) == 0'i32:
osError(osLastError()) osError(osLastError())
proc fileClose(h: THandle) {.inline.} = proc fileClose(h: THandle) {.inline.} =
@ -400,28 +400,28 @@ when defined(Windows) and not defined(useNimRtl):
env: PStringTable = nil, env: PStringTable = nil,
options: set[TProcessOption] = {poStdErrToStdOut}): PProcess = options: set[TProcessOption] = {poStdErrToStdOut}): PProcess =
var var
si: TStartupInfo si: TSTARTUPINFO
procInfo: TProcessInformation procInfo: TPROCESS_INFORMATION
success: int success: int
hi, ho, he: THandle hi, ho, he: THandle
new(result) new(result)
SI.cb = SizeOf(SI).cint si.cb = sizeof(si).cint
if poParentStreams notin options: if poParentStreams notin options:
SI.dwFlags = STARTF_USESTDHANDLES # STARTF_USESHOWWINDOW or si.dwFlags = STARTF_USESTDHANDLES # STARTF_USESHOWWINDOW or
CreatePipeHandles(SI.hStdInput, HI) createPipeHandles(si.hStdInput, hi)
CreatePipeHandles(HO, Si.hStdOutput) createPipeHandles(ho, si.hStdOutput)
if poStdErrToStdOut in options: if poStdErrToStdOut in options:
SI.hStdError = SI.hStdOutput si.hStdError = si.hStdOutput
HE = HO he = ho
else: else:
CreatePipeHandles(HE, Si.hStdError) createPipeHandles(he, si.hStdError)
result.inHandle = TFileHandle(hi) result.inHandle = TFileHandle(hi)
result.outHandle = TFileHandle(ho) result.outHandle = TFileHandle(ho)
result.errHandle = TFileHandle(he) result.errHandle = TFileHandle(he)
else: else:
SI.hStdError = GetStdHandle(STD_ERROR_HANDLE) si.hStdError = getStdHandle(STD_ERROR_HANDLE)
SI.hStdInput = GetStdHandle(STD_INPUT_HANDLE) si.hStdInput = getStdHandle(STD_INPUT_HANDLE)
SI.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE) si.hStdOutput = getStdHandle(STD_OUTPUT_HANDLE)
result.inHandle = TFileHandle(si.hStdInput) result.inHandle = TFileHandle(si.hStdInput)
result.outHandle = TFileHandle(si.hStdOutput) result.outHandle = TFileHandle(si.hStdOutput)
result.errHandle = TFileHandle(si.hStdError) result.errHandle = TFileHandle(si.hStdError)
@ -442,17 +442,17 @@ when defined(Windows) and not defined(useNimRtl):
var wwd = newWideCString(wd) var wwd = newWideCString(wd)
success = winlean.CreateProcessW(nil, success = winlean.CreateProcessW(nil,
tmp, nil, nil, 1, NORMAL_PRIORITY_CLASS or CREATE_UNICODE_ENVIRONMENT, tmp, nil, nil, 1, NORMAL_PRIORITY_CLASS or CREATE_UNICODE_ENVIRONMENT,
ee, wwd, SI, ProcInfo) ee, wwd, si, procInfo)
else: else:
success = winlean.CreateProcessA(nil, success = winlean.CreateProcessA(nil,
cmdl, nil, nil, 1, NORMAL_PRIORITY_CLASS, e, wd, SI, ProcInfo) cmdl, nil, nil, 1, NORMAL_PRIORITY_CLASS, e, wd, SI, ProcInfo)
let lastError = osLastError() let lastError = osLastError()
if poParentStreams notin options: if poParentStreams notin options:
FileClose(si.hStdInput) fileClose(si.hStdInput)
FileClose(si.hStdOutput) fileClose(si.hStdOutput)
if poStdErrToStdOut notin options: if poStdErrToStdOut notin options:
FileClose(si.hStdError) fileClose(si.hStdError)
if e != nil: dealloc(e) if e != nil: dealloc(e)
dealloc(cmdl) dealloc(cmdl)
@ -471,10 +471,10 @@ when defined(Windows) and not defined(useNimRtl):
discard CloseHandle(p.FProcessHandle) discard CloseHandle(p.FProcessHandle)
proc suspend(p: PProcess) = proc suspend(p: PProcess) =
discard SuspendThread(p.FProcessHandle) discard suspendThread(p.FProcessHandle)
proc resume(p: PProcess) = proc resume(p: PProcess) =
discard ResumeThread(p.FProcessHandle) discard resumeThread(p.FProcessHandle)
proc running(p: PProcess): bool = proc running(p: PProcess): bool =
var x = waitForSingleObject(p.FProcessHandle, 50) var x = waitForSingleObject(p.FProcessHandle, 50)
@ -482,22 +482,22 @@ when defined(Windows) and not defined(useNimRtl):
proc terminate(p: PProcess) = proc terminate(p: PProcess) =
if running(p): if running(p):
discard TerminateProcess(p.FProcessHandle, 0) discard terminateProcess(p.FProcessHandle, 0)
proc waitForExit(p: PProcess, timeout: int = -1): int = proc waitForExit(p: PProcess, timeout: int = -1): int =
discard WaitForSingleObject(p.FProcessHandle, timeout.int32) discard waitForSingleObject(p.FProcessHandle, timeout.int32)
var res: int32 var res: int32
discard GetExitCodeProcess(p.FProcessHandle, res) discard getExitCodeProcess(p.FProcessHandle, res)
result = res result = res
discard CloseHandle(p.FProcessHandle) discard closeHandle(p.FProcessHandle)
proc peekExitCode(p: PProcess): int = proc peekExitCode(p: PProcess): int =
var b = waitForSingleObject(p.FProcessHandle, 50) == WAIT_TIMEOUT var b = waitForSingleObject(p.FProcessHandle, 50) == WAIT_TIMEOUT
if b: result = -1 if b: result = -1
else: else:
var res: int32 var res: int32
discard GetExitCodeProcess(p.FProcessHandle, res) discard getExitCodeProcess(p.FProcessHandle, res)
return res return res
proc inputStream(p: PProcess): PStream = proc inputStream(p: PProcess): PStream =
@ -511,32 +511,32 @@ when defined(Windows) and not defined(useNimRtl):
proc execCmd(command: string): int = proc execCmd(command: string): int =
var var
si: TStartupInfo si: TSTARTUPINFO
procInfo: TProcessInformation procInfo: TPROCESS_INFORMATION
process: THandle process: THandle
L: int32 L: int32
SI.cb = SizeOf(SI).cint si.cb = sizeof(si).cint
SI.hStdError = GetStdHandle(STD_ERROR_HANDLE) si.hStdError = getStdHandle(STD_ERROR_HANDLE)
SI.hStdInput = GetStdHandle(STD_INPUT_HANDLE) si.hStdInput = getStdHandle(STD_INPUT_HANDLE)
SI.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE) si.hStdOutput = getStdHandle(STD_OUTPUT_HANDLE)
when useWinUnicode: when useWinUnicode:
var c = newWideCString(command) var c = newWideCString(command)
var res = winlean.CreateProcessW(nil, c, nil, nil, 0, var res = winlean.CreateProcessW(nil, c, nil, nil, 0,
NORMAL_PRIORITY_CLASS, nil, nil, SI, ProcInfo) NORMAL_PRIORITY_CLASS, nil, nil, si, procInfo)
else: else:
var res = winlean.CreateProcessA(nil, command, nil, nil, 0, var res = winlean.CreateProcessA(nil, command, nil, nil, 0,
NORMAL_PRIORITY_CLASS, nil, nil, SI, ProcInfo) NORMAL_PRIORITY_CLASS, nil, nil, SI, ProcInfo)
if res == 0: if res == 0:
osError(osLastError()) osError(osLastError())
else: else:
Process = ProcInfo.hProcess process = procInfo.hProcess
discard CloseHandle(ProcInfo.hThread) discard closeHandle(procInfo.hThread)
if WaitForSingleObject(Process, INFINITE) != -1: if waitForSingleObject(process, INFINITE) != -1:
discard GetExitCodeProcess(Process, L) discard getExitCodeProcess(process, L)
result = int(L) result = int(L)
else: else:
result = -1 result = -1
discard CloseHandle(Process) discard closeHandle(process)
proc select(readfds: var seq[PProcess], timeout = 500): int = proc select(readfds: var seq[PProcess], timeout = 500): int =
assert readfds.len <= MAXIMUM_WAIT_OBJECTS assert readfds.len <= MAXIMUM_WAIT_OBJECTS

6
lib/pure/parseopt.nim
View file

@ -50,7 +50,7 @@ when defined(os.ParamCount):
result.cmd = cmdline result.cmd = cmdline
else: else:
result.cmd = "" result.cmd = ""
for i in countup(1, ParamCount()): for i in countup(1, paramCount()):
result.cmd = result.cmd & quoteIfContainsWhite(paramStr(i).string) & ' ' result.cmd = result.cmd & quoteIfContainsWhite(paramStr(i).string) & ' '
result.kind = cmdEnd result.kind = cmdEnd
result.key = TaintedString"" result.key = TaintedString""
@ -94,8 +94,8 @@ proc next*(p: var TOptParser) {.
var i = p.pos var i = p.pos
while p.cmd[i] in {'\x09', ' '}: inc(i) while p.cmd[i] in {'\x09', ' '}: inc(i)
p.pos = i p.pos = i
setlen(p.key.string, 0) setLen(p.key.string, 0)
setlen(p.val.string, 0) setLen(p.val.string, 0)
if p.inShortState: if p.inShortState:
handleShortOption(p) handleShortOption(p)
return return

Some files were not shown because too many files have changed in this diff Show more