got rid of some arcane module names

34 files changed, 326 insertions, 1257 deletions

diff --git a/compiler/c2nim/c2nim.nim b/compiler/c2nim/c2nim.nim
index f4e185445..beb4465fc 100755
--- a/compiler/c2nim/c2nim.nim
+++ b/compiler/c2nim/c2nim.nim
@@ -8,7 +8,7 @@
 #
 
 import 
-  strutils, os, times, parseopt, llstream, ast, rnimsyn, options, msgs,
+  strutils, os, times, parseopt, llstream, ast, renderer, options, msgs,
   clex, cparse
 
 const
diff --git a/compiler/c2nim/cparse.nim b/compiler/c2nim/cparse.nim
index ce9caf7f5..d2b7caff6 100755
--- a/compiler/c2nim/cparse.nim
+++ b/compiler/c2nim/cparse.nim
@@ -14,7 +14,7 @@
 # XXX cleanup of declaration handling.
 
 import 
-  os, llstream, rnimsyn, clex, idents, strutils, pegs, ast, astalgo, msgs,
+  os, llstream, renderer, clex, idents, strutils, pegs, ast, astalgo, msgs,
   options, strtabs
 
 type 
diff --git a/compiler/cgen.nim b/compiler/cgen.nim
index a15c4c4ca..d76793c9a 100755
--- a/compiler/cgen.nim
+++ b/compiler/cgen.nim
@@ -14,7 +14,7 @@ import
   ast, astalgo, strutils, nhashes, trees, platform, magicsys, extccomp,
   options, 
   nversion, nimsets, msgs, crc, bitsets, idents, lists, types, ccgutils, os, 
-  times, ropes, math, passes, rodread, wordrecg, rnimsyn, treetab, cgmeth,
+  times, ropes, math, passes, rodread, wordrecg, treetab, cgmeth,
   rodutils
 
 when options.hasTinyCBackend:
diff --git a/compiler/cgmeth.nim b/compiler/cgmeth.nim
index f9b12647f..12d58cdc1 100755
--- a/compiler/cgmeth.nim
+++ b/compiler/cgmeth.nim
@@ -10,7 +10,7 @@
 ## This module implements code generation for multi methods.
 
 import 
-  options, ast, astalgo, msgs, idents, rnimsyn, types, magicsys
+  options, ast, astalgo, msgs, idents, renderer, types, magicsys
 
 proc genConv(n: PNode, d: PType, downcast: bool): PNode = 
   var 
diff --git a/compiler/docgen.nim b/compiler/docgen.nim
index ed5ca20ed..74316871d 100755
--- a/compiler/docgen.nim
+++ b/compiler/docgen.nim
@@ -13,7 +13,7 @@
 
 import 
   ast, astalgo, strutils, nhashes, options, nversion, msgs, os, ropes, idents, 
-  wordrecg, math, syntaxes, rnimsyn, scanner, rst, times, highlite
+  wordrecg, math, syntaxes, renderer, lexer, rst, times, highlite
 
 proc CommandDoc*(filename: string)
 proc CommandRst2Html*(filename: string)
diff --git a/compiler/ecmasgen.nim b/compiler/ecmasgen.nim
index 6898b01d1..a46c2b805 100755
--- a/compiler/ecmasgen.nim
+++ b/compiler/ecmasgen.nim
@@ -14,7 +14,7 @@
 import 
   ast, astalgo, strutils, nhashes, trees, platform, magicsys, extccomp,
   options, nversion, nimsets, msgs, crc, bitsets, idents, lists, types, os,
-  times, ropes, math, passes, ccgutils, wordrecg, rnimsyn, rodread, rodutils
+  times, ropes, math, passes, ccgutils, wordrecg, renderer, rodread, rodutils
 
 proc ecmasgenPass*(): TPass
 # implementation
diff --git a/compiler/evals.nim b/compiler/evals.nim
index 7d0f9c801..d9c577367 100755
--- a/compiler/evals.nim
+++ b/compiler/evals.nim
@@ -15,7 +15,7 @@
 
 import 
   strutils, magicsys, lists, options, ast, astalgo, trees, treetab, nimsets, 
-  msgs, os, condsyms, idents, rnimsyn, types, passes, semfold
+  msgs, os, condsyms, idents, renderer, types, passes, semfold
 
 type 
   PStackFrame* = ref TStackFrame
diff --git a/compiler/ptmplsyn.nim b/compiler/filter_tmpl.nim
index 9699f1c58..0bb402874 100755
--- a/compiler/ptmplsyn.nim
+++ b/compiler/filter_tmpl.nim
@@ -11,7 +11,7 @@
 
 import 
   llstream, os, wordrecg, idents, strutils, ast, astalgo, msgs, options, 
-  rnimsyn, filters
+  renderer, filters
 
 proc filterTmpl*(stdin: PLLStream, filename: string, call: PNode): PLLStream
   # #! template(subsChar='$', metaChar='#') | standard(version="0.7.2")
diff --git a/compiler/filters.nim b/compiler/filters.nim
index d1c61749d..43ac13c00 100755
--- a/compiler/filters.nim
+++ b/compiler/filters.nim
@@ -10,7 +10,8 @@
 # This module implements Nimrod's simple filters and helpers for filters.
 
 import
-  llstream, os, wordrecg, idents, strutils, ast, astalgo, msgs, options, rnimsyn
+  llstream, os, wordrecg, idents, strutils, ast, astalgo, msgs, options, 
+  renderer
 
 proc filterReplace*(stdin: PLLStream, filename: string, call: PNode): PLLStream
 proc filterStrip*(stdin: PLLStream, filename: string, call: PNode): PLLStream
diff --git a/compiler/highlite.nim b/compiler/highlite.nim
index c2fc95da8..c343074e7 100755
--- a/compiler/highlite.nim
+++ b/compiler/highlite.nim
@@ -12,7 +12,7 @@
 # The interface supports one language nested in another.
 
 import 
-  nhashes, options, msgs, strutils, platform, idents, lexbase, wordrecg, scanner
+  nhashes, options, msgs, strutils, platform, idents, lexbase, wordrecg, lexer
 
 type 
   TTokenClass* = enum 
@@ -154,7 +154,7 @@ proc nimNextToken(g: var TGeneralTokenizer) =
       while not (g.buf[pos] in {'\0', '\x0A', '\x0D'}): inc(pos)
     of 'a'..'z', 'A'..'Z', '_', '\x80'..'\xFF': 
       var id = ""
-      while g.buf[pos] in scanner.SymChars + {'_'}: 
+      while g.buf[pos] in lexer.SymChars + {'_'}: 
         add(id, g.buf[pos])
         inc(pos)
       if (g.buf[pos] == '\"'): 
@@ -247,9 +247,9 @@ proc nimNextToken(g: var TGeneralTokenizer) =
     of '\0': 
       g.kind = gtEof
     else: 
-      if g.buf[pos] in scanner.OpChars: 
+      if g.buf[pos] in lexer.OpChars: 
         g.kind = gtOperator
-        while g.buf[pos] in scanner.OpChars: inc(pos)
+        while g.buf[pos] in lexer.OpChars: inc(pos)
       else: 
         inc(pos)
         g.kind = gtNone
