system files use new identifiers

13 files changed, 371 insertions, 338 deletions

diff --git a/lib/system.nim b/lib/system.nim
index 0ba99f915..73b470052 100644
--- a/lib/system.nim
+++ b/lib/system.nim
@@ -1,7 +1,7 @@
 #
 #
-#            Nimrod's Runtime Library
-#        (c) Copyright 2013 Andreas Rumpf
+#            Nim's Runtime Library
+#        (c) Copyright 2014 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
 #    distribution, for details about the copyright.
@@ -77,23 +77,23 @@ type
   auto* = expr
   any* = distinct auto
 
-  TSignedInt* = int|int8|int16|int32|int64
+  SomeSignedInt* = int|int8|int16|int32|int64
     ## type class matching all signed integer types
 
-  TUnsignedInt* = uint|uint8|uint16|uint32|uint64
+  SomeUnsignedInt* = uint|uint8|uint16|uint32|uint64
     ## type class matching all unsigned integer types
 
-  TInteger* = TSignedInt|TUnsignedInt
+  SomeInteger* = SomeSignedInt|SomeUnsignedInt
     ## type class matching all integer types
 
-  TOrdinal* = int|int8|int16|int32|int64|bool|enum|uint8|uint16|uint32
+  SomeOrdinal* = int|int8|int16|int32|int64|bool|enum|uint8|uint16|uint32
     ## type class matching all ordinal types; however this includes enums with
     ## holes.
   
-  TReal* = float|float32|float64
+  SomeReal* = float|float32|float64
     ## type class matching all floating point number types
 
-  TNumber* = TInteger|TReal
+  SomeNumber* = SomeInteger|SomeReal
     ## type class matching all number types
 
 proc defined*(x: expr): bool {.magic: "Defined", noSideEffect.}
@@ -108,6 +108,15 @@ proc defined*(x: expr): bool {.magic: "Defined", noSideEffect.}
   ##     # Do here programmer friendly expensive sanity checks.
   ##   # Put here the normal code
 
+when defined(nimalias):
+  {.deprecated: [
+    TSignedInt: SomeSignedInt,
+    TUnsignedInt: SomeUnsignedInt,
+    TInteger: SomeInteger,
+    TReal: SomeReal,
+    TNumber: SomeNumber,
+    TOrdinal: SomeOrdinal].}
+
 proc declared*(x: expr): bool {.magic: "Defined", noSideEffect.}
   ## Special compile-time procedure that checks whether `x` is
   ## declared. `x` has to be an identifier or a qualified identifier.
@@ -202,10 +211,13 @@ type
   set*{.magic: "Set".}[T]  ## Generic type to construct bit sets.
 
 type
-  TSlice* {.final, pure.}[T] = object ## builtin slice type
-    a*, b*: T                         ## the bounds
+  Slice* {.final, pure.}[T] = object ## builtin slice type
+    a*, b*: T                        ## the bounds
+
+when defined(nimalias):
+  {.deprecated: [TSlice: Slice].}
 
-proc `..`*[T](a, b: T): TSlice[T] {.noSideEffect, inline.} =
+proc `..`*[T](a, b: T): Slice[T] {.noSideEffect, inline.} =
   ## `slice`:idx: operator that constructs an interval ``[a, b]``, both `a`
   ## and `b` are inclusive. Slices can also be used in the set constructor
   ## and in ordinal case statements, but then they are special-cased by the
@@ -213,7 +225,7 @@ proc `..`*[T](a, b: T): TSlice[T] {.noSideEffect, inline.} =
   result.a = a
   result.b = b
 
-proc `..`*[T](b: T): TSlice[T] {.noSideEffect, inline.} =
+proc `..`*[T](b: T): Slice[T] {.noSideEffect, inline.} =
   ## `slice`:idx: operator that constructs an interval ``[default(T), b]``
   result.b = b
 
@@ -307,29 +319,29 @@ type
     ## is an int type ranging from one to the maximum value
     ## of an int. This type is often useful for documentation and debugging.
 
-  TObject* {.exportc: "TNimObject", inheritable.} =
+  RootObj* {.exportc: "TNimObject", inheritable.} =
     object ## the root of Nimrod's object hierarchy. Objects should
            ## inherit from TObject or one of its descendants. However,
            ## objects that have no ancestor are allowed.
-  PObject* = ref TObject ## reference to TObject
+  RootRef* = ref RootObj ## reference to RootObj
 
-  TEffect* {.compilerproc.} = object of TObject ## \
+  RootEffect* {.compilerproc.} = object of RootObj ## \
     ## base effect class; each effect should
     ## inherit from `TEffect` unless you know what
     ## you doing.
-  FTime* = object of TEffect   ## Time effect.
-  FIO* = object of TEffect     ## IO effect.
-  FReadIO* = object of FIO     ## Effect describing a read IO operation.
-  FWriteIO* = object of FIO    ## Effect describing a write IO operation.
-  FExecIO* = object of FIO     ## Effect describing an executing IO operation.
+  TimeEffect* = object of RootEffect   ## Time effect.
+  IOEffect* = object of RootEffect     ## IO effect.
+  ReadIOEffect* = object of IOEffect   ## Effect describing a read IO operation.
+  WriteIOEffect* = object of IOEffect  ## Effect describing a write IO operation.
+  ExecIOEffect* = object of IOEffect   ## Effect describing an executing IO operation.
 
-  E_Base* {.compilerproc.} = object of TObject ## \
+  Exception* {.compilerproc.} = object of RootObj ## \
     ## Base exception class.
     ##
-    ## Each exception has to inherit from `E_Base`. See the full `exception
+    ## Each exception has to inherit from `Exception`. See the full `exception
     ## hierarchy`_.
-    parent: ref E_Base        ## parent exception (can be used as a stack)
-    name: cstring             ## The exception's name is its Nimrod identifier.
+    parent: ref Exception     ## parent exception (can be used as a stack)
+    name: cstring             ## The exception's name is its Nim identifier.
                               ## This field is filled automatically in the
                               ## ``raise`` statement.
     msg* {.exportc: "message".}: string ## the exception's message. Not
@@ -337,130 +349,117 @@ type
                                         ## is bad style.
     trace: string
 
-  EAsynch* = object of E_Base ## \
-    ## Abstract exception class for *asynchronous exceptions* (interrupts).
-    ##
-    ## This is rarely needed: most exception types inherit from `ESynch
-    ## <#ESynch>`_. See the full `exception hierarchy`_.
-  EControlC* = object of EAsynch ## \
-    ## Raised for Ctrl+C key presses in console applications.
-    ##
-    ## See the full `exception hierarchy`_.
-  ESynch* = object of E_Base ## \
-    ## Abstract exception class for *synchronous exceptions*.
-    ##
-    ## Most exceptions should be inherited (directly or indirectly) from
-    ## `ESynch` instead of from `EAsynch <#EAsynch>`_. See the full `exception
-    ## hierarchy`_.
-  ESystem* = object of ESynch ## \
+  SystemError* = object of Exception ## \
     ## Abstract class for exceptions that the runtime system raises.
     ##
     ## See the full `exception hierarchy`_.
-  EIO* = object of ESystem ## \
+  IOError* = object of SystemError ## \
     ## Raised if an IO error occured.
     ##
     ## See the full `exception hierarchy`_.
-  EOS* = object of ESystem ## \
+  OSError* = object of SystemError ## \
     ## Raised if an operating system service failed.
     ##
     ## See the full `exception hierarchy`_.
     errorCode*: int32 ## OS-defined error code describing this error.
-  EInvalidLibrary* = object of EOS ## \
+  LibraryError* = object of OSError ## \
     ## Raised if a dynamic library could not be loaded.
     ##
     ## See the full `exception hierarchy`_.
-  EResourceExhausted* = object of ESystem ## \
+  ResourceExhaustedError* = object of SystemError ## \
     ## Raised if a resource request could not be fullfilled.
     ##
     ## See the full `exception hierarchy`_.
-  EArithmetic* = object of ESynch ## \
+  ArithmeticError* = object of Exception ## \
     ## Raised if any kind of arithmetic error occured.
     ##
     ## See the full `exception hierarchy`_.
-  EDivByZero* {.compilerproc.} = object of EArithmetic ## \
+  DivByZeroError* = object of ArithmeticError ## \
     ## Raised for runtime integer divide-by-zero errors.
     ##
     ## See the full `exception hierarchy`_.
-  EOverflow* {.compilerproc.} = object of EArithmetic ## \
+
+  OverflowError* = object of ArithmeticError ## \
     ## Raised for runtime integer overflows.
     ##
     ## This happens for calculations whose results are too large to fit in the
     ## provided bits.  See the full `exception hierarchy`_.
-  EAccessViolation* {.compilerproc.} = object of ESynch ## \
+  AccessViolationError* {.compilerproc.} = object of Exception ## \
     ## Raised for invalid memory access errors
     ##
     ## See the full `exception hierarchy`_.
-  EAssertionFailed* {.compilerproc.} = object of ESynch ## \
+  AssertionError* {.compilerproc.} = object of Exception ## \
     ## Raised when assertion is proved wrong.
     ##
     ## Usually the result of using the `assert() template <#assert>`_.  See the
     ## full `exception hierarchy`_.
-  EInvalidValue* = object of ESynch ## \
+  ValueError* = object of Exception ## \
     ## Raised for string and object conversion errors.
-  EInvalidKey* = object of EInvalidValue ## \
+  KeyError* = object of ValueError ## \
     ## Raised if a key cannot be found in a table.
     ##
     ## Mostly used by the `tables <tables.html>`_ module, it can also be raised
     ## by other collection modules like `sets <sets.html>`_ or `strtabs
     ## <strtabs.html>`_. See the full `exception hierarchy`_.
-  EOutOfMemory* = object of ESystem ## \
+  OutOfMemError* = object of SystemError ## \
     ## Raised for unsuccessful attempts to allocate memory.
     ##
     ## See the full `exception hierarchy`_.
-  EInvalidIndex* = object of ESynch ## \
+  IndexError* = object of Exception ## \
     ## Raised if an array index is out of bounds.
     ##
     ## See the full `exception hierarchy`_.
-  EInvalidField* = object of ESynch ## \
+
+  FieldError* = object of Exception ## \
     ## Raised if a record field is not accessible because its dicriminant's
     ## value does not fit.
     ##
     ## See the full `exception hierarchy`_.
-  EOutOfRange* = object of ESynch ## \
+  RangeError* = object of Exception ## \
     ## Raised if a range check error occurred.
     ##
     ## See the full `exception hierarchy`_.
-  EStackOverflow* = object of ESystem ## \
+  StackOverflowError* = object of SystemError ## \
     ## Raised if the hardware stack used for subroutine calls overflowed.
     ##
     ## See the full `exception hierarchy`_.
-  ENoExceptionToReraise* = object of ESynch ## \
+  ReraiseError* = object of Exception ## \
     ## Raised if there is no exception to reraise.
     ##
     ## See the full `exception hierarchy`_.
-  EInvalidObjectAssignment* = object of ESynch ## \
+  ObjectAssignmentError* = object of Exception ## \
     ## Raised if an object gets assigned to its parent's object.
     ##
     ## See the full `exception hierarchy`_.
-  EInvalidObjectConversion* = object of ESynch ## \
+  ObjectConversionError* = object of Exception ## \
     ## Raised if an object is converted to an incompatible object type.
     ##
     ## See the full `exception hierarchy`_.
-  EFloatingPoint* = object of ESynch ## \
+  FloatingPointError* = object of Exception ## \
     ## Base class for floating point exceptions.
     ##
     ## See the full `exception hierarchy`_.
-  EFloatInvalidOp* {.compilerproc.} = object of EFloatingPoint ## \
+  FloatInvalidOpError* = object of FloatingPointError ## \
     ## Raised by invalid operations according to IEEE.
     ##
     ## Raised by ``0.0/0.0``, for example.  See the full `exception
     ## hierarchy`_.
-  EFloatDivByZero* {.compilerproc.} = object of EFloatingPoint ## \
+  FloatDivByZeroError* = object of FloatingPointError ## \
     ## Raised by division by zero.
     ##
     ## Divisor is zero and dividend is a finite nonzero number.  See the full
     ## `exception hierarchy`_.
-  EFloatOverflow* {.compilerproc.} = object of EFloatingPoint ## \
+  FloatOverflowError* = object of FloatingPointError ## \
     ## Raised for overflows.
     ##
     ## The operation produced a result that exceeds the range of the exponent.
     ## See the full `exception hierarchy`_.
-  EFloatUnderflow* {.compilerproc.} = object of EFloatingPoint ## \
+  FloatUnderflowError* = object of FloatingPointError ## \
     ## Raised for underflows.
     ##
     ## The operation produced a result that is too small to be represented as a
     ## normal number. See the full `exception hierarchy`_.
-  EFloatInexact* {.compilerproc.} = object of EFloatingPoint ## \
+  FloatInexactError* = object of FloatingPointError ## \
     ## Raised for inexact results.
     ##
     ## The operation produced a result that cannot be represented with infinite
@@ -468,12 +467,37 @@ type
     ##
     ## **NOTE**: Nimrod currently does not detect these!  See the full
     ## `exception hierarchy`_.
