bugfix: GC more forgiving

lib/pure/htmlparser.nim

@@ -333,11 +333,11 @@ proc parse(x: var TXmlParser, errors: var seq[string]): PXmlNode =
   of xmlElementOpen: 
     result = newElement(x.elementName.toLower)
     next(x)
-    result.attr = newStringTable()
+    result.attrs = newStringTable()
     while true: 
       case x.kind
       of xmlAttribute:
-        result.attr[x.attrKey] = x.attrValue
+        result.attrs[x.attrKey] = x.attrValue
         next(x)
       of xmlElementClose:
         next(x)

lib/system.nim

@@ -1213,14 +1213,14 @@ iterator fieldPairs*(x, y: tuple[]): tuple[a, b: expr] {.
   ## in the loop body.
 
 proc `==`*[T: tuple](x, y: T): bool = 
-  ## generic ``==`` operator that is lifted from the components
+  ## generic ``==`` operator for tuples that is lifted from the components
   ## of `x` and `y`.
   for a, b in fields(x, y):
     if a != b: return false
   return true
 
 proc `<=`*[T: tuple](x, y: T): bool = 
-  ## generic ``<=`` operator that is lifted from the components
+  ## generic ``<=`` operator for tuples that is lifted from the components
   ## of `x` and `y`. This implementation uses `cmp`.
   for a, b in fields(x, y):
     var c = cmp(a, b)
@@ -1229,7 +1229,7 @@ proc `<=`*[T: tuple](x, y: T): bool =
   return true
 
 proc `<`*[T: tuple](x, y: T): bool = 
-  ## generic ``<`` operator that is lifted from the components
+  ## generic ``<`` operator for tuples that is lifted from the components
   ## of `x` and `y`. This implementation uses `cmp`.
   for a, b in fields(x, y):
     var c = cmp(a, b)
@@ -1238,7 +1238,8 @@ proc `<`*[T: tuple](x, y: T): bool =
   return false
 
 proc `$`*[T: tuple](x: T): string = 
-  ## generic ``$`` operator that is lifted from the components of `x`.
+  ## generic ``$`` operator for tuples that is lifted from the components
+  ## of `x`.
   result = "("
   for name, value in fieldPairs(x):
     if result.len > 1: result.add(", ")

lib/system/gc.nim

@@ -265,7 +265,10 @@ proc unsureAsgnRef(dest: ppointer, src: pointer) {.compilerProc.} =
   # reference is in the stack or not (this can happen for var parameters).
   if not IsOnStack(dest):
     if src != nil: incRef(usrToCell(src))
-    if dest^ != nil: decRef(usrToCell(dest^))
+    # XXX finally use assembler for the stack checking instead!
+    # the test for '!= nil' is correct, but I got tired of the segfaults
+    # resulting from the crappy stack checking:
+    if cast[int](dest^) >=% PageSize: decRef(usrToCell(dest^))
   dest^ = src
 
 proc initGC() =