further steps for thread support; bootstrapping should require unzip C sources and ./build.sh

2026-07-21 16:31:39 +00:00 · 2011-05-16 00:27:47 +02:00
parent c7b3d828be
commit 67a30d8371
21 changed files with 372 additions and 421 deletions
--- a/compiler/ccgexprs.nim
+++ b/compiler/ccgexprs.nim
@@ -154,29 +154,25 @@ proc getStorageLoc(n: PNode): TStorageLoc =
  else: result = OnUnknown

 proc genRefAssign(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) =
-  if (dest.s == OnStack) or not (optRefcGC in gGlobalOptions):
+  if dest.s == OnStack or optRefcGC notin gGlobalOptions:
    appf(p.s[cpsStmts], "$1 = $2;$n", [rdLoc(dest), rdLoc(src)])
  elif dest.s == OnHeap:
    # location is on heap
    # now the writer barrier is inlined for performance:
    #
-    #    if afSrcIsNotNil in flags then begin
-    #      UseMagic(p.module, 'nimGCref');
-    #      appf(p.s[cpsStmts], 'nimGCref($1);$n', [rdLoc(src)]);
-    #    end
-    #    else if not (afSrcIsNil in flags) then begin
-    #      UseMagic(p.module, 'nimGCref');
-    #      appf(p.s[cpsStmts], 'if ($1) nimGCref($1);$n', [rdLoc(src)]);
-    #    end;
-    #    if afDestIsNotNil in flags then begin
-    #      UseMagic(p.module, 'nimGCunref');
-    #      appf(p.s[cpsStmts], 'nimGCunref($1);$n', [rdLoc(dest)]);
-    #    end
-    #    else if not (afDestIsNil in flags) then begin
-    #      UseMagic(p.module, 'nimGCunref');
-    #      appf(p.s[cpsStmts], 'if ($1) nimGCunref($1);$n', [rdLoc(dest)]);
-    #    end;
-    #    appf(p.s[cpsStmts], '$1 = $2;$n', [rdLoc(dest), rdLoc(src)]);
+    #    if afSrcIsNotNil in flags:
+    #      UseMagic(p.module, 'nimGCref')
+    #      appf(p.s[cpsStmts], 'nimGCref($1);$n', [rdLoc(src)])
+    #    elif afSrcIsNil notin flags:
+    #      UseMagic(p.module, 'nimGCref')
+    #      appf(p.s[cpsStmts], 'if ($1) nimGCref($1);$n', [rdLoc(src)])
+    #    if afDestIsNotNil in flags:
+    #      UseMagic(p.module, 'nimGCunref')
+    #      appf(p.s[cpsStmts], 'nimGCunref($1);$n', [rdLoc(dest)])
+    #    elif afDestIsNil notin flags:
+    #      UseMagic(p.module, 'nimGCunref')
+    #      appf(p.s[cpsStmts], 'if ($1) nimGCunref($1);$n', [rdLoc(dest)])
+    #    appf(p.s[cpsStmts], '$1 = $2;$n', [rdLoc(dest), rdLoc(src)])
    if canFormAcycle(dest.t):
      appcg(p.module, p.s[cpsStmts], "#asgnRef((void**) $1, $2);$n",
           [addrLoc(dest), rdLoc(src)])
@@ -196,7 +192,7 @@ proc genGenericAsgn(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) =
  # (for objects, etc.):
  if needToCopy notin flags or 
      tfShallow in skipTypes(dest.t, abstractVarRange).flags:
-    if (dest.s == OnStack) or not (optRefcGC in gGlobalOptions):
+    if dest.s == OnStack or optRefcGC notin gGlobalOptions:
      appcg(p, cpsStmts,
           "memcpy((void*)$1, (NIM_CONST void*)$2, sizeof($3));$n",
           [addrLoc(dest), addrLoc(src), rdLoc(dest)])
@@ -224,7 +220,7 @@ proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) =
    if needToCopy notin flags:
      genRefAssign(p, dest, src, flags)
    else:
-      if (dest.s == OnStack) or not (optRefcGC in gGlobalOptions):
+      if dest.s == OnStack or optRefcGC notin gGlobalOptions:
        appcg(p, cpsStmts, "$1 = #copyString($2);$n", [rdLoc(dest), rdLoc(src)])
      elif dest.s == OnHeap:
        appcg(p, cpsStmts, "#asgnRefNoCycle((void**) $1, #copyString($2));$n",
@@ -826,19 +822,7 @@ proc genCall(p: BProc, t: PNode, d: var TLoc) =
    app(pl, ")")
    app(p.s[cpsStmts], pl)
    app(p.s[cpsStmts], ';' & tnl)
-    
-  when false:
-    app(pl, ")")
-    if (typ.sons[0] != nil) and not invalidRetType:
-      if d.k == locNone: getTemp(p, typ.sons[0], d)
-      assert(d.t != nil)        # generate an assignment to d:
-      initLoc(list, locCall, nil, OnUnknown)
-      list.r = pl
-      genAssignment(p, d, list, {}) # no need for deep copying
-    else:
-      app(p.s[cpsStmts], pl)
-      app(p.s[cpsStmts], ';' & tnl)
-
+  
 proc genStrConcat(p: BProc, e: PNode, d: var TLoc) =
  #   <Nimrod code>
  #   s = 'Hello ' & name & ', how do you feel?' & 'z'
--- a/compiler/ccgstmts.nim
+++ b/compiler/ccgstmts.nim
@@ -7,13 +7,11 @@
 #    distribution, for details about the copyright.
 #

-const 
+const
  RangeExpandLimit = 256      # do not generate ranges
                              # over 'RangeExpandLimit' elements
  stringCaseThreshold = 8
    # above X strings a hash-switch for strings is generated
-    # this version sets it too high to avoid hashing, because this has not
-    # been tested for a long time

 proc genLineDir(p: BProc, t: PNode) = 
  var line = toLinenumber(t.info) # BUGFIX
@@ -23,11 +21,11 @@ proc genLineDir(p: BProc, t: PNode) =
    appff(p.s[cpsStmts], "#line $2 \"$1\"$n", "; line $2 \"$1\"$n", 
          [toRope(toFilename(t.info)), toRope(line)])
  if ({optStackTrace, optEndb} * p.Options == {optStackTrace, optEndb}) and
-      ((p.prc == nil) or not (sfPure in p.prc.flags)): 
+      (p.prc == nil or sfPure notin p.prc.flags): 
    appcg(p, cpsStmts, "#endb($1);$n", [toRope(line)])
  elif ({optLineTrace, optStackTrace} * p.Options ==
      {optLineTrace, optStackTrace}) and
-      ((p.prc == nil) or not (sfPure in p.prc.flags)): 
+      (p.prc == nil or sfPure notin p.prc.flags): 
    appf(p.s[cpsStmts], "F.line = $1;F.filename = $2;$n", 
        [toRope(line), makeCString(toFilename(t.info).extractFilename)])

@@ -458,7 +456,7 @@ proc genTryStmtCpp(p: BProc, t: PNode) =
    rethrowFlag = getTempName()
    appf(p.s[cpsLocals], "volatile NIM_BOOL $1 = NIM_FALSE;$n", [rethrowFlag])
  if optStackTrace in p.Options: 
-    appcg(p, cpsStmts, "#framePtr = (TFrame*)&F;" & tnl)
+    appcg(p, cpsStmts, "#setFrame((TFrame*)&F);$n")
  app(p.s[cpsStmts], "try {" & tnl)
  add(p.nestedTryStmts, t)
  genStmts(p, t.sons[0])
@@ -493,6 +491,72 @@ proc genTryStmtCpp(p: BProc, t: PNode) =
  if rethrowFlag != nil: 
    appf(p.s[cpsStmts], "if ($1) { throw; }$n", [rethrowFlag])
  
+proc genTryStmtCpp2(p: BProc, t: PNode) = 
+  # code to generate:
+  #
+  #  TSafePoint sp;
+  #  pushSafePoint(&sp);
+  #  sp.status = setjmp(sp.context);
+  #  if (sp.status == 0) {
+  #    myDiv(4, 9);
+  #    popSafePoint();
+  #  } else {
+  #    popSafePoint();
+  #    /* except DivisionByZero: */
+  #    if (sp.status == DivisionByZero) {
+  #      printf('Division by Zero\n');
+  #      clearException();
+  #    } else {
+  #      clearException();
+  #    }
+  #  }
+  #  /* finally: */
+  #  printf('fin!\n');
+  #  if (exception not cleared)
+  #    propagateCurrentException();
+  genLineDir(p, t)
+  var safePoint = getTempName()
+  discard cgsym(p.module, "E_Base")
+  appcg(p, cpsLocals, "#TSafePoint $1;$n", [safePoint])
+  appcg(p, cpsStmts, "#pushSafePoint(&$1);$n" &
+        "$1.status = setjmp($1.context);$n", [safePoint])
+  if optStackTrace in p.Options: 
+    appcg(p, cpsStmts, "#setFrame((TFrame*)&F);$n")
+  appf(p.s[cpsStmts], "if ($1.status == 0) {$n", [safePoint])
+  var length = sonsLen(t)
+  add(p.nestedTryStmts, t)
+  genStmts(p, t.sons[0])
+  appcg(p, cpsStmts, "#popSafePoint();$n} else {$n#popSafePoint();$n")
+  var i = 1
+  while (i < length) and (t.sons[i].kind == nkExceptBranch): 
+    var blen = sonsLen(t.sons[i])
+    if blen == 1: 
+      # general except section:
+      if i > 1: app(p.s[cpsStmts], "else {" & tnl)
+      genStmts(p, t.sons[i].sons[0])
+      appcg(p, cpsStmts, "$1.status = 0;#popCurrentException();$n", [safePoint])
+      if i > 1: app(p.s[cpsStmts], '}' & tnl)
+    else: 
+      var orExpr: PRope = nil
+      for j in countup(0, blen - 2): 
+        assert(t.sons[i].sons[j].kind == nkType)
+        if orExpr != nil: app(orExpr, "||")
+        appcg(p.module, orExpr, 
+              "#isObj(#getCurrentException()->Sup.m_type, $1)", 
+              [genTypeInfo(p.module, t.sons[i].sons[j].typ)])
+      if i > 1: app(p.s[cpsStmts], "else ")
+      appf(p.s[cpsStmts], "if ($1) {$n", [orExpr])
+      genStmts(p, t.sons[i].sons[blen-1]) 
+      # code to clear the exception:
+      appcg(p, cpsStmts, "$1.status = 0;#popCurrentException();}$n",
+           [safePoint])
+    inc(i)
+  app(p.s[cpsStmts], '}' & tnl) # end of if statement
+  discard pop(p.nestedTryStmts)
+  if i < length and t.sons[i].kind == nkFinally: 
+    genStmts(p, t.sons[i].sons[0])
+  appcg(p, cpsStmts, "if ($1.status != 0) #reraiseException();$n", [safePoint])
+  
 proc genTryStmt(p: BProc, t: PNode) = 
  # code to generate:
  #
@@ -523,7 +587,7 @@ proc genTryStmt(p: BProc, t: PNode) =
  appcg(p, cpsStmts, "#pushSafePoint(&$1);$n" &
        "$1.status = setjmp($1.context);$n", [safePoint])
  if optStackTrace in p.Options: 
-    appcg(p, cpsStmts, "#framePtr = (TFrame*)&F;" & tnl)
+    appcg(p, cpsStmts, "#setFrame((TFrame*)&F);$n")
  appf(p.s[cpsStmts], "if ($1.status == 0) {$n", [safePoint])
  var length = sonsLen(t)
  add(p.nestedTryStmts, t)
@@ -543,8 +607,9 @@ proc genTryStmt(p: BProc, t: PNode) =
      for j in countup(0, blen - 2): 
        assert(t.sons[i].sons[j].kind == nkType)
        if orExpr != nil: app(orExpr, "||")
-        appcg(p.module, orExpr, "#getCurrentException()->Sup.m_type == $1", 
-             [genTypeInfo(p.module, t.sons[i].sons[j].typ)])
+        appcg(p.module, orExpr, 
+              "#isObj(#getCurrentException()->Sup.m_type, $1)", 
+              [genTypeInfo(p.module, t.sons[i].sons[j].typ)])
      if i > 1: app(p.s[cpsStmts], "else ")
      appf(p.s[cpsStmts], "if ($1) {$n", [orExpr])
      genStmts(p, t.sons[i].sons[blen-1]) 
--- a/compiler/cgen.nim
+++ b/compiler/cgen.nim
@@ -84,6 +84,7 @@ type
    module*: PSym
    filename*: string
    s*: TCFileSections        # sections of the C file
+    PreventStackTrace: bool   # true if stack traces need to be prevented
    cfilename*: string        # filename of the module (including path,
                              # without extension)
    typeCache*: TIdTable      # cache the generated types
@@ -99,7 +100,6 @@ type
    typeNodes*, nimTypes*: int # used for type info generation
    typeNodesName*, nimTypesName*: PRope # used for type info generation
    labels*: natural          # for generating unique module-scope names
-  

 var 
  mainModProcs, mainModInit: PRope # parts of the main module
@@ -603,19 +603,12 @@ proc retIsNotVoid(s: PSym): bool =
 proc initFrame(p: BProc, procname, filename: PRope): PRope = 
  result = ropecg(p.module, 
    "F.procname = $1;$n" &
-    "F.prev = #framePtr;$n" &
    "F.filename = $2;$n" & 
    "F.line = 0;$n" & 
-    "framePtr = (TFrame*)&F;$n", [procname, filename])
+    "#pushFrame((TFrame*)&F);$n", [procname, filename])