-  EDeadThread* = object of ESynch ## \
+  DeadThreadError* = object of Exception ## \
     ## Raised if it is attempted to send a message to a dead thread.
     ##
     ## See the full `exception hierarchy`_.
 
-  TResult* = enum Failure, Success
+  TResult* {.deprecated.} = enum Failure, Success
+
+{.deprecated: [TObject: RootObj, PObject: RootRef, TEffect: RootEffect,
+  FTime: TimeEffect, FIO: IOEffect, FReadIO: ReadIOEffect,
+  FWriteIO: WriteIOEffect, FExecIO: ExecIOEffect,
+
+  E_Base: Exception, ESystem: SystemError, EIO: IOError,
+  EOS: OSError, EInvalidLibrary: LibraryError,
+  EResourceExhausted: ResourceExhaustedError, 
+  EArithmetic: ArithmeticError, EDivByZero: DivByZeroError,
+  EOverflow: OverflowError, EAccessViolation: AccessViolationError,
+  EAssertionFailed: AssertionError, EInvalidValue: ValueError,
+  EInvalidKey: KeyError, EOutOfMemory: OutOfMemError,
+  EInvalidIndex: IndexError, EInvalidField: FieldError,
+  EOutOfRange: RangeError, EStackOverflow: StackOverflowError,
+  ENoExceptionToReraise: ReraiseError,
+  EInvalidObjectAssignment: ObjectAssignmentError,
+  EInvalidObjectConversion: ObjectConversionError,
+  EDeadThread: DeadThreadError,
+  EFloatInexact: FloatInexactError, 
+  EFloatUnderflow: FloatUnderflowError,
+  EFloatingPoint: FloatingPointError,
+  EFloatInvalidOp: FloatInvalidOpError,
+  EFloatDivByZero: FloatDivByZeroError,
+  EFloatOverflow: FloatOverflowError
+].}
 
 proc sizeof*[T](x: T): Natural {.magic: "SizeOf", noSideEffect.}
   ## returns the size of ``x`` in bytes. Since this is a low-level proc,
@@ -839,7 +863,7 @@ proc contains*[T](x: set[T], y: T): bool {.magic: "InSet", noSideEffect.}
   ## is achieved by reversing the parameters for ``contains``; ``in`` then
   ## passes its arguments in reverse order.
 
-proc contains*[T](s: TSlice[T], value: T): bool {.noSideEffect, inline.} =
+proc contains*[T](s: Slice[T], value: T): bool {.noSideEffect, inline.} =
   ## Checks if `value` is withing the range of `s`; returns true iff
   ## `value >= s.a and value <= s.b`
   ##
@@ -978,7 +1002,7 @@ proc add*(x: var string, y: string) {.magic: "AppendStrStr", noSideEffect.}
   ##   assert(tmp == "abcd")
 
 type
-  TEndian* = enum ## is a type describing the endianness of a processor.
+  Endianness* = enum ## is a type describing the endianness of a processor.
     littleEndian, bigEndian
 
 const
@@ -994,23 +1018,23 @@ const
     ## is the time of compilation as a string of the form
     ## ``HH:MM:SS``. This works thanks to compiler magic.
 
-  NimrodVersion* {.magic: "NimrodVersion"}: string = "0.0.0"
+  NimVersion* {.magic: "NimrodVersion"}: string = "0.0.0"
     ## is the version of Nimrod as a string.
     ## This works thanks to compiler magic.
 
-  NimrodMajor* {.magic: "NimrodMajor"}: int = 0
+  NimMajor* {.magic: "NimrodMajor"}: int = 0
     ## is the major number of Nimrod's version.
     ## This works thanks to compiler magic.
 
-  NimrodMinor* {.magic: "NimrodMinor"}: int = 0
+  NimMinor* {.magic: "NimrodMinor"}: int = 0
     ## is the minor number of Nimrod's version.
     ## This works thanks to compiler magic.
 
-  NimrodPatch* {.magic: "NimrodPatch"}: int = 0
+  NimPatch* {.magic: "NimrodPatch"}: int = 0
     ## is the patch number of Nimrod's version.
     ## This works thanks to compiler magic.
 
-  cpuEndian* {.magic: "CpuEndian"}: TEndian = littleEndian
+  cpuEndian* {.magic: "CpuEndian"}: Endianness = littleEndian
     ## is the endianness of the target CPU. This is a valuable piece of
     ## information for low-level code only. This works thanks to compiler
     ## magic.
@@ -1025,7 +1049,10 @@ const
     ## "i386", "alpha", "powerpc", "sparc", "amd64", "mips", "arm".
   
   seqShallowFlag = low(int)
-  
+
+{.deprecated: [TEndian: Endianness, NimrodVersion: NimVersion, 
+    NimrodMajor: NimMajor, NimrodMinor: NimMinor, NimrodPatch: NimPatch].}
+
 proc compileOption*(option: string): bool {.
   magic: "CompileOption", noSideEffect.}
   ## can be used to determine an on|off compile-time option. Example:
@@ -1160,7 +1187,7 @@ proc repr*[T](x: T): string {.magic: "Repr", noSideEffect.}
   ## debugging tool.
 
 type
-  TAddress* = int
+  ByteAddress* = int
     ## is the signed integer type that should be used for converting
     ## pointers to integer addresses for readability.
 
@@ -1174,6 +1201,8 @@ type
     ## compiler supports. Currently this is ``float64``, but it is
     ## platform-dependant in general.
 
+{.deprecated: [TAddress: ByteAddress].}
+
 when defined(windows):
   type
     clong* {.importc: "long", nodecl.} = int32
@@ -1833,7 +1862,7 @@ proc map*[T](data: var openArray[T], op: proc (x: var T) {.closure.}) =
   ##   # --> ["142", "242", "342", "442"]
   for i in 0..data.len-1: op(data[i])
 