@@ -462,10 +462,10 @@ proc clikeNextToken(g: var TGeneralTokenizer, keywords: openarray[string],
     of '\0': 
       g.kind = gtEof
     else: 
-      if g.buf[pos] in scanner.OpChars: 
+      if g.buf[pos] in lexer.OpChars: 
         g.kind = gtOperator
-        while g.buf[pos] in scanner.OpChars: inc(pos)
-      else: 
+        while g.buf[pos] in lexer.OpChars: inc(pos)
+      else:
         inc(pos)
         g.kind = gtNone
   g.length = pos - g.pos
diff --git a/compiler/scanner.nim b/compiler/lexer.nim
index f3d83480d..f3d83480d 100755
--- a/compiler/scanner.nim
+++ b/compiler/lexer.nim
diff --git a/compiler/lookups.nim b/compiler/lookups.nim
index f65fe24b7..80a6cd17e 100755
--- a/compiler/lookups.nim
+++ b/compiler/lookups.nim
@@ -10,7 +10,7 @@
 # This module implements lookup helpers.
 
 import 
-  ast, astalgo, idents, semdata, types, msgs, options, rodread, rnimsyn
+  ast, astalgo, idents, semdata, types, msgs, options, rodread, renderer
 
 type 
   TOverloadIterMode* = enum 
diff --git a/compiler/main.nim b/compiler/main.nim
index bd429cad9..c43d35a96 100755
--- a/compiler/main.nim
+++ b/compiler/main.nim
@@ -11,7 +11,7 @@
 # module handling
 
 import 
-  llstream, strutils, ast, astalgo, scanner, syntaxes, rnimsyn, options, msgs, 
+  llstream, strutils, ast, astalgo, lexer, syntaxes, renderer, options, msgs, 
   os, lists, condsyms, rodread, rodwrite, ropes, trees, 
   wordrecg, sem, semdata, idents, passes, docgen, extccomp,
   cgen, ecmasgen,
diff --git a/compiler/nimconf.nim b/compiler/nimconf.nim
index 31558fe74..5d549c0f4 100755
--- a/compiler/nimconf.nim
+++ b/compiler/nimconf.nim
@@ -10,7 +10,7 @@
 # This module handles the reading of the config file.
 
 import 
-  llstream, nversion, commands, os, strutils, msgs, platform, condsyms, scanner, 
+  llstream, nversion, commands, os, strutils, msgs, platform, condsyms, lexer, 
   options, idents, wordrecg
 
 # ---------------- configuration file parser -----------------------------
diff --git a/compiler/nimrod.nim b/compiler/nimrod.nim
index a1751da7f..05c7a2af1 100755
--- a/compiler/nimrod.nim
+++ b/compiler/nimrod.nim
@@ -11,7 +11,7 @@ when defined(gcc) and defined(windows):
   {.link: "icons/nimrod.res".}
 
 import 
-  times, commands, scanner, condsyms, options, msgs, nversion, nimconf, ropes, 
+  times, commands, lexer, condsyms, options, msgs, nversion, nimconf, ropes, 
   extccomp, strutils, os, platform, main, parseopt
 
 when hasTinyCBackend:
diff --git a/compiler/nimsets.nim b/compiler/nimsets.nim
index 337aedda9..218cd8b62 100755
--- a/compiler/nimsets.nim
+++ b/compiler/nimsets.nim
@@ -10,7 +10,7 @@
 # this unit handles Nimrod sets; it implements symbolic sets
 
 import 
-  ast, astalgo, trees, nversion, msgs, platform, bitsets, types, rnimsyn
+  ast, astalgo, trees, nversion, msgs, platform, bitsets, types, renderer
 
 proc toBitSet*(s: PNode, b: var TBitSet)
   # this function is used for case statement checking:
@@ -172,4 +172,4 @@ proc SetHasRange(s: PNode): bool =
 
 proc emptyRange(a, b: PNode): bool = 
   result = not leValue(a, b)  # a > b iff not (a <= b)
-  
\ No newline at end of file
+  
diff --git a/compiler/pnimsyn.nim b/compiler/parser.nim
index 80adc7824..871f486fc 100755
--- a/compiler/pnimsyn.nim
+++ b/compiler/parser.nim
@@ -15,7 +15,7 @@
 # from the grammar and how comments belong to the AST.
 
 import
-  llstream, scanner, idents, strutils, ast, msgs
+  llstream, lexer, idents, strutils, ast, msgs
 
 type 
   TParser*{.final.} = object  # a TParser object represents a module that
diff --git a/compiler/pas2nim/pas2nim.nim b/compiler/pas2nim/pas2nim.nim
index 5c7b68857..7f66e8e47 100755
--- a/compiler/pas2nim/pas2nim.nim
+++ b/compiler/pas2nim/pas2nim.nim
@@ -8,7 +8,7 @@
 #
 
 import 
-  strutils, os, parseopt, llstream, ast, rnimsyn, options, msgs,
+  strutils, os, parseopt, llstream, ast, renderer, options, msgs,
   paslex, pasparse
 
 const
diff --git a/compiler/passes.nim b/compiler/passes.nim
index b380cd66f..34e2b03a5 100755
--- a/compiler/passes.nim
+++ b/compiler/passes.nim
@@ -12,8 +12,8 @@
 
 import 
   strutils, lists, options, ast, astalgo, llstream, msgs, platform, os, 
-  condsyms, idents, rnimsyn, types, extccomp, math, magicsys, nversion, nimsets, 
-  syntaxes, times, rodread
+  condsyms, idents, renderer, types, extccomp, math, magicsys, nversion, 
+  nimsets, syntaxes, times, rodread
 
 type 
   TPassContext* = object of TObject # the pass's context
diff --git a/compiler/pbraces.nim b/compiler/pbraces.nim
index 45d38e342..18d654d6c 100755
--- a/compiler/pbraces.nim
+++ b/compiler/pbraces.nim
@@ -8,1194 +8,11 @@
 #
 
 import 
-  llstream, scanner, idents, strutils, ast, msgs, pnimsyn
+  llstream, lexer, parser, idents, strutils, ast, msgs
 
-proc ParseAll*(p: var TParser): PNode
-proc parseTopLevelStmt*(p: var TParser): PNode
-  # implements an iterator. Returns the next top-level statement or nil if end
-  # of stream.
-# implementation
-# ------------------- Expression parsing ------------------------------------
-
-proc parseExpr(p: var TParser): PNode
-proc parseStmt(p: var TParser): PNode
-proc parseTypeDesc(p: var TParser): PNode
-proc parseParamList(p: var TParser): PNode
-proc optExpr(p: var TParser): PNode = 
-  # [expr]
-  if (p.tok.tokType != tkComma) and (p.tok.tokType != tkBracketRi) and
-      (p.tok.tokType != tkDotDot): 
-    result = parseExpr(p)
-  else: 
-    result = nil
-  
-proc dotdotExpr(p: var TParser, first: PNode = nil): PNode = 
-  result = newNodeP(nkRange, p)
-  addSon(result, first)
-  getTok(p)
-  optInd(p, result)
-  addSon(result, optExpr(p))
-
-proc indexExpr(p: var TParser): PNode = 
-  # indexExpr ::= '..' [expr] | expr ['=' expr | '..' expr]
-  var a, b: PNode
-  if p.tok.tokType == tkDotDot: 
-    result = dotdotExpr(p)
-  else: 
-    a = parseExpr(p)
-    case p.tok.tokType
-    of tkEquals: 
-      result = newNodeP(nkExprEqExpr, p)
-      addSon(result, a)
-      getTok(p)
-      if p.tok.tokType == tkDotDot: 
-        addSon(result, dotdotExpr(p))
-      else: 
-        b = parseExpr(p)
-        if p.tok.tokType == tkDotDot: b = dotdotExpr(p, b)
-        addSon(result, b)
-    of tkDotDot: 
-      result = dotdotExpr(p, a)
-    else: result = a
-  
-proc indexExprList(p: var TParser, first: PNode): PNode = 
-  var a: PNode
-  result = newNodeP(nkBracketExpr, p)
-  addSon(result, first)
-  getTok(p)
-  optInd(p, result)
-  while (p.tok.tokType != tkBracketRi) and (p.tok.tokType != tkEof) and
-      (p.tok.tokType != tkSad): 
-    a = indexExpr(p)
-    addSon(result, a)
-    if p.tok.tokType != tkComma: break 
-    getTok(p)
-    optInd(p, a)
-  optPar(p)
-  eat(p, tkBracketRi)
-
-proc exprColonEqExpr(p: var TParser, kind: TNodeKind, tok: TTokType): PNode = 
-  var a: PNode
-  a = parseExpr(p)
-  if p.tok.tokType == tok: 
-    result = newNodeP(kind, p)
-    getTok(p)                 #optInd(p, result);
-    addSon(result, a)
-    addSon(result, parseExpr(p))
-  else: 
-    result = a
-  
-proc exprListAux(p: var TParser, elemKind: TNodeKind, endTok, sepTok: TTokType, 
-                 result: PNode) = 
-  var a: PNode
-  getTok(p)
-  optInd(p, result)
-  while (p.tok.tokType != endTok) and (p.tok.tokType != tkEof): 
-    a = exprColonEqExpr(p, elemKind, sepTok)
-    addSon(result, a)
-    if p.tok.tokType != tkComma: break 
-    getTok(p)
-    optInd(p, a)
-  eat(p, endTok)
-
-proc qualifiedIdent(p: var TParser): PNode = 
-  var a: PNode
-  result = parseSymbol(p)
-  if p.tok.tokType == tkDot: 
-    getTok(p)
-    optInd(p, result)
-    a = result
-    result = newNodeI(nkDotExpr, a.info)
-    addSon(result, a)
-    addSon(result, parseSymbol(p))
-
-proc qualifiedIdentListAux(p: var TParser, endTok: TTokType, result: PNode) = 
-  var a: PNode
-  getTok(p)
-  optInd(p, result)
-  while (p.tok.tokType != endTok) and (p.tok.tokType != tkEof): 
-    a = qualifiedIdent(p)
-    addSon(result, a)
-    if p.tok.tokType != tkComma: break 
-    getTok(p)
-    optInd(p, a)
-  eat(p, endTok)
-
-proc exprColonEqExprListAux(p: var TParser, elemKind: TNodeKind, 
-                            endTok, sepTok: TTokType, result: PNode) = 
-  var a: PNode
-  getTok(p)
-  optInd(p, result)
-  while (p.tok.tokType != endTok) and (p.tok.tokType != tkEof) and
-      (p.tok.tokType != tkSad): 
-    a = exprColonEqExpr(p, elemKind, sepTok)
-    addSon(result, a)
-    if p.tok.tokType != tkComma: break 
-    getTok(p)
-    optInd(p, a)
-  optPar(p)
-  eat(p, endTok)
-
-proc exprColonEqExprList(p: var TParser, kind, elemKind: TNodeKind, 
-                         endTok, sepTok: TTokType): PNode = 
-  result = newNodeP(kind, p)
-  exprColonEqExprListAux(p, elemKind, endTok, sepTok, result)
-
-proc parseCast(p: var TParser): PNode = 
-  result = newNodeP(nkCast, p)
-  getTok(p)
-  eat(p, tkBracketLe)
-  optInd(p, result)
-  addSon(result, parseTypeDesc(p))
-  optPar(p)
-  eat(p, tkBracketRi)
-  eat(p, tkParLe)
-  optInd(p, result)
-  addSon(result, parseExpr(p))
-  optPar(p)
-  eat(p, tkParRi)
-
-proc parseAddr(p: var TParser): PNode = 
-  result = newNodeP(nkAddr, p)
-  getTok(p)
-  eat(p, tkParLe)
-  optInd(p, result)
-  addSon(result, parseExpr(p))
-  optPar(p)
-  eat(p, tkParRi)
-  
-proc parseGStrLit(p: var TParser, a: PNode): PNode = 
-  case p.tok.tokType
-  of tkGStrLit: 
-    result = newNodeP(nkCallStrLit, p)
-    addSon(result, a)
-    addSon(result, newStrNodeP(nkRStrLit, p.tok.literal, p))
-    getTok(p)
-  of tkGTripleStrLit: 
-    result = newNodeP(nkCallStrLit, p)
-    addSon(result, a)
-    addSon(result, newStrNodeP(nkTripleStrLit, p.tok.literal, p))
-    getTok(p)
-  else:
-    result = a
-
-proc identOrLiteral(p: var TParser): PNode = 
-  case p.tok.tokType
-  of tkSymbol: 
-    result = newIdentNodeP(p.tok.ident, p)
-    getTok(p)
-    result = parseGStrLit(p, result)
-  of tkAccent: 
-    result = accExpr(p)       # literals
-  of tkIntLit: 
-    result = newIntNodeP(nkIntLit, p.tok.iNumber, p)
-    setBaseFlags(result, p.tok.base)
-    getTok(p)
-  of tkInt8Lit: 
-    result = newIntNodeP(nkInt8Lit, p.tok.iNumber, p)
-    setBaseFlags(result, p.tok.base)
-    getTok(p)
-  of tkInt16Lit: 
-    result = newIntNodeP(nkInt16Lit, p.tok.iNumber, p)
-    setBaseFlags(result, p.tok.base)
-    getTok(p)
-  of tkInt32Lit: 
-    result = newIntNodeP(nkInt32Lit, p.tok.iNumber, p)
-    setBaseFlags(result, p.tok.base)
-    getTok(p)
-  of tkInt64Lit: 
-    result = newIntNodeP(nkInt64Lit, p.tok.iNumber, p)
-    setBaseFlags(result, p.tok.base)
-    getTok(p)
-  of tkFloatLit: 
-    result = newFloatNodeP(nkFloatLit, p.tok.fNumber, p)
-    setBaseFlags(result, p.tok.base)
-    getTok(p)
-  of tkFloat32Lit: 
-    result = newFloatNodeP(nkFloat32Lit, p.tok.fNumber, p)
-    setBaseFlags(result, p.tok.base)
-    getTok(p)
-  of tkFloat64Lit: 
-    result = newFloatNodeP(nkFloat64Lit, p.tok.fNumber, p)
-    setBaseFlags(result, p.tok.base)
-    getTok(p)
-  of tkStrLit: 
-    result = newStrNodeP(nkStrLit, p.tok.literal, p)
-    getTok(p)
-  of tkRStrLit: 
-    result = newStrNodeP(nkRStrLit, p.tok.literal, p)
-    getTok(p)
-  of tkTripleStrLit: 
-    result = newStrNodeP(nkTripleStrLit, p.tok.literal, p)
-    getTok(p)
-  of tkCharLit: 
-    result = newIntNodeP(nkCharLit, ord(p.tok.literal[0]), p)
-    getTok(p)
-  of tkNil: 
-    result = newNodeP(nkNilLit, p)
-    getTok(p)
-  of tkParLe: 
-    # () constructor
-    result = exprColonEqExprList(p, nkPar, nkExprColonExpr, tkParRi, tkColon)
-  of tkCurlyLe: 
-    # {} constructor
-    result = exprColonEqExprList(p, nkCurly, nkRange, tkCurlyRi, tkDotDot)
-  of tkBracketLe: 
-    # [] constructor
-    result = exprColonEqExprList(p, nkBracket, nkExprColonExpr, tkBracketRi, 
-                                 tkColon)
-  of tkCast: 
-    result = parseCast(p)
-  of tkAddr: 
-    result = parseAddr(p)
-  else: 
-    parMessage(p, errExprExpected, tokToStr(p.tok))
-    getTok(p)                 # we must consume a token here to prevend endless loops!
-    result = nil
-
-proc primary(p: var TParser): PNode = 
-  var a: PNode
-  # prefix operator?
-  if (p.tok.tokType == tkNot) or (p.tok.tokType == tkOpr): 
-    result = newNodeP(nkPrefix, p)
-    a = newIdentNodeP(p.tok.ident, p)
-    addSon(result, a)
-    getTok(p)
-    optInd(p, a)
-    addSon(result, primary(p))
-    return 
-  elif p.tok.tokType == tkBind: 
-    result = newNodeP(nkBind, p)
-    getTok(p)
-    optInd(p, result)
-    addSon(result, primary(p))
-    return 
-  result = identOrLiteral(p)
-  while true: 
-    case p.tok.tokType
-    of tkParLe: 
-      a = result
-      result = newNodeP(nkCall, p)
-      addSon(result, a)
-      exprColonEqExprListAux(p, nkExprEqExpr, tkParRi, tkEquals, result)
-    of tkDot: 
-      a = result
-      result = newNodeP(nkDotExpr, p)
-      addSon(result, a)
-      getTok(p)               # skip '.'
-      optInd(p, result)
-      addSon(result, parseSymbol(p))
-      result = parseGStrLit(p, result)
-    of tkHat: 
-      a = result
-      result = newNodeP(nkDerefExpr, p)
-      addSon(result, a)
-      getTok(p)
-    of tkBracketLe: 
-      result = indexExprList(p, result)
-    else: break 
-  
-proc lowestExprAux(p: var TParser, v: var PNode, limit: int): PToken = 
-  var 
-    op, nextop: PToken
-    opPred: int
-    v2, node, opNode: PNode
-  v = primary(p)              # expand while operators have priorities higher than 'limit'
-  op = p.tok
-  opPred = getPrecedence(p.tok)
-  while (opPred > limit): 
-    node = newNodeP(nkInfix, p)
-    opNode = newIdentNodeP(op.ident, p) # skip operator:
-    getTok(p)
-    optInd(p, opNode)         # read sub-expression with higher priority
-    nextop = lowestExprAux(p, v2, opPred)
-    addSon(node, opNode)
-    addSon(node, v)
-    addSon(node, v2)
-    v = node
-    op = nextop
-    opPred = getPrecedence(nextop)
-  result = op                 # return first untreated operator
-  
-proc lowestExpr(p: var TParser): PNode = 
-  discard lowestExprAux(p, result, - 1)
-
-proc parseIfExpr(p: var TParser): PNode = 
-  # if (expr) expr else expr
-  var branch: PNode
-  result = newNodeP(nkIfExpr, p)
-  while true: 
-    getTok(p)                 # skip `if`, `elif`
-    branch = newNodeP(nkElifExpr, p)
-    eat(p, tkParLe)
-    addSon(branch, parseExpr(p))
-    eat(p, tkParRi)
-    addSon(branch, parseExpr(p))
-    addSon(result, branch)
-    if p.tok.tokType != tkElif: break 
-  branch = newNodeP(nkElseExpr, p)
-  eat(p, tkElse)
-  addSon(branch, parseExpr(p))
-  addSon(result, branch)
-
-proc parsePragma(p: var TParser): PNode = 
-  var a: PNode
-  result = newNodeP(nkPragma, p)
-  getTok(p)
-  optInd(p, result)
-  while (p.tok.tokType != tkCurlyDotRi) and (p.tok.tokType != tkCurlyRi) and
-      (p.tok.tokType != tkEof) and (p.tok.tokType != tkSad): 
-    a = exprColonEqExpr(p, nkExprColonExpr, tkColon)
-    addSon(result, a)
-    if p.tok.tokType == tkComma: 
-      getTok(p)
-      optInd(p, a)
-  optPar(p)
-  if (p.tok.tokType == tkCurlyDotRi) or (p.tok.tokType == tkCurlyRi): getTok(p)
-  else: parMessage(p, errTokenExpected, ".}")
-  
-proc identVis(p: var TParser): PNode = 
-  # identifier with visability
-  var a: PNode
-  a = parseSymbol(p)
-  if p.tok.tokType == tkOpr: 
-    result = newNodeP(nkPostfix, p)
-    addSon(result, newIdentNodeP(p.tok.ident, p))
-    addSon(result, a)
-    getTok(p)
-  else: 
-    result = a
-  
-proc identWithPragma(p: var TParser): PNode = 
-  var a: PNode
-  a = identVis(p)
-  if p.tok.tokType == tkCurlyDotLe: 
-    result = newNodeP(nkPragmaExpr, p)
-    addSon(result, a)
-    addSon(result, parsePragma(p))
-  else: 
-    result = a
-  
-type 
-  TDeclaredIdentFlag = enum 
-    withPragma,               # identifier may have pragma
-    withBothOptional          # both ':' and '=' parts are optional
-  TDeclaredIdentFlags = set[TDeclaredIdentFlag]
-
-proc parseIdentColonEquals(p: var TParser, flags: TDeclaredIdentFlags): PNode = 
-  var a: PNode
-  result = newNodeP(nkIdentDefs, p)
-  while true: 
-    case p.tok.tokType
-    of tkSymbol, tkAccent: 
-      if withPragma in flags: a = identWithPragma(p)
-      else: a = parseSymbol(p)
-      if a == nil: return 
-    else: break 
-    addSon(result, a)
-    if p.tok.tokType != tkComma: break 
-    getTok(p)
-    optInd(p, a)
-  if p.tok.tokType == tkColon: 
-    getTok(p)
-    optInd(p, result)
-    addSon(result, parseTypeDesc(p))
-  else: 
-    addSon(result, nil)
-    if (p.tok.tokType != tkEquals) and not (withBothOptional in flags): 
-      parMessage(p, errColonOrEqualsExpected, tokToStr(p.tok))
-  if p.tok.tokType == tkEquals: 
-    getTok(p)
-    optInd(p, result)
-    addSon(result, parseExpr(p))
-  else: 
-    addSon(result, nil)
-  
-proc parseTuple(p: var TParser): PNode = 
-  var a: PNode
-  result = newNodeP(nkTupleTy, p)
-  getTok(p)
-  eat(p, tkBracketLe)
-  optInd(p, result)
-  while (p.tok.tokType == tkSymbol) or (p.tok.tokType == tkAccent): 
-    a = parseIdentColonEquals(p, {})
-    addSon(result, a)
-    if p.tok.tokType != tkComma: break 
-    getTok(p)
-    optInd(p, a)
-  optPar(p)
-  eat(p, tkBracketRi)
-
-proc parseParamList(p: var TParser): PNode = 
-  var a: PNode
-  result = newNodeP(nkFormalParams, p)
-  addSon(result, nil)         # return type
-  if p.tok.tokType == tkParLe: 
-    getTok(p)
-    optInd(p, result)
-    while true: 
-      case p.tok.tokType
-      of tkSymbol, tkAccent: a = parseIdentColonEquals(p, {})
-      of tkParRi: break 
-      else: 
-        parMessage(p, errTokenExpected, ")")
-        break 
-      addSon(result, a)
-      if p.tok.tokType != tkComma: break 
-      getTok(p)
-      optInd(p, a)
-    optPar(p)
-    eat(p, tkParRi)
-  if p.tok.tokType == tkColon: 
-    getTok(p)
-    optInd(p, result)
-    result.sons[0] = parseTypeDesc(p)
-
-proc parseProcExpr(p: var TParser, isExpr: bool): PNode = 
-  # either a proc type or a anonymous proc
-  var 
-    pragmas, params: PNode
-    info: TLineInfo
-  info = parLineInfo(p)
-  getTok(p)
-  params = parseParamList(p)
-  if p.tok.tokType == tkCurlyDotLe: pragmas = parsePragma(p)
-  else: pragmas = nil
-  if (p.tok.tokType == tkCurlyLe) and isExpr: 
-    result = newNodeI(nkLambda, info)
-    addSon(result, nil)       # no name part
-    addSon(result, nil)       # no generic parameters
-    addSon(result, params)
-    addSon(result, pragmas)   #getTok(p); skipComment(p, result);
-    addSon(result, parseStmt(p))
-  else: 
-    result = newNodeI(nkProcTy, info)
-    addSon(result, params)
-    addSon(result, pragmas)
-
-proc parseTypeDescKAux(p: var TParser, kind: TNodeKind): PNode = 
-  result = newNodeP(kind, p)
-  getTok(p)
-  optInd(p, result)
-  addSon(result, parseTypeDesc(p))
-
-proc parseExpr(p: var TParser): PNode = 
-  #
-  #expr ::= lowestExpr
-  #     | 'if' expr ':' expr ('elif' expr ':' expr)* 'else' ':' expr
-  #     | 'var' expr
-  #     | 'ref' expr
-  #     | 'ptr' expr
-  #     | 'type' expr
-  #     | 'tuple' tupleDesc
-  #     | 'proc' paramList [pragma] ['=' stmt] 
-  #
-  case p.tok.toktype
-  of tkVar: result = parseTypeDescKAux(p, nkVarTy)
-  of tkRef: result = parseTypeDescKAux(p, nkRefTy)
-  of tkPtr: result = parseTypeDescKAux(p, nkPtrTy)
-  of tkType: result = parseTypeDescKAux(p, nkTypeOfExpr)
-  of tkTuple: result = parseTuple(p)
-  of tkProc: result = parseProcExpr(p, true)
-  of tkIf: result = parseIfExpr(p)
-  else: result = lowestExpr(p)
-  
-proc parseTypeDesc(p: var TParser): PNode = 
-  if p.tok.toktype == tkProc: result = parseProcExpr(p, false)
-  else: result = parseExpr(p)
-  
-proc isExprStart(p: TParser): bool = 
-  case p.tok.tokType
-  of tkSymbol, tkAccent, tkOpr, tkNot, tkNil, tkCast, tkIf, tkProc, tkBind, 
-     tkParLe, tkBracketLe, tkCurlyLe, tkIntLit..tkCharLit, tkVar, tkRef, tkPtr, 
-     tkTuple, tkType: 
-    result = true
-  else: result = false
-  
-proc parseExprStmt(p: var TParser): PNode = 
-  var a, b, e: PNode
-  a = lowestExpr(p)
-  if p.tok.tokType == tkEquals: 
-    getTok(p)
-    optInd(p, result)
-    b = parseExpr(p)
-    result = newNodeI(nkAsgn, a.info)
-    addSon(result, a)
-    addSon(result, b)
-  else: 
-    result = newNodeP(nkCommand, p)
-    result.info = a.info
-    addSon(result, a)
-    while true: 
-      if not isExprStart(p): break 
-      e = parseExpr(p)
-      addSon(result, e)
-      if p.tok.tokType != tkComma: break 
-      getTok(p)
-      optInd(p, a)
-    if sonsLen(result) <= 1: result = a
-    else: a = result
-    if p.tok.tokType == tkCurlyLe: 
-      # macro statement
-      result = newNodeP(nkMacroStmt, p)
-      result.info = a.info
-      addSon(result, a)
-      getTok(p)
-      skipComment(p, result)
-      if (p.tok.tokType == tkInd) or
-          not (p.tok.TokType in {tkOf, tkElif, tkElse, tkExcept}): 
-        addSon(result, parseStmt(p))
-      while true: 
-        if p.tok.tokType == tkSad: getTok(p)
-        case p.tok.tokType
-        of tkOf: 
-          b = newNodeP(nkOfBranch, p)
-          exprListAux(p, nkRange, tkCurlyLe, tkDotDot, b)
-        of tkElif: 
-          b = newNodeP(nkElifBranch, p)
-          getTok(p)
-          optInd(p, b)
-          addSon(b, parseExpr(p))
-          eat(p, tkCurlyLe)
-        of tkExcept: 
-          b = newNodeP(nkExceptBranch, p)
-          qualifiedIdentListAux(p, tkCurlyLe, b)
-          skipComment(p, b)
-        of tkElse: 
-          b = newNodeP(nkElse, p)
-          getTok(p)
-          eat(p, tkCurlyLe)
-        else: break 
-        addSon(b, parseStmt(p))
-        eat(p, tkCurlyRi)
-        addSon(result, b)
-        if b.kind == nkElse: break 
-      eat(p, tkCurlyRi)
-
-proc parseImportOrIncludeStmt(p: var TParser, kind: TNodeKind): PNode = 
-  var a: PNode
-  result = newNodeP(kind, p)
-  getTok(p)                   # skip `import` or `include`
-  optInd(p, result)
-  while true: 
-    case p.tok.tokType
-    of tkEof, tkSad, tkDed: 
-      break 
-    of tkSymbol, tkAccent: 
-      a = parseSymbol(p)
-    of tkRStrLit: 
-      a = newStrNodeP(nkRStrLit, p.tok.literal, p)
-      getTok(p)
-    of tkStrLit: 
-      a = newStrNodeP(nkStrLit, p.tok.literal, p)
-      getTok(p)
-    of tkTripleStrLit: 
-      a = newStrNodeP(nkTripleStrLit, p.tok.literal, p)
-      getTok(p)
-    else: 
-      parMessage(p, errIdentifierExpected, tokToStr(p.tok))
-      break 
-    addSon(result, a)
-    if p.tok.tokType != tkComma: break 
-    getTok(p)
-    optInd(p, a)
-
-proc parseFromStmt(p: var TParser): PNode = 
-  var a: PNode
-  result = newNodeP(nkFromStmt, p)
-  getTok(p)                   # skip `from`
-  optInd(p, result)
-  case p.tok.tokType
-  of tkSymbol, tkAccent: 
-    a = parseSymbol(p)
-  of tkRStrLit: 
-    a = newStrNodeP(nkRStrLit, p.tok.literal, p)
-    getTok(p)
-  of tkStrLit: 
-    a = newStrNodeP(nkStrLit, p.tok.literal, p)
-    getTok(p)
-  of tkTripleStrLit: 
-    a = newStrNodeP(nkTripleStrLit, p.tok.literal, p)
-    getTok(p)
-  else: 
-    parMessage(p, errIdentifierExpected, tokToStr(p.tok))
-    return 
-  addSon(result, a)           #optInd(p, a);
-  eat(p, tkImport)
-  optInd(p, result)
-  while true: 
-    case p.tok.tokType        #optInd(p, a);
-    of tkEof, tkSad, tkDed: 
-      break 
-    of tkSymbol, tkAccent: 
-      a = parseSymbol(p)
-    else: 
-      parMessage(p, errIdentifierExpected, tokToStr(p.tok))
-      break 
-    addSon(result, a)
-    if p.tok.tokType != tkComma: break 
-    getTok(p)
-    optInd(p, a)
-
-proc parseReturnOrRaise(p: var TParser, kind: TNodeKind): PNode = 
-  result = newNodeP(kind, p)
-  getTok(p)
-  optInd(p, result)
-  case p.tok.tokType
-  of tkEof, tkSad, tkDed: addSon(result, nil)
-  else: addSon(result, parseExpr(p))
-  
-proc parseYieldOrDiscard(p: var TParser, kind: TNodeKind): PNode = 
-  result = newNodeP(kind, p)
-  getTok(p)
-  optInd(p, result)
-  addSon(result, parseExpr(p))
-
-proc parseBreakOrContinue(p: var TParser, kind: TNodeKind): PNode = 
-  result = newNodeP(kind, p)
-  getTok(p)
-  optInd(p, result)
-  case p.tok.tokType
-  of tkEof, tkSad, tkDed: addSon(result, nil)
-  else: addSon(result, parseSymbol(p))
-  
-proc parseIfOrWhen(p: var TParser, kind: TNodeKind): PNode = 
-  var branch: PNode
-  result = newNodeP(kind, p)
-  while true: 
-    getTok(p)                 # skip `if`, `when`, `elif`
-    branch = newNodeP(nkElifBranch, p)
-    optInd(p, branch)
-    eat(p, tkParLe)
-    addSon(branch, parseExpr(p))
-    eat(p, tkParRi)
-    skipComment(p, branch)
-    addSon(branch, parseStmt(p))
-    skipComment(p, branch)
-    addSon(result, branch)
-    if p.tok.tokType != tkElif: break 
-  if p.tok.tokType == tkElse: 
-    branch = newNodeP(nkElse, p)
-    eat(p, tkElse)
-    skipComment(p, branch)
-    addSon(branch, parseStmt(p))
-    addSon(result, branch)
-
-proc parseWhile(p: var TParser): PNode = 
-  result = newNodeP(nkWhileStmt, p)
-  getTok(p)
-  optInd(p, result)
-  eat(p, tkParLe)
-  addSon(result, parseExpr(p))
-  eat(p, tkParRi)
-  skipComment(p, result)
-  addSon(result, parseStmt(p))
-
-proc parseCase(p: var TParser): PNode = 
-  var 
-    b: PNode
-    inElif: bool
-  result = newNodeP(nkCaseStmt, p)
-  getTok(p)
-  eat(p, tkParLe)
-  addSon(result, parseExpr(p))
-  eat(p, tkParRi)
-  skipComment(p, result)
-  inElif = false
-  while true: 
-    if p.tok.tokType == tkSad: getTok(p)
-    case p.tok.tokType
-    of tkOf: 
-      if inElif: break 
-      b = newNodeP(nkOfBranch, p)
-      exprListAux(p, nkRange, tkColon, tkDotDot, b)
-    of tkElif: 
-      inElif = true
-      b = newNodeP(nkElifBranch, p)
-      getTok(p)
-      optInd(p, b)
-      addSon(b, parseExpr(p))
-      eat(p, tkColon)
-    of tkElse: 
-      b = newNodeP(nkElse, p)
-      getTok(p)
-      eat(p, tkColon)
-    else: break 
-    skipComment(p, b)
-    addSon(b, parseStmt(p))
-    addSon(result, b)
-    if b.kind == nkElse: break 
-  
-proc parseTry(p: var TParser): PNode = 
-  var b: PNode
-  result = newNodeP(nkTryStmt, p)
-  getTok(p)
-  eat(p, tkColon)
-  skipComment(p, result)
-  addSon(result, parseStmt(p))
-  b = nil
-  while true: 
-    if p.tok.tokType == tkSad: getTok(p)
-    case p.tok.tokType
-    of tkExcept: 
-      b = newNodeP(nkExceptBranch, p)
-      qualifiedIdentListAux(p, tkColon, b)
-    of tkFinally: 
-      b = newNodeP(nkFinally, p)
-      getTok(p)
-      eat(p, tkColon)
-    else: break 
-    skipComment(p, b)
-    addSon(b, parseStmt(p))
-    addSon(result, b)
-    if b.kind == nkFinally: break 
-  if b == nil: parMessage(p, errTokenExpected, "except")
-  
-proc parseFor(p: var TParser): PNode = 
-  var a: PNode
-  result = newNodeP(nkForStmt, p)
-  getTok(p)
-  optInd(p, result)
-  a = parseSymbol(p)
-  addSon(result, a)
-  while p.tok.tokType == tkComma: 
-    getTok(p)
-    optInd(p, a)
-    a = parseSymbol(p)
-    addSon(result, a)
-  eat(p, tkIn)
-  addSon(result, exprColonEqExpr(p, nkRange, tkDotDot))
-  eat(p, tkColon)
-  skipComment(p, result)
-  addSon(result, parseStmt(p))
-
-proc parseBlock(p: var TParser): PNode = 
-  result = newNodeP(nkBlockStmt, p)
-  getTok(p)
-  optInd(p, result)
-  case p.tok.tokType
-  of tkEof, tkSad, tkDed, tkColon: addSon(result, nil)
-  else: addSon(result, parseSymbol(p))
-  eat(p, tkColon)
-  skipComment(p, result)
-  addSon(result, parseStmt(p))
-
-proc parseAsm(p: var TParser): PNode = 
-  result = newNodeP(nkAsmStmt, p)
-  getTok(p)
-  optInd(p, result)
-  if p.tok.tokType == tkCurlyDotLe: addSon(result, parsePragma(p))
-  else: addSon(result, nil)
-  case p.tok.tokType
-  of tkStrLit: addSon(result, newStrNodeP(nkStrLit, p.tok.literal, p))
-  of tkRStrLit: addSon(result, newStrNodeP(nkRStrLit, p.tok.literal, p))
-  of tkTripleStrLit: addSon(result, 
-                            newStrNodeP(nkTripleStrLit, p.tok.literal, p))
-  else: 
-    parMessage(p, errStringLiteralExpected)
-    addSon(result, nil)
-    return 
-  getTok(p)
-
-proc parseGenericParamList(p: var TParser): PNode = 
-  var a: PNode
-  result = newNodeP(nkGenericParams, p)
-  getTok(p)
-  optInd(p, result)
-  while (p.tok.tokType == tkSymbol) or (p.tok.tokType == tkAccent): 
-    a = parseIdentColonEquals(p, {withBothOptional})
-    addSon(result, a)
-    if p.tok.tokType != tkComma: break 
-    getTok(p)
-    optInd(p, a)
-  optPar(p)
-  eat(p, tkBracketRi)
-
-proc parseRoutine(p: var TParser, kind: TNodeKind): PNode = 
-  result = newNodeP(kind, p)
-  getTok(p)
-  optInd(p, result)
-  addSon(result, identVis(p))
-  if p.tok.tokType == tkBracketLe: addSon(result, parseGenericParamList(p))
-  else: addSon(result, nil)
-  addSon(result, parseParamList(p))
-  if p.tok.tokType == tkCurlyDotLe: addSon(result, parsePragma(p))
-  else: addSon(result, nil)
-  if p.tok.tokType == tkEquals: 
-    getTok(p)
-    skipComment(p, result)
-    addSon(result, parseStmt(p))
-  else: 
-    addSon(result, nil)
-  indAndComment(p, result)    # XXX: document this in the grammar!
-  
-proc newCommentStmt(p: var TParser): PNode = 
-  result = newNodeP(nkCommentStmt, p)
-  result.info.line = result.info.line - int16(1)
-
-type 
-  TDefParser = proc (p: var TParser): PNode
-
-proc parseSection(p: var TParser, kind: TNodeKind, defparser: TDefParser): PNode = 
-  var a: PNode
-  result = newNodeP(kind, p)
-  getTok(p)
-  skipComment(p, result)
-  case p.tok.tokType
-  of tkInd: 
-    pushInd(p.lex[] , p.tok.indent)
-    getTok(p)
-    skipComment(p, result)
-    while true: 
-      case p.tok.tokType
-      of tkSad: 
-        getTok(p)
-      of tkSymbol, tkAccent: 
-        a = defparser(p)
-        skipComment(p, a)
-        addSon(result, a)
-      of tkDed: 
-        getTok(p)
-        break 
-      of tkEof: 
-        break                 # BUGFIX
-      of tkComment: 
-        a = newCommentStmt(p)
-        skipComment(p, a)
-        addSon(result, a)
-      else: 
-        parMessage(p, errIdentifierExpected, tokToStr(p.tok))
-        break 
-    popInd(p.lex[] )
-  of tkSymbol, tkAccent, tkParLe: 
-    # tkParLe is allowed for ``var (x, y) = ...`` tuple parsing
-    addSon(result, defparser(p))
-  else: parMessage(p, errIdentifierExpected, tokToStr(p.tok))
-  
-proc parseConstant(p: var TParser): PNode = 
-  result = newNodeP(nkConstDef, p)
-  addSon(result, identWithPragma(p))
-  if p.tok.tokType == tkColon: 
-    getTok(p)
-    optInd(p, result)
-    addSon(result, parseTypeDesc(p))
-  else: 
-    addSon(result, nil)
-  eat(p, tkEquals)
-  optInd(p, result)
-  addSon(result, parseExpr(p))
-  indAndComment(p, result)    # XXX: special extension!
-  
-proc parseConstSection(p: var TParser): PNode = 
-  result = newNodeP(nkConstSection, p)
-  getTok(p)
-  skipComment(p, result)
-  if p.tok.tokType == tkCurlyLe: 
-    getTok(p)
-    skipComment(p, result)
-    while (p.tok.tokType != tkCurlyRi) and (p.tok.tokType != tkEof): 
-      addSon(result, parseConstant(p))
-    eat(p, tkCurlyRi)
-  else: 
-    addSon(result, parseConstant(p))
-  
-proc parseEnum(p: var TParser): PNode = 
-  var a, b: PNode
-  result = newNodeP(nkEnumTy, p)
-  a = nil
-  getTok(p)
-  optInd(p, result)
-  if p.tok.tokType == tkOf: 
-    a = newNodeP(nkOfInherit, p)
-    getTok(p)
-    optInd(p, a)
-    addSon(a, parseTypeDesc(p))
-    addSon(result, a)
-  else: 
-    addSon(result, nil)
-  while true: 
-    case p.tok.tokType
-    of tkEof, tkSad, tkDed: break 
-    else: a = parseSymbol(p)
-    optInd(p, a)
-    if p.tok.tokType == tkEquals: 
-      getTok(p)
-      optInd(p, a)
-      b = a
-      a = newNodeP(nkEnumFieldDef, p)
-      addSon(a, b)
-      addSon(a, parseExpr(p))
-      skipComment(p, a)
-    if p.tok.tokType == tkComma: 
-      getTok(p)
-      optInd(p, a)
-    addSon(result, a)
-
-proc parseObjectPart(p: var TParser): PNode
-proc parseObjectWhen(p: var TParser): PNode = 
-  var branch: PNode
-  result = newNodeP(nkRecWhen, p)
-  while true: 
-    getTok(p)                 # skip `when`, `elif`
-    branch = newNodeP(nkElifBranch, p)
-    optInd(p, branch)
-    addSon(branch, parseExpr(p))
-    eat(p, tkColon)
-    skipComment(p, branch)
-    addSon(branch, parseObjectPart(p))
-    skipComment(p, branch)
-    addSon(result, branch)
-    if p.tok.tokType != tkElif: break 
-  if p.tok.tokType == tkElse: 
-    branch = newNodeP(nkElse, p)
-    eat(p, tkElse)
-    eat(p, tkColon)
-    skipComment(p, branch)
-    addSon(branch, parseObjectPart(p))
-    addSon(result, branch)
-
-proc parseObjectCase(p: var TParser): PNode = 
-  var a, b: PNode
-  result = newNodeP(nkRecCase, p)
-  getTok(p)
-  a = newNodeP(nkIdentDefs, p)
-  addSon(a, identWithPragma(p))
-  eat(p, tkColon)
-  addSon(a, parseTypeDesc(p))
-  addSon(a, nil)
-  addSon(result, a)
-  skipComment(p, result)
-  while true: 
-    if p.tok.tokType == tkSad: getTok(p)
-    case p.tok.tokType
-    of tkOf: 
-      b = newNodeP(nkOfBranch, p)
-      exprListAux(p, nkRange, tkColon, tkDotDot, b)
-    of tkElse: 
-      b = newNodeP(nkElse, p)
-      getTok(p)
-      eat(p, tkColon)
-    else: break 
-    skipComment(p, b)
-    addSon(b, parseObjectPart(p))
-    addSon(result, b)
-    if b.kind == nkElse: break 
-  
-proc parseObjectPart(p: var TParser): PNode = 
-  case p.tok.tokType
-  of tkInd: 
-    result = newNodeP(nkRecList, p)
-    pushInd(p.lex[] , p.tok.indent)
-    getTok(p)
-    skipComment(p, result)
-    while true: 
-      case p.tok.tokType
-      of tkSad: 
-        getTok(p)
-      of tkCase, tkWhen, tkSymbol, tkAccent, tkNil: 
-        addSon(result, parseObjectPart(p))
-      of tkDed: 
-        getTok(p)
-        break 
-      of tkEof: 
-        break 
-      else: 
-        parMessage(p, errIdentifierExpected, tokToStr(p.tok))
-        break 
-    popInd(p.lex[] )
-  of tkWhen: 
-    result = parseObjectWhen(p)
-  of tkCase: 
-    result = parseObjectCase(p)
-  of tkSymbol, tkAccent: 
-    result = parseIdentColonEquals(p, {withPragma})
-    skipComment(p, result)
-  of tkNil: 
-    result = newNodeP(nkNilLit, p)
-    getTok(p)
-  else: result = nil
-  
-proc parseObject(p: var TParser): PNode = 
-  var a: PNode
-  result = newNodeP(nkObjectTy, p)
-  getTok(p)
-  if p.tok.tokType == tkCurlyDotLe: addSon(result, parsePragma(p))
-  else: addSon(result, nil)
-  if p.tok.tokType == tkOf: 
-    a = newNodeP(nkOfInherit, p)
-    getTok(p)
-    addSon(a, parseTypeDesc(p))
-    addSon(result, a)
-  else: 
-    addSon(result, nil)
-  skipComment(p, result)
-  addSon(result, parseObjectPart(p))
-
-proc parseDistinct(p: var TParser): PNode = 
-  result = newNodeP(nkDistinctTy, p)
-  getTok(p)
-  optInd(p, result)
-  addSon(result, parseTypeDesc(p))
-
-proc parseTypeDef(p: var TParser): PNode = 
-  var a: PNode
-  result = newNodeP(nkTypeDef, p)
-  addSon(result, identWithPragma(p))
-  if p.tok.tokType == tkBracketLe: addSon(result, parseGenericParamList(p))
-  else: addSon(result, nil)
-  if p.tok.tokType == tkEquals: 
-    getTok(p)
-    optInd(p, result)
-    case p.tok.tokType
-    of tkObject: a = parseObject(p)
-    of tkEnum: a = parseEnum(p)
-    of tkDistinct: a = parseDistinct(p)
-    else: a = parseTypeDesc(p)
-    addSon(result, a)
-  else: 
-    addSon(result, nil)
-  indAndComment(p, result)    # special extension!
-  
-proc parseVarTuple(p: var TParser): PNode = 
-  var a: PNode
-  result = newNodeP(nkVarTuple, p)
-  getTok(p)                   # skip '('
-  optInd(p, result)
-  while (p.tok.tokType == tkSymbol) or (p.tok.tokType == tkAccent): 
-    a = identWithPragma(p)
-    addSon(result, a)
-    if p.tok.tokType != tkComma: break 
-    getTok(p)
-    optInd(p, a)
-  addSon(result, nil)         # no type desc
-  optPar(p)
-  eat(p, tkParRi)
-  eat(p, tkEquals)
-  optInd(p, result)
-  addSon(result, parseExpr(p))
-
-proc parseVariable(p: var TParser): PNode = 
-  if p.tok.tokType == tkParLe: result = parseVarTuple(p)
-  else: result = parseIdentColonEquals(p, {withPragma})
-  indAndComment(p, result)    # special extension!
-  
-proc simpleStmt(p: var TParser): PNode = 
-  case p.tok.tokType
-  of tkReturn: result = parseReturnOrRaise(p, nkReturnStmt)
-  of tkRaise: result = parseReturnOrRaise(p, nkRaiseStmt)
-  of tkYield: result = parseYieldOrDiscard(p, nkYieldStmt)
-  of tkDiscard: result = parseYieldOrDiscard(p, nkDiscardStmt)
-  of tkBreak: result = parseBreakOrContinue(p, nkBreakStmt)
-  of tkContinue: result = parseBreakOrContinue(p, nkContinueStmt)
-  of tkCurlyDotLe: result = parsePragma(p)
-  of tkImport: result = parseImportOrIncludeStmt(p, nkImportStmt)
-  of tkFrom: result = parseFromStmt(p)
-  of tkInclude: result = parseImportOrIncludeStmt(p, nkIncludeStmt)
-  of tkComment: result = newCommentStmt(p)
-  else: 
-    if isExprStart(p): result = parseExprStmt(p)
-    else: result = nil
-  if result != nil: skipComment(p, result)
-  
-proc parseType(p: var TParser): PNode = 
-  result = newNodeP(nkTypeSection, p)
-  while true: 
-    case p.tok.tokType
-    of tkComment: 
-      skipComment(p, result)
-    of tkType: 
-      # type alias:
-    of tkEnum: 
-      nil
-    of tkObject: 
-      nil
-    of tkTuple: 
-      nil
-    else: break 
-  
-proc complexOrSimpleStmt(p: var TParser): PNode = 
-  case p.tok.tokType
-  of tkIf: 
-    result = parseIfOrWhen(p, nkIfStmt)
-  of tkWhile: 
-    result = parseWhile(p)
-  of tkCase: 
-    result = parseCase(p)
-  of tkTry: 
-    result = parseTry(p)
-  of tkFor: 
-    result = parseFor(p)
-  of tkBlock: 
-    result = parseBlock(p)
-  of tkAsm: 
-    result = parseAsm(p)
-  of tkProc: 
-    result = parseRoutine(p, nkProcDef)
-  of tkMethod: 
-    result = parseRoutine(p, nkMethodDef)
-  of tkIterator: 
-    result = parseRoutine(p, nkIteratorDef)
-  of tkMacro: 
-    result = parseRoutine(p, nkMacroDef)
-  of tkTemplate: 
-    result = parseRoutine(p, nkTemplateDef)
-  of tkConverter: 
-    result = parseRoutine(p, nkConverterDef)
-  of tkType, tkEnum, tkObject, tkTuple: 
-    result = nil              #result := parseTypeAlias(p, nkTypeSection, parseTypeDef);
-  of tkConst: 
-    result = parseConstSection(p)
-  of tkWhen: 
-    result = parseIfOrWhen(p, nkWhenStmt)
-  of tkVar: 
-    result = parseSection(p, nkVarSection, parseVariable)
-  else: result = simpleStmt(p)
-  
-proc parseStmt(p: var TParser): PNode = 
-  var a: PNode
-  if p.tok.tokType == tkCurlyLe: 
-    result = newNodeP(nkStmtList, p)
-    getTok(p)
-    while true: 
-      case p.tok.tokType
-      of tkSad, tkInd, tkDed: getTok(p)
-      of tkEof, tkCurlyRi: break 
-      else: 
-        a = complexOrSimpleStmt(p)
-        if a == nil: break 
-        addSon(result, a)
-    eat(p, tkCurlyRi)
-  else: 
-    # the case statement is only needed for better error messages:
-    case p.tok.tokType
-    of tkIf, tkWhile, tkCase, tkTry, tkFor, tkBlock, tkAsm, tkProc, tkIterator, 
-       tkMacro, tkType, tkConst, tkWhen, tkVar: 
-      parMessage(p, errComplexStmtRequiresInd)
-      result = nil
-    else: 
-      result = simpleStmt(p)
-      if result == nil: parMessage(p, errExprExpected, tokToStr(p.tok))
-      if p.tok.tokType in {tkInd, tkDed, tkSad}: getTok(p)
-  
-proc parseAll(p: var TParser): PNode = 
-  var a: PNode
-  result = newNodeP(nkStmtList, p)
-  while true: 
-    case p.tok.tokType
-    of tkDed, tkInd, tkSad: getTok(p)
-    of tkEof: break 
-    else: 
-      a = complexOrSimpleStmt(p)
-      if a == nil: parMessage(p, errExprExpected, tokToStr(p.tok))
-      addSon(result, a)
+proc ParseAll*(p: var TParser): PNode = 
+  result = nil
 
-proc parseTopLevelStmt(p: var TParser): PNode = 
+proc parseTopLevelStmt*(p: var TParser): PNode = 
   result = nil
-  while true: 
-    case p.tok.tokType
-    of tkDed, tkInd, tkSad: getTok(p)
-    of tkEof: break 
-    else: 
-      result = complexOrSimpleStmt(p)
-      if result == nil: parMessage(p, errExprExpected, tokToStr(p.tok))
-      break 
+
diff --git a/compiler/pendx.nim b/compiler/pendx.nim
index debe0d852..72c80126d 100755
--- a/compiler/pendx.nim
+++ b/compiler/pendx.nim
@@ -8,16 +8,11 @@
 #
 
 import 
-  llstream, scanner, idents, strutils, ast, msgs, pnimsyn
+  llstream, lexer, parser, idents, strutils, ast, msgs
 
-proc ParseAll*(p: var TParser): PNode
-proc parseTopLevelStmt*(p: var TParser): PNode
-  # implements an iterator. Returns the next top-level statement or nil if end
-  # of stream.
-# implementation
-
-proc ParseAll(p: var TParser): PNode = 
+proc ParseAll*(p: var TParser): PNode = 
   result = nil
 
-proc parseTopLevelStmt(p: var TParser): PNode = 
+proc parseTopLevelStmt*(p: var TParser): PNode = 
   result = nil
+  
diff --git a/compiler/pragmas.nim b/compiler/pragmas.nim
index d7bda4099..c94b8b68b 100755
--- a/compiler/pragmas.nim
+++ b/compiler/pragmas.nim
@@ -10,7 +10,7 @@
 # This module implements semantic checking for pragmas
 
 import 
-  os, platform, condsyms, ast, astalgo, idents, semdata, msgs, rnimsyn, 
+  os, platform, condsyms, ast, astalgo, idents, semdata, msgs, renderer, 
   wordrecg, ropes, options, strutils, lists, extccomp, math, magicsys, trees,
   rodread
 
diff --git a/compiler/rnimsyn.nim b/compiler/renderer.nim
index 4436467fa..5ba24bbfa 100755
--- a/compiler/rnimsyn.nim
+++ b/compiler/renderer.nim
@@ -10,7 +10,7 @@
 # This module implements the renderer of the standard Nimrod representation.
 
 import 
-  scanner, options, idents, strutils, ast, msgs, lists
+  lexer, options, idents, strutils, ast, msgs, lists
 
 type 
   TRenderFlag* = enum 
@@ -637,7 +637,7 @@ proc gasm(g: var TSrcGen, n: PNode) =
 proc gident(g: var TSrcGen, n: PNode) = 
   var t: TTokType
   var s = atom(n)
-  if (s[0] in scanner.SymChars): 
+  if (s[0] in lexer.SymChars): 
     if (n.kind == nkIdent): 
       if (n.ident.id < ord(tokKeywordLow) - ord(tkSymbol)) or
           (n.ident.id > ord(tokKeywordHigh) - ord(tkSymbol)): 
diff --git a/compiler/sem.nim b/compiler/sem.nim
index bb948ffc9..5f717f006 100755
--- a/compiler/sem.nim
+++ b/compiler/sem.nim
@@ -10,9 +10,9 @@
 # This module implements the semantic checking pass.
 
 import
-  strutils, nhashes, lists, options, scanner, ast, astalgo, trees, treetab, 
-  wordrecg, ropes, msgs, os, condsyms, idents, rnimsyn, types, platform, math, 
-  magicsys, pnimsyn, nversion, nimsets, semdata, evals, semfold, importer, 
+  strutils, nhashes, lists, options, lexer, ast, astalgo, trees, treetab, 
+  wordrecg, ropes, msgs, os, condsyms, idents, renderer, types, platform, math, 
+  magicsys, parser, nversion, nimsets, semdata, evals, semfold, importer, 
   procfind, lookups, rodread, pragmas, passes, semtypinst, sigmatch, suggest
 
 proc semPass*(): TPass
diff --git a/compiler/semdata.nim b/compiler/semdata.nim
index e052a0baf..240a783d4 100755
--- a/compiler/semdata.nim
+++ b/compiler/semdata.nim
@@ -10,9 +10,9 @@
 # This module contains the data structures for the semantic checking phase.
 
 import 
-  strutils, lists, options, scanner, ast, astalgo, trees, treetab, wordrecg, 
-  ropes, msgs, platform, os, condsyms, idents, rnimsyn, types, extccomp, math, 
-  magicsys, nversion, nimsets, pnimsyn, times, passes, rodread
+  strutils, lists, options, lexer, ast, astalgo, trees, treetab, wordrecg, 
+  ropes, msgs, platform, os, condsyms, idents, renderer, types, extccomp, math, 
+  magicsys, nversion, nimsets, parser, times, passes, rodread
 
 type 
   TOptionEntry* = object of lists.TListEntry # entries to put on a
diff --git a/compiler/semfold.nim b/compiler/semfold.nim
index bae2a19bc..041655ef6 100755
--- a/compiler/semfold.nim
+++ b/compiler/semfold.nim
@@ -12,7 +12,7 @@
 
 import 
   strutils, lists, options, ast, astalgo, trees, treetab, nimsets, times, 
-  nversion, platform, math, msgs, os, condsyms, idents, rnimsyn, types,
+  nversion, platform, math, msgs, os, condsyms, idents, renderer, types,
   commands
 
 proc getConstExpr*(m: PSym, n: PNode): PNode
diff --git a/compiler/sigmatch.nim b/compiler/sigmatch.nim
index 1e61ddfe0..d5b8f3204 100755
--- a/compiler/sigmatch.nim
+++ b/compiler/sigmatch.nim
@@ -11,7 +11,7 @@
 # the call to overloaded procs, generic procs and operators.
 
 import 
-  ast, astalgo, semdata, types, msgs, rnimsyn, lookups, semtypinst, 
+  ast, astalgo, semdata, types, msgs, renderer, lookups, semtypinst, 
   magicsys
 
 type 
diff --git a/compiler/suggest.nim b/compiler/suggest.nim
index 6f4babe63..b16c4eba7 100755
--- a/compiler/suggest.nim
+++ b/compiler/suggest.nim
@@ -9,7 +9,8 @@
 
 ## This file implements features required for IDE support.
 
-import scanner, idents, ast, astalgo, semdata, msgs, types, sigmatch, options
+import 
+  lexer, idents, ast, astalgo, semdata, msgs, types, sigmatch, options
 
 const
   sep = '\t'
@@ -38,7 +39,7 @@ proc SymToStr(s: PSym, isLocal: bool, section: string): string =
   result.add($ToColumn(s.info))
 
 proc filterSym(s: PSym): bool {.inline.} = 
-  result = s.name.s[0] in scanner.SymChars
+  result = s.name.s[0] in lexer.SymChars
 
 proc suggestField(s: PSym) = 
   if filterSym(s):
diff --git a/compiler/syntaxes.nim b/compiler/syntaxes.nim
index adb17efee..b098e4817 100755
--- a/compiler/syntaxes.nim
+++ b/compiler/syntaxes.nim
@@ -10,8 +10,8 @@
 ## Implements the dispatcher for the different parsers.
 
 import 
-  strutils, llstream, ast, astalgo, idents, scanner, options, msgs, pnimsyn, 
-  pbraces, ptmplsyn, filters, rnimsyn
+  strutils, llstream, ast, astalgo, idents, lexer, options, msgs, parser, 
+  pbraces, filters, filter_tmpl, renderer
 
 type 
   TFilterKind* = enum 
@@ -54,7 +54,7 @@ proc ParseFile(filename: string): PNode =
 proc parseAll(p: var TParsers): PNode = 
   case p.skin
   of skinStandard: 
-    result = pnimsyn.parseAll(p.parser)
+    result = parser.parseAll(p.parser)
   of skinBraces: 
     result = pbraces.parseAll(p.parser)
   of skinEndX: 
@@ -65,7 +65,7 @@ proc parseAll(p: var TParsers): PNode =
 proc parseTopLevelStmt(p: var TParsers): PNode = 
   case p.skin
   of skinStandard: 
-    result = pnimsyn.parseTopLevelStmt(p.parser)
+    result = parser.parseTopLevelStmt(p.parser)
   of skinBraces: 
     result = pbraces.parseTopLevelStmt(p.parser)
   of skinEndX: 
@@ -99,7 +99,7 @@ proc parsePipe(filename: string, inputStream: PLLStream): PNode =
       while line[i] in WhiteSpace: inc(i)
       var q: TParser
       OpenParser(q, filename, LLStreamOpen(copy(line, i)))
-      result = pnimsyn.parseAll(q)
+      result = parser.parseAll(q)
       CloseParser(q)
     LLStreamClose(s)
 
@@ -167,7 +167,7 @@ proc openParsers(p: var TParsers, filename: string, inputstream: PLLStream) =
   else: s = inputStream
   case p.skin
   of skinStandard, skinBraces, skinEndX: 
-    pnimsyn.openParser(p.parser, filename, s)
+    parser.openParser(p.parser, filename, s)
   
 proc closeParsers(p: var TParsers) = 
-  pnimsyn.closeParser(p.parser)
+  parser.closeParser(p.parser)
diff --git a/compiler/transf.nim b/compiler/transf.nim
index db5146bb5..cdc89538c 100755
--- a/compiler/transf.nim
+++ b/compiler/transf.nim
@@ -18,7 +18,7 @@
 
 import 
   strutils, lists, options, ast, astalgo, trees, treetab, evals, msgs, os, 
-  idents, rnimsyn, types, passes, semfold, magicsys, cgmeth
+  idents, renderer, types, passes, semfold, magicsys, cgmeth
 
 const 
   genPrefix* = ":tmp"         # prefix for generated names
diff --git a/compiler/trees.nim b/compiler/trees.nim
index 69b77b8ab..54f688103 100755
--- a/compiler/trees.nim
+++ b/compiler/trees.nim
@@ -10,7 +10,7 @@
 # tree helper routines
 
 import 
-  ast, astalgo, scanner, msgs, strutils
+  ast, astalgo, lexer, msgs, strutils
 
 proc getMagic*(op: PNode): TMagic
 
diff --git a/doc/filelist.txt b/doc/filelist.txt
index 7bcd424db..ce9923453 100755
--- a/doc/filelist.txt
+++ b/doc/filelist.txt
@@ -9,16 +9,11 @@ nimrod          main module: parses the command line and calls
 main            implements the top-level command dispatching
 nimconf         implements the config file reader
 syntaxes        dispatcher for the different parsers and filters
-ptmplsyn        standard template filter (``#! stdtempl``)
+filter_tmpl     standard template filter (``#! stdtempl``)
 lexbase         buffer handling of the lexical analyser
-scanner         lexical analyser
-pnimsyn         Nimrod's parser
-rnimsyn         Nimrod code renderer (AST back to its textual form)
-
-paslex          lexer for Pascal
-pasparse        parser for Pascal; Pascal's advanced OO features are not
-                supported
-
+lexer           lexical analyser
+parser          Nimrod's parser
+renderer        Nimrod code renderer (AST back to its textual form)
 options         contains global and local compiler options
 ast             type definitions of the abstract syntax tree (AST) and
                 node constructors
diff --git a/lib/pure/collections/hashtables.nim b/lib/pure/collections/hashtables.nim
index 133db66e1..6730163c2 100644
--- a/lib/pure/collections/hashtables.nim
+++ b/lib/pure/collections/hashtables.nim
@@ -18,8 +18,8 @@ type
   TKeyValuePair[A, B] = tuple[slot: TSlotEnum, key: A, val: B]
   TKeyValuePairSeq[A, B] = seq[TKeyValuePair[A, B]]
   THashTable[A, B] = object of TObject
-    counter: int
     data: TKeyValuePairSeq[A, B]
+    counter: int
 
   PHashTable*[A, B] = ref THashTable[A, B] ## use this type to declare tables
 
@@ -32,12 +32,12 @@ iterator pairs*[A, B](t: PHashTable[A, B]): tuple[key: A, val: B] =
   for h in 0..high(t.data):
     if t.data[h].slot == seFilled: yield (t.data[h].key, t.data[h].val)
 
-iterator keys*[A, B](t: PHashTable[A, B]): tuple[key: A, val: B] =
+iterator keys*[A, B](t: PHashTable[A, B]): A =
   ## iterates over any key in the table `t`.
   for h in 0..high(t.data):
     if t.data[h].slot == seFilled: yield t.data[h].key
 
-iterator values*[A, B](t: PHashTable[A, B]): tuple[key: A, val: B] =
+iterator values*[A, B](t: PHashTable[A, B]): B =
   ## iterates over any value in the table `t`.
   for h in 0..high(t.data):
     if t.data[h].slot == seFilled: yield t.data[h].val
@@ -103,6 +103,7 @@ proc del*[A, B](t: PHashTable[A, B], key: A) =
   var index = RawGet(t, key)
   if index >= 0:
     t.data[index].slot = seDeleted
+    dec(t.counter)
 
 proc newHashTable*[A, B](initialSize = 64): PHashTable[A, B] =
   ## creates a new string table that is empty. `initialSize` needs to be
@@ -125,6 +126,110 @@ proc `$`*[A, B](t: PHashTable[A, B]): string =
       result.add($val)
     result.add("}")
 
+
+# ------------------------------ count tables -------------------------------
+
+const
+  deletedCount = -1
+
+type
+  TCountTable*[A] {.final.} = object
+    data: seq[tuple[key: A, val: int]]
+    counter: int
+
+proc len*[A](t: TCountTable[A]): int =
+  ## returns the number of keys in `t`.
+  result = t.counter
+
+iterator pairs*[A](t: TCountTable[A]): tuple[key: A, val: int] =
+  ## iterates over any (key, value) pair in the table `t`.
+  for h in 0..high(t.data):
+    if t.data[h].slot == seFilled: yield (t.data[h].key, t.data[h].val)
+
+iterator keys*[A](t: TCountTable[A]): A =
+  ## iterates over any key in the table `t`.
+  for h in 0..high(t.data):
+    if t.data[h].slot == seFilled: yield t.data[h].key
+
+iterator values*[A](t: TCountTable[A]): int =
+  ## iterates over any value in the table `t`.
+  for h in 0..high(t.data):
+    if t.data[h].slot == seFilled: yield t.data[h].val
+
+proc RawGet[A](t: TCountTable[A], key: A): int =
+  var h: THash = hash(key) and high(t.data) # start with real hash value
+  while t.data[h].slot != seEmpty:
+    if t.data[h].key == key and t.data[h].slot == seFilled:
+      return h
+    h = nextTry(h, high(t.data))
+  result = -1
+
+proc `[]`*[A](t: TCountTable[A], key: A): B =
+  ## retrieves the value at ``t[key]``. If `key` is not in `t`,
+  ## default empty value for the type `B` is returned
+  ## and no exception is raised. One can check with ``hasKey`` whether the key
+  ## exists.
+  var index = RawGet(t, key)
+  if index >= 0: result = t.data[index].val
+
+proc hasKey*[A](t: TCountTable[A], key: A): bool =
+  ## returns true iff `key` is in the table `t`.
+  result = rawGet(t, key) >= 0
+
+proc RawInsert[A](t: TCountTable[A], data: var TKeyValuePairSeq[A, B],
+                     key: A, val: int) =
+  var h: THash = hash(key) and high(data)
+  while data[h].slot == seFilled:
+    h = nextTry(h, high(data))
+  data[h].key = key
+  data[h].val = val
+  data[h].slot = seFilled
+
+proc Enlarge[A](t: TCountTable[A]) =
+  var n: TKeyValuePairSeq[A, B]
+  newSeq(n, len(t.data) * growthFactor)
+  for i in countup(0, high(t.data)):
+    if t.data[i].slot == seFilled: RawInsert(t, n, t.data[i].key, t.data[i].val)
+  swap(t.data, n)
+
+proc `[]=`*[A](t: TCountTable[A], key: A, val: int) =
+  ## puts a (key, value)-pair into `t`.
+  var index = RawGet(t, key)
+  if index >= 0:
+    t.data[index].val = val
+  else:
+    if mustRehash(len(t.data), t.counter): Enlarge(t)
+    RawInsert(t, t.data, key, val)
+    inc(t.counter)
+
+proc del*[A](t: TCountTable[A], key: A) =
+  ## deletes `key` from hash table `t`.
+  var index = RawGet(t, key)
+  if index >= 0:
+    t.data[index].slot = seDeleted
+
+proc newHashTable*[A, B](initialSize = 64): PHashTable[A, B] =
+  ## creates a new string table that is empty. `initialSize` needs to be
+  ## a power of two.
+  assert isPowerOfTwo(initialSize)
+  new(result)
+  result.counter = 0
+  newSeq(result.data, initialSize)
+
+proc `$`*[A](t: TCountTable[A]): string =
+  ## The `$` operator for string tables.
+  if t.len == 0:
+    result = "{:}"
+  else:
+    result = "{"
+    for key, val in pairs(t):
+      if result.len > 1: result.add(", ")
+      result.add($key)
+      result.add(": ")
+      result.add($val)
+    result.add("}")
+
+
 when isMainModule:
   var table = newHashTable[string, float]()
   table["test"] = 1.2345
diff --git a/lib/pure/collections/lists.nim b/lib/pure/collections/lists.nim
new file mode 100755
index 000000000..cae6d4620
--- /dev/null
+++ b/lib/pure/collections/lists.nim
@@ -0,0 +1,155 @@
+#
+#
+#            Nimrod's Runtime Library
+#        (c) Copyright 2011 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## Implementation of singly and doubly linked lists. Because it makes no sense
+## to do so, the 'next' and 'prev' pointers are not hidden from you and can
+## be manipulated directly for efficiency.
+
+type
+  TDoublyLinkedNode[T] {.pure, final.} = object
+    next*, prev*: ref TDoublyLinkedNode[T]
+    value*: T
+  PDoublyLinkedNode*[T] = ref TDoublyLinkedNode[T]
+
+  TSinglyLinkedNode[T] {.pure, final.} = object
+    next*: ref TSinglyLinkedNode[T]
+    value*: T
+  PSinglyLinkedNode*[T] = ref TSinglyLinkedNode[T]
+
+proc newDoublyLinkedNode*[T](value: T): PDoublyLinkedNode[T] =
+  ## creates a new doubly linked node with the given `value`.
+  new(result)
+  result.value = value
+
+proc newSinglyLinkedNode*[T](value: T): PSinglyLinkedNode[T] =
+  ## creates a new singly linked node with the given `value`.
+  new(result)
+  result.value = value
+
+iterator items*[T](n: PDoublyLinkedNode[T]): T = 
+  ## yields every value of `x`.
+  var it = n
+  while it != nil:
+    yield it.value
+    it = it.next
+
+iterator items*[T](n: PSinglyLinkedNode[T]): T = 
+  ## yields every value of `x`.
+  var it = n
+  while it != nil:
+    yield it.value
+    it = it.next
+
+iterator nodes*[T](n: PSinglyLinkedNode[T]): PSinglyLinkedNode[T] = 
+  ## iterates over every node of `x`. Removing the current node from the
+  ## list during traversal is supported.
+  var it = n
+  while it != nil:
+    var nxt = it.next
+    yield it
+    it = nxt
+
+iterator nodes*[T](n: PDoublyLinkedNode[T]): PDoublyLinkedNode[T] = 
+  ## iterates over every node of `x`. Removing the current node from the
+  ## list during traversal is supported.
+  var it = n
+  while it != nil:
+    var nxt = it.next
+    yield it
+    it = nxt
+
+proc `$`*[list: PSinglyLinkedNode|PDoublyLinkedNode](n: list): string = 
+  ## turns a list into its string representation.
+  result = "["
+  for x in nodes(n):
+    if result.len > 1: result.add(", ")
+    result.add($x.value)
+  result.add("]")
+
+proc find*[list: PSinglyLinkedNode|PDoublyLinkedNode, T](
+           n: list, value: T): list = 
+  ## searches in the list for a value. Returns nil if the value does not
+  ## exist.
+  for x in nodes(n):
+    if x.value == value: return x
+
+proc contains*[list: PSinglyLinkedNode|PDoublyLinkedNode, T](
+           n: list, value: T): list = 
+  ## searches in the list for a value. Returns false if the value does not
+  ## exist, true otherwise.
+  for x in nodes(n):
+    if x.value == value: return true
+
+proc prepend*[T](head: var PSinglyLinkedNode[T], 
+                 toAdd: PSinglyLinkedNode[T]) {.inline.} = 
+  ## prepends a node to `head`. Efficiency: O(1).
+  toAdd.next = head
+  head = toAdd
+
+proc prepend*[T](head: var PSinglyLinkedNode[T], x: T) {.inline.} = 
+  ## creates a new node with the value `x` and prepends that node to `head`.
+  ## Efficiency: O(1).
+  preprend(head, newSinglyLinkedNode(x))
+
+proc append*[T](head: var PSinglyLinkedNode[T], 
+                toAdd: PSinglyLinkedNode[T]) = 
+  ## appends a node to `head`. Efficiency: O(n).
+  if head == nil:
+    head = toAdd
+  else:
+    var it = head
+    while it.next != nil: it = it.next
+    it.next = toAdd
+
+proc append*[T](head: var PSinglyLinkedNode[T], x: T) {.inline.} = 
+  ## creates a new node with the value `x` and appends that node to `head`.
+  ## Efficiency: O(n).
+  append(head, newSinglyLinkedNode(x))
+
+
+proc prepend*[T](head: var PDoublyLinkedNode[T], 
+                 toAdd: PDoublyLinkedNode[T]) {.inline.} = 
+  ## prepends a node to `head`. Efficiency: O(1).
+  if head == nil:
+    head = toAdd
+    # head.prev stores the last node:
+    head.prev = toAdd
+  else:
+    toAdd.next = head
+    toAdd.prev = head.prev # copy pointer to last element
+    head.prev = toAdd
+    head = toAdd
+
+proc prepend*[T](head: var PDoublyLinkedNode[T], x: T) {.inline.} = 
+  ## creates a new node with the value `x` and prepends that node to `head`.
+  ## Efficiency: O(1).
+  preprend(head, newDoublyLinkedNode(x))
+
+proc append*[T](head: var PDoublyLinkedNode[T], 
+                toAdd: PDoublyLinkedNode[T]) {.inline.} = 
+  ## appends a node to `head`. Efficiency: O(1).
+  if head == nil:
+    head = toAdd
+    # head.prev stores the last node:
+    head.prev = toAdd
+  else:
+    var last = head.prev
+    assert last.next == nil
+    last.next = toAdd
+    toAdd.prev = last
+    head.prev = toAdd # new last element
+
+proc append*[T](head: var PDoublyLinkedNode[T], x: T) {.inline.} = 
+  ## creates a new node with the value `x` and appends that node to `head`.
+  ## Efficiency: O(1).
+  append(head, newDoublyLinkedNode(x))
+
+
+
+