-proc deinitFrame(p: BProc): PRope = 
-  inc(p.labels, 3)
-  result = ropeff("framePtr = framePtr->prev;$n", 
-      "%LOC$1 = load %TFrame* @framePtr$n" &
-      "%LOC$2 = getelementptr %TFrame* %LOC$1, %NI 0$n" &
-      "%LOC$3 = load %TFrame** %LOC$2$n" &
-      "store %TFrame* $LOC$3, %TFrame** @framePtr", [toRope(p.labels), 
-      toRope(p.labels - 1), toRope(p.labels - 2)])
+proc deinitFrame(p: BProc): PRope =
+  result = ropecg(p.module, "#popFrame();$n")

 proc genProcAux(m: BModule, prc: PSym) = 
  var 
@@ -628,7 +621,7 @@ proc genProcAux(m: BModule, prc: PSym) =
    header = con("N_LIB_EXPORT ", header)
  returnStmt = nil
  assert(prc.ast != nil)
-  if not (sfPure in prc.flags) and (prc.typ.sons[0] != nil): 
+  if sfPure notin prc.flags and prc.typ.sons[0] != nil:
    res = prc.ast.sons[resultPos].sym # get result symbol
    if not isInvalidReturnType(prc.typ.sons[0]): 
      # declare the result symbol:
@@ -868,14 +861,17 @@ proc genInitCode(m: BModule) =
  if m.nimTypes > 0: 
    appcg(m, m.s[cfsTypeInit1], "static #TNimType $1[$2];$n", 
          [m.nimTypesName, toRope(m.nimTypes)])
-  if optStackTrace in m.initProc.options: 
+  if optStackTrace in m.initProc.options:
+    # BUT: the generated init code might depend on a current frame, so
+    # declare it nevertheless:
    getFrameDecl(m.initProc)
+  if optStackTrace in m.initProc.options and not m.PreventStackTrace: 
    app(prc, m.initProc.s[cpsLocals])
    app(prc, m.s[cfsTypeInit1])
    procname = CStringLit(m.initProc, prc, m.module.name.s)
    filename = CStringLit(m.initProc, prc, toFilename(m.module.info))
    app(prc, initFrame(m.initProc, procname, filename))
-  else: 
+  else:
    app(prc, m.initProc.s[cpsLocals])
    app(prc, m.s[cfsTypeInit1])
  app(prc, m.s[cfsTypeInit2])
@@ -884,7 +880,8 @@ proc genInitCode(m: BModule) =
  app(prc, m.s[cfsDynLibInit])
  app(prc, m.initProc.s[cpsInit])
  app(prc, m.initProc.s[cpsStmts])
-  if optStackTrace in m.initProc.options: app(prc, deinitFrame(m.initProc))
+  if optStackTrace in m.initProc.options and not m.PreventStackTrace: 
+    app(prc, deinitFrame(m.initProc))
  app(prc, '}' & tnl & tnl)
  app(m.s[cfsProcs], prc)

@@ -911,6 +908,7 @@ proc rawNewModule(module: PSym, filename: string): BModule =
  result.forwardedProcs = @[]
  result.typeNodesName = getTempName()
  result.nimTypesName = getTempName()
+  result.PreventStackTrace = sfSystemModule in module.flags

 proc newModule(module: PSym, filename: string): BModule = 
  result = rawNewModule(module, filename)
@@ -923,6 +921,7 @@ proc registerTypeInfoModule() =
  const moduleName = "nim__dat"
  var s = NewSym(skModule, getIdent(moduleName), nil)
  gNimDat = rawNewModule(s, joinPath(options.projectPath, moduleName) & ".nim")
+  gNimDat.PreventStackTrace = true
  addPendingModule(gNimDat)
  appff(mainModProcs, "N_NOINLINE(void, $1)(void);$n", 
        "declare void $1() noinline$n", [getInitName(s)])
@@ -935,7 +934,6 @@ proc myOpenCached(module: PSym, filename: string,
                  rd: PRodReader): PPassContext = 
  if gNimDat == nil: 
    registerTypeInfoModule()