-iterator fields*[T: tuple|object](x: T): TObject {.
+iterator fields*[T: tuple|object](x: T): RootObj {.
   magic: "Fields", noSideEffect.}
   ## iterates over every field of `x`. Warning: This really transforms
   ## the 'for' and unrolls the loop. The current implementation also has a bug
@@ -1844,7 +1873,7 @@ iterator fields*[S:tuple|object, T:tuple|object](x: S, y: T): tuple[a,b: expr] {
   ## Warning: This is really transforms the 'for' and unrolls the loop. 
   ## The current implementation also has a bug that affects symbol binding
   ## in the loop body.
-iterator fieldPairs*[T: tuple|object](x: T): TObject {.
+iterator fieldPairs*[T: tuple|object](x: T): RootObj {.
   magic: "FieldPairs", noSideEffect.}
   ## Iterates over every field of `x` returning their name and value.
   ##
@@ -1975,13 +2004,15 @@ when not defined(nimrodVM) and hostOS != "standalone":
     ## Ordinary code does not need to call this (and should not).
 
   type
-    TGC_Strategy* = enum ## the strategy the GC should use for the application
+    GC_Strategy* = enum ## the strategy the GC should use for the application
       gcThroughput,      ## optimize for throughput
       gcResponsiveness,  ## optimize for responsiveness (default)
       gcOptimizeTime,    ## optimize for speed
       gcOptimizeSpace    ## optimize for memory footprint
 
-  proc GC_setStrategy*(strategy: TGC_Strategy) {.rtl, deprecated.}
+  {.deprecated: [TGC_Strategy: GC_Strategy].}
+
+  proc GC_setStrategy*(strategy: GC_Strategy) {.rtl, deprecated.}
     ## tells the GC the desired strategy for the application.
     ## **Deprecated** since version 0.8.14. This has always been a nop.
 
@@ -2024,7 +2055,7 @@ const NimStackTrace = compileOption("stacktrace")
 # of the code
 
 var
-  globalRaiseHook*: proc (e: ref E_Base): bool {.nimcall, gcsafe.}
+  globalRaiseHook*: proc (e: ref Exception): bool {.nimcall, gcsafe.}
     ## with this hook you can influence exception handling on a global level.
     ## If not nil, every 'raise' statement ends up calling this hook. Ordinary
     ## application code should never set this hook! You better know what you
@@ -2032,7 +2063,7 @@ var
     ## exception is caught and does not propagate further through the call
     ## stack.
 
-  localRaiseHook* {.threadvar.}: proc (e: ref E_Base): bool {.nimcall, gcsafe.}
+  localRaiseHook* {.threadvar.}: proc (e: ref Exception): bool {.nimcall, gcsafe.}
     ## with this hook you can influence exception handling on a
     ## thread local level.
     ## If not nil, every 'raise' statement ends up calling this hook. Ordinary
@@ -2092,7 +2123,7 @@ elif hostOS != "standalone":
       inc(i)
   {.pop.}
 
-proc echo*[T](x: varargs[T, `$`]) {.magic: "Echo", tags: [FWriteIO], gcsafe.}
+proc echo*[T](x: varargs[T, `$`]) {.magic: "Echo", tags: [WriteIOEffect], gcsafe.}
   ## Writes and flushes the parameters to the standard output.
   ##
   ## Special built-in that takes a variable number of arguments. Each argument
@@ -2224,9 +2255,9 @@ when not defined(JS): #and not defined(NimrodVM):
     type
       CFile {.importc: "FILE", header: "<stdio.h>", 
               final, incompletestruct.} = object
-      TFile* = ptr CFile ## The type representing a file handle.
+      File* = ptr CFile ## The type representing a file handle.
 
-      TFileMode* = enum           ## The file mode when opening a file.
+      FileMode* = enum           ## The file mode when opening a file.
         fmRead,                   ## Open the file for read access only.
         fmWrite,                  ## Open the file for write access only.
         fmReadWrite,              ## Open the file for read and write access.
@@ -2238,49 +2269,51 @@ when not defined(JS): #and not defined(NimrodVM):
         fmAppend                  ## Open the file for writing only; append data
                                   ## at the end.
 
-      TFileHandle* = cint ## type that represents an OS file handle; this is
-                          ## useful for low-level file access
+      FileHandle* = cint ## type that represents an OS file handle; this is
+                         ## useful for low-level file access
+
+    {.deprecated: [TFile: File, TFileHandle: FileHandle, TFileMode: FileMode].}
 
     # text file handling:
     var
-      stdin* {.importc: "stdin", header: "<stdio.h>".}: TFile
+      stdin* {.importc: "stdin", header: "<stdio.h>".}: File
         ## The standard input stream.
-      stdout* {.importc: "stdout", header: "<stdio.h>".}: TFile
+      stdout* {.importc: "stdout", header: "<stdio.h>".}: File
         ## The standard output stream.
-      stderr* {.importc: "stderr", header: "<stdio.h>".}: TFile
+      stderr* {.importc: "stderr", header: "<stdio.h>".}: File
         ## The standard error stream.
 
     when defined(useStdoutAsStdmsg):
-      template stdmsg*: TFile = stdout
+      template stdmsg*: File = stdout
     else:
-      template stdmsg*: TFile = stderr
+      template stdmsg*: File = stderr
         ## Template which expands to either stdout or stderr depending on
         ## `useStdoutAsStdmsg` compile-time switch.
 
-    proc open*(f: var TFile, filename: string,
-               mode: TFileMode = fmRead, bufSize: int = -1): bool {.tags: [],
+    proc open*(f: var File, filename: string,
+               mode: FileMode = fmRead, bufSize: int = -1): bool {.tags: [],
                gcsafe.}
       ## Opens a file named `filename` with given `mode`.
       ##
       ## Default mode is readonly. Returns true iff the file could be opened.
       ## This throws no exception if the file could not be opened.
 
-    proc open*(f: var TFile, filehandle: TFileHandle,
-               mode: TFileMode = fmRead): bool {.tags: [], gcsafe.}
+    proc open*(f: var File, filehandle: FileHandle,
+               mode: FileMode = fmRead): bool {.tags: [], gcsafe.}
       ## Creates a ``TFile`` from a `filehandle` with given `mode`.
       ##
       ## Default mode is readonly. Returns true iff the file could be opened.
       
     proc open*(filename: string,
-               mode: TFileMode = fmRead, bufSize: int = -1): TFile = 
+               mode: FileMode = fmRead, bufSize: int = -1): File = 
       ## Opens a file named `filename` with given `mode`.
       ##
       ## Default mode is readonly. Raises an ``IO`` exception if the file
       ## could not be opened.
       if not open(result, filename, mode, bufSize):
-        sysFatal(EIO, "cannot open: ", filename)
+        sysFatal(IOError, "cannot open: ", filename)
 
-    proc reopen*(f: TFile, filename: string, mode: TFileMode = fmRead): bool {.
+    proc reopen*(f: File, filename: string, mode: FileMode = fmRead): bool {.
       tags: [], gcsafe.}
       ## reopens the file `f` with given `filename` and `mode`. This 
       ## is often used to redirect the `stdin`, `stdout` or `stderr`
@@ -2288,52 +2321,52 @@ when not defined(JS): #and not defined(NimrodVM):
       ##
       ## Default mode is readonly. Returns true iff the file could be reopened.
 
-    proc close*(f: TFile) {.importc: "fclose", header: "<stdio.h>", tags: [].}
+    proc close*(f: File) {.importc: "fclose", header: "<stdio.h>", tags: [].}
       ## Closes the file.
 
-    proc endOfFile*(f: TFile): bool {.tags: [], gcsafe.}
+    proc endOfFile*(f: File): bool {.tags: [], gcsafe.}
       ## Returns true iff `f` is at the end.
       
-    proc readChar*(f: TFile): char {.
-      importc: "fgetc", header: "<stdio.h>", tags: [FReadIO].}
+    proc readChar*(f: File): char {.
+      importc: "fgetc", header: "<stdio.h>", tags: [ReadIOEffect].}
       ## Reads a single character from the stream `f`.
-    proc flushFile*(f: TFile) {.
-      importc: "fflush", header: "<stdio.h>", tags: [FWriteIO].}
+    proc flushFile*(f: File) {.
+      importc: "fflush", header: "<stdio.h>", tags: [WriteIOEffect].}
       ## Flushes `f`'s buffer.
 
-    proc readAll*(file: TFile): TaintedString {.tags: [FReadIO], gcsafe.}
+    proc readAll*(file: File): TaintedString {.tags: [ReadIOEffect], gcsafe.}
       ## Reads all data from the stream `file`.
       ##
       ## Raises an IO exception in case of an error. It is an error if the
       ## current file position is not at the beginning of the file.
     
-    proc readFile*(filename: string): TaintedString {.tags: [FReadIO], gcsafe.}
+    proc readFile*(filename: string): TaintedString {.tags: [ReadIOEffect], gcsafe.}
       ## Opens a file named `filename` for reading. Then calls `readAll`
       ## and closes the file afterwards. Returns the string. 
       ## Raises an IO exception in case of an error.
 
-    proc writeFile*(filename, content: string) {.tags: [FWriteIO], gcsafe.}
+    proc writeFile*(filename, content: string) {.tags: [WriteIOEffect], gcsafe.}
       ## Opens a file named `filename` for writing. Then writes the
       ## `content` completely to the file and closes the file afterwards.
       ## Raises an IO exception in case of an error.
 
-    proc write*(f: TFile, r: float32) {.tags: [FWriteIO], gcsafe.}
-    proc write*(f: TFile, i: int) {.tags: [FWriteIO], gcsafe.}
-    proc write*(f: TFile, i: BiggestInt) {.tags: [FWriteIO], gcsafe.}
-    proc write*(f: TFile, r: BiggestFloat) {.tags: [FWriteIO], gcsafe.}
-    proc write*(f: TFile, s: string) {.tags: [FWriteIO], gcsafe.}
-    proc write*(f: TFile, b: bool) {.tags: [FWriteIO], gcsafe.}
-    proc write*(f: TFile, c: char) {.tags: [FWriteIO], gcsafe.}
-    proc write*(f: TFile, c: cstring) {.tags: [FWriteIO], gcsafe.}
-    proc write*(f: TFile, a: varargs[string, `$`]) {.tags: [FWriteIO], gcsafe.}
+    proc write*(f: File, r: float32) {.tags: [WriteIOEffect], gcsafe.}
+    proc write*(f: File, i: int) {.tags: [WriteIOEffect], gcsafe.}
+    proc write*(f: File, i: BiggestInt) {.tags: [WriteIOEffect], gcsafe.}
+    proc write*(f: File, r: BiggestFloat) {.tags: [WriteIOEffect], gcsafe.}
+    proc write*(f: File, s: string) {.tags: [WriteIOEffect], gcsafe.}
+    proc write*(f: File, b: bool) {.tags: [WriteIOEffect], gcsafe.}
+    proc write*(f: File, c: char) {.tags: [WriteIOEffect], gcsafe.}
+    proc write*(f: File, c: cstring) {.tags: [WriteIOEffect], gcsafe.}
+    proc write*(f: File, a: varargs[string, `$`]) {.tags: [WriteIOEffect], gcsafe.}
       ## Writes a value to the file `f`. May throw an IO exception.
 
-    proc readLine*(f: TFile): TaintedString  {.tags: [FReadIO], gcsafe.}
+    proc readLine*(f: File): TaintedString  {.tags: [ReadIOEffect], gcsafe.}
       ## reads a line of text from the file `f`. May throw an IO exception.
       ## A line of text may be delimited by ``CR``, ``LF`` or
       ## ``CRLF``. The newline character(s) are not part of the returned string.
     
-    proc readLine*(f: TFile, line: var TaintedString): bool {.tags: [FReadIO], 
+    proc readLine*(f: File, line: var TaintedString): bool {.tags: [ReadIOEffect], 
                   gcsafe.}
       ## reads a line of text from the file `f` into `line`. `line` must not be
       ## ``nil``! May throw an IO exception.
@@ -2343,63 +2376,63 @@ when not defined(JS): #and not defined(NimrodVM):
       ## otherwise. If ``false`` is returned `line` contains no new data.
 
     when not defined(booting):
-      proc writeln*[Ty](f: TFile, x: varargs[Ty, `$`]) {.inline, 
-                               tags: [FWriteIO], gcsafe.}
+      proc writeln*[Ty](f: File, x: varargs[Ty, `$`]) {.inline, 
+                               tags: [WriteIOEffect], gcsafe.}
         ## writes the values `x` to `f` and then writes "\n".
         ## May throw an IO exception.
     else:
-      proc writeln*[Ty](f: TFile, x: varargs[Ty, `$`]) {.inline, 
-                               tags: [FWriteIO].}
+      proc writeln*[Ty](f: File, x: varargs[Ty, `$`]) {.inline, 
+                               tags: [WriteIOEffect].}
 
-    proc getFileSize*(f: TFile): int64 {.tags: [FReadIO], gcsafe.}
+    proc getFileSize*(f: File): int64 {.tags: [ReadIOEffect], gcsafe.}
       ## retrieves the file size (in bytes) of `f`.
 
-    proc readBytes*(f: TFile, a: var openArray[int8], start, len: int): int {.
-      tags: [FReadIO], gcsafe.}
+    proc readBytes*(f: File, a: var openArray[int8], start, len: int): int {.
+      tags: [ReadIOEffect], gcsafe.}
       ## reads `len` bytes into the buffer `a` starting at ``a[start]``. Returns
       ## the actual number of bytes that have been read which may be less than
       ## `len` (if not as many bytes are remaining), but not greater.
 
-    proc readChars*(f: TFile, a: var openArray[char], start, len: int): int {.
-      tags: [FReadIO], gcsafe.}
+    proc readChars*(f: File, a: var openArray[char], start, len: int): int {.
+      tags: [ReadIOEffect], gcsafe.}
       ## reads `len` bytes into the buffer `a` starting at ``a[start]``. Returns
       ## the actual number of bytes that have been read which may be less than
       ## `len` (if not as many bytes are remaining), but not greater.
 
-    proc readBuffer*(f: TFile, buffer: pointer, len: int): int {.
-      tags: [FReadIO], gcsafe.}
+    proc readBuffer*(f: File, buffer: pointer, len: int): int {.
+      tags: [ReadIOEffect], gcsafe.}
       ## reads `len` bytes into the buffer pointed to by `buffer`. Returns
       ## the actual number of bytes that have been read which may be less than
       ## `len` (if not as many bytes are remaining), but not greater.
 
-    proc writeBytes*(f: TFile, a: openArray[int8], start, len: int): int {.
-      tags: [FWriteIO], gcsafe.}
+    proc writeBytes*(f: File, a: openArray[int8], start, len: int): int {.
+      tags: [WriteIOEffect], gcsafe.}
       ## writes the bytes of ``a[start..start+len-1]`` to the file `f`. Returns
       ## the number of actual written bytes, which may be less than `len` in case
       ## of an error.
 
-    proc writeChars*(f: TFile, a: openArray[char], start, len: int): int {.
-      tags: [FWriteIO], gcsafe.}
+    proc writeChars*(f: File, a: openArray[char], start, len: int): int {.
+      tags: [WriteIOEffect], gcsafe.}
       ## writes the bytes of ``a[start..start+len-1]`` to the file `f`. Returns
       ## the number of actual written bytes, which may be less than `len` in case
       ## of an error.
 
-    proc writeBuffer*(f: TFile, buffer: pointer, len: int): int {.
-      tags: [FWriteIO], gcsafe.}
+    proc writeBuffer*(f: File, buffer: pointer, len: int): int {.
+      tags: [WriteIOEffect], gcsafe.}
       ## writes the bytes of buffer pointed to by the parameter `buffer` to the
       ## file `f`. Returns the number of actual written bytes, which may be less
       ## than `len` in case of an error.
 
-    proc setFilePos*(f: TFile, pos: int64) {.gcsafe.}
+    proc setFilePos*(f: File, pos: int64) {.gcsafe.}
       ## sets the position of the file pointer that is used for read/write
       ## operations. The file's first byte has the index zero.
 
-    proc getFilePos*(f: TFile): int64 {.gcsafe.}
+    proc getFilePos*(f: File): int64 {.gcsafe.}
       ## 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.
 
-    proc fileHandle*(f: TFile): TFileHandle {.importc: "fileno",
-                                              header: "<stdio.h>"}
+    proc getFileHandle*(f: File): FileHandle {.importc: "fileno",
+                                               header: "<stdio.h>"}
       ## returns the OS file handle of the file ``f``. This is only useful for
       ## platform specific programming.
 
@@ -2454,7 +2487,7 @@ when not defined(JS): #and not defined(NimrodVM):
       status: int
       context: C_JmpBuf
       hasRaiseAction: bool
-      raiseAction: proc (e: ref E_Base): bool {.closure.}
+      raiseAction: proc (e: ref Exception): bool {.closure.}
   
   when declared(initAllocator):
     initAllocator()
@@ -2470,14 +2503,14 @@ when not defined(JS): #and not defined(NimrodVM):
       ## allows you to override the behaviour of your application when CTRL+C
       ## is pressed. Only one such hook is supported.
       
-    proc writeStackTrace*() {.tags: [FWriteIO].}
+    proc writeStackTrace*() {.tags: [WriteIOEffect].}
       ## writes the current stack trace to ``stderr``. This is only works
       ## for debug builds.
     when hostOS != "standalone":
       proc getStackTrace*(): string
         ## gets the current stack trace. This only works for debug builds.
 
-      proc getStackTrace*(e: ref E_Base): string
+      proc getStackTrace*(e: ref Exception): string
         ## gets the stack trace associated with `e`, which is the stack that
         ## lead to the ``raise`` statement. This only works for debug builds.
         
@@ -2505,7 +2538,7 @@ when not defined(JS): #and not defined(NimrodVM):
     proc getDiscriminant(aa: pointer, n: ptr TNimNode): int =
       sysAssert(n.kind == nkCase, "getDiscriminant: node != nkCase")
       var d: int
-      var a = cast[TAddress](aa)
+      var a = cast[ByteAddress](aa)
       case n.typ.size
       of 1: d = ze(cast[ptr int8](a +% n.offset)[])
       of 2: d = ze(cast[ptr int16](a +% n.offset)[])
@@ -2534,7 +2567,7 @@ when not defined(JS): #and not defined(NimrodVM):
     include "system/sysio"
 
   when hostOS != "standalone":
-    iterator lines*(filename: string): TaintedString {.tags: [FReadIO].} =
+    iterator lines*(filename: string): TaintedString {.tags: [ReadIOEffect].} =
       ## Iterates over any line in the file named `filename`.
       ##
       ## If the file does not exist `EIO` is raised. The trailing newline
@@ -2553,14 +2586,14 @@ when not defined(JS): #and not defined(NimrodVM):
       while f.readLine(res): yield res
       close(f)
 
-    iterator lines*(f: TFile): TaintedString {.tags: [FReadIO].} =
+    iterator lines*(f: File): TaintedString {.tags: [ReadIOEffect].} =
       ## Iterate over any line in the file `f`.
       ##
       ## The trailing newline character(s) are removed from the iterated lines.
       ## Example:
       ##
       ## .. code-block:: nimrod
-      ##   proc countZeros(filename: TFile): tuple[lines, zeros: int] =
+      ##   proc countZeros(filename: File): tuple[lines, zeros: int] =
       ##     for line in filename.lines:
       ##       for letter in line:
       ##         if letter == '0':
@@ -2573,7 +2606,7 @@ when not defined(JS): #and not defined(NimrodVM):
     include "system/assign"
     include "system/repr"
 
-    proc getCurrentException*(): ref E_Base {.compilerRtl, inl, gcsafe.} =
+    proc getCurrentException*(): ref Exception {.compilerRtl, inl, gcsafe.} =
       ## retrieves the current exception; if there is none, nil is returned.
       result = currException
 
@@ -2583,7 +2616,7 @@ when not defined(JS): #and not defined(NimrodVM):
       var e = getCurrentException()
       return if e == nil: "" else: e.msg
 
-    proc onRaise*(action: proc(e: ref E_Base): bool{.closure.}) =
+    proc onRaise*(action: proc(e: ref Exception): bool{.closure.}) =
       ## can be used in a ``try`` statement to setup a Lisp-like
       ## `condition system`:idx:\: This prevents the 'raise' statement to
       ## raise an exception but instead calls ``action``.
@@ -2721,11 +2754,11 @@ template spliceImpl(s, a, L, b: expr): stmt {.immediate.} =
   for i in 0 .. <b.len: s[i+a] = b[i]  
 
 when hostOS != "standalone":
-  proc `[]`*(s: string, x: TSlice[int]): string {.inline.} =
+  proc `[]`*(s: string, x: Slice[int]): string {.inline.} =
     ## slice operation for strings. Negative indexes are supported.
     result = s.substr(x.a-|s, x.b-|s)
 
-  proc `[]=`*(s: var string, x: TSlice[int], b: string) = 
+  proc `[]=`*(s: var string, x: Slice[int], b: string) = 
     ## slice assignment for strings. Negative indexes are supported. If
     ## ``b.len`` is not exactly the number of elements that are referred to
     ## by `x`, a `splice`:idx: is performed:
@@ -2741,7 +2774,7 @@ when hostOS != "standalone":
     else:
       spliceImpl(s, a, L, b)
 
-proc `[]`*[Idx, T](a: array[Idx, T], x: TSlice[int]): seq[T] =
+proc `[]`*[Idx, T](a: array[Idx, T], x: Slice[int]): seq[T] =
   ## slice operation for arrays. Negative indexes are **not** supported
   ## because the array might have negative bounds.
   when low(a) < 0:
@@ -2750,7 +2783,7 @@ proc `[]`*[Idx, T](a: array[Idx, T], x: TSlice[int]): seq[T] =
   newSeq(result, L)
   for i in 0.. <L: result[i] = a[i + x.a]
 
-proc `[]=`*[Idx, T](a: var array[Idx, T], x: TSlice[int], b: openArray[T]) =
+proc `[]=`*[Idx, T](a: var array[Idx, T], x: Slice[int], b: openArray[T]) =
   ## slice assignment for arrays. Negative indexes are **not** supported
   ## because the array might have negative bounds.
   when low(a) < 0:
@@ -2759,9 +2792,9 @@ proc `[]=`*[Idx, T](a: var array[Idx, T], x: TSlice[int], b: openArray[T]) =
   if L == b.len:
     for i in 0 .. <L: a[i+x.a] = b[i]
   else:
-    sysFatal(EOutOfRange, "different lengths for slice assignment")
+    sysFatal(RangeError, "different lengths for slice assignment")
 
-proc `[]`*[Idx, T](a: array[Idx, T], x: TSlice[Idx]): seq[T] =
+proc `[]`*[Idx, T](a: array[Idx, T], x: Slice[Idx]): seq[T] =
   ## slice operation for arrays. Negative indexes are **not** supported
   ## because the array might have negative bounds.
   var L = ord(x.b) - ord(x.a) + 1
@@ -2771,7 +2804,7 @@ proc `[]`*[Idx, T](a: array[Idx, T], x: TSlice[Idx]): seq[T] =
     result[i] = a[j]
     inc(j)
 
-proc `[]=`*[Idx, T](a: var array[Idx, T], x: TSlice[Idx], b: openArray[T]) =
+proc `[]=`*[Idx, T](a: var array[Idx, T], x: Slice[Idx], b: openArray[T]) =
   ## slice assignment for arrays. Negative indexes are **not** supported
   ## because the array might have negative bounds.
   var L = ord(x.b) - ord(x.a) + 1
@@ -2781,16 +2814,16 @@ proc `[]=`*[Idx, T](a: var array[Idx, T], x: TSlice[Idx], b: openArray[T]) =
       a[j] = b[i]
       inc(j)
   else:
-    sysFatal(EOutOfRange, "different lengths for slice assignment")
+    sysFatal(RangeError, "different lengths for slice assignment")
 
-proc `[]`*[T](s: seq[T], x: TSlice[int]): seq[T] = 
+proc `[]`*[T](s: seq[T], x: Slice[int]): seq[T] = 
   ## slice operation for sequences. Negative indexes are supported.
   var a = x.a-|s
   var L = x.b-|s - a + 1
   newSeq(result, L)
   for i in 0.. <L: result[i] = s[i + a]
 
-proc `[]=`*[T](s: var seq[T], x: TSlice[int], b: openArray[T]) = 
+proc `[]=`*[T](s: var seq[T], x: Slice[int], b: openArray[T]) = 
   ## slice assignment for sequences. Negative indexes are supported. If
   ## ``b.len`` is not exactly the number of elements that are referred to
   ## by `x`, a `splice`:idx: is performed. 
@@ -2830,13 +2863,13 @@ proc staticExec*(command: string, input = ""): string {.
   ## inside a pragma like `passC <nimrodc.html#passc-pragma>`_ or `passL
   ## <nimrodc.html#passl-pragma>`_.
 
-proc `+=`*[T: TOrdinal|uint|uint64](x: var T, y: T) {.magic: "Inc", noSideEffect.}
+proc `+=`*[T: SomeOrdinal|uint|uint64](x: var T, y: T) {.magic: "Inc", noSideEffect.}
   ## Increments an ordinal
 
-proc `-=`*[T: TOrdinal|uint|uint64](x: var T, y: T) {.magic: "Dec", noSideEffect.}
+proc `-=`*[T: SomeOrdinal|uint|uint64](x: var T, y: T) {.magic: "Dec", noSideEffect.}
   ## Decrements an ordinal
 
-proc `*=`*[T: TOrdinal|uint|uint64](x: var T, y: T) {.inline, noSideEffect.} =
+proc `*=`*[T: SomeOrdinal|uint|uint64](x: var T, y: T) {.inline, noSideEffect.} =
   ## Binary `*=` operator for ordinals
   x = x * y
 
@@ -2897,7 +2930,7 @@ template currentSourcePath*: string = instantiationInfo(-1, true).filename
   ## returns the full file-system path of the current source
 
 proc raiseAssert*(msg: string) {.noinline.} =
-  sysFatal(EAssertionFailed, msg)
+  sysFatal(AssertionError, msg)
 
 when true:
   proc failedAssertImpl*(msg: string) {.raises: [], tags: [].} =
@@ -3046,7 +3079,7 @@ when hostOS != "standalone":
     if x == nil: x = y
     else: x.add(y)
 
-proc locals*(): TObject {.magic: "Locals", noSideEffect.} =
+proc locals*(): RootObj {.magic: "Locals", noSideEffect.} =
   ## generates a tuple constructor expression listing all the local variables
   ## in the current scope. This is quite fast as it does not rely
   ## on any debug or runtime information. Note that in constrast to what
diff --git a/lib/system/alloc.nim b/lib/system/alloc.nim
index 9638472c2..f225b53ed 100644
--- a/lib/system/alloc.nim
+++ b/lib/system/alloc.nim
@@ -218,7 +218,7 @@ proc llAlloc(a: var TMemRegion, size: int): pointer =
     a.llmem.size = PageSize - sizeof(TLLChunk)
     a.llmem.acc = sizeof(TLLChunk)
     a.llmem.next = old
-  result = cast[pointer](cast[TAddress](a.llmem) + a.llmem.acc)
+  result = cast[pointer](cast[ByteAddress](a.llmem) + a.llmem.acc)
   dec(a.llmem.size, size)
   inc(a.llmem.acc, size)
   zeroMem(result, size)
@@ -321,7 +321,7 @@ iterator allObjects(m: TMemRegion): pointer {.inline.} =
           var c = cast[PSmallChunk](c)
           
           let size = c.size
-          var a = cast[TAddress](addr(c.data))
+          var a = cast[ByteAddress](addr(c.data))
           let limit = a + c.acc
           while a <% limit:
             yield cast[pointer](a)
@@ -335,27 +335,27 @@ proc isCell(p: pointer): bool {.inline.} =
 
 # ------------- chunk management ----------------------------------------------
 proc pageIndex(c: PChunk): int {.inline.} = 
-  result = cast[TAddress](c) shr PageShift
+  result = cast[ByteAddress](c) shr PageShift
 
 proc pageIndex(p: pointer): int {.inline.} = 
-  result = cast[TAddress](p) shr PageShift
+  result = cast[ByteAddress](p) shr PageShift
 
 proc pageAddr(p: pointer): PChunk {.inline.} = 
-  result = cast[PChunk](cast[TAddress](p) and not PageMask)
+  result = cast[PChunk](cast[ByteAddress](p) and not PageMask)
   #sysAssert(Contains(allocator.chunkStarts, pageIndex(result)))
 
 proc requestOsChunks(a: var TMemRegion, size: int): PBigChunk = 
   incCurrMem(a, size)
   inc(a.freeMem, size)
   result = cast[PBigChunk](osAllocPages(size))
-  sysAssert((cast[TAddress](result) and PageMask) == 0, "requestOsChunks 1")
+  sysAssert((cast[ByteAddress](result) and PageMask) == 0, "requestOsChunks 1")
   #zeroMem(result, size)
   result.next = nil
   result.prev = nil
   result.used = false
   result.size = size
   # update next.prevSize:
-  var nxt = cast[TAddress](result) +% size
+  var nxt = cast[ByteAddress](result) +% size
   sysAssert((nxt and PageMask) == 0, "requestOsChunks 2")
   var next = cast[PChunk](nxt)
   if pageIndex(next) in a.chunkStarts:
@@ -363,7 +363,7 @@ proc requestOsChunks(a: var TMemRegion, size: int): PBigChunk =
     next.prevSize = size
   # set result.prevSize:
   var lastSize = if a.lastSize != 0: a.lastSize else: PageSize
-  var prv = cast[TAddress](result) -% lastSize
+  var prv = cast[ByteAddress](result) -% lastSize
   sysAssert((nxt and PageMask) == 0, "requestOsChunks 3")
   var prev = cast[PChunk](prv)
   if pageIndex(prev) in a.chunkStarts and prev.size == lastSize:
@@ -376,7 +376,7 @@ proc requestOsChunks(a: var TMemRegion, size: int): PBigChunk =
 proc freeOsChunks(a: var TMemRegion, p: pointer, size: int) = 
   # update next.prevSize:
   var c = cast[PChunk](p)
-  var nxt = cast[TAddress](p) +% c.size
+  var nxt = cast[ByteAddress](p) +% c.size
   sysAssert((nxt and PageMask) == 0, "freeOsChunks")
   var next = cast[PChunk](nxt)
   if pageIndex(next) in a.chunkStarts:
@@ -429,8 +429,8 @@ proc listRemove[T](head: var T, c: T) {.inline.} =
   
 proc updatePrevSize(a: var TMemRegion, c: PBigChunk, 
                     prevSize: int) {.inline.} = 
-  var ri = cast[PChunk](cast[TAddress](c) +% c.size)
-  sysAssert((cast[TAddress](ri) and PageMask) == 0, "updatePrevSize")
+  var ri = cast[PChunk](cast[ByteAddress](c) +% c.size)
+  sysAssert((cast[ByteAddress](ri) and PageMask) == 0, "updatePrevSize")
   if isAccessible(a, ri):
     ri.prevSize = prevSize
   
@@ -439,8 +439,8 @@ proc freeBigChunk(a: var TMemRegion, c: PBigChunk) =
   sysAssert(c.size >= PageSize, "freeBigChunk")
   inc(a.freeMem, c.size)
   when coalescRight:
-    var ri = cast[PChunk](cast[TAddress](c) +% c.size)
-    sysAssert((cast[TAddress](ri) and PageMask) == 0, "freeBigChunk 2")
+    var ri = cast[PChunk](cast[ByteAddress](c) +% c.size)
+    sysAssert((cast[ByteAddress](ri) and PageMask) == 0, "freeBigChunk 2")
     if isAccessible(a, ri) and chunkUnused(ri):
       sysAssert(not isSmallChunk(ri), "freeBigChunk 3")
       if not isSmallChunk(ri):
@@ -449,8 +449,8 @@ proc freeBigChunk(a: var TMemRegion, c: PBigChunk) =
         excl(a.chunkStarts, pageIndex(ri))
   when coalescLeft:
     if c.prevSize != 0: 
-      var le = cast[PChunk](cast[TAddress](c) -% c.prevSize)
-      sysAssert((cast[TAddress](le) and PageMask) == 0, "freeBigChunk 4")
+      var le = cast[PChunk](cast[ByteAddress](c) -% c.prevSize)
+      sysAssert((cast[ByteAddress](le) and PageMask) == 0, "freeBigChunk 4")
       if isAccessible(a, le) and chunkUnused(le):
         sysAssert(not isSmallChunk(le), "freeBigChunk 5")
         if not isSmallChunk(le):
@@ -468,7 +468,7 @@ proc freeBigChunk(a: var TMemRegion, c: PBigChunk) =
     freeOsChunks(a, c, c.size)
 
 proc splitChunk(a: var TMemRegion, c: PBigChunk, size: int) = 
-  var rest = cast[PBigChunk](cast[TAddress](c) +% size)
+  var rest = cast[PBigChunk](cast[ByteAddress](c) +% size)
   sysAssert(rest notin a.freeChunksList, "splitChunk")
   rest.size = c.size - size
   rest.used = false
@@ -559,7 +559,7 @@ proc rawAlloc(a: var TMemRegion, requestedSize: int): pointer =
       c.prev = nil
       listAdd(a.freeSmallChunks[s], c)
       result = addr(c.data)
-      sysAssert((cast[TAddress](result) and (MemAlign-1)) == 0, "rawAlloc 4")
+      sysAssert((cast[ByteAddress](result) and (MemAlign-1)) == 0, "rawAlloc 4")
     else:
       sysAssert(allocInv(a), "rawAlloc: begin c != nil")
       sysAssert c.next != c, "rawAlloc 5"
@@ -569,21 +569,21 @@ proc rawAlloc(a: var TMemRegion, requestedSize: int): pointer =
       if c.freeList == nil:
         sysAssert(c.acc + smallChunkOverhead() + size <= SmallChunkSize, 
                   "rawAlloc 7")
-        result = cast[pointer](cast[TAddress](addr(c.data)) +% c.acc)
+        result = cast[pointer](cast[ByteAddress](addr(c.data)) +% c.acc)
         inc(c.acc, size)
       else:
         result = c.freeList
         sysAssert(c.freeList.zeroField == 0, "rawAlloc 8")
         c.freeList = c.freeList.next
       dec(c.free, size)
-      sysAssert((cast[TAddress](result) and (MemAlign-1)) == 0, "rawAlloc 9")
+      sysAssert((cast[ByteAddress](result) and (MemAlign-1)) == 0, "rawAlloc 9")
       sysAssert(allocInv(a), "rawAlloc: end c != nil")
     sysAssert(allocInv(a), "rawAlloc: before c.free < size")
     if c.free < size:
       sysAssert(allocInv(a), "rawAlloc: before listRemove test")
       listRemove(a.freeSmallChunks[s], c)
       sysAssert(allocInv(a), "rawAlloc: end listRemove test")
-    sysAssert(((cast[TAddress](result) and PageMask) - smallChunkOverhead()) %%
+    sysAssert(((cast[ByteAddress](result) and PageMask) - smallChunkOverhead()) %%
                size == 0, "rawAlloc 21")
     sysAssert(allocInv(a), "rawAlloc: end small size")
   else:
@@ -594,9 +594,9 @@ proc rawAlloc(a: var TMemRegion, requestedSize: int): pointer =
     sysAssert c.next == nil, "rawAlloc 11"
     sysAssert c.size == size, "rawAlloc 12"
     result = addr(c.data)
-    sysAssert((cast[TAddress](result) and (MemAlign-1)) == 0, "rawAlloc 13")
+    sysAssert((cast[ByteAddress](result) and (MemAlign-1)) == 0, "rawAlloc 13")
     if a.root == nil: a.root = bottom
-    add(a, a.root, cast[TAddress](result), cast[TAddress](result)+%size)
+    add(a, a.root, cast[ByteAddress](result), cast[TAddress](result)+%size)
   sysAssert(isAccessible(a, result), "rawAlloc 14")
   sysAssert(allocInv(a), "rawAlloc: end")
   when logAlloc: cprintf("rawAlloc: %ld %p\n", requestedSize, result)
@@ -613,7 +613,7 @@ proc rawDealloc(a: var TMemRegion, p: pointer) =
     # `p` is within a small chunk:
     var c = cast[PSmallChunk](c)
     var s = c.size
-    sysAssert(((cast[TAddress](p) and PageMask) - smallChunkOverhead()) %%
+    sysAssert(((cast[ByteAddress](p) and PageMask) - smallChunkOverhead()) %%
                s == 0, "rawDealloc 3")
     var f = cast[ptr TFreeCell](p)
     #echo("setting to nil: ", $cast[TAddress](addr(f.zeroField)))
@@ -636,7 +636,7 @@ proc rawDealloc(a: var TMemRegion, p: pointer) =
         listRemove(a.freeSmallChunks[s div MemAlign], c)
         c.size = SmallChunkSize
         freeBigChunk(a, cast[PBigChunk](c))
-    sysAssert(((cast[TAddress](p) and PageMask) - smallChunkOverhead()) %%
+    sysAssert(((cast[ByteAddress](p) and PageMask) - smallChunkOverhead()) %%
                s == 0, "rawDealloc 2")
   else:
     # set to 0xff to check for usage after free bugs:
@@ -655,7 +655,7 @@ proc isAllocatedPtr(a: TMemRegion, p: pointer): bool =
     if not chunkUnused(c):
       if isSmallChunk(c):
         var c = cast[PSmallChunk](c)
-        var offset = (cast[TAddress](p) and (PageSize-1)) -% 
+        var offset = (cast[ByteAddress](p) and (PageSize-1)) -% 
                      smallChunkOverhead()
         result = (c.acc >% offset) and (offset %% c.size == 0) and
           (cast[ptr TFreeCell](p).zeroField >% 1)
@@ -673,12 +673,12 @@ proc interiorAllocatedPtr(a: TMemRegion, p: pointer): pointer =
     if not chunkUnused(c):
       if isSmallChunk(c):
         var c = cast[PSmallChunk](c)
-        var offset = (cast[TAddress](p) and (PageSize-1)) -% 
+        var offset = (cast[ByteAddress](p) and (PageSize-1)) -% 
                      smallChunkOverhead()
         if c.acc >% offset:
-          sysAssert(cast[TAddress](addr(c.data)) +% offset ==
-                    cast[TAddress](p), "offset is not what you think it is")
-          var d = cast[ptr TFreeCell](cast[TAddress](addr(c.data)) +% 
+          sysAssert(cast[ByteAddress](addr(c.data)) +% offset ==
+                    cast[ByteAddress](p), "offset is not what you think it is")
+          var d = cast[ptr TFreeCell](cast[ByteAddress](addr(c.data)) +% 
                     offset -% (offset %% c.size))
           if d.zeroField >% 1:
             result = d
@@ -704,7 +704,7 @@ proc interiorAllocatedPtr(a: TMemRegion, p: pointer): pointer =
           sysAssert isAllocatedPtr(a, result), " result wrong pointer!"
 
 proc ptrSize(p: pointer): int =
-  var x = cast[pointer](cast[TAddress](p) -% sizeof(TFreeCell))
+  var x = cast[pointer](cast[ByteAddress](p) -% sizeof(TFreeCell))
   var c = pageAddr(p)
   sysAssert(not chunkUnused(c), "ptrSize")
   result = c.size -% sizeof(TFreeCell)
@@ -715,7 +715,7 @@ proc alloc(allocator: var TMemRegion, size: int): pointer =
   result = rawAlloc(allocator, size+sizeof(TFreeCell))
   cast[ptr TFreeCell](result).zeroField = 1 # mark it as used
   sysAssert(not isAllocatedPtr(allocator, result), "alloc")
-  result = cast[pointer](cast[TAddress](result) +% sizeof(TFreeCell))
+  result = cast[pointer](cast[ByteAddress](result) +% sizeof(TFreeCell))
 
 proc alloc0(allocator: var TMemRegion, size: int): pointer =
   result = alloc(allocator, size)
@@ -723,7 +723,7 @@ proc alloc0(allocator: var TMemRegion, size: int): pointer =
 
 proc dealloc(allocator: var TMemRegion, p: pointer) =
   sysAssert(p != nil, "dealloc 0")
-  var x = cast[pointer](cast[TAddress](p) -% sizeof(TFreeCell))
+  var x = cast[pointer](cast[ByteAddress](p) -% sizeof(TFreeCell))
   sysAssert(x != nil, "dealloc 1")
   sysAssert(isAccessible(allocator, x), "is not accessible")
   sysAssert(cast[ptr TFreeCell](x).zeroField == 1, "dealloc 2")
@@ -769,7 +769,7 @@ template instantiateForRegion(allocator: expr) =
       result = interiorAllocatedPtr(allocator, p)
 
     proc isAllocatedPtr*(p: pointer): bool =
-      let p = cast[pointer](cast[TAddress](p)-%TAddress(sizeof(TCell)))
+      let p = cast[pointer](cast[ByteAddress](p)-%TAddress(sizeof(TCell)))
       result = isAllocatedPtr(allocator, p)
 
   proc deallocOsPages = deallocOsPages(allocator)
@@ -784,7 +784,7 @@ template instantiateForRegion(allocator: expr) =
     dealloc(allocator, p)
 
   proc realloc(p: pointer, newsize: int): pointer =
-    result = realloc(allocator, p, newsize)
+    result = realloc(allocator, p, newSize)
 
   when false:
     proc countFreeMem(): int =
@@ -833,7 +833,7 @@ template instantiateForRegion(allocator: expr) =
       result = realloc(sharedHeap, p, newsize)
       releaseSys(heapLock)
     else:
-      result = realloc(p, newsize)
+      result = realloc(p, newSize)
 
   when hasThreadSupport:
 
diff --git a/lib/system/arithm.nim b/lib/system/arithm.nim
index 1cc9b41e6..c4df287cf 100644
--- a/lib/system/arithm.nim
+++ b/lib/system/arithm.nim
@@ -12,10 +12,10 @@
 
 proc raiseOverflow {.compilerproc, noinline, noreturn.} =
   # a single proc to reduce code size to a minimum
-  sysFatal(EOverflow, "over- or underflow")
+  sysFatal(OverflowError, "over- or underflow")
 
 proc raiseDivByZero {.compilerproc, noinline, noreturn.} =
-  sysFatal(EDivByZero, "divison by zero")
+  sysFatal(DivByZeroError, "divison by zero")
 
 proc addInt64(a, b: int64): int64 {.compilerProc, inline.} =
   result = a +% b
@@ -328,16 +328,16 @@ when not declared(mulInt):
 # written in other languages.
 
 proc raiseFloatInvalidOp {.noinline, noreturn.} =
-  sysFatal(EFloatInvalidOp, "FPU operation caused a NaN result")
+  sysFatal(FloatInvalidOpError, "FPU operation caused a NaN result")
 
 proc nanCheck(x: float64) {.compilerProc, inline.} =
   if x != x: raiseFloatInvalidOp()
 
 proc raiseFloatOverflow(x: float64) {.noinline, noreturn.} =
   if x > 0.0:
-    sysFatal(EFloatOverflow, "FPU operation caused an overflow")
+    sysFatal(FloatOverflowError, "FPU operation caused an overflow")
   else:
-    sysFatal(EFloatUnderflow, "FPU operations caused an underflow")
+    sysFatal(FloatUnderflowError, "FPU operations caused an underflow")
 
 proc infCheck(x: float64) {.compilerProc, inline.} =
   if x != 0.0 and x*0.5 == x: raiseFloatOverflow(x)
diff --git a/lib/system/assign.nim b/lib/system/assign.nim
index a213a9d97..6c58c24c2 100644
--- a/lib/system/assign.nim
+++ b/lib/system/assign.nim
@@ -13,8 +13,8 @@ proc genericAssignAux(dest, src: pointer, mt: PNimType, shallow: bool) {.gcsafe.
 proc genericAssignAux(dest, src: pointer, n: ptr TNimNode,
                       shallow: bool) {.gcsafe.} =
   var
-    d = cast[TAddress](dest)
-    s = cast[TAddress](src)
+    d = cast[ByteAddress](dest)
+    s = cast[ByteAddress](src)
   case n.kind
   of nkSlot:
     genericAssignAux(cast[pointer](d +% n.offset), 
@@ -40,8 +40,8 @@ proc genericAssignAux(dest, src: pointer, n: ptr TNimNode,
 
 proc genericAssignAux(dest, src: pointer, mt: PNimType, shallow: bool) =
   var
-    d = cast[TAddress](dest)
-    s = cast[TAddress](src)
+    d = cast[ByteAddress](dest)
+    s = cast[ByteAddress](src)
   sysAssert(mt != nil, "genericAssignAux 2")
   case mt.kind
   of tyString:
@@ -62,11 +62,11 @@ proc genericAssignAux(dest, src: pointer, mt: PNimType, shallow: bool) =
       return
     sysAssert(dest != nil, "genericAssignAux 3")
     unsureAsgnRef(x, newSeq(mt, seq.len))
-    var dst = cast[TAddress](cast[PPointer](dest)[])
+    var dst = cast[ByteAddress](cast[PPointer](dest)[])
     for i in 0..seq.len-1:
       genericAssignAux(
         cast[pointer](dst +% i*% mt.base.size +% GenericSeqSize),
-        cast[pointer](cast[TAddress](s2) +% i *% mt.base.size +%
+        cast[pointer](cast[ByteAddress](s2) +% i *% mt.base.size +%
                      GenericSeqSize),
         mt.base, shallow)
   of tyObject:
@@ -130,15 +130,15 @@ proc genericSeqAssign(dest, src: pointer, mt: PNimType) {.compilerProc.} =
 proc genericAssignOpenArray(dest, src: pointer, len: int,
                             mt: PNimType) {.compilerproc.} =
   var
-    d = cast[TAddress](dest)
-    s = cast[TAddress](src)
+    d = cast[ByteAddress](dest)
+    s = cast[ByteAddress](src)
   for i in 0..len-1:
     genericAssign(cast[pointer](d +% i*% mt.base.size),
                   cast[pointer](s +% i*% mt.base.size), mt.base)
 
 proc objectInit(dest: pointer, typ: PNimType) {.compilerProc, gcsafe.}
 proc objectInitAux(dest: pointer, n: ptr TNimNode) {.gcsafe.} =
-  var d = cast[TAddress](dest)
+  var d = cast[ByteAddress](dest)
   case n.kind
   of nkNone: sysAssert(false, "objectInitAux")
   of nkSlot: objectInit(cast[pointer](d +% n.offset), n.typ)
@@ -152,7 +152,7 @@ proc objectInitAux(dest: pointer, n: ptr TNimNode) {.gcsafe.} =
 proc objectInit(dest: pointer, typ: PNimType) =
   # the generic init proc that takes care of initialization of complex
   # objects on the stack or heap
-  var d = cast[TAddress](dest)
+  var d = cast[ByteAddress](dest)
   case typ.kind
   of tyObject:
     # iterate over any structural type
@@ -184,7 +184,7 @@ else:
 
 proc genericReset(dest: pointer, mt: PNimType) {.compilerProc, gcsafe.}
 proc genericResetAux(dest: pointer, n: ptr TNimNode) =
-  var d = cast[TAddress](dest)
+  var d = cast[ByteAddress](dest)
   case n.kind
   of nkNone: sysAssert(false, "genericResetAux")
   of nkSlot: genericReset(cast[pointer](d +% n.offset), n.typ)
@@ -196,7 +196,7 @@ proc genericResetAux(dest: pointer, n: ptr TNimNode) =
     zeroMem(cast[pointer](d +% n.offset), n.typ.size)
   
 proc genericReset(dest: pointer, mt: PNimType) =
-  var d = cast[TAddress](dest)
+  var d = cast[ByteAddress](dest)
   sysAssert(mt != nil, "genericReset 2")
   case mt.kind
   of tyString, tyRef, tySequence:
@@ -223,4 +223,4 @@ proc FieldDiscriminantCheck(oldDiscVal, newDiscVal: int,
   var oldBranch = selectBranch(oldDiscVal, L, a)
   var newBranch = selectBranch(newDiscVal, L, a)
   if newBranch != oldBranch and oldDiscVal != 0:
-    sysFatal(EInvalidField, "assignment to discriminant changes object branch")
+    sysFatal(FieldError, "assignment to discriminant changes object branch")
diff --git a/lib/system/cellsets.nim b/lib/system/cellsets.nim
index 653aed241..0e3a01eba 100644
--- a/lib/system/cellsets.nim
+++ b/lib/system/cellsets.nim
@@ -27,7 +27,7 @@ type
   TBitIndex = range[0..UnitsPerPage-1]
   TPageDesc {.final, pure.} = object
     next: PPageDesc # all nodes are connected with this pointer
-    key: TAddress   # start address at bit 0
+    key: ByteAddress   # start address at bit 0
     bits: array[TBitIndex, int] # a bit vector
 
   PPageDescArray = ptr array[0..1000_000, PPageDesc]
@@ -98,7 +98,7 @@ proc nextTry(h, maxHash: int): int {.inline.} =
   # generates each int in range(maxHash) exactly once (see any text on
   # random-number generation for proof).
   
-proc cellSetGet(t: TCellSet, key: TAddress): PPageDesc =
+proc cellSetGet(t: TCellSet, key: ByteAddress): PPageDesc =
   var h = cast[int](key) and t.max
   while t.data[h] != nil:
     if t.data[h].key == key: return t.data[h]
@@ -123,7 +123,7 @@ proc cellSetEnlarge(t: var TCellSet) =
   dealloc(t.data)
   t.data = n
 
-proc cellSetPut(t: var TCellSet, key: TAddress): PPageDesc =
+proc cellSetPut(t: var TCellSet, key: ByteAddress): PPageDesc =
   var h = cast[int](key) and t.max
   while true:
     var x = t.data[h]
@@ -147,7 +147,7 @@ proc cellSetPut(t: var TCellSet, key: TAddress): PPageDesc =
 # ---------- slightly higher level procs --------------------------------------
 
 proc contains(s: TCellSet, cell: PCell): bool =
-  var u = cast[TAddress](cell)
+  var u = cast[ByteAddress](cell)
   var t = cellSetGet(s, u shr PageShift)
   if t != nil:
     u = (u %% PageSize) /% MemAlign
@@ -156,13 +156,13 @@ proc contains(s: TCellSet, cell: PCell): bool =
     result = false
 
 proc incl(s: var TCellSet, cell: PCell) {.noinline.} =
-  var u = cast[TAddress](cell)
+  var u = cast[ByteAddress](cell)
   var t = cellSetPut(s, u shr PageShift)
   u = (u %% PageSize) /% MemAlign
   t.bits[u shr IntShift] = t.bits[u shr IntShift] or (1 shl (u and IntMask))
 
 proc excl(s: var TCellSet, cell: PCell) =
-  var u = cast[TAddress](cell)
+  var u = cast[ByteAddress](cell)
   var t = cellSetGet(s, u shr PageShift)
   if t != nil:
     u = (u %% PageSize) /% MemAlign
@@ -170,7 +170,7 @@ proc excl(s: var TCellSet, cell: PCell) =
                               not (1 shl (u and IntMask)))
 
 proc containsOrIncl(s: var TCellSet, cell: PCell): bool = 
-  var u = cast[TAddress](cell)
+  var u = cast[ByteAddress](cell)
   var t = cellSetGet(s, u shr PageShift)
   if t != nil:
     u = (u %% PageSize) /% MemAlign
diff --git a/lib/system/chcks.nim b/lib/system/chcks.nim
index c018a7631..5c32a307a 100644
--- a/lib/system/chcks.nim
+++ b/lib/system/chcks.nim
@@ -13,13 +13,13 @@ proc raiseRangeError(val: BiggestInt) {.compilerproc, noreturn, noinline.} =
   when hostOS == "standalone":
     sysFatal(EOutOfRange, "value out of range")
   else:
-    sysFatal(EOutOfRange, "value out of range: ", $val)
+    sysFatal(RangeError, "value out of range: ", $val)
 
 proc raiseIndexError() {.compilerproc, noreturn, noinline.} =
-  sysFatal(EInvalidIndex, "index out of bounds")
+  sysFatal(IndexError, "index out of bounds")
 
 proc raiseFieldError(f: string) {.compilerproc, noreturn, noinline.} =
-  sysFatal(EInvalidField, f, " is not accessible")
+  sysFatal(FieldError, f, " is not accessible")
 
 proc chckIndx(i, a, b: int): int =
   if i >= a and i <= b:
@@ -46,11 +46,11 @@ proc chckRangeF(x, a, b: float): float =
     when hostOS == "standalone":
       sysFatal(EOutOfRange, "value out of range")
     else:
-      sysFatal(EOutOfRange, "value out of range: ", $x)
+      sysFatal(RangeError, "value out of range: ", $x)
 
 proc chckNil(p: pointer) =
   if p == nil:
-    sysFatal(EInvalidValue, "attempt to write to a nil address")
+    sysFatal(ValueError, "attempt to write to a nil address")
     #c_raise(SIGSEGV)
 
 proc chckObj(obj, subclass: PNimType) {.compilerproc.} =
@@ -59,13 +59,13 @@ proc chckObj(obj, subclass: PNimType) {.compilerproc.} =
   if x == subclass: return # optimized fast path
   while x != subclass:
     if x == nil:
-      sysFatal(EInvalidObjectConversion, "invalid object conversion")
+      sysFatal(ObjectConversionError, "invalid object conversion")
       break
     x = x.base
 
 proc chckObjAsgn(a, b: PNimType) {.compilerproc, inline.} =
   if a != b:
-    sysFatal(EInvalidObjectAssignment, "invalid object assignment")
+    sysFatal(ObjectAssignmentError, "invalid object assignment")
 
 type ObjCheckCache = array[0..1, PNimType]
 
diff --git a/lib/system/deepcopy.nim b/lib/system/deepcopy.nim
index 243cc85e8..902999970 100644
--- a/lib/system/deepcopy.nim
+++ b/lib/system/deepcopy.nim
@@ -10,8 +10,8 @@
 proc genericDeepCopyAux(dest, src: pointer, mt: PNimType) {.gcsafe.}
 proc genericDeepCopyAux(dest, src: pointer, n: ptr TNimNode) {.gcsafe.} =
   var
-    d = cast[TAddress](dest)
-    s = cast[TAddress](src)
+    d = cast[ByteAddress](dest)
+    s = cast[ByteAddress](src)
   case n.kind
   of nkSlot:
     genericDeepCopyAux(cast[pointer](d +% n.offset), 
@@ -40,8 +40,8 @@ proc copyDeepString(src: NimString): NimString {.inline.} =
 
 proc genericDeepCopyAux(dest, src: pointer, mt: PNimType) =
   var
-    d = cast[TAddress](dest)
-    s = cast[TAddress](src)
+    d = cast[ByteAddress](dest)
+    s = cast[ByteAddress](src)
   sysAssert(mt != nil, "genericDeepCopyAux 2")
   case mt.kind
   of tyString:
@@ -60,11 +60,11 @@ proc genericDeepCopyAux(dest, src: pointer, mt: PNimType) =
       return
     sysAssert(dest != nil, "genericDeepCopyAux 3")
     unsureAsgnRef(x, newSeq(mt, seq.len))
-    var dst = cast[TAddress](cast[PPointer](dest)[])
+    var dst = cast[ByteAddress](cast[PPointer](dest)[])
     for i in 0..seq.len-1:
       genericDeepCopyAux(
         cast[pointer](dst +% i*% mt.base.size +% GenericSeqSize),
-        cast[pointer](cast[TAddress](s2) +% i *% mt.base.size +%
+        cast[pointer](cast[ByteAddress](s2) +% i *% mt.base.size +%
                      GenericSeqSize),
         mt.base)
   of tyObject:
@@ -82,8 +82,8 @@ proc genericDeepCopyAux(dest, src: pointer, mt: PNimType) =
       genericDeepCopyAux(cast[pointer](d +% i*% mt.base.size),
                          cast[pointer](s +% i*% mt.base.size), mt.base)
   of tyRef:
-    if mt.base.deepCopy != nil:
-      let z = mt.base.deepCopy(cast[PPointer](src)[])
+    if mt.base.deepcopy != nil:
+      let z = mt.base.deepcopy(cast[PPointer](src)[])
       unsureAsgnRef(cast[PPointer](dest), z)
     else:
       # we modify the header of the cell temporarily; instead of the type
@@ -116,8 +116,8 @@ proc genericDeepCopyAux(dest, src: pointer, mt: PNimType) =
         genericDeepCopyAux(z, s2, realType.base)        
   of tyPtr:
     # no cycle check here, but also not really required
-    if mt.base.deepCopy != nil:
-      cast[PPointer](dest)[] = mt.base.deepCopy(cast[PPointer](s)[])
+    if mt.base.deepcopy != nil:
+      cast[PPointer](dest)[] = mt.base.deepcopy(cast[PPointer](s)[])
     else:
       cast[PPointer](dest)[] = cast[PPointer](s)[]
   else:
@@ -134,8 +134,8 @@ proc genericSeqDeepCopy(dest, src: pointer, mt: PNimType) {.compilerProc.} =
 proc genericDeepCopyOpenArray(dest, src: pointer, len: int,
                             mt: PNimType) {.compilerproc.} =
   var
-    d = cast[TAddress](dest)
-    s = cast[TAddress](src)
+    d = cast[ByteAddress](dest)
+    s = cast[ByteAddress](src)
   for i in 0..len-1:
     genericDeepCopy(cast[pointer](d +% i*% mt.base.size),
                     cast[pointer](s +% i*% mt.base.size), mt.base)
diff --git a/lib/system/dyncalls.nim b/lib/system/dyncalls.nim
index eb57559fd..e0d99cf88 100644
--- a/lib/system/dyncalls.nim
+++ b/lib/system/dyncalls.nim
@@ -17,7 +17,7 @@
 const
   NilLibHandle: TLibHandle = nil
 
-proc rawWrite(f: TFile, s: string) = 
+proc rawWrite(f: File, s: string) = 
   # we cannot throw an exception here!
   discard writeBuffer(f, cstring(s), s.len)
 
diff --git a/lib/system/excpt.nim b/lib/system/excpt.nim
index 04a23db9d..c7e6803d2 100644
--- a/lib/system/excpt.nim
+++ b/lib/system/excpt.nim
@@ -11,7 +11,7 @@
 # use the heap (and nor exceptions) do not include the GC or memory allocator.
 
 var
-  errorMessageWriter*: (proc(msg: string) {.tags: [FWriteIO], gcsafe.})
+  errorMessageWriter*: (proc(msg: string) {.tags: [WriteIOEffect], gcsafe.})
     ## Function that will be called
     ## instead of stdmsg.write when printing stacktrace.
     ## Unstable API.
@@ -42,7 +42,7 @@ var
   excHandler {.threadvar.}: PSafePoint
     # list of exception handlers
     # a global variable for the root of all try blocks
-  currException {.threadvar.}: ref E_Base
+  currException {.threadvar.}: ref Exception
 
 proc popFrame {.compilerRtl, inl.} =
   framePtr = framePtr.prev
@@ -58,7 +58,7 @@ proc pushSafePoint(s: PSafePoint) {.compilerRtl, inl.} =
 proc popSafePoint {.compilerRtl, inl.} =
   excHandler = excHandler.prev
 
-proc pushCurrentException(e: ref E_Base) {.compilerRtl, inl.} = 
+proc pushCurrentException(e: ref Exception) {.compilerRtl, inl.} = 
   e.parent = currException
   currException = e
 
@@ -195,7 +195,7 @@ proc quitOrDebug() {.inline.} =
   else:
     endbStep() # call the debugger
 
-proc raiseExceptionAux(e: ref E_Base) =
+proc raiseExceptionAux(e: ref Exception) =
   if localRaiseHook != nil:
     if not localRaiseHook(e): return
   if globalRaiseHook != nil:
@@ -204,7 +204,7 @@ proc raiseExceptionAux(e: ref E_Base) =
     if not excHandler.hasRaiseAction or excHandler.raiseAction(e):
       pushCurrentException(e)
       c_longjmp(excHandler.context, 1)
-  elif e[] of EOutOfMemory:
+  elif e[] of OutOfMemError:
     showErrorMessage(e.name)
     quitOrDebug()
   else:
@@ -236,7 +236,7 @@ proc raiseExceptionAux(e: ref E_Base) =
       showErrorMessage(buf)
     quitOrDebug()
 
-proc raiseException(e: ref E_Base, ename: cstring) {.compilerRtl.} =
+proc raiseException(e: ref Exception, ename: cstring) {.compilerRtl.} =
   e.name = ename
   when hasSomeStackTrace:
     e.trace = ""
@@ -245,7 +245,7 @@ proc raiseException(e: ref E_Base, ename: cstring) {.compilerRtl.} =
 
 proc reraiseException() {.compilerRtl.} =
   if currException == nil:
-    sysFatal(ENoExceptionToReraise, "no exception to reraise")
+    sysFatal(ReraiseError, "no exception to reraise")
   else:
     raiseExceptionAux(currException)
 
@@ -264,7 +264,7 @@ proc getStackTrace(): string =
   else:
     result = "No stack traceback available\n"
 
-proc getStackTrace(e: ref E_Base): string =
+proc getStackTrace(e: ref Exception): string =
   if not isNil(e) and not isNil(e.trace):
     result = e.trace
   else:
diff --git a/lib/system/gc.nim b/lib/system/gc.nim
index 053c7df69..cf8ebbe60 100644
--- a/lib/system/gc.nim
+++ b/lib/system/gc.nim
@@ -111,11 +111,11 @@ proc addZCT(s: var TCellSeq, c: PCell) {.noinline.} =
 
 proc cellToUsr(cell: PCell): pointer {.inline.} =
   # convert object (=pointer to refcount) to pointer to userdata
-  result = cast[pointer](cast[TAddress](cell)+%TAddress(sizeof(TCell)))
+  result = cast[pointer](cast[ByteAddress](cell)+%TAddress(sizeof(TCell)))
 
 proc usrToCell(usr: pointer): PCell {.inline.} =
   # convert pointer to userdata to object (=pointer to refcount)
-  result = cast[PCell](cast[TAddress](usr)-%TAddress(sizeof(TCell)))
+  result = cast[PCell](cast[ByteAddress](usr)-%TAddress(sizeof(TCell)))
 
 proc canbeCycleRoot(c: PCell): bool {.inline.} =
   result = ntfAcyclic notin c.typ.flags
@@ -312,7 +312,7 @@ proc cellsetReset(s: var TCellSet) =
   init(s)
 
 proc forAllSlotsAux(dest: pointer, n: ptr TNimNode, op: TWalkOp) {.gcsafe.} =
-  var d = cast[TAddress](dest)
+  var d = cast[ByteAddress](dest)
   case n.kind
   of nkSlot: forAllChildrenAux(cast[pointer](d +% n.offset), n.typ, op)
   of nkList:
@@ -332,7 +332,7 @@ proc forAllSlotsAux(dest: pointer, n: ptr TNimNode, op: TWalkOp) {.gcsafe.} =
   of nkNone: sysAssert(false, "forAllSlotsAux")
 
 proc forAllChildrenAux(dest: pointer, mt: PNimType, op: TWalkOp) =
-  var d = cast[TAddress](dest)
+  var d = cast[ByteAddress](dest)
   if dest == nil: return # nothing to do
   if ntfNoRefs notin mt.flags:
     case mt.kind
@@ -358,7 +358,7 @@ proc forAllChildren(cell: PCell, op: TWalkOp) =
     of tyRef: # common case
       forAllChildrenAux(cellToUsr(cell), cell.typ.base, op)
     of tySequence:
-      var d = cast[TAddress](cellToUsr(cell))
+      var d = cast[ByteAddress](cellToUsr(cell))
       var s = cast[PGenericSeq](d)
       if s != nil:
         for i in 0..s.len-1:
@@ -424,7 +424,7 @@ proc rawNewObj(typ: PNimType, size: int, gch: var TGcHeap): pointer =
   gcAssert(typ.kind in {tyRef, tyString, tySequence}, "newObj: 1")
   collectCT(gch)
   var res = cast[PCell](rawAlloc(gch.region, size + sizeof(TCell)))
-  gcAssert((cast[TAddress](res) and (MemAlign-1)) == 0, "newObj: 2")
+  gcAssert((cast[ByteAddress](res) and (MemAlign-1)) == 0, "newObj: 2")
   # now it is buffered in the ZCT
   res.typ = typ
   when leakDetector and not hasThreadSupport:
@@ -470,7 +470,7 @@ proc newObjRC1(typ: PNimType, size: int): pointer {.compilerRtl.} =
   
   var res = cast[PCell](rawAlloc(gch.region, size + sizeof(TCell)))
   sysAssert(allocInv(gch.region), "newObjRC1 after rawAlloc")
-  sysAssert((cast[TAddress](res) and (MemAlign-1)) == 0, "newObj: 2")
+  sysAssert((cast[ByteAddress](res) and (MemAlign-1)) == 0, "newObj: 2")
   # now it is buffered in the ZCT
   res.typ = typ
   when leakDetector and not hasThreadSupport:
@@ -511,9 +511,9 @@ proc growObj(old: pointer, newsize: int, gch: var TGcHeap): pointer =
   
   var oldsize = cast[PGenericSeq](old).len*elemSize + GenericSeqSize
   copyMem(res, ol, oldsize + sizeof(TCell))
-  zeroMem(cast[pointer](cast[TAddress](res)+% oldsize +% sizeof(TCell)),
+  zeroMem(cast[pointer](cast[ByteAddress](res)+% oldsize +% sizeof(TCell)),
           newsize-oldsize)
-  sysAssert((cast[TAddress](res) and (MemAlign-1)) == 0, "growObj: 3")
+  sysAssert((cast[ByteAddress](res) and (MemAlign-1)) == 0, "growObj: 3")
   sysAssert(res.refcount shr rcShift <=% 1, "growObj: 4")
   #if res.refcount <% rcIncrement:
   #  add(gch.zct, res)
@@ -728,7 +728,7 @@ proc gcMark(gch: var TGcHeap, p: pointer) {.inline.} =
   # the addresses are not as cells on the stack, so turn them to cells:
   sysAssert(allocInv(gch.region), "gcMark begin")
   var cell = usrToCell(p)
-  var c = cast[TAddress](cell)
+  var c = cast[ByteAddress](cell)
   if c >% PageSize:
     # fast check: does it look like a cell?
     var objStart = cast[PCell](interiorAllocatedPtr(gch.region, cell))
@@ -778,8 +778,8 @@ when not defined(useNimRtl):
     # the first init must be the one that defines the stack bottom:
     if gch.stackBottom == nil: gch.stackBottom = theStackBottom
     else:
-      var a = cast[TAddress](theStackBottom) # and not PageMask - PageSize*2
-      var b = cast[TAddress](gch.stackBottom)
+      var a = cast[ByteAddress](theStackBottom) # and not PageMask - PageSize*2
+      var b = cast[ByteAddress](gch.stackBottom)
       #c_fprintf(c_stdout, "old: %p new: %p;\n",gch.stackBottom,theStackBottom)
       when stackIncreases:
         gch.stackBottom = cast[pointer](min(a, b))
@@ -854,9 +854,9 @@ else:
   proc isOnStack(p: pointer): bool =
     var stackTop {.volatile.}: pointer
     stackTop = addr(stackTop)
-    var b = cast[TAddress](gch.stackBottom)
-    var a = cast[TAddress](stackTop)
-    var x = cast[TAddress](p)
+    var b = cast[ByteAddress](gch.stackBottom)
+    var a = cast[ByteAddress](stackTop)
+    var x = cast[ByteAddress](p)
     result = a <=% x and x <=% b
 
   template forEachStackSlot(gch, gcMark: expr) {.immediate, dirty.} =
@@ -866,8 +866,8 @@ else:
     type PStackSlice = ptr array [0..7, pointer]
     var registers {.noinit.}: C_JmpBuf
     if c_setjmp(registers) == 0'i32: # To fill the C stack with registers.
-      var max = cast[TAddress](gch.stackBottom)
-      var sp = cast[TAddress](addr(registers))
+      var max = cast[ByteAddress](gch.stackBottom)
+      var sp = cast[ByteAddress](addr(registers))
       # loop unrolled:
       while sp <% max - 8*sizeof(pointer):
         gcMark(gch, cast[PStackSlice](sp)[0])
@@ -1040,7 +1040,7 @@ when not defined(useNimRtl):
       else:
         dec(gch.recGcLock)
 
-  proc GC_setStrategy(strategy: TGC_Strategy) =
+  proc GC_setStrategy(strategy: GC_Strategy) =
     discard
 
   proc GC_enableMarkAndSweep() =
diff --git a/lib/system/repr.nim b/lib/system/repr.nim
index 7408552f9..2de603cea 100644
--- a/lib/system/repr.nim
+++ b/lib/system/repr.nim
@@ -155,7 +155,7 @@ when not defined(useNimRtl):
     var bs = typ.base.size
     for i in 0..typ.size div bs - 1:
       if i > 0: add result, ", "
-      reprAux(result, cast[pointer](cast[TAddress](p) + i*bs), typ.base, cl)
+      reprAux(result, cast[pointer](cast[ByteAddress](p) + i*bs), typ.base, cl)
     add result, "]"
 
   proc reprSequence(result: var string, p: pointer, typ: PNimType,
@@ -167,7 +167,7 @@ when not defined(useNimRtl):
     var bs = typ.base.size
     for i in 0..cast[PGenericSeq](p).len-1:
       if i > 0: add result, ", "
-      reprAux(result, cast[pointer](cast[TAddress](p) + GenericSeqSize + i*bs),
+      reprAux(result, cast[pointer](cast[ByteAddress](p) + GenericSeqSize + i*bs),
               typ.base, cl)
     add result, "]"
 
@@ -178,14 +178,14 @@ when not defined(useNimRtl):
     of nkSlot:
       add result, $n.name
       add result, " = "
-      reprAux(result, cast[pointer](cast[TAddress](p) + n.offset), n.typ, cl)
+      reprAux(result, cast[pointer](cast[ByteAddress](p) + n.offset), n.typ, cl)
     of nkList:
       for i in 0..n.len-1:
         if i > 0: add result, ",\n"
         reprRecordAux(result, p, n.sons[i], cl)
     of nkCase:
       var m = selectBranch(p, n)
-      reprAux(result, cast[pointer](cast[TAddress](p) + n.offset), n.typ, cl)
+      reprAux(result, cast[pointer](cast[ByteAddress](p) + n.offset), n.typ, cl)
       if m != nil: reprRecordAux(result, p, m, cl)
 
   proc reprRecord(result: var string, p: pointer, typ: PNimType,
@@ -265,7 +265,7 @@ proc reprOpenArray(p: pointer, length: int, elemtyp: PNimType): string {.
   var bs = elemtyp.size
   for i in 0..length - 1:
     if i > 0: add result, ", "
-    reprAux(result, cast[pointer](cast[TAddress](p) + i*bs), elemtyp, cl)
+    reprAux(result, cast[pointer](cast[ByteAddress](p) + i*bs), elemtyp, cl)
   add result, "]"
   deinitReprClosure(cl)
 
diff --git a/lib/system/sysio.nim b/lib/system/sysio.nim
index 32d4c3e91..56de5e6e8 100644
--- a/lib/system/sysio.nim
+++ b/lib/system/sysio.nim
@@ -1,6 +1,6 @@
 #
 #
-#            Nimrod's Runtime Library
+#            Nim's Runtime Library
 #        (c) Copyright 2013 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
@@ -8,7 +8,7 @@
 #
 
 
-# Nimrod's standard IO library. It contains high-performance
+# Nim's standard IO library. It contains high-performance
 # routines for reading and writing data to (buffered) files or
 # TTYs.
 
@@ -16,33 +16,33 @@
                        # of the standard library!
 
 
-proc fputs(c: cstring, f: TFile) {.importc: "fputs", header: "<stdio.h>", 
-  tags: [FWriteIO].}
-proc fgets(c: cstring, n: int, f: TFile): cstring {.
-  importc: "fgets", header: "<stdio.h>", tags: [FReadIO].}
-proc fgetc(stream: TFile): cint {.importc: "fgetc", header: "<stdio.h>",
-  tags: [FReadIO].}
-proc ungetc(c: cint, f: TFile) {.importc: "ungetc", header: "<stdio.h>",
+proc fputs(c: cstring, f: File) {.importc: "fputs", header: "<stdio.h>", 
+  tags: [WriteIOEffect].}
+proc fgets(c: cstring, n: int, f: File): cstring {.
+  importc: "fgets", header: "<stdio.h>", tags: [ReadIOEffect].}
+proc fgetc(stream: File): cint {.importc: "fgetc", header: "<stdio.h>",
+  tags: [ReadIOEffect].}
+proc ungetc(c: cint, f: File) {.importc: "ungetc", header: "<stdio.h>",
   tags: [].}
-proc putc(c: char, stream: TFile) {.importc: "putc", header: "<stdio.h>",
-  tags: [FWriteIO].}
-proc fprintf(f: TFile, frmt: cstring) {.importc: "fprintf", 
-  header: "<stdio.h>", varargs, tags: [FWriteIO].}
+proc putc(c: char, stream: File) {.importc: "putc", header: "<stdio.h>",
+  tags: [WriteIOEffect].}
+proc fprintf(f: File, frmt: cstring) {.importc: "fprintf", 
+  header: "<stdio.h>", varargs, tags: [WriteIOEffect].}
 proc strlen(c: cstring): int {.
   importc: "strlen", header: "<string.h>", tags: [].}
 
 
 # C routine that is used here:
-proc fread(buf: pointer, size, n: int, f: TFile): int {.
-  importc: "fread", header: "<stdio.h>", tags: [FReadIO].}
-proc fseek(f: TFile, offset: clong, whence: int): int {.
+proc fread(buf: pointer, size, n: int, f: File): int {.
+  importc: "fread", header: "<stdio.h>", tags: [ReadIOEffect].}
+proc fseek(f: File, offset: clong, whence: int): int {.
   importc: "fseek", header: "<stdio.h>", tags: [].}
-proc ftell(f: TFile): int {.importc: "ftell", header: "<stdio.h>", tags: [].}
-proc setvbuf(stream: TFile, buf: pointer, typ, size: cint): cint {.
+proc ftell(f: File): int {.importc: "ftell", header: "<stdio.h>", tags: [].}
+proc setvbuf(stream: File, buf: pointer, typ, size: cint): cint {.
   importc, header: "<stdio.h>", tags: [].}
 
 {.push stackTrace:off, profiler:off.}
-proc write(f: TFile, c: cstring) = fputs(c, f)
+proc write(f: File, c: cstring) = fputs(c, f)
 {.pop.}
 
 when NoFakeVars:
@@ -65,9 +65,9 @@ const
   BufSize = 4000
 
 proc raiseEIO(msg: string) {.noinline, noreturn.} =
-  sysFatal(EIO, msg)
+  sysFatal(IOError, msg)
 
-proc readLine(f: TFile, line: var TaintedString): bool =
+proc readLine(f: File, line: var TaintedString): bool =
   # of course this could be optimized a bit; but IO is slow anyway...
   # and it was difficult to get this CORRECT with Ansi C's methods
   setLen(line.string, 0) # reuse the buffer!
@@ -84,34 +84,34 @@ proc readLine(f: TFile, line: var TaintedString): bool =
     add line.string, chr(int(c))
   result = true
 
-proc readLine(f: TFile): TaintedString =
+proc readLine(f: File): TaintedString =
   result = TaintedString(newStringOfCap(80))
   if not readLine(f, result): raiseEIO("EOF reached")
 
-proc write(f: TFile, i: int) = 
+proc write(f: File, i: int) = 
   when sizeof(int) == 8:
     fprintf(f, "%lld", i)
   else:
     fprintf(f, "%ld", i)
 
-proc write(f: TFile, i: BiggestInt) = 
+proc write(f: File, i: BiggestInt) = 
   when sizeof(BiggestInt) == 8:
     fprintf(f, "%lld", i)
   else:
     fprintf(f, "%ld", i)
     
-proc write(f: TFile, b: bool) =
+proc write(f: File, b: bool) =
   if b: write(f, "true")
   else: write(f, "false")
-proc write(f: TFile, r: float32) = fprintf(f, "%g", r)
-proc write(f: TFile, r: BiggestFloat) = fprintf(f, "%g", r)
+proc write(f: File, r: float32) = fprintf(f, "%g", r)
+proc write(f: File, r: BiggestFloat) = fprintf(f, "%g", r)
 
-proc write(f: TFile, c: char) = putc(c, f)
-proc write(f: TFile, a: varargs[string, `$`]) =
+proc write(f: File, c: char) = putc(c, f)
+proc write(f: File, a: varargs[string, `$`]) =
   for x in items(a): write(f, x)
 
-proc readAllBuffer(file: TFile): string = 
-  # This proc is for TFile we want to read but don't know how many
+proc readAllBuffer(file: File): string = 
+  # This proc is for File we want to read but don't know how many
   # bytes we need to read before the buffer is empty.
   result = ""
   var buffer = newString(BufSize)
@@ -124,27 +124,27 @@ proc readAllBuffer(file: TFile): string =
       result.add(buffer)
       break
   
-proc rawFileSize(file: TFile): int = 
+proc rawFileSize(file: File): int = 
   # this does not raise an error opposed to `getFileSize`
   var oldPos = ftell(file)
   discard fseek(file, 0, 2) # seek the end of the file
   result = ftell(file)
   discard fseek(file, clong(oldPos), 0)
 
-proc readAllFile(file: TFile, len: int): string =
+proc readAllFile(file: File, len: int): string =
   # We aquire the filesize beforehand and hope it doesn't change.
   # Speeds things up.
   result = newString(int(len))
   if readBuffer(file, addr(result[0]), int(len)) != len:
     raiseEIO("error while reading from file")
 
-proc readAllFile(file: TFile): string =
+proc readAllFile(file: File): string =
   var len = rawFileSize(file)
   result = readAllFile(file, len)
   
-proc readAll(file: TFile): TaintedString = 
+proc readAll(file: File): TaintedString = 
   # Separate handling needed because we need to buffer when we
-  # don't know the overall length of the TFile.
+  # don't know the overall length of the File.
   var len = rawFileSize(file)
   if len >= 0:
     result = readAllFile(file, len).TaintedString
@@ -165,13 +165,13 @@ proc writeFile(filename, content: string) =
   finally:
     close(f)
 
-proc endOfFile(f: TFile): bool =
+proc endOfFile(f: File): bool =
   # do not blame me; blame the ANSI C standard this is so brain-damaged
   var c = fgetc(f)
   ungetc(c, f)
   return c < 0'i32
 
-proc writeln[Ty](f: TFile, x: varargs[Ty, `$`]) =
+proc writeln[Ty](f: File, x: varargs[Ty, `$`]) =
   for i in items(x): write(f, i)
   write(f, "\n")
 
@@ -186,7 +186,7 @@ when (defined(windows) and not defined(useWinAnsi)) or defined(nimdoc):
 when defined(windows) and not defined(useWinAnsi):  
   proc wfopen(filename, mode: WideCString): pointer {.
     importc: "_wfopen", nodecl.}
-  proc wfreopen(filename, mode: WideCString, stream: TFile): TFile {.
+  proc wfreopen(filename, mode: WideCString, stream: File): File {.
     importc: "_wfreopen", nodecl.}
 
   proc fopen(filename, mode: cstring): pointer =
@@ -194,82 +194,82 @@ when defined(windows) and not defined(useWinAnsi):
     var m = newWideCString(mode)
     result = wfopen(f, m)
 
-  proc freopen(filename, mode: cstring, stream: TFile): TFile =
+  proc freopen(filename, mode: cstring, stream: File): File =
     var f = newWideCString(filename)
     var m = newWideCString(mode)
     result = wfreopen(f, m, stream)
 
 else:
   proc fopen(filename, mode: cstring): pointer {.importc: "fopen", noDecl.}
-  proc freopen(filename, mode: cstring, stream: TFile): TFile {.
+  proc freopen(filename, mode: cstring, stream: File): File {.
     importc: "freopen", nodecl.}
 
 const
-  FormatOpen: array [TFileMode, string] = ["rb", "wb", "w+b", "r+b", "ab"]
+  FormatOpen: array [FileMode, string] = ["rb", "wb", "w+b", "r+b", "ab"]
     #"rt", "wt", "w+t", "r+t", "at"
-    # we always use binary here as for Nimrod the OS line ending
+    # we always use binary here as for Nim the OS line ending
     # should not be translated.
 
 
-proc open(f: var TFile, filename: string,
-          mode: TFileMode = fmRead,
+proc open(f: var File, filename: string,
+          mode: FileMode = fmRead,
           bufSize: int = -1): bool =
   var p: pointer = fopen(filename, FormatOpen[mode])
   result = (p != nil)
-  f = cast[TFile](p)
+  f = cast[File](p)
   if bufSize > 0 and bufSize <= high(cint).int:
     if setvbuf(f, nil, IOFBF, bufSize.cint) != 0'i32:
-      sysFatal(EOutOfMemory, "out of memory")
+      sysFatal(OutOfMemError, "out of memory")
   elif bufSize == 0:
     discard setvbuf(f, nil, IONBF, 0)
 
-proc reopen(f: TFile, filename: string, mode: TFileMode = fmRead): bool = 
+proc reopen(f: File, filename: string, mode: FileMode = fmRead): bool = 
   var p: pointer = freopen(filename, FormatOpen[mode], f)
   result = p != nil
 
-proc fdopen(filehandle: TFileHandle, mode: cstring): TFile {.
+proc fdopen(filehandle: FileHandle, mode: cstring): File {.
   importc: pccHack & "fdopen", header: "<stdio.h>".}
 
-proc open(f: var TFile, filehandle: TFileHandle, mode: TFileMode): bool =
+proc open(f: var File, filehandle: FileHandle, mode: FileMode): bool =
   f = fdopen(filehandle, FormatOpen[mode])
   result = f != nil
 
-proc fwrite(buf: pointer, size, n: int, f: TFile): int {.
+proc fwrite(buf: pointer, size, n: int, f: File): int {.
   importc: "fwrite", noDecl.}
 
-proc readBuffer(f: TFile, buffer: pointer, len: int): int =
+proc readBuffer(f: File, buffer: pointer, len: int): int =
   result = fread(buffer, 1, len, f)
 
-proc readBytes(f: TFile, a: var openArray[int8], start, len: int): int =
+proc readBytes(f: File, a: var openArray[int8], start, len: int): int =
   result = readBuffer(f, addr(a[start]), len)
 
-proc readChars(f: TFile, a: var openArray[char], start, len: int): int =
+proc readChars(f: File, a: var openArray[char], start, len: int): int =
   result = readBuffer(f, addr(a[start]), len)
 
 {.push stackTrace:off, profiler:off.}
-proc writeBytes(f: TFile, a: openArray[int8], start, len: int): int =
+proc writeBytes(f: File, a: openArray[int8], start, len: int): int =
   var x = cast[ptr array[0..1000_000_000, int8]](a)
   result = writeBuffer(f, addr(x[start]), len)
-proc writeChars(f: TFile, a: openArray[char], start, len: int): int =
+proc writeChars(f: File, a: openArray[char], start, len: int): int =
   var x = cast[ptr array[0..1000_000_000, int8]](a)
   result = writeBuffer(f, addr(x[start]), len)
-proc writeBuffer(f: TFile, buffer: pointer, len: int): int =
+proc writeBuffer(f: File, buffer: pointer, len: int): int =
   result = fwrite(buffer, 1, len, f)
 
-proc write(f: TFile, s: string) =
+proc write(f: File, s: string) =
   if writeBuffer(f, cstring(s), s.len) != s.len:
     raiseEIO("cannot write string to file")
 {.pop.}
 
-proc setFilePos(f: TFile, pos: int64) =
+proc setFilePos(f: File, pos: int64) =
   if fseek(f, clong(pos), 0) != 0:
     raiseEIO("cannot set file position")
 
-proc getFilePos(f: TFile): int64 =
+proc getFilePos(f: File): int64 =
   result = ftell(f)
   if result < 0: raiseEIO("cannot retrieve file position")
 
-proc getFileSize(f: TFile): int64 =
+proc getFileSize(f: File): int64 =
   var oldPos = getFilePos(f)
   discard fseek(f, 0, 2) # seek the end of the file
   result = getFilePos(f)
diff --git a/lib/system/sysstr.nim b/lib/system/sysstr.nim
index 14b24cca6..ba973e9b5 100644
--- a/lib/system/sysstr.nim
+++ b/lib/system/sysstr.nim
@@ -217,7 +217,7 @@ proc setLengthSeq(seq: PGenericSeq, elemSize, newLen: int): PGenericSeq {.
           gch.tempStack.len = len0
       else:
         for i in newLen..result.len-1:
-          forAllChildrenAux(cast[pointer](cast[TAddress](result) +%
+          forAllChildrenAux(cast[pointer](cast[ByteAddress](result) +%
                             GenericSeqSize +% (i*%elemSize)),
                             extGetCellType(result).base, waZctDecRef)
       
@@ -227,7 +227,7 @@ proc setLengthSeq(seq: PGenericSeq, elemSize, newLen: int): PGenericSeq {.
     # presense of user defined destructors, the user will expect the cell to be
     # "destroyed" thus creating the same problem. We can destoy the cell in the
     # finalizer of the sequence, but this makes destruction non-deterministic.
-    zeroMem(cast[pointer](cast[TAddress](result) +% GenericSeqSize +%
+    zeroMem(cast[pointer](cast[ByteAddress](result) +% GenericSeqSize +%
            (newLen*%elemSize)), (result.len-%newLen) *% elemSize)
   result.len = newLen