-    #MessageOut('cgen.myOpenCached has been called ' + filename)
  var cfile = changeFileExt(completeCFilePath(filename), cExt)
  var cfilenoext = changeFileExt(cfile, "")
  addFileToLink(cfilenoext)
--- a/compiler/commands.nim
+++ b/compiler/commands.nim
@@ -513,7 +513,7 @@ proc processSwitch(switch, arg: string, pass: TCmdlinePass, info: TLineInfo) =
    else: InvalidCmdLineOption(pass, switch, info)
  
 proc ProcessCommand(switch: string, pass: TCmdLinePass) = 
-  var 
+  var
    cmd, arg: string
    info: TLineInfo
  info = newLineInfo("command line", 1, 1)
--- a/install.sh
+++ b/install.sh
@@ -63,15 +63,6 @@ if [ $# -eq 1 ] ; then
  mkdir -p $libdir/wrappers/sdl || exit 1
  mkdir -p $libdir/wrappers/x11 || exit 1
  mkdir -p $libdir/wrappers/zip || exit 1
-  mkdir -p $libdir/oldwrappers || exit 1
-  mkdir -p $libdir/oldwrappers/cairo || exit 1
-  mkdir -p $libdir/oldwrappers/gtk || exit 1
-  mkdir -p $libdir/oldwrappers/lua || exit 1
-  mkdir -p $libdir/oldwrappers/opengl || exit 1
-  mkdir -p $libdir/oldwrappers/pcre || exit 1
-  mkdir -p $libdir/oldwrappers/sdl || exit 1
-  mkdir -p $libdir/oldwrappers/x11 || exit 1
-  mkdir -p $libdir/oldwrappers/zip || exit 1
  mkdir -p $libdir/windows || exit 1
  mkdir -p $libdir/posix || exit 1
  mkdir -p $libdir/ecmas || exit 1
@@ -140,8 +131,6 @@ if [ $# -eq 1 ] ; then
  chmod 644 $docdir/tut1.txt
  cp doc/tut2.txt $docdir/tut2.txt || exit 1
  chmod 644 $docdir/tut2.txt
-  cp doc/manual.html $docdir/manual.html || exit 1
-  chmod 644 $docdir/manual.html
  cp doc/mytest.cfg $docdir/mytest.cfg || exit 1
  chmod 644 $docdir/mytest.cfg
  cp doc/c2nim.pdf $docdir/c2nim.pdf || exit 1
@@ -470,136 +459,6 @@ if [ $# -eq 1 ] ; then
  chmod 644 $libdir/wrappers/zip/zzip.nim
  cp lib/wrappers/zip/libzip_all.c $libdir/wrappers/zip/libzip_all.c || exit 1
  chmod 644 $libdir/wrappers/zip/libzip_all.c
-  cp lib/oldwrappers/iup.nim $libdir/oldwrappers/iup.nim || exit 1
-  chmod 644 $libdir/oldwrappers/iup.nim
-  cp lib/oldwrappers/libcurl.nim $libdir/oldwrappers/libcurl.nim || exit 1
-  chmod 644 $libdir/oldwrappers/libcurl.nim
-  cp lib/oldwrappers/mysql.nim $libdir/oldwrappers/mysql.nim || exit 1
-  chmod 644 $libdir/oldwrappers/mysql.nim
-  cp lib/oldwrappers/odbcsql.nim $libdir/oldwrappers/odbcsql.nim || exit 1
-  chmod 644 $libdir/oldwrappers/odbcsql.nim
-  cp lib/oldwrappers/postgres.nim $libdir/oldwrappers/postgres.nim || exit 1
-  chmod 644 $libdir/oldwrappers/postgres.nim
-  cp lib/oldwrappers/python.nim $libdir/oldwrappers/python.nim || exit 1
-  chmod 644 $libdir/oldwrappers/python.nim
-  cp lib/oldwrappers/sqlite3.nim $libdir/oldwrappers/sqlite3.nim || exit 1
-  chmod 644 $libdir/oldwrappers/sqlite3.nim
-  cp lib/oldwrappers/tcl.nim $libdir/oldwrappers/tcl.nim || exit 1
-  chmod 644 $libdir/oldwrappers/tcl.nim
-  cp lib/oldwrappers/cairo/cairo.nim $libdir/oldwrappers/cairo/cairo.nim || exit 1
-  chmod 644 $libdir/oldwrappers/cairo/cairo.nim
-  cp lib/oldwrappers/cairo/cairoft.nim $libdir/oldwrappers/cairo/cairoft.nim || exit 1
-  chmod 644 $libdir/oldwrappers/cairo/cairoft.nim
-  cp lib/oldwrappers/cairo/cairowin32.nim $libdir/oldwrappers/cairo/cairowin32.nim || exit 1
-  chmod 644 $libdir/oldwrappers/cairo/cairowin32.nim
-  cp lib/oldwrappers/cairo/cairoxlib.nim $libdir/oldwrappers/cairo/cairoxlib.nim || exit 1
-  chmod 644 $libdir/oldwrappers/cairo/cairoxlib.nim
-  cp lib/oldwrappers/gtk/atk.nim $libdir/oldwrappers/gtk/atk.nim || exit 1
-  chmod 644 $libdir/oldwrappers/gtk/atk.nim
-  cp lib/oldwrappers/gtk/gdk2.nim $libdir/oldwrappers/gtk/gdk2.nim || exit 1
-  chmod 644 $libdir/oldwrappers/gtk/gdk2.nim
-  cp lib/oldwrappers/gtk/gdk2pixbuf.nim $libdir/oldwrappers/gtk/gdk2pixbuf.nim || exit 1
-  chmod 644 $libdir/oldwrappers/gtk/gdk2pixbuf.nim
-  cp lib/oldwrappers/gtk/gdkglext.nim $libdir/oldwrappers/gtk/gdkglext.nim || exit 1
-  chmod 644 $libdir/oldwrappers/gtk/gdkglext.nim
-  cp lib/oldwrappers/gtk/glib2.nim $libdir/oldwrappers/gtk/glib2.nim || exit 1
-  chmod 644 $libdir/oldwrappers/gtk/glib2.nim
-  cp lib/oldwrappers/gtk/gtk2.nim $libdir/oldwrappers/gtk/gtk2.nim || exit 1
-  chmod 644 $libdir/oldwrappers/gtk/gtk2.nim
-  cp lib/oldwrappers/gtk/gtkglext.nim $libdir/oldwrappers/gtk/gtkglext.nim || exit 1
-  chmod 644 $libdir/oldwrappers/gtk/gtkglext.nim
-  cp lib/oldwrappers/gtk/gtkhtml.nim $libdir/oldwrappers/gtk/gtkhtml.nim || exit 1
-  chmod 644 $libdir/oldwrappers/gtk/gtkhtml.nim
-  cp lib/oldwrappers/gtk/libglade2.nim $libdir/oldwrappers/gtk/libglade2.nim || exit 1
-  chmod 644 $libdir/oldwrappers/gtk/libglade2.nim
-  cp lib/oldwrappers/gtk/pango.nim $libdir/oldwrappers/gtk/pango.nim || exit 1
-  chmod 644 $libdir/oldwrappers/gtk/pango.nim
-  cp lib/oldwrappers/gtk/pangoutils.nim $libdir/oldwrappers/gtk/pangoutils.nim || exit 1
-  chmod 644 $libdir/oldwrappers/gtk/pangoutils.nim
-  cp lib/oldwrappers/lua/lauxlib.nim $libdir/oldwrappers/lua/lauxlib.nim || exit 1
-  chmod 644 $libdir/oldwrappers/lua/lauxlib.nim
-  cp lib/oldwrappers/lua/lua.nim $libdir/oldwrappers/lua/lua.nim || exit 1
-  chmod 644 $libdir/oldwrappers/lua/lua.nim
-  cp lib/oldwrappers/lua/lualib.nim $libdir/oldwrappers/lua/lualib.nim || exit 1
-  chmod 644 $libdir/oldwrappers/lua/lualib.nim
-  cp lib/oldwrappers/opengl/gl.nim $libdir/oldwrappers/opengl/gl.nim || exit 1
-  chmod 644 $libdir/oldwrappers/opengl/gl.nim
-  cp lib/oldwrappers/opengl/glext.nim $libdir/oldwrappers/opengl/glext.nim || exit 1
-  chmod 644 $libdir/oldwrappers/opengl/glext.nim
-  cp lib/oldwrappers/opengl/glu.nim $libdir/oldwrappers/opengl/glu.nim || exit 1
-  chmod 644 $libdir/oldwrappers/opengl/glu.nim
-  cp lib/oldwrappers/opengl/glut.nim $libdir/oldwrappers/opengl/glut.nim || exit 1
-  chmod 644 $libdir/oldwrappers/opengl/glut.nim
-  cp lib/oldwrappers/opengl/glx.nim $libdir/oldwrappers/opengl/glx.nim || exit 1
-  chmod 644 $libdir/oldwrappers/opengl/glx.nim
-  cp lib/oldwrappers/opengl/wingl.nim $libdir/oldwrappers/opengl/wingl.nim || exit 1
-  chmod 644 $libdir/oldwrappers/opengl/wingl.nim
-  cp lib/oldwrappers/pcre/pcre.nim $libdir/oldwrappers/pcre/pcre.nim || exit 1
-  chmod 644 $libdir/oldwrappers/pcre/pcre.nim
-  cp lib/oldwrappers/pcre/pcre_all.c $libdir/oldwrappers/pcre/pcre_all.c || exit 1
-  chmod 644 $libdir/oldwrappers/pcre/pcre_all.c
-  cp lib/oldwrappers/sdl/sdl.nim $libdir/oldwrappers/sdl/sdl.nim || exit 1
-  chmod 644 $libdir/oldwrappers/sdl/sdl.nim
-  cp lib/oldwrappers/sdl/sdl_gfx.nim $libdir/oldwrappers/sdl/sdl_gfx.nim || exit 1
-  chmod 644 $libdir/oldwrappers/sdl/sdl_gfx.nim
-  cp lib/oldwrappers/sdl/sdl_image.nim $libdir/oldwrappers/sdl/sdl_image.nim || exit 1
-  chmod 644 $libdir/oldwrappers/sdl/sdl_image.nim
-  cp lib/oldwrappers/sdl/sdl_mixer.nim $libdir/oldwrappers/sdl/sdl_mixer.nim || exit 1
-  chmod 644 $libdir/oldwrappers/sdl/sdl_mixer.nim
-  cp lib/oldwrappers/sdl/sdl_mixer_nosmpeg.nim $libdir/oldwrappers/sdl/sdl_mixer_nosmpeg.nim || exit 1
-  chmod 644 $libdir/oldwrappers/sdl/sdl_mixer_nosmpeg.nim
-  cp lib/oldwrappers/sdl/sdl_net.nim $libdir/oldwrappers/sdl/sdl_net.nim || exit 1
-  chmod 644 $libdir/oldwrappers/sdl/sdl_net.nim
-  cp lib/oldwrappers/sdl/sdl_ttf.nim $libdir/oldwrappers/sdl/sdl_ttf.nim || exit 1
-  chmod 644 $libdir/oldwrappers/sdl/sdl_ttf.nim
-  cp lib/oldwrappers/sdl/smpeg.nim $libdir/oldwrappers/sdl/smpeg.nim || exit 1
-  chmod 644 $libdir/oldwrappers/sdl/smpeg.nim
-  cp lib/oldwrappers/x11/cursorfont.nim $libdir/oldwrappers/x11/cursorfont.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/cursorfont.nim
-  cp lib/oldwrappers/x11/keysym.nim $libdir/oldwrappers/x11/keysym.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/keysym.nim
-  cp lib/oldwrappers/x11/x.nim $libdir/oldwrappers/x11/x.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/x.nim
-  cp lib/oldwrappers/x11/xatom.nim $libdir/oldwrappers/x11/xatom.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xatom.nim
-  cp lib/oldwrappers/x11/xcms.nim $libdir/oldwrappers/x11/xcms.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xcms.nim
-  cp lib/oldwrappers/x11/xf86dga.nim $libdir/oldwrappers/x11/xf86dga.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xf86dga.nim
-  cp lib/oldwrappers/x11/xf86vmode.nim $libdir/oldwrappers/x11/xf86vmode.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xf86vmode.nim
-  cp lib/oldwrappers/x11/xi.nim $libdir/oldwrappers/x11/xi.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xi.nim
-  cp lib/oldwrappers/x11/xinerama.nim $libdir/oldwrappers/x11/xinerama.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xinerama.nim
-  cp lib/oldwrappers/x11/xkb.nim $libdir/oldwrappers/x11/xkb.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xkb.nim
-  cp lib/oldwrappers/x11/xkblib.nim $libdir/oldwrappers/x11/xkblib.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xkblib.nim
-  cp lib/oldwrappers/x11/xlib.nim $libdir/oldwrappers/x11/xlib.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xlib.nim
-  cp lib/oldwrappers/x11/xrandr.nim $libdir/oldwrappers/x11/xrandr.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xrandr.nim
-  cp lib/oldwrappers/x11/xrender.nim $libdir/oldwrappers/x11/xrender.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xrender.nim
-  cp lib/oldwrappers/x11/xresource.nim $libdir/oldwrappers/x11/xresource.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xresource.nim
-  cp lib/oldwrappers/x11/xshm.nim $libdir/oldwrappers/x11/xshm.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xshm.nim
-  cp lib/oldwrappers/x11/xutil.nim $libdir/oldwrappers/x11/xutil.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xutil.nim
-  cp lib/oldwrappers/x11/xv.nim $libdir/oldwrappers/x11/xv.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xv.nim
-  cp lib/oldwrappers/x11/xvlib.nim $libdir/oldwrappers/x11/xvlib.nim || exit 1
-  chmod 644 $libdir/oldwrappers/x11/xvlib.nim
-  cp lib/oldwrappers/zip/libzip.nim $libdir/oldwrappers/zip/libzip.nim || exit 1
-  chmod 644 $libdir/oldwrappers/zip/libzip.nim
-  cp lib/oldwrappers/zip/zlib.nim $libdir/oldwrappers/zip/zlib.nim || exit 1
-  chmod 644 $libdir/oldwrappers/zip/zlib.nim
-  cp lib/oldwrappers/zip/zzip.nim $libdir/oldwrappers/zip/zzip.nim || exit 1
-  chmod 644 $libdir/oldwrappers/zip/zzip.nim
-  cp lib/oldwrappers/zip/libzip_all.c $libdir/oldwrappers/zip/libzip_all.c || exit 1
-  chmod 644 $libdir/oldwrappers/zip/libzip_all.c
  cp lib/windows/mmsystem.nim $libdir/windows/mmsystem.nim || exit 1
  chmod 644 $libdir/windows/mmsystem.nim
  cp lib/windows/nb30.nim $libdir/windows/nb30.nim || exit 1
--- a/lib/core/threads.nim
+++ b/lib/core/threads.nim
@@ -143,8 +143,6 @@ else:
    var c = cast[ptr TThreadProcClosure[TParam]](closure)
    c.fn(c.data)

-  {.passL: "-pthread".}
-  {.passC: "-pthread".}

 const
  noDeadlocks = true # compileOption("deadlockPrevention")
@@ -285,6 +283,7 @@ proc createThread*[TParam](t: var TThread[TParam],
  ## proc `tp`. `param` is passed to `tp`.
  t.c.data = param
  t.c.fn = tp
+  CreateThreadLocalStorage()
  when hostOS == "windows":
    var dummyThreadId: int32
    t.sys = CreateThread(nil, 0'i32, threadProcWrapper[TParam], 
--- a/lib/nimbase.h
+++ b/lib/nimbase.h
@@ -400,15 +400,6 @@ static unsigned long nimNaN[2]={0xffffffff, 0x7fffffff};
 #    define INF (1.0 / 0.0)
 #  endif
 #endif
-/*
-typedef struct TSafePoint TSafePoint;
-struct TSafePoint {
-  NI exc;
-  NCSTRING excname;
-  NCSTRING msg;
-  TSafePoint* prev;
-  jmp_buf context;
-}; */

 typedef struct TFrame TFrame;
 struct TFrame {
@@ -419,25 +410,8 @@ struct TFrame {
  NI len;
 };

-/*
-extern TFrame* framePtr;
-extern TSafePoint* excHandler; */
-
-#if defined(__cplusplus)
-struct NimException {
-  TSafePoint sp;
-
-  NimException(NI aExc, NCSTRING aExcname, NCSTRING aMsg) {
-    sp.exc = aExc; sp.excname = aExcname; sp.msg = aMsg;
-    sp.prev = excHandler;
-    excHandler = &sp;
-  }
-};
-#endif
-
 #define NIM_POSIX_INIT  __attribute__((constructor)) 

-
 #if defined(_MSCVER) && defined(__i386__)
 __declspec(naked) int __fastcall NimXadd(volatile int* pNum, int val) {
  __asm {
--- a/lib/system.nim
+++ b/lib/system.nim
@@ -44,10 +44,6 @@ type
  typeDesc* {.magic: TypeDesc.} ## meta type to denote
                                ## a type description (for templates)

-const
-  hasThreadSupport = false # deactivate for now: thread stack walking
-                           # is missing!
-
 proc defined*[T](x: T): bool {.magic: "Defined", noSideEffect.}
  ## Special compile-time procedure that checks whether `x` is
  ## defined. `x` has to be an identifier or a qualified identifier.
@@ -779,7 +775,10 @@ proc compileOption*(option, arg: string): bool {.
  ## .. code-block:: nimrod
  ##   when compileOption("opt", "size") and compileOption("gc", "boehm"): 
  ##     echo "compiled with optimization for size and uses Boehm's GC"
-  
+
+const
+  hasThreadSupport = compileOption("threads")
+
 include "system/inclrtl"

 when not defined(ecmascript) and not defined(nimrodVm):
@@ -1391,19 +1390,20 @@ type
    filename: CString
    len: int  # length of slots (when not debugging always zero)

-var
-  framePtr {.threadvar, compilerproc.}: PFrame
+when defined(ecmaScript):
+  var
+    framePtr {.compilerproc.}: PFrame

 when not defined(ECMAScript):
-  {.push overflow_checks:off}
-  proc add* (x: var string, y: cstring) =
+  {.push stack_trace:off}
+  proc add*(x: var string, y: cstring) =
    var i = 0
    while y[i] != '\0':
      add(x, y[i])
      inc(i)
  {.pop.}
 else:
-  proc add* (x: var string, y: cstring) {.pure.} =
+  proc add*(x: var string, y: cstring) {.pure.} =
    asm """
      var len = `x`[0].length-1;
      for (var i = 0; i < `y`.length; ++i) {
@@ -1413,10 +1413,6 @@ else:
      `x`[0][len] = 0
    """

-proc `/`*(x, y: int): float {.inline, noSideEffect.} =
-  ## integer division that results in a float.
-  result = toFloat(x) / toFloat(y)
-
 proc echo*[Ty](x: openarray[Ty]) {.magic: "Echo".}
  ## equivalent to ``writeln(stdout, x); flush(stdout)``. BUT: This is
  ## available for the ECMAScript target too!
@@ -1450,6 +1446,7 @@ proc quit*(errorcode: int = QuitSuccess) {.
  ## unless a quit procedure calls ``GC_collect``.

 when not defined(EcmaScript) and not defined(NimrodVM):
+  {.push stack_trace: off.}

  proc atomicInc*(memLoc: var int, x: int): int {.inline.}
    ## atomic increment of `memLoc`. Returns the value after the operation.
@@ -1475,8 +1472,6 @@ when not defined(EcmaScript) and not defined(NimrodVM):
  initStackBottom()
  initGC() # BUGFIX: need to be called here!

-  {.push stack_trace: off.}
-
  include "system/ansi_c"

  proc cmp(x, y: string): int =
@@ -1650,25 +1645,6 @@ when not defined(EcmaScript) and not defined(NimrodVM):
    ## retrieves the current position of the file pointer that is used to
    ## read from the file `f`. The file's first byte has the index zero.

-  include "system/sysio"
-
-  iterator lines*(filename: string): string =
-    ## Iterate over any line in the file named `filename`.
-    ## If the file does not exist `EIO` is raised.
-    var f = open(filename)
-    var res = ""
-    while not endOfFile(f):
-      rawReadLine(f, res)
-      yield res
-    Close(f)
-
-  iterator lines*(f: TFile): string =
-    ## Iterate over any line in the file `f`.
-    var res = ""
-    while not endOfFile(f):
-      rawReadLine(f, res)
-      yield res
-
  proc fileHandle*(f: TFile): TFileHandle {.importc: "fileno",
                                            header: "<stdio.h>"}
    ## returns the OS file handle of the file ``f``. This is only useful for
@@ -1694,6 +1670,26 @@ when not defined(EcmaScript) and not defined(NimrodVM):
  # as it would recurse endlessly!
  include "system/arithm"
  {.pop.} # stack trace
+
+  include "system/sysio"
+
+  iterator lines*(filename: string): string =
+    ## Iterate over any line in the file named `filename`.
+    ## If the file does not exist `EIO` is raised.
+    var f = open(filename)
+    var res = ""
+    while not endOfFile(f):
+      rawReadLine(f, res)
+      yield res
+    Close(f)
+
+  iterator lines*(f: TFile): string =
+    ## Iterate over any line in the file `f`.
+    var res = ""
+    while not endOfFile(f):
+      rawReadLine(f, res)
+      yield res
+      
  include "system/dyncalls"
  include "system/sets"

@@ -1723,14 +1719,18 @@ when not defined(EcmaScript) and not defined(NimrodVM):
      result = n.sons[n.len]

  include "system/systhread"
+  {.push stack_trace: off.}
  include "system/mmdisp"
+  {.pop.}
+
  include "system/sysstr"
  include "system/assign"
  include "system/repr"

  proc getCurrentException*(): ref E_Base {.compilerRtl, inl.} =
    ## retrieves the current exception; if there is none, nil is returned.
-    result = currException
+    ThreadGlobals()
+    result = ||currException

  proc getCurrentExceptionMsg*(): string {.inline.} =
    ## retrieves the error message that was attached to the current
@@ -1789,6 +1789,10 @@ proc quit*(errormsg: string, errorcode = QuitFailure) {.noReturn.} =
 {.pop.} # checks
 {.pop.} # hints

+proc `/`*(x, y: int): float {.inline, noSideEffect.} =
+  ## integer division that results in a float.
+  result = toFloat(x) / toFloat(y)
+
 template `-|`(b, s: expr): expr =
  (if b >= 0: b else: s.len + b)

--- a/lib/system/cgprocs.nim
+++ b/lib/system/cgprocs.nim
@@ -23,50 +23,3 @@ proc nimLoadLibraryError(path: string) {.compilerproc, noinline.}

 proc setStackBottom(theStackBottom: pointer) {.compilerRtl, noinline.}

-when false:
-  # Support for thread local storage:
-  when defined(windows):
-    type
-      TThreadVarSlot {.compilerproc.} = distinct int32
-
-    proc TlsAlloc(): TThreadVarSlot {.
-      importc: "TlsAlloc", stdcall, dynlib: "kernel32".}
-    proc TlsSetValue(dwTlsIndex: TThreadVarSlot, lpTlsValue: pointer) {.
-      importc: "TlsSetValue", stdcall, dynlib: "kernel32".}
-    proc TlsGetValue(dwTlsIndex: TThreadVarSlot): pointer {.
-      importc: "TlsGetValue", stdcall, dynlib: "kernel32".}
-    
-    proc ThreadVarAlloc(): TThreadVarSlot {.compilerproc, inline.} =
-      result = TlsAlloc()
-    proc ThreadVarSetValue(s: TThreadVarSlot, value: pointer) {.
-                           compilerproc, inline.} =
-      TlsSetValue(s, value)
-    proc ThreadVarGetValue(s: TThreadVarSlot): pointer {.
-                           compilerproc, inline.} =
-      result = TlsGetValue(s)
-    
-  else:
-    type
-      Tpthread_key {.importc: "pthread_key_t", 
-                     header: "<sys/types.h>".} = distinct int
-      TThreadVarSlot {.compilerproc.} = Tpthread_key
-
-    proc pthread_getspecific(a1: Tpthread_key): pointer {.
-      importc: "pthread_getspecific", header: "<pthread.h>".}
-    proc pthread_key_create(a1: ptr Tpthread_key, 
-                            destruct: proc (x: pointer) {.noconv.}): int32 {.
-      importc: "pthread_key_create", header: "<pthread.h>".}
-    proc pthread_key_delete(a1: Tpthread_key): int32 {.
-      importc: "pthread_key_delete", header: "<pthread.h>".}
-
-    proc pthread_setspecific(a1: Tpthread_key, a2: pointer): int32 {.
-      importc: "pthread_setspecific", header: "<pthread.h>".}
-    
-    proc ThreadVarAlloc(): TThreadVarSlot {.compilerproc, inline.} =
-      discard pthread_key_create(addr(result), nil)
-    proc ThreadVarSetValue(s: TThreadVarSlot, value: pointer) {.
-                           compilerproc, inline.} =
-      discard pthread_setspecific(s, value)
-    proc ThreadVarGetValue(s: TThreadVarSlot): pointer {.compilerproc, inline.} =
-      result = pthread_getspecific(s)
-
--- a/lib/system/debugger.nim
+++ b/lib/system/debugger.nim
@@ -85,8 +85,7 @@ proc openAppend(filename: string): TFile =
    write(result, "----------------------------------------\n")

 proc dbgRepr(p: pointer, typ: PNimType): string =
-  var
-    cl: TReprClosure
+  var cl: TReprClosure
  initReprClosure(cl)
  cl.recDepth = maxDisplayRecDepth
  # locks for the GC turned out to be a bad idea...
@@ -139,8 +138,10 @@ proc dbgShowCurrentProc(dbgFramePointer: PFrame) =
    write(stdout, "*** endb| (procedure name not available) ***\n")

 proc dbgShowExecutionPoint() =
-  write(stdout, "*** endb| " & $framePtr.filename & "(" & $framePtr.line &
-                ") " & $framePtr.procname & " ***\n")
+  ThreadGlobals()
+  write(stdout, "*** endb| " & $(||framePtr).filename & 
+                "(" & $(||framePtr).line & ") " & 
+                $(||framePtr).procname & " ***\n")

 when defined(windows) or defined(dos) or defined(os2):
  {.define: FileSystemCaseInsensitive.}
@@ -171,9 +172,10 @@ proc fileMatches(c, bp: cstring): bool =
  return true

 proc dbgBreakpointReached(line: int): int =
+  ThreadGlobals()
  for i in 0..dbgBPlen-1:
    if line >= dbgBP[i].low and line <= dbgBP[i].high and
-        fileMatches(framePtr.filename, dbgBP[i].filename): return i
+        fileMatches((||framePtr).filename, dbgBP[i].filename): return i
  return -1

 proc scanAndAppendWord(src: string, a: var string, start: int): int =
@@ -255,6 +257,7 @@ proc hasExt(s: string): bool =
  return false

 proc setBreakPoint(s: string, start: int) =
+  ThreadGlobals()
  var dbgTemp: string
  var i = scanWord(s, dbgTemp, start)
  if i <= start:
@@ -269,7 +272,7 @@ proc setBreakPoint(s: string, start: int) =
  i = scanNumber(s, dbgBP[x].low, i)
  if dbgBP[x].low == 0:
    # set to current line:
-    dbgBP[x].low = framePtr.line
+    dbgBP[x].low = (||framePtr).line
  i = scanNumber(s, dbgBP[x].high, i)
  if dbgBP[x].high == 0: # set to low:
    dbgBP[x].high = dbgBP[x].low
@@ -278,7 +281,7 @@ proc setBreakPoint(s: string, start: int) =
    if not hasExt(dbgTemp): add(dbgTemp, ".nim")
    dbgBP[x].filename = dbgTemp
  else: # use current filename
-    dbgBP[x].filename = $framePtr.filename
+    dbgBP[x].filename = $(||framePtr).filename
  # skip whitespace:
  while s[i] in {' ', '\t'}: inc(i)
  if s[i] != '\0':
@@ -347,9 +350,10 @@ proc dbgStackFrame(s: string, start: int, currFrame: PExtendedFrame) =

 proc CommandPrompt() =
  # if we return from this routine, user code executes again
+  ThreadGlobals()
  var
    again = True
-    dbgFramePtr = framePtr # for going down and up the stack
+    dbgFramePtr = ||framePtr # for going down and up the stack
    dbgDown = 0 # how often we did go down

  while again:
@@ -366,11 +370,11 @@ proc CommandPrompt() =
      again = false
    of "n", "next":
      dbgState = dbStepOver
-      dbgSkipToFrame = framePtr
+      dbgSkipToFrame = ||framePtr
      again = false
    of "f", "skipcurrent":
      dbgState = dbSkipCurrent
-      dbgSkipToFrame = framePtr.prev
+      dbgSkipToFrame = (||framePtr).prev
      again = false
    of "c", "continue":
      dbgState = dbBreakpoints
@@ -401,7 +405,7 @@ proc CommandPrompt() =
      if dbgDown <= 0:
        debugOut("[Warning] cannot go up any further ")
      else:
-        dbgFramePtr = framePtr
+        dbgFramePtr = ||framePtr
        for j in 0 .. dbgDown-2: # BUGFIX
          dbgFramePtr = dbgFramePtr.prev
        dec(dbgDown)
@@ -442,16 +446,17 @@ proc endbStep() =
  CommandPrompt()

 proc checkForBreakpoint() =
-  var i = dbgBreakpointReached(framePtr.line)
+  ThreadGlobals()
+  var i = dbgBreakpointReached((||framePtr).line)
  if i >= 0:
    write(stdout, "*** endb| reached ")
    write(stdout, dbgBP[i].name)
    write(stdout, " in ")
-    write(stdout, framePtr.filename)
+    write(stdout, (||framePtr).filename)
    write(stdout, "(")
-    write(stdout, framePtr.line)
+    write(stdout, (||framePtr).line)
    write(stdout, ") ")
-    write(stdout, framePtr.procname)
+    write(stdout, (||framePtr).procname)
    write(stdout, " ***\n")
    CommandPrompt()

@@ -482,7 +487,8 @@ proc endb(line: int) {.compilerproc.} =
  # Thus, it must have as few parameters as possible to keep the
  # code size small!
  # Check if we are at an enabled breakpoint or "in the mood"
-  framePtr.line = line # this is done here for smaller code size!
+  ThreadGlobals()
+  (||framePtr).line = line # this is done here for smaller code size!
  if dbgLineHook != nil: dbgLineHook()
  case dbgState
  of dbStepInto:
@@ -490,7 +496,7 @@ proc endb(line: int) {.compilerproc.} =
    dbgShowExecutionPoint()
    CommandPrompt()
  of dbSkipCurrent, dbStepOver: # skip current routine
-    if framePtr == dbgSkipToFrame:
+    if ||framePtr == dbgSkipToFrame:
      dbgShowExecutionPoint()
      CommandPrompt()
    else: # breakpoints are wanted though (I guess)
--- a/lib/system/dyncalls.nim
+++ b/lib/system/dyncalls.nim
@@ -12,6 +12,8 @@
 # However, the interface has been designed to take platform differences into
 # account and been ported to all major platforms.

+{.push stack_trace: off.}
+
 const
  NilLibHandle: TLibHandle = nil

@@ -135,3 +137,6 @@ elif defined(mac):

 else:
  {.error: "no implementation for dyncalls".}
+  
+{.pop.}
+
--- a/lib/system/excpt.nim
+++ b/lib/system/excpt.nim
@@ -13,6 +13,7 @@
 var
  stackTraceNewLine* = "\n" ## undocumented feature; it is replaced by ``<br>``
                            ## for CGI applications
+  isMultiThreaded: bool # true when prog created at least 1 thread

 when not defined(windows) or not defined(guiapp):
  proc writeToStdErr(msg: CString) = write(stdout, msg)
@@ -36,30 +37,139 @@ type
  TSafePoint {.compilerproc, final.} = object
    prev: PSafePoint # points to next safe point ON THE STACK
    status: int
-    exc: ref E_Base  # XXX only needed for bootstrapping; unused
    context: C_JmpBuf

-#when hasThreadSupport: nil
+when hasThreadSupport:
+  # Support for thread local storage:
+  when defined(windows):
+    type
+      TThreadVarSlot {.compilerproc.} = distinct int32

-var
-  excHandler {.threadvar, compilerproc.}: PSafePoint = nil
-    # list of exception handlers
-    # a global variable for the root of all try blocks
-  currException {.threadvar.}: ref E_Base
+    proc TlsAlloc(): TThreadVarSlot {.
+      importc: "TlsAlloc", stdcall, dynlib: "kernel32".}
+    proc TlsSetValue(dwTlsIndex: TThreadVarSlot, lpTlsValue: pointer) {.
+      importc: "TlsSetValue", stdcall, dynlib: "kernel32".}
+    proc TlsGetValue(dwTlsIndex: TThreadVarSlot): pointer {.
+      importc: "TlsGetValue", stdcall, dynlib: "kernel32".}
+    
+    proc ThreadVarAlloc(): TThreadVarSlot {.compilerproc, inline.} =
+      result = TlsAlloc()
+    proc ThreadVarSetValue(s: TThreadVarSlot, value: pointer) {.
+                           compilerproc, inline.} =
+      TlsSetValue(s, value)
+    proc ThreadVarGetValue(s: TThreadVarSlot): pointer {.
+                           compilerproc, inline.} =
+      result = TlsGetValue(s)
+    
+  else:
+    {.passL: "-pthread".}
+    {.passC: "-pthread".}
+
+    type
+      Tpthread_key {.importc: "pthread_key_t", 
+                     header: "<sys/types.h>".} = distinct int
+      TThreadVarSlot {.compilerproc.} = Tpthread_key
+
+    proc pthread_getspecific(a1: Tpthread_key): pointer {.
+      importc: "pthread_getspecific", header: "<pthread.h>".}
+    proc pthread_key_create(a1: ptr Tpthread_key, 
+                            destruct: proc (x: pointer) {.noconv.}): int32 {.
+      importc: "pthread_key_create", header: "<pthread.h>".}
+    proc pthread_key_delete(a1: Tpthread_key): int32 {.
+      importc: "pthread_key_delete", header: "<pthread.h>".}
+
+    proc pthread_setspecific(a1: Tpthread_key, a2: pointer): int32 {.
+      importc: "pthread_setspecific", header: "<pthread.h>".}
+    
+    proc specificDestroy(mem: pointer) {.noconv.} = dealloc(mem)
+    
+    proc ThreadVarAlloc(): TThreadVarSlot {.compilerproc, inline.} =
+      discard pthread_key_create(addr(result), specificDestroy)
+    proc ThreadVarSetValue(s: TThreadVarSlot, value: pointer) {.
+                           compilerproc, inline.} =
+      discard pthread_setspecific(s, value)
+    proc ThreadVarGetValue(s: TThreadVarSlot): pointer {.compilerproc, inline.} =
+      result = pthread_getspecific(s)
+      
+  type
+    TGlobals {.final, pure.} = object
+      excHandler: PSafePoint
+      currException: ref E_Base
+      framePtr: PFrame
+      buf: string       # cannot be allocated on the stack!
+      assertBuf: string # we need a different buffer for
+                        # assert, as it raises an exception and
+                        # exception handler needs the buffer too
+      gAssertionFailed: ref EAssertionFailed
+      tempFrames: array [0..127, PFrame] # cannot be allocated on the stack!
+      data: float # compiler should add thread local variables here!
+    PGlobals = ptr TGlobals
+
+  var globalsSlot = ThreadVarAlloc()
+  proc CreateThreadLocalStorage*() {.inl.} =
+    isMultiThreaded = true
+    ThreadVarSetValue(globalsSlot, alloc0(sizeof(TGlobals)))
+    
+  proc GetGlobals(): PGlobals {.compilerRtl, inl.} =
+    result = cast[PGlobals](ThreadVarGetValue(globalsSlot))
+
+  # create for the main thread:
+  ThreadVarSetValue(globalsSlot, alloc0(sizeof(TGlobals)))
+
+when hasThreadSupport:
+  template ThreadGlobals = 
+    var globals = GetGlobals()
+  template `||`(varname: expr): expr = globals.varname
+  
+  ThreadGlobals()
+else:
+  template ThreadGlobals = nil # nothing
+  template `||`(varname: expr): expr = varname
+
+  var
+    framePtr {.compilerproc.}: PFrame # XXX only temporarily a compilerproc
+    excHandler: PSafePoint = nil
+      # list of exception handlers
+      # a global variable for the root of all try blocks
+    currException: ref E_Base
+
+    buf: string       # cannot be allocated on the stack!
+    assertBuf: string # we need a different buffer for
+                      # assert, as it raises an exception and
+                      # exception handler needs the buffer too
+    tempFrames: array [0..127, PFrame] # cannot be allocated on the stack!
+    gAssertionFailed: ref EAssertionFailed
+
+proc pushFrame(s: PFrame) {.compilerRtl, inl.} = 
+  ThreadGlobals()
+  s.prev = ||framePtr
+  ||framePtr = s
+
+proc popFrame {.compilerRtl, inl.} =
+  ThreadGlobals()
+  ||framePtr = (||framePtr).prev
+
+proc setFrame(s: PFrame) {.compilerRtl, inl.} =
+  ThreadGlobals()
+  ||framePtr = s

 proc pushSafePoint(s: PSafePoint) {.compilerRtl, inl.} = 
-  s.prev = excHandler
-  excHandler = s
+  ThreadGlobals()
+  s.prev = ||excHandler
+  ||excHandler = s

 proc popSafePoint {.compilerRtl, inl.} =
-  excHandler = excHandler.prev
+  ThreadGlobals()
+  ||excHandler = (||excHandler).prev

 proc pushCurrentException(e: ref E_Base) {.compilerRtl, inl.} = 
-  e.parent = currException
-  currException = e
+  ThreadGlobals()
+  e.parent = ||currException
+  ||currException = e

 proc popCurrentException {.compilerRtl, inl.} =
-  currException = currException.parent
+  ThreadGlobals()
+  ||currException = (||currException).parent

 # some platforms have native support for stack traces:
 const
@@ -80,11 +190,16 @@ when defined(nativeStacktrace) and nativeStackTraceSupported:
  proc dladdr(addr1: pointer, info: ptr TDl_info): int {.
    importc: "dladdr", header: "<dlfcn.h>".}

-  var
-    tempAddresses: array [0..127, pointer] # cannot be allocated on the stack!
-    tempDlInfo: TDl_info
+  when not hasThreadSupport:
+    var
+      tempAddresses: array [0..127, pointer] # should not be alloc'd on stack
+      tempDlInfo: TDl_info

  proc auxWriteStackTraceWithBacktrace(s: var string) =
+    when hasThreadSupport:
+      var
+        tempAddresses: array [0..127, pointer] # but better than a threadvar
+        tempDlInfo: TDl_info
    # This is allowed to be expensive since it only happens during crashes
    # (but this way you don't need manual stack tracing)
    var size = backtrace(cast[ptr pointer](addr(tempAddresses)), 
@@ -108,24 +223,18 @@ when defined(nativeStacktrace) and nativeStackTraceSupported:
          # Once we're past signalHandler, we're at what the user is
          # interested in
          enabled = true
-
-var
-  buf: string       # cannot be allocated on the stack!
-  assertBuf: string # we need a different buffer for
-                    # assert, as it raises an exception and
-                    # exception handler needs the buffer too
-  tempFrames: array [0..127, PFrame] # cannot be allocated on the stack!
  
 proc auxWriteStackTrace(f: PFrame, s: var string) =
  const 
    firstCalls = 32
+  ThreadGlobals()  
  var
    it = f
    i = 0
    total = 0
-  while it != nil and i <= high(tempFrames)-(firstCalls-1):
+  while it != nil and i <= high(||tempFrames)-(firstCalls-1):
    # the (-1) is for a nil entry that marks where the '...' should occur
-    tempFrames[i] = it
+    (||tempFrames)[i] = it
    inc(i)
    inc(total)
    it = it.prev
@@ -136,37 +245,38 @@ proc auxWriteStackTrace(f: PFrame, s: var string) =
  for j in 1..total-i-(firstCalls-1): 
    if b != nil: b = b.prev
  if total != i:
-    tempFrames[i] = nil
+    (||tempFrames)[i] = nil
    inc(i)
-  while b != nil and i <= high(tempFrames):
-    tempFrames[i] = b
+  while b != nil and i <= high(||tempFrames):
+    (||tempFrames)[i] = b
    inc(i)
    b = b.prev
  for j in countdown(i-1, 0):
-    if tempFrames[j] == nil: 
+    if (||tempFrames)[j] == nil: 
      add(s, "(")
      add(s, $(total-i-1))
      add(s, " calls omitted) ...")
    else:
      var oldLen = s.len
-      add(s, tempFrames[j].filename)
-      if tempFrames[j].line > 0:
+      add(s, (||tempFrames)[j].filename)
+      if (||tempFrames)[j].line > 0:
        add(s, '(')
-        add(s, $tempFrames[j].line)
+        add(s, $(||tempFrames)[j].line)
        add(s, ')')
      for k in 1..max(1, 25-(s.len-oldLen)): add(s, ' ')
-      add(s, tempFrames[j].procname)
+      add(s, (||tempFrames)[j].procname)
    add(s, stackTraceNewLine)

 proc rawWriteStackTrace(s: var string) =
  when nimrodStackTrace:
-    if framePtr == nil:
+    ThreadGlobals()
+    if ||framePtr == nil:
      add(s, "No stack traceback available")
      add(s, stackTraceNewLine)
    else:
      add(s, "Traceback (most recent call last)")
      add(s, stackTraceNewLine)
-      auxWriteStackTrace(framePtr, s)
+      auxWriteStackTrace(||framePtr, s)
  elif defined(nativeStackTrace) and nativeStackTraceSupported:
    add(s, "Traceback from system (most recent call last)")
    add(s, stackTraceNewLine)
@@ -184,53 +294,53 @@ proc quitOrDebug() {.inline.} =
 proc raiseException(e: ref E_Base, ename: CString) {.compilerRtl.} =
  GC_disable() # a bad thing is an error in the GC while raising an exception
  e.name = ename
-  if excHandler != nil:
+  ThreadGlobals()
+  if ||excHandler != nil:
    pushCurrentException(e)
-    c_longjmp(excHandler.context, 1)
+    c_longjmp((||excHandler).context, 1)
  else:
-    if not isNil(buf):
-      setLen(buf, 0)
-      rawWriteStackTrace(buf)
+    if not isNil(||buf):
+      setLen(||buf, 0)
+      rawWriteStackTrace(||buf)
      if e.msg != nil and e.msg[0] != '\0':
-        add(buf, "Error: unhandled exception: ")
-        add(buf, $e.msg)
+        add(||buf, "Error: unhandled exception: ")
+        add(||buf, $e.msg)
      else:
-        add(buf, "Error: unhandled exception")
-      add(buf, " [")
-      add(buf, $ename)
-      add(buf, "]\n")
-      writeToStdErr(buf)
+        add(||buf, "Error: unhandled exception")
+      add(||buf, " [")
+      add(||buf, $ename)
+      add(||buf, "]\n")
+      writeToStdErr(||buf)
    else:
      writeToStdErr(ename)
    quitOrDebug()
  GC_enable()

 proc reraiseException() {.compilerRtl.} =
-  if currException == nil:
+  ThreadGlobals()
+  if ||currException == nil:
    raise newException(ENoExceptionToReraise, "no exception to reraise")
  else:
-    raiseException(currException, currException.name)
-
-var
-  gAssertionFailed: ref EAssertionFailed
+    raiseException(||currException, (||currException).name)

 proc internalAssert(file: cstring, line: int, cond: bool) {.compilerproc.} =
  if not cond:
+    ThreadGlobals()    
    #c_fprintf(c_stdout, "Assertion failure: file %s line %ld\n", file, line)
    #quit(1)
    GC_disable() # BUGFIX: `$` allocates a new string object!
-    if not isNil(assertBuf):
+    if not isNil(||assertBuf):
      # BUGFIX: when debugging the GC, assertBuf may be nil
-      setLen(assertBuf, 0)
-      add(assertBuf, "[Assertion failure] file: ")
-      add(assertBuf, file)
-      add(assertBuf, " line: ")
-      add(assertBuf, $line)
-      add(assertBuf, "\n")
-      gAssertionFailed.msg = assertBuf
+      setLen(||assertBuf, 0)
+      add(||assertBuf, "[Assertion failure] file: ")
+      add(||assertBuf, file)
+      add(||assertBuf, " line: ")
+      add(||assertBuf, $line)
+      add(||assertBuf, "\n")
+      (||gAssertionFailed).msg = ||assertBuf
    GC_enable()
-    if gAssertionFailed != nil:
-      raise gAssertionFailed
+    if ||gAssertionFailed != nil:
+      raise ||gAssertionFailed
    else:
      c_fprintf(c_stdout, "Assertion failure: file %s line %ld\n", file, line)
      quit(1)
@@ -245,23 +355,24 @@ var

 proc signalHandler(sig: cint) {.exportc: "signalHandler", noconv.} =
  # print stack trace and quit
+  ThreadGlobals()
  var s = sig
  GC_disable()
-  setLen(buf, 0)
-  rawWriteStackTrace(buf)
+  setLen(||buf, 0)
+  rawWriteStackTrace(||buf)

-  if s == SIGINT: add(buf, "SIGINT: Interrupted by Ctrl-C.\n")
+  if s == SIGINT: add(||buf, "SIGINT: Interrupted by Ctrl-C.\n")
  elif s == SIGSEGV: 
-    add(buf, "SIGSEGV: Illegal storage access. (Attempt to read from nil?)\n")
+    add(||buf, "SIGSEGV: Illegal storage access. (Attempt to read from nil?)\n")
  elif s == SIGABRT:
    if dbgAborting: return # the debugger wants to abort
-    add(buf, "SIGABRT: Abnormal termination.\n")
-  elif s == SIGFPE: add(buf, "SIGFPE: Arithmetic error.\n")
-  elif s == SIGILL: add(buf, "SIGILL: Illegal operation.\n")
+    add(||buf, "SIGABRT: Abnormal termination.\n")
+  elif s == SIGFPE: add(||buf, "SIGFPE: Arithmetic error.\n")
+  elif s == SIGILL: add(||buf, "SIGILL: Illegal operation.\n")
  elif s == SIGBUS: 
-    add(buf, "SIGBUS: Illegal storage access. (Attempt to read from nil?)\n")
-  else: add(buf, "unknown signal\n")
-  writeToStdErr(buf)
+    add(||buf, "SIGBUS: Illegal storage access. (Attempt to read from nil?)\n")
+  else: add(||buf, "unknown signal\n")
+  writeToStdErr(||buf)
  dbgAborting = True # play safe here...
  GC_enable()
  quit(1) # always quit when SIGABRT
@@ -278,11 +389,9 @@ when not defined(noSignalHandler):
  registerSignalHandler() # call it in initialization section
 # for easier debugging of the GC, this memory is only allocated after the
 # signal handlers have been registered
-new(gAssertionFailed)
-buf = newString(2048)
-assertBuf = newString(2048)
-setLen(buf, 0)
-setLen(assertBuf, 0)
+new(||gAssertionFailed)
+||buf = newStringOfCap(2000)
+||assertBuf = newStringOfCap(2000)

 proc raiseRangeError(val: biggestInt) {.compilerproc, noreturn, noinline.} =
  raise newException(EOutOfRange, "value " & $val & " out of range")
--- a/lib/system/gc.nim
+++ b/lib/system/gc.nim
@@ -391,7 +391,7 @@ proc newObj(typ: PNimType, size: int): pointer {.compilerRtl.} =
  assert((cast[TAddress](res) and (MemAlign-1)) == 0)
  # now it is buffered in the ZCT
  res.typ = typ
-  when debugGC:
+  when debugGC and not hasThreadSupport:
    if framePtr != nil and framePtr.prev != nil:
      res.filename = framePtr.prev.filename
      res.line = framePtr.prev.line
--- a/lib/system/hti.nim
+++ b/lib/system/hti.nim
@@ -1,7 +1,7 @@
 #
 #
 #            Nimrod's Runtime Library
-#        (c) Copyright 2009 Andreas Rumpf
+#        (c) Copyright 2011 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
 #    distribution, for details about the copyright.
--- a/lib/system/systhread.nim
+++ b/lib/system/systhread.nim
@@ -23,9 +23,6 @@ else:
    inc(p, val)
    result = p

-var
-  isMultiThreaded: bool # true when prog created at least 1 thread
-
 proc atomicInc(memLoc: var int, x: int): int =
  when hasThreadSupport:
    result = sync_add_and_fetch(memLoc, x)
--- a/tests/accept/run/texcsub.nim
+++ b/tests/accept/run/texcsub.nim
@@ -1,7 +1,6 @@
 discard """
  file: "texcsub.nim"
  output: "caught!"
-  disabled: true
 """
 # Test inheritance for exception matching:

--- a/todo.txt
+++ b/todo.txt
@@ -1,5 +1,4 @@
-* thread support: threadvar on Windows seems broken; 
-  add --deadlock_prevention:on|off switch
+* add --deadlock_prevention:on|off switch; timeout for locks
 * implicit ref/ptr->var conversion


@@ -21,7 +20,6 @@ Bugs
 ----
 - proc (x: int) is passable to proc (x: var int)  !?
 - the parser allows empty object case branches
- Exception matching needs to take subclasses into account
 - pegs: the anchor '^' does not work because many procs use a linear search
  and matchLen()
 - BUG: generic assign still buggy
--- a/tools/nimgrep.nim
+++ b/tools/nimgrep.nim
@@ -142,7 +142,7 @@ proc processFile(filename: string) =
    if t.first <= 0: break
    inc(line, countLines(buffer, i, t.first-1))
    
-    var wholeMatch = buffer.copy(t.first, t.last)
+    var wholeMatch = buffer.substr(t.first, t.last)
    
    if optReplace notin options: 
      highlight(buffer, wholeMatch, "", t, line, showRepl=false)
@@ -168,15 +168,15 @@ proc processFile(filename: string) =
      else:
        highlight(buffer, wholeMatch, r, t, line, showRepl=reallyReplace)
      if reallyReplace:
-        result.add(buffer.copy(i, t.first-1))
+        result.add(buffer.substr(i, t.first-1))
        result.add(r)
      else:
-        result.add(buffer.copy(i, t.last))
+        result.add(buffer.substr(i, t.last))

    inc(line, countLines(buffer, t.first, t.last))
    i = t.last+1
  if optReplace in options:
-    result.add(copy(buffer, i))
+    result.add(substr(buffer, i))
    var f: TFile
    if open(f, filename, fmWrite):
      f.write(result)
@@ -185,7 +185,7 @@ proc processFile(filename: string) =
      quit "cannot open file for overwriting: " & filename

 proc hasRightExt(filename: string, exts: seq[string]): bool =
-  var y = splitFile(filename).ext.copy(1) # skip leading '.'
+  var y = splitFile(filename).ext.substr(1) # skip leading '.'
  for x in items(exts): 
    if os.cmpPaths(x, y) == 0: return true

--- a/tools/niminst.nim
+++ b/tools/niminst.nim
@@ -148,7 +148,7 @@ proc parseCmdLine(c: var TConfigData) =
      of "var":
        var idx = val.find('=')
        if idx < 0: quit("invalid command line")
-        c.vars[copy(val, 0, idx-1)] = copy(val, idx+1)
+        c.vars[substr(val, 0, idx-1)] = substr(val, idx+1)
      else: quit(Usage)
    of cmdEnd: break
  if c.infile.len == 0: quit(Usage)
--- a/tools/nimweb.nim
+++ b/tools/nimweb.nim
@@ -76,7 +76,7 @@ proc parseCmdLine(c: var TConfigData) =
      of "var":
        var idx = val.find('=')
        if idx < 0: quit("invalid command line")
-        c.vars[copy(val, 0, idx-1)] = copy(val, idx+1)
+        c.vars[substr(val, 0, idx-1)] = substr(val, idx+1)
      else: quit(Usage)
    of cmdEnd: break
  if c.infile.len == 0: quit(Usage)
--- a/web/news.txt
+++ b/web/news.txt
@@ -21,6 +21,7 @@ Bugfixes
  copied.
 - Bugfix: The compiler does not emit very inaccurate floating point literals
  anymore.
+- Bugfix: Subclasses are taken into account for ``try except`` matching.
 - Lots of other bugfixes: Too many to list them all.