p[] instead of p^

2026-06-03 02:18:00 +00:00 · 2011-04-11 23:28:53 +02:00
parent 3d696c3da5
commit 46c41e4369
32 changed files with 242 additions and 346 deletions
--- a/examples/tclex.nim
+++ b/examples/tclex.nim
@@ -14,7 +14,7 @@ bind .e <Return> {
 }  
 """

-FindExecutable(getApplicationFilename())
+FindExecutable(getAppFilename())
 var interp = CreateInterp()
 if interp == nil: quit("cannot create TCL interpreter")
 if Init(interp) != TCL_OK: 
--- a/install.sh
+++ b/install.sh
@@ -140,120 +140,6 @@ if [ $# -eq 1 ] ; then
  chmod 644 $docdir/tut1.txt
  cp doc/tut2.txt $docdir/tut2.txt || exit 1
  chmod 644 $docdir/tut2.txt
-  cp doc/apis.html $docdir/apis.html || exit 1
-  chmod 644 $docdir/apis.html
-  cp doc/browsers.html $docdir/browsers.html || exit 1
-  chmod 644 $docdir/browsers.html
-  cp doc/c2nim.html $docdir/c2nim.html || exit 1
-  chmod 644 $docdir/c2nim.html
-  cp doc/cgi.html $docdir/cgi.html || exit 1
-  chmod 644 $docdir/cgi.html
-  cp doc/colors.html $docdir/colors.html || exit 1
-  chmod 644 $docdir/colors.html
-  cp doc/complex.html $docdir/complex.html || exit 1
-  chmod 644 $docdir/complex.html
-  cp doc/db_mysql.html $docdir/db_mysql.html || exit 1
-  chmod 644 $docdir/db_mysql.html
-  cp doc/db_postgres.html $docdir/db_postgres.html || exit 1
-  chmod 644 $docdir/db_postgres.html
-  cp doc/db_sqlite.html $docdir/db_sqlite.html || exit 1
-  chmod 644 $docdir/db_sqlite.html
-  cp doc/dynlib.html $docdir/dynlib.html || exit 1
-  chmod 644 $docdir/dynlib.html
-  cp doc/endb.html $docdir/endb.html || exit 1
-  chmod 644 $docdir/endb.html
-  cp doc/graphics.html $docdir/graphics.html || exit 1
-  chmod 644 $docdir/graphics.html
-  cp doc/hashes.html $docdir/hashes.html || exit 1
-  chmod 644 $docdir/hashes.html
-  cp doc/htmlparser.html $docdir/htmlparser.html || exit 1
-  chmod 644 $docdir/htmlparser.html
-  cp doc/httpclient.html $docdir/httpclient.html || exit 1
-  chmod 644 $docdir/httpclient.html
-  cp doc/httpserver.html $docdir/httpserver.html || exit 1
-  chmod 644 $docdir/httpserver.html
-  cp doc/intern.html $docdir/intern.html || exit 1
-  chmod 644 $docdir/intern.html
-  cp doc/json.html $docdir/json.html || exit 1
-  chmod 644 $docdir/json.html
-  cp doc/lexbase.html $docdir/lexbase.html || exit 1
-  chmod 644 $docdir/lexbase.html
-  cp doc/lib.html $docdir/lib.html || exit 1
-  chmod 644 $docdir/lib.html
-  cp doc/macros.html $docdir/macros.html || exit 1
-  chmod 644 $docdir/macros.html
-  cp doc/manual.html $docdir/manual.html || exit 1
-  chmod 644 $docdir/manual.html
-  cp doc/math.html $docdir/math.html || exit 1
-  chmod 644 $docdir/math.html
-  cp doc/niminst.html $docdir/niminst.html || exit 1
-  chmod 644 $docdir/niminst.html
-  cp doc/nimrodc.html $docdir/nimrodc.html || exit 1
-  chmod 644 $docdir/nimrodc.html
-  cp doc/os.html $docdir/os.html || exit 1
-  chmod 644 $docdir/os.html
-  cp doc/osproc.html $docdir/osproc.html || exit 1
-  chmod 644 $docdir/osproc.html
-  cp doc/overview.html $docdir/overview.html || exit 1
-  chmod 644 $docdir/overview.html
-  cp doc/parsecfg.html $docdir/parsecfg.html || exit 1
-  chmod 644 $docdir/parsecfg.html
-  cp doc/parsecsv.html $docdir/parsecsv.html || exit 1
-  chmod 644 $docdir/parsecsv.html
-  cp doc/parseopt.html $docdir/parseopt.html || exit 1
-  chmod 644 $docdir/parseopt.html
-  cp doc/parsesql.html $docdir/parsesql.html || exit 1
-  chmod 644 $docdir/parsesql.html
-  cp doc/parseutils.html $docdir/parseutils.html || exit 1
-  chmod 644 $docdir/parseutils.html
-  cp doc/parsexml.html $docdir/parsexml.html || exit 1
-  chmod 644 $docdir/parsexml.html
-  cp doc/pegs.html $docdir/pegs.html || exit 1
-  chmod 644 $docdir/pegs.html
-  cp doc/re.html $docdir/re.html || exit 1
-  chmod 644 $docdir/re.html
-  cp doc/ropes.html $docdir/ropes.html || exit 1
-  chmod 644 $docdir/ropes.html
-  cp doc/sockets.html $docdir/sockets.html || exit 1
-  chmod 644 $docdir/sockets.html
-  cp doc/streams.html $docdir/streams.html || exit 1
-  chmod 644 $docdir/streams.html
-  cp doc/strtabs.html $docdir/strtabs.html || exit 1
-  chmod 644 $docdir/strtabs.html
-  cp doc/strutils.html $docdir/strutils.html || exit 1
-  chmod 644 $docdir/strutils.html
-  cp doc/system.html $docdir/system.html || exit 1
-  chmod 644 $docdir/system.html
-  cp doc/terminal.html $docdir/terminal.html || exit 1
-  chmod 644 $docdir/terminal.html
-  cp doc/theindex.html $docdir/theindex.html || exit 1
-  chmod 644 $docdir/theindex.html
-  cp doc/times.html $docdir/times.html || exit 1
-  chmod 644 $docdir/times.html
-  cp doc/tools.html $docdir/tools.html || exit 1
-  chmod 644 $docdir/tools.html
-  cp doc/tut1.html $docdir/tut1.html || exit 1
-  chmod 644 $docdir/tut1.html
-  cp doc/tut2.html $docdir/tut2.html || exit 1
-  chmod 644 $docdir/tut2.html
-  cp doc/unicode.html $docdir/unicode.html || exit 1
-  chmod 644 $docdir/unicode.html
-  cp doc/unidecode.html $docdir/unidecode.html || exit 1
-  chmod 644 $docdir/unidecode.html
-  cp doc/web.html $docdir/web.html || exit 1
-  chmod 644 $docdir/web.html
-  cp doc/xmldom.html $docdir/xmldom.html || exit 1
-  chmod 644 $docdir/xmldom.html
-  cp doc/xmldomparser.html $docdir/xmldomparser.html || exit 1
-  chmod 644 $docdir/xmldomparser.html
-  cp doc/xmlgen.html $docdir/xmlgen.html || exit 1
-  chmod 644 $docdir/xmlgen.html
-  cp doc/xmlparser.html $docdir/xmlparser.html || exit 1
-  chmod 644 $docdir/xmlparser.html
-  cp doc/xmltree.html $docdir/xmltree.html || exit 1
-  chmod 644 $docdir/xmltree.html
-  cp doc/zipfiles.html $docdir/zipfiles.html || exit 1
-  chmod 644 $docdir/zipfiles.html
  cp doc/mytest.cfg $docdir/mytest.cfg || exit 1
  chmod 644 $docdir/mytest.cfg
  cp doc/c2nim.pdf $docdir/c2nim.pdf || exit 1
--- a/lib/core/marshal.nim
+++ b/lib/core/marshal.nim
@@ -101,10 +101,10 @@ proc reprSetAux(result: var string, p: pointer, typ: PNimType) =
  add result, "{"
  var u: int64
  case typ.size
-  of 1: u = ze64(cast[ptr int8](p)^)
-  of 2: u = ze64(cast[ptr int16](p)^)
-  of 4: u = ze64(cast[ptr int32](p)^)
-  of 8: u = cast[ptr int64](p)^
+  of 1: u = ze64(cast[ptr int8](p)[])
+  of 2: u = ze64(cast[ptr int16](p)[])
+  of 4: u = ze64(cast[ptr int32](p)[])
+  of 8: u = cast[ptr int64](p)[]
  else:
    var a = cast[pbyteArray](p)
    for i in 0 .. typ.size*8-1:
@@ -217,31 +217,31 @@ when not defined(useNimRtl):
    of tyArray: reprArray(result, p, typ, cl)
    of tyTuple, tyPureObject: reprRecord(result, p, typ, cl)
    of tyObject: 
-      var t = cast[ptr PNimType](p)^
+      var t = cast[ptr PNimType](p)[]
      reprRecord(result, p, t, cl)
    of tyRef, tyPtr:
      assert(p != nil)
-      if cast[ppointer](p)^ == nil: add result, "nil"
-      else: reprRef(result, cast[ppointer](p)^, typ, cl)
+      if cast[ppointer](p)[] == nil: add result, "nil"
+      else: reprRef(result, cast[ppointer](p)[], typ, cl)
    of tySequence:
-      reprSequence(result, cast[ppointer](p)^, typ, cl)
-    of tyInt: add result, $(cast[ptr int](p)^)
-    of tyInt8: add result, $int(cast[ptr Int8](p)^)
-    of tyInt16: add result, $int(cast[ptr Int16](p)^)
-    of tyInt32: add result, $int(cast[ptr Int32](p)^)
-    of tyInt64: add result, $(cast[ptr Int64](p)^)
-    of tyFloat: add result, $(cast[ptr float](p)^)
-    of tyFloat32: add result, $(cast[ptr float32](p)^)
-    of tyFloat64: add result, $(cast[ptr float64](p)^)
-    of tyEnum: add result, reprEnum(cast[ptr int](p)^, typ)
-    of tyBool: add result, reprBool(cast[ptr bool](p)^)
-    of tyChar: add result, reprChar(cast[ptr char](p)^)
-    of tyString: reprStrAux(result, cast[ptr string](p)^)
-    of tyCString: reprStrAux(result, $(cast[ptr cstring](p)^))
+      reprSequence(result, cast[ppointer](p)[], typ, cl)
+    of tyInt: add result, $(cast[ptr int](p)[])
+    of tyInt8: add result, $int(cast[ptr Int8](p)[])
+    of tyInt16: add result, $int(cast[ptr Int16](p)[])
+    of tyInt32: add result, $int(cast[ptr Int32](p)[])
+    of tyInt64: add result, $(cast[ptr Int64](p)[])
+    of tyFloat: add result, $(cast[ptr float](p)[])
+    of tyFloat32: add result, $(cast[ptr float32](p)[])
+    of tyFloat64: add result, $(cast[ptr float64](p)[])
+    of tyEnum: add result, reprEnum(cast[ptr int](p)[], typ)
+    of tyBool: add result, reprBool(cast[ptr bool](p)[])
+    of tyChar: add result, reprChar(cast[ptr char](p)[])
+    of tyString: reprStrAux(result, cast[ptr string](p)[])
+    of tyCString: reprStrAux(result, $(cast[ptr cstring](p)[]))
    of tyRange: reprAux(result, p, typ.base, cl)
    of tyProc, tyPointer:
-      if cast[ppointer](p)^ == nil: add result, "nil"
-      else: add result, reprPointer(cast[ppointer](p)^)
+      if cast[ppointer](p)[] == nil: add result, "nil"
+      else: add result, reprPointer(cast[ppointer](p)[])
    else:
      add result, "(invalid data!)"
    inc(cl.recdepth)
--- a/lib/pure/os.nim
+++ b/lib/pure/os.nim
@@ -720,7 +720,7 @@ else:
    # retrieves the variables of char** env of C's main proc
    if not envComputed:
      when useNSGetEnviron:
-        var gEnv = NSGetEnviron()^
+        var gEnv = NSGetEnviron()[]
      var i = 0
      while True:
        if gEnv[i] == nil: break
--- a/lib/pure/pegs.nim
+++ b/lib/pure/pegs.nim
@@ -120,7 +120,7 @@ proc charSet*(s: set[char]): TPeg {.nosideEffect, rtl, extern: "npegs$1".} =
  assert '\0' notin s
  result.kind = pkCharChoice
  new(result.charChoice)
-  result.charChoice^ = s
+  result.charChoice[] = s

 proc len(a: TPeg): int {.inline.} = return a.sons.len
 proc add(d: var TPeg, s: TPeg) {.inline.} = add(d.sons, s)
@@ -131,9 +131,9 @@ proc addChoice(dest: var TPeg, elem: TPeg) =
    # caution! Do not introduce false aliasing here!
    case elem.kind
    of pkCharChoice:
-      dest.sons[L] = charSet(dest.sons[L].charChoice^ + elem.charChoice^)
+      dest.sons[L] = charSet(dest.sons[L].charChoice[] + elem.charChoice[])
    of pkChar: 
-      dest.sons[L] = charSet(dest.sons[L].charChoice^ + {elem.ch})
+      dest.sons[L] = charSet(dest.sons[L].charChoice[] + {elem.ch})
    else: add(dest, elem)
  else: add(dest, elem)

@@ -435,7 +435,7 @@ proc toStrAux(r: TPeg, res: var string) =
    add(res, 'y')
    add(res, singleQuoteEsc(r.term))
  of pkChar: add(res, singleQuoteEsc(r.ch))
-  of pkCharChoice: add(res, charSetEsc(r.charChoice^))
+  of pkCharChoice: add(res, charSetEsc(r.charChoice[]))
  of pkNonTerminal: add(res, r.nt.name)
  of pkSequence:
    add(res, '(')
@@ -458,7 +458,7 @@ proc toStrAux(r: TPeg, res: var string) =
    add(res, singleQuoteEsc(r.ch))
    add(res, '*')
  of pkGreedyRepSet:
-    add(res, charSetEsc(r.charChoice^))
+    add(res, charSetEsc(r.charChoice[]))
    add(res, '*')
  of pkGreedyAny:
    add(res, ".*")
@@ -640,7 +640,7 @@ proc rawMatch*(s: string, p: TPeg, start: int, c: var TCaptures): int {.
    if p.ch == s[start]: result = 1
    else: result = -1
  of pkCharChoice:
-    if contains(p.charChoice^, s[start]): result = 1
+    if contains(p.charChoice[], s[start]): result = 1
    else: result = -1
  of pkNonTerminal:
    var oldMl = c.ml
@@ -706,7 +706,7 @@ proc rawMatch*(s: string, p: TPeg, start: int, c: var TCaptures): int {.
    while ch == s[start+result]: inc(result)
  of pkGreedyRepSet:
    result = 0
-    while contains(p.charChoice^, s[start+result]): inc(result)
+    while contains(p.charChoice[], s[start+result]): inc(result)
  of pkOption:
    result = max(0, rawMatch(s, p.sons[0], start, c))
  of pkAndPredicate:
--- a/lib/pure/times.nim
+++ b/lib/pure/times.nim
@@ -1,7 +1,7 @@
 #
 #
 #            Nimrod's Runtime Library
-#        (c) Copyright 2010 Andreas Rumpf
+#        (c) Copyright 2011 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
 #    distribution, for details about the copyright.
@@ -246,13 +246,13 @@ when not defined(ECMAScript):
  proc getTime(): TTime = return timec(nil)
  proc getLocalTime(t: TTime): TTimeInfo =
    var a = t
-    result = tmToTimeInfo(localtime(addr(a))^)
+    result = tmToTimeInfo(localtime(addr(a))[])
    # copying is needed anyway to provide reentrancity; thus
    # the convertion is not expensive
  
  proc getGMTime(t: TTime): TTimeInfo =
    var a = t
-    result = tmToTimeInfo(gmtime(addr(a))^)
+    result = tmToTimeInfo(gmtime(addr(a))[])
    # copying is needed anyway to provide reentrancity; thus
    # the convertion is not expensive
  
--- a/lib/system.nim
+++ b/lib/system.nim
@@ -1641,9 +1641,9 @@ when not defined(EcmaScript) and not defined(NimrodVM):
    var d: int
    var a = cast[TAddress](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)^)
-    of 4: d = int(cast[ptr int32](a +% n.offset)^)
+    of 1: d = ze(cast[ptr int8](a +% n.offset)[])
+    of 2: d = ze(cast[ptr int16](a +% n.offset)[])
+    of 4: d = int(cast[ptr int32](a +% n.offset)[])
    else: assert(false)
    return d

--- a/lib/system/alloc.nim
+++ b/lib/system/alloc.nim
@@ -195,7 +195,7 @@ proc IntSetGet(t: TIntSet, key: int): PTrunk =
 proc IntSetPut(t: var TIntSet, key: int): PTrunk = 
  result = IntSetGet(t, key)
  if result == nil:
-    result = cast[PTrunk](llAlloc(allocator, sizeof(result^)))
+    result = cast[PTrunk](llAlloc(allocator, sizeof(result[])))
    result.next = t.data[key and high(t.data)]
    t.data[key and high(t.data)] = result
    result.key = key
--- a/lib/system/assign.nim
+++ b/lib/system/assign.nim
@@ -34,13 +34,13 @@ proc genericAssignAux(dest, src: Pointer, mt: PNimType, shallow: bool) =
  case mt.Kind
  of tyString:
    var x = cast[ppointer](dest)
-    var s2 = cast[ppointer](s)^
+    var s2 = cast[ppointer](s)[]
    if s2 == nil or shallow:
      unsureAsgnRef(x, s2)
    else:
      unsureAsgnRef(x, copyString(cast[NimString](s2)))
  of tySequence:
-    var s2 = cast[ppointer](src)^
+    var s2 = cast[ppointer](src)[]
    var seq = cast[PGenericSeq](s2)      
    var x = cast[ppointer](dest)
    if s2 == nil or shallow:
@@ -49,7 +49,7 @@ proc genericAssignAux(dest, src: Pointer, mt: PNimType, shallow: bool) =
      return
    assert(dest != nil)
    unsureAsgnRef(x, newObj(mt, seq.len * mt.base.size + GenericSeqSize))
-    var dst = cast[taddress](cast[ppointer](dest)^)
+    var dst = cast[taddress](cast[ppointer](dest)[])
    for i in 0..seq.len-1:
      genericAssignAux(
        cast[pointer](dst +% i*% mt.base.size +% GenericSeqSize),
@@ -67,7 +67,7 @@ proc genericAssignAux(dest, src: Pointer, mt: PNimType, shallow: bool) =
      genericAssignAux(cast[pointer](d +% i*% mt.base.size),
                       cast[pointer](s +% i*% mt.base.size), mt.base, shallow)
  of tyRef:
-    unsureAsgnRef(cast[ppointer](dest), cast[ppointer](s)^)
+    unsureAsgnRef(cast[ppointer](dest), cast[ppointer](s)[])
  else:
    copyMem(dest, src, mt.size) # copy raw bits

@@ -116,7 +116,7 @@ proc objectInit(dest: Pointer, typ: PNimType) =
    # iterate over any structural type
    # here we have to init the type field:
    var pint = cast[ptr PNimType](dest)
-    pint^ = typ
+    pint[] = typ
    objectInitAux(dest, typ.node)
  of tyTuple, tyPureObject:
    objectInitAux(dest, typ.node)
--- a/lib/system/gc.nim
+++ b/lib/system/gc.nim
@@ -1,7 +1,7 @@
 #
 #
 #            Nimrod's Runtime Library
-#        (c) Copyright 2010 Andreas Rumpf
+#        (c) Copyright 2011 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
 #    distribution, for details about the copyright.
@@ -244,8 +244,8 @@ proc asgnRef(dest: ppointer, src: pointer) {.compilerProc, inline.} =
  assert(not isOnStack(dest))
  # BUGFIX: first incRef then decRef!
  if src != nil: incRef(usrToCell(src))
-  if dest^ != nil: decRef(usrToCell(dest^))
-  dest^ = src
+  if dest[] != nil: decRef(usrToCell(dest[]))
+  dest[] = src

 proc asgnRefNoCycle(dest: ppointer, src: pointer) {.compilerProc, inline.} =
  # the code generator calls this proc if it is known at compile time that no 
@@ -253,11 +253,11 @@ proc asgnRefNoCycle(dest: ppointer, src: pointer) {.compilerProc, inline.} =
  if src != nil: 
    var c = usrToCell(src)
    discard atomicInc(c.refcount, rcIncrement)
-  if dest^ != nil: 
-    var c = usrToCell(dest^)
+  if dest[] != nil: 
+    var c = usrToCell(dest[])
    if atomicDec(c.refcount, rcIncrement) <% rcIncrement:
      rtlAddZCT(c)
-  dest^ = src
+  dest[] = src

 proc unsureAsgnRef(dest: ppointer, src: pointer) {.compilerProc.} =
  # unsureAsgnRef updates the reference counters only if dest is not on the
@@ -268,8 +268,8 @@ proc unsureAsgnRef(dest: ppointer, src: pointer) {.compilerProc.} =
    # 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
+    if cast[int](dest[]) >=% PageSize: decRef(usrToCell(dest[]))
+  dest[] = src

 proc initGC() =
  when not defined(useNimRtl):
@@ -311,7 +311,7 @@ proc forAllChildrenAux(dest: Pointer, mt: PNimType, op: TWalkOp) =
      for i in 0..(mt.size div mt.base.size)-1:
        forAllChildrenAux(cast[pointer](d +% i *% mt.base.size), mt.base, op)
    of tyRef, tyString, tySequence: # leaf:
-      doOperation(cast[ppointer](d)^, op)
+      doOperation(cast[ppointer](d)[], op)
    of tyObject, tyTuple, tyPureObject:
      forAllSlotsAux(dest, mt.node, op)
    else: nil
@@ -545,7 +545,7 @@ when defined(sparc): # For SPARC architecture.
    sp = addr(stackTop[0])
    # Addresses decrease as the stack grows.
    while sp <= max:
-      gcMark(sp^)
+      gcMark(sp[])
      sp = cast[ppointer](cast[TAddress](sp) +% sizeof(pointer))

 elif defined(ELATE):
@@ -575,7 +575,7 @@ elif stackIncreases:
      # sp will traverse the JMP_BUF as well (jmp_buf size is added,
      # otherwise sp would be below the registers structure).
      while sp >=% max:
-        gcMark(cast[ppointer](sp)^)
+        gcMark(cast[ppointer](sp)[])
        sp = sp -% sizeof(pointer)

 else:
@@ -598,7 +598,7 @@ else:
      var max = cast[TAddress](stackBottom)
      var sp = cast[TAddress](addr(registers))
      while sp <=% max:
-        gcMark(cast[ppointer](sp)^)
+        gcMark(cast[ppointer](sp)[])
        sp = sp +% sizeof(pointer)

 # ----------------------------------------------------------------------------
@@ -611,13 +611,13 @@ proc CollectZCT(gch: var TGcHeap) =
  # avoid a deep stack, we move objects to keep the ZCT small.
  # This is performance critical!
  var L = addr(gch.zct.len)
-  while L^ > 0:
+  while L[] > 0:
    var c = gch.zct.d[0]
    # remove from ZCT:
    assert((c.refcount and colorMask) == rcZct)
    c.refcount = c.refcount and not colorMask
-    gch.zct.d[0] = gch.zct.d[L^ - 1]
-    dec(L^)
+    gch.zct.d[0] = gch.zct.d[L[] - 1]
+    dec(L[])
    if c.refcount <% rcIncrement: 
      # It may have a RC > 0, if it is in the hardware stack or
      # it has not been removed yet from the ZCT. This is because
--- a/lib/system/repr.nim
+++ b/lib/system/repr.nim
@@ -78,10 +78,10 @@ proc reprSetAux(result: var string, p: pointer, typ: PNimType) =
  add result, "{"
  var u: int64
  case typ.size
-  of 1: u = ze64(cast[ptr int8](p)^)
-  of 2: u = ze64(cast[ptr int16](p)^)
-  of 4: u = ze64(cast[ptr int32](p)^)
-  of 8: u = cast[ptr int64](p)^
+  of 1: u = ze64(cast[ptr int8](p)[])
+  of 2: u = ze64(cast[ptr int16](p)[])
+  of 4: u = ze64(cast[ptr int32](p)[])
+  of 8: u = cast[ptr int64](p)[]
  else:
    var a = cast[pbyteArray](p)
    for i in 0 .. typ.size*8-1:
@@ -194,31 +194,31 @@ when not defined(useNimRtl):
    of tyArray: reprArray(result, p, typ, cl)
    of tyTuple, tyPureObject: reprRecord(result, p, typ, cl)
    of tyObject: 
-      var t = cast[ptr PNimType](p)^
+      var t = cast[ptr PNimType](p)[]
      reprRecord(result, p, t, cl)
    of tyRef, tyPtr:
      assert(p != nil)
-      if cast[ppointer](p)^ == nil: add result, "nil"
-      else: reprRef(result, cast[ppointer](p)^, typ, cl)
+      if cast[ppointer](p)[] == nil: add result, "nil"
+      else: reprRef(result, cast[ppointer](p)[], typ, cl)
    of tySequence:
-      reprSequence(result, cast[ppointer](p)^, typ, cl)
-    of tyInt: add result, $(cast[ptr int](p)^)
-    of tyInt8: add result, $int(cast[ptr Int8](p)^)
-    of tyInt16: add result, $int(cast[ptr Int16](p)^)
-    of tyInt32: add result, $int(cast[ptr Int32](p)^)
-    of tyInt64: add result, $(cast[ptr Int64](p)^)
-    of tyFloat: add result, $(cast[ptr float](p)^)
-    of tyFloat32: add result, $(cast[ptr float32](p)^)
-    of tyFloat64: add result, $(cast[ptr float64](p)^)
-    of tyEnum: add result, reprEnum(cast[ptr int](p)^, typ)
-    of tyBool: add result, reprBool(cast[ptr bool](p)^)
-    of tyChar: add result, reprChar(cast[ptr char](p)^)
-    of tyString: reprStrAux(result, cast[ptr string](p)^)
-    of tyCString: reprStrAux(result, $(cast[ptr cstring](p)^))
+      reprSequence(result, cast[ppointer](p)[], typ, cl)
+    of tyInt: add result, $(cast[ptr int](p)[])
+    of tyInt8: add result, $int(cast[ptr Int8](p)[])
+    of tyInt16: add result, $int(cast[ptr Int16](p)[])
+    of tyInt32: add result, $int(cast[ptr Int32](p)[])
+    of tyInt64: add result, $(cast[ptr Int64](p)[])
+    of tyFloat: add result, $(cast[ptr float](p)[])
+    of tyFloat32: add result, $(cast[ptr float32](p)[])
+    of tyFloat64: add result, $(cast[ptr float64](p)[])
+    of tyEnum: add result, reprEnum(cast[ptr int](p)[], typ)
+    of tyBool: add result, reprBool(cast[ptr bool](p)[])
+    of tyChar: add result, reprChar(cast[ptr char](p)[])
+    of tyString: reprStrAux(result, cast[ptr string](p)[])
+    of tyCString: reprStrAux(result, $(cast[ptr cstring](p)[]))
    of tyRange: reprAux(result, p, typ.base, cl)
    of tyProc, tyPointer:
-      if cast[ppointer](p)^ == nil: add result, "nil"
-      else: add result, reprPointer(cast[ppointer](p)^)
+      if cast[ppointer](p)[] == nil: add result, "nil"
+      else: add result, reprPointer(cast[ppointer](p)[])
    else:
      add result, "(invalid data!)"
    inc(cl.recdepth)
--- a/lib/wrappers/expat.nim
+++ b/lib/wrappers/expat.nim
@@ -564,7 +564,7 @@ proc SetUserData*(parser: PParser, userData: pointer){.cdecl,
 # Returns the last value set by XML_SetUserData or NULL. 

 template GetUserData*(parser: expr): expr = 
-  (cast[ptr pointer]((parser))^ )
+  (cast[ptr pointer]((parser))[] )

 # This is equivalent to supplying an encoding argument to
 #   XML_ParserCreate. On success XML_SetEncoding returns non-zero,
--- a/lib/wrappers/gtk/glib2.nim
+++ b/lib/wrappers/gtk/glib2.nim
@@ -3468,8 +3468,8 @@ when false:
    result = g_array_insert_vals(a, i, addr(v), 1)

  proc g_ptr_array_index*(parray: PGPtrArray, index: guint): gpointer = 
-    result = cast[PGPointer](cast[int](parray ^. pdata) +
-        index * SizeOf(GPointer))^ 
+    result = cast[PGPointer](cast[int](parray []. pdata) +
+        index * SizeOf(GPointer))[] 

  proc G_THREAD_ERROR*(): TGQuark = 
    result = g_thread_error_quark()
@@ -3754,7 +3754,7 @@ proc TGIOChannel_set_is_seekable*(a: PGIOChannel, `is_seekable`: guint) =
      bm_TGIOChannel_is_seekable)

 proc utf8_next_char*(p: pguchar): pguchar = 
-  result = cast[pguchar](cast[TAddress](p) + 1) # p + ord((g_utf8_skip + p^ )^ )
+  result = cast[pguchar](cast[TAddress](p) + 1) # p + ord((g_utf8_skip + p[] )[] )
  
 when false: 
  proc GLIB_CHECK_VERSION*(major, minor, micro: guint): bool = 
--- a/lib/wrappers/gtk/gtk2.nim
+++ b/lib/wrappers/gtk/gtk2.nim
@@ -10892,127 +10892,127 @@ proc FUNDAMENTAL_TYPE*(thetype: GType): GType =

 proc VALUE_CHAR*(a: TArg): gchar = 
  var a = a
-  Result = cast[ptr gchar](addr(a.d))^ 
+  Result = cast[ptr gchar](addr(a.d))[] 

 proc VALUE_UCHAR*(a: TArg): guchar = 
  var a = a
-  Result = cast[ptr guchar](addr(a.d))^ 
+  Result = cast[ptr guchar](addr(a.d))[] 

 proc VALUE_BOOL*(a: TArg): gboolean = 
  var a = a
-  Result = cast[ptr gboolean](addr(a.d))^ 
+  Result = cast[ptr gboolean](addr(a.d))[] 

 proc VALUE_INT*(a: TArg): gint = 
  var a = a
-  Result = cast[ptr gint](addr(a.d))^ 
+  Result = cast[ptr gint](addr(a.d))[] 

 proc VALUE_UINT*(a: TArg): guint = 
  var a = a
-  Result = cast[ptr guint](addr(a.d))^ 
+  Result = cast[ptr guint](addr(a.d))[] 

 proc VALUE_LONG*(a: TArg): glong = 
  var a = a
-  Result = cast[ptr glong](addr(a.d))^ 
+  Result = cast[ptr glong](addr(a.d))[] 

 proc VALUE_ULONG*(a: TArg): gulong = 
  var a = a
-  Result = cast[ptr gulong](addr(a.d))^ 
+  Result = cast[ptr gulong](addr(a.d))[] 

 proc VALUE_FLOAT*(a: TArg): gfloat = 
  var a = a
-  Result = cast[ptr gfloat](addr(a.d))^ 
+  Result = cast[ptr gfloat](addr(a.d))[] 

 proc VALUE_DOUBLE*(a: TArg): gdouble = 
  var a = a
-  Result = cast[ptr gdouble](addr(a.d))^ 
+  Result = cast[ptr gdouble](addr(a.d))[] 

 proc VALUE_STRING*(a: TArg): cstring = 
  var a = a
-  Result = cast[ptr cstring](addr(a.d))^ 
+  Result = cast[ptr cstring](addr(a.d))[] 

 proc VALUE_ENUM*(a: TArg): gint = 
  var a = a
-  Result = cast[ptr gint](addr(a.d))^ 
+  Result = cast[ptr gint](addr(a.d))[] 

 proc VALUE_FLAGS*(a: TArg): guint = 
  var a = a
-  Result = cast[ptr guint](addr(a.d))^ 
+  Result = cast[ptr guint](addr(a.d))[] 

 proc VALUE_BOXED*(a: TArg): gpointer = 
  var a = a
-  Result = cast[ptr gpointer](addr(a.d))^ 
+  Result = cast[ptr gpointer](addr(a.d))[] 

 proc VALUE_OBJECT*(a: TArg): PObject = 
  var a = a
-  Result = cast[ptr PObject](addr(a.d))^ 
+  Result = cast[ptr PObject](addr(a.d))[] 

 proc VALUE_POINTER*(a: TArg): GPointer = 
  var a = a
-  Result = cast[ptr gpointer](addr(a.d))^ 
+  Result = cast[ptr gpointer](addr(a.d))[] 

 proc VALUE_SIGNAL*(a: TArg): TArgSignalData = 
  var a = a
-  Result = cast[ptr TArgSignalData](addr(a.d))^ 
+  Result = cast[ptr TArgSignalData](addr(a.d))[] 

 proc RETLOC_CHAR*(a: TArg): cstring = 
  var a = a
-  Result = cast[ptr cstring](addr(a.d))^ 
+  Result = cast[ptr cstring](addr(a.d))[] 

 proc RETLOC_UCHAR*(a: TArg): Pguchar = 
  var a = a
-  Result = cast[ptr pguchar](addr(a.d))^ 
+  Result = cast[ptr pguchar](addr(a.d))[] 

 proc RETLOC_BOOL*(a: TArg): Pgboolean = 
  var a = a
-  Result = cast[ptr pgboolean](addr(a.d))^ 
+  Result = cast[ptr pgboolean](addr(a.d))[] 

 proc RETLOC_INT*(a: TArg): Pgint = 
  var a = a
-  Result = cast[ptr pgint](addr(a.d))^ 
+  Result = cast[ptr pgint](addr(a.d))[] 

 proc RETLOC_UINT*(a: TArg): Pguint = 
  var a = a
-  Result = cast[ptr pguint](addr(a.d))^ 
+  Result = cast[ptr pguint](addr(a.d))[] 

 proc RETLOC_LONG*(a: TArg): Pglong = 
  var a = a
-  Result = cast[ptr pglong](addr(a.d))^ 
+  Result = cast[ptr pglong](addr(a.d))[] 

 proc RETLOC_ULONG*(a: TArg): Pgulong = 
  var a = a
-  Result = cast[ptr pgulong](addr(a.d))^ 
+  Result = cast[ptr pgulong](addr(a.d))[] 

 proc RETLOC_FLOAT*(a: TArg): Pgfloat = 
  var a = a
-  Result = cast[ptr pgfloat](addr(a.d))^ 
+  Result = cast[ptr pgfloat](addr(a.d))[] 

 proc RETLOC_DOUBLE*(a: TArg): Pgdouble = 
  var a = a
-  Result = cast[ptr pgdouble](addr(a.d))^ 
+  Result = cast[ptr pgdouble](addr(a.d))[] 

 proc RETLOC_STRING*(a: TArg): Ppgchar = 
  var a = a
-  Result = cast[ptr Ppgchar](addr(a.d))^ 
+  Result = cast[ptr Ppgchar](addr(a.d))[] 

 proc RETLOC_ENUM*(a: TArg): Pgint = 
  var a = a
-  Result = cast[ptr Pgint](addr(a.d))^ 
+  Result = cast[ptr Pgint](addr(a.d))[] 

 proc RETLOC_FLAGS*(a: TArg): Pguint = 
  var a = a
-  Result = cast[ptr pguint](addr(a.d))^ 
+  Result = cast[ptr pguint](addr(a.d))[] 

 proc RETLOC_BOXED*(a: TArg): Pgpointer = 
  var a = a
-  Result = cast[ptr pgpointer](addr(a.d))^ 
+  Result = cast[ptr pgpointer](addr(a.d))[] 

 proc RETLOC_OBJECT*(a: TArg): PPGtkObject = 
  var a = a
-  Result = cast[ptr ppgtkobject](addr(a.d))^ 
+  Result = cast[ptr ppgtkobject](addr(a.d))[] 

 proc RETLOC_POINTER*(a: TArg): Pgpointer = 
  var a = a
-  Result = cast[ptr pgpointer](addr(a.d))^ 
+  Result = cast[ptr pgpointer](addr(a.d))[] 

 proc TYPE_WIDGET*(): GType = 
  result = widget_get_type()
--- a/lib/wrappers/python.nim
+++ b/lib/wrappers/python.nim
@@ -1337,7 +1337,7 @@ proc PyImport_ExecCodeModule(name: string, codeobject: PPyObject): PPyObject =
  Py_XDECREF(v)
  modules = PyImport_GetModuleDict()
  if PyDict_GetItemString(modules, cstring(name)) == nil: 
-    PyErr_SetString(PyExc_ImportError^ , cstring(
+    PyErr_SetString(PyExc_ImportError[] , cstring(
        "Loaded module " & name & "not found in sys.modules"))
    return nil
  Py_XINCREF(m)
@@ -1371,37 +1371,37 @@ proc PyTuple_Check(obj: PPyObject): bool =
  Result = PyObject_TypeCheck(obj, PyTuple_Type)

 proc PyTuple_CheckExact(obj: PPyObject): bool = 
-  Result = (obj != nil) and (obj^ .ob_type == PyTuple_Type)
+  Result = (obj != nil) and (obj[].ob_type == PyTuple_Type)

 proc PyInstance_Check(obj: PPyObject): bool = 
-  Result = (obj != nil) and (obj^ .ob_type == PyInstance_Type)
+  Result = (obj != nil) and (obj[].ob_type == PyInstance_Type)

 proc PyClass_Check(obj: PPyObject): bool = 
-  Result = (obj != nil) and (obj^ .ob_type == PyClass_Type)
+  Result = (obj != nil) and (obj[].ob_type == PyClass_Type)

 proc PyMethod_Check(obj: PPyObject): bool = 
-  Result = (obj != nil) and (obj^ .ob_type == PyMethod_Type)
+  Result = (obj != nil) and (obj[].ob_type == PyMethod_Type)

 proc PyList_Check(obj: PPyObject): bool = 
  Result = PyObject_TypeCheck(obj, PyList_Type)

 proc PyList_CheckExact(obj: PPyObject): bool = 
-  Result = (obj != nil) and (obj^ .ob_type == PyList_Type)
+  Result = (obj != nil) and (obj[].ob_type == PyList_Type)

 proc PyDict_Check(obj: PPyObject): bool = 
  Result = PyObject_TypeCheck(obj, PyDict_Type)

 proc PyDict_CheckExact(obj: PPyObject): bool = 
-  Result = (obj != nil) and (obj^ .ob_type == PyDict_Type)
+  Result = (obj != nil) and (obj[].ob_type == PyDict_Type)

 proc PyModule_Check(obj: PPyObject): bool = 
  Result = PyObject_TypeCheck(obj, PyModule_Type)

 proc PyModule_CheckExact(obj: PPyObject): bool = 
-  Result = (obj != nil) and (obj^ .ob_type == PyModule_Type)
+  Result = (obj != nil) and (obj[].ob_type == PyModule_Type)

 proc PySlice_Check(obj: PPyObject): bool = 
-  Result = (obj != nil) and (obj^ .ob_type == PySlice_Type)
+  Result = (obj != nil) and (obj[].ob_type == PySlice_Type)

 proc PyFunction_Check(obj: PPyObject): bool = 
  Result = (obj != nil) and
--- a/lib/wrappers/sdl/sdl.nim
+++ b/lib/wrappers/sdl/sdl.nim
@@ -2525,8 +2525,8 @@ proc AllocSurface(flags: int32, width, height, depth: int,
                            AMask)

 proc MustLock(Surface: PSurface): bool = 
-  Result = ((surface^ .offset != 0) or
-      ((surface^ .flags and (HWSURFACE or ASYNCBLIT or RLEACCEL)) != 0))
+  Result = ((surface[] .offset != 0) or
+      ((surface[] .flags and (HWSURFACE or ASYNCBLIT or RLEACCEL)) != 0))

 proc LockMutex(mutex: Pmutex): int = 
  Result = mutexP(mutex)
--- a/lib/wrappers/x11/xlib.nim
+++ b/lib/wrappers/x11/xlib.nim
@@ -2065,154 +2065,154 @@ when defined(MACROS):

 when defined(MACROS): 
  proc ConnectionNumber(dpy: PDisplay): cint = 
-    ConnectionNumber = (PXPrivDisplay(dpy))^ .fd
+    ConnectionNumber = (PXPrivDisplay(dpy))[] .fd

  proc RootWindow(dpy: PDisplay, scr: cint): TWindow = 
-    RootWindow = (ScreenOfDisplay(dpy, scr))^ .root
+    RootWindow = (ScreenOfDisplay(dpy, scr))[] .root

  proc DefaultScreen(dpy: PDisplay): cint = 
-    DefaultScreen = (PXPrivDisplay(dpy))^ .default_screen
+    DefaultScreen = (PXPrivDisplay(dpy))[] .default_screen

  proc DefaultRootWindow(dpy: PDisplay): TWindow = 
-    DefaultRootWindow = (ScreenOfDisplay(dpy, DefaultScreen(dpy)))^ .root
+    DefaultRootWindow = (ScreenOfDisplay(dpy, DefaultScreen(dpy)))[] .root

  proc DefaultVisual(dpy: PDisplay, scr: cint): PVisual = 
-    DefaultVisual = (ScreenOfDisplay(dpy, scr))^ .root_visual
+    DefaultVisual = (ScreenOfDisplay(dpy, scr))[] .root_visual

  proc DefaultGC(dpy: PDisplay, scr: cint): TGC = 
-    DefaultGC = (ScreenOfDisplay(dpy, scr))^ .default_gc
+    DefaultGC = (ScreenOfDisplay(dpy, scr))[] .default_gc

  proc BlackPixel(dpy: PDisplay, scr: cint): culong = 
-    BlackPixel = (ScreenOfDisplay(dpy, scr))^ .black_pixel
+    BlackPixel = (ScreenOfDisplay(dpy, scr))[] .black_pixel

  proc WhitePixel(dpy: PDisplay, scr: cint): culong = 
-    WhitePixel = (ScreenOfDisplay(dpy, scr))^ .white_pixel
+    WhitePixel = (ScreenOfDisplay(dpy, scr))[] .white_pixel

  proc QLength(dpy: PDisplay): cint = 
-    QLength = (PXPrivDisplay(dpy))^ .qlen
+    QLength = (PXPrivDisplay(dpy))[] .qlen

  proc DisplayWidth(dpy: PDisplay, scr: cint): cint = 
-    DisplayWidth = (ScreenOfDisplay(dpy, scr))^ .width
+    DisplayWidth = (ScreenOfDisplay(dpy, scr))[] .width

  proc DisplayHeight(dpy: PDisplay, scr: cint): cint = 
-    DisplayHeight = (ScreenOfDisplay(dpy, scr))^ .height
+    DisplayHeight = (ScreenOfDisplay(dpy, scr))[] .height

  proc DisplayWidthMM(dpy: PDisplay, scr: cint): cint = 
-    DisplayWidthMM = (ScreenOfDisplay(dpy, scr))^ .mwidth
+    DisplayWidthMM = (ScreenOfDisplay(dpy, scr))[] .mwidth

  proc DisplayHeightMM(dpy: PDisplay, scr: cint): cint = 
-    DisplayHeightMM = (ScreenOfDisplay(dpy, scr))^ .mheight
+    DisplayHeightMM = (ScreenOfDisplay(dpy, scr))[] .mheight

  proc DisplayPlanes(dpy: PDisplay, scr: cint): cint = 
-    DisplayPlanes = (ScreenOfDisplay(dpy, scr))^ .root_depth
+    DisplayPlanes = (ScreenOfDisplay(dpy, scr))[] .root_depth

  proc DisplayCells(dpy: PDisplay, scr: cint): cint = 
-    DisplayCells = (DefaultVisual(dpy, scr))^ .map_entries
+    DisplayCells = (DefaultVisual(dpy, scr))[] .map_entries

  proc ScreenCount(dpy: PDisplay): cint = 
-    ScreenCount = (PXPrivDisplay(dpy))^ .nscreens
+    ScreenCount = (PXPrivDisplay(dpy))[] .nscreens

  proc ServerVendor(dpy: PDisplay): cstring = 
-    ServerVendor = (PXPrivDisplay(dpy))^ .vendor
+    ServerVendor = (PXPrivDisplay(dpy))[] .vendor

  proc ProtocolVersion(dpy: PDisplay): cint = 
-    ProtocolVersion = (PXPrivDisplay(dpy))^ .proto_major_version
+    ProtocolVersion = (PXPrivDisplay(dpy))[] .proto_major_version

  proc ProtocolRevision(dpy: PDisplay): cint = 
-    ProtocolRevision = (PXPrivDisplay(dpy))^ .proto_minor_version
+    ProtocolRevision = (PXPrivDisplay(dpy))[] .proto_minor_version

  proc VendorRelease(dpy: PDisplay): cint = 
-    VendorRelease = (PXPrivDisplay(dpy))^ .release
+    VendorRelease = (PXPrivDisplay(dpy))[] .release

  proc DisplayString(dpy: PDisplay): cstring = 
-    DisplayString = (PXPrivDisplay(dpy))^ .display_name
+    DisplayString = (PXPrivDisplay(dpy))[] .display_name

  proc DefaultDepth(dpy: PDisplay, scr: cint): cint = 
-    DefaultDepth = (ScreenOfDisplay(dpy, scr))^ .root_depth
+    DefaultDepth = (ScreenOfDisplay(dpy, scr))[] .root_depth

  proc DefaultColormap(dpy: PDisplay, scr: cint): TColormap = 
-    DefaultColormap = (ScreenOfDisplay(dpy, scr))^ .cmap
+    DefaultColormap = (ScreenOfDisplay(dpy, scr))[] .cmap

  proc BitmapUnit(dpy: PDisplay): cint = 
-    BitmapUnit = (PXPrivDisplay(dpy))^ .bitmap_unit
+    BitmapUnit = (PXPrivDisplay(dpy))[] .bitmap_unit

  proc BitmapBitOrder(dpy: PDisplay): cint = 
-    BitmapBitOrder = (PXPrivDisplay(dpy))^ .bitmap_bit_order
+    BitmapBitOrder = (PXPrivDisplay(dpy))[] .bitmap_bit_order

  proc BitmapPad(dpy: PDisplay): cint = 
-    BitmapPad = (PXPrivDisplay(dpy))^ .bitmap_pad
+    BitmapPad = (PXPrivDisplay(dpy))[] .bitmap_pad

  proc ImageByteOrder(dpy: PDisplay): cint = 
-    ImageByteOrder = (PXPrivDisplay(dpy))^ .byte_order
+    ImageByteOrder = (PXPrivDisplay(dpy))[] .byte_order

  proc NextRequest(dpy: PDisplay): culong = 
-    NextRequest = ((PXPrivDisplay(dpy))^ .request) + 1
+    NextRequest = ((PXPrivDisplay(dpy))[] .request) + 1

  proc LastKnownRequestProcessed(dpy: PDisplay): culong = 
-    LastKnownRequestProcessed = (PXPrivDisplay(dpy))^ .last_request_read
+    LastKnownRequestProcessed = (PXPrivDisplay(dpy))[] .last_request_read

  proc ScreenOfDisplay(dpy: PDisplay, scr: cint): PScreen = 
-    ScreenOfDisplay = addr((((PXPrivDisplay(dpy))^ .screens)[scr]))
+    ScreenOfDisplay = addr((((PXPrivDisplay(dpy))[] .screens)[scr]))

  proc DefaultScreenOfDisplay(dpy: PDisplay): PScreen = 
    DefaultScreenOfDisplay = ScreenOfDisplay(dpy, DefaultScreen(dpy))

  proc DisplayOfScreen(s: PScreen): PDisplay = 
-    DisplayOfScreen = s^ .display
+    DisplayOfScreen = s[] .display

  proc RootWindowOfScreen(s: PScreen): TWindow = 
-    RootWindowOfScreen = s^ .root
+    RootWindowOfScreen = s[] .root

  proc BlackPixelOfScreen(s: PScreen): culong = 
-    BlackPixelOfScreen = s^ .black_pixel
+    BlackPixelOfScreen = s[] .black_pixel

  proc WhitePixelOfScreen(s: PScreen): culong = 
-    WhitePixelOfScreen = s^ .white_pixel
+    WhitePixelOfScreen = s[] .white_pixel

  proc DefaultColormapOfScreen(s: PScreen): TColormap = 
-    DefaultColormapOfScreen = s^ .cmap
+    DefaultColormapOfScreen = s[] .cmap

  proc DefaultDepthOfScreen(s: PScreen): cint = 
-    DefaultDepthOfScreen = s^ .root_depth
+    DefaultDepthOfScreen = s[] .root_depth

  proc DefaultGCOfScreen(s: PScreen): TGC = 
-    DefaultGCOfScreen = s^ .default_gc
+    DefaultGCOfScreen = s[] .default_gc

  proc DefaultVisualOfScreen(s: PScreen): PVisual = 
-    DefaultVisualOfScreen = s^ .root_visual
+    DefaultVisualOfScreen = s[] .root_visual

  proc WidthOfScreen(s: PScreen): cint = 
-    WidthOfScreen = s^ .width
+    WidthOfScreen = s[] .width

  proc HeightOfScreen(s: PScreen): cint = 
-    HeightOfScreen = s^ .height
+    HeightOfScreen = s[] .height

  proc WidthMMOfScreen(s: PScreen): cint = 
-    WidthMMOfScreen = s^ .mwidth
+    WidthMMOfScreen = s[] .mwidth

  proc HeightMMOfScreen(s: PScreen): cint = 
-    HeightMMOfScreen = s^ .mheight
+    HeightMMOfScreen = s[] .mheight

  proc PlanesOfScreen(s: PScreen): cint = 
-    PlanesOfScreen = s^ .root_depth
+    PlanesOfScreen = s[] .root_depth

  proc CellsOfScreen(s: PScreen): cint = 
-    CellsOfScreen = (DefaultVisualOfScreen(s))^ .map_entries
+    CellsOfScreen = (DefaultVisualOfScreen(s))[] .map_entries

  proc MinCmapsOfScreen(s: PScreen): cint = 
-    MinCmapsOfScreen = s^ .min_maps
+    MinCmapsOfScreen = s[] .min_maps

  proc MaxCmapsOfScreen(s: PScreen): cint = 
-    MaxCmapsOfScreen = s^ .max_maps
+    MaxCmapsOfScreen = s[] .max_maps

  proc DoesSaveUnders(s: PScreen): TBool = 
-    DoesSaveUnders = s^ .save_unders
+    DoesSaveUnders = s[] .save_unders

  proc DoesBackingStore(s: PScreen): cint = 
-    DoesBackingStore = s^ .backing_store
+    DoesBackingStore = s[] .backing_store

  proc EventMaskOfScreen(s: PScreen): clong = 
-    EventMaskOfScreen = s^ .root_input_mask
+    EventMaskOfScreen = s[] .root_input_mask

  proc XAllocID(dpy: PDisplay): TXID = 
-    XAllocID = (PXPrivDisplay(dpy))^ .resource_alloc(dpy)
+    XAllocID = (PXPrivDisplay(dpy))[] .resource_alloc(dpy)
--- a/lib/wrappers/x11/xutil.nim
+++ b/lib/wrappers/x11/xutil.nim
@@ -375,19 +375,19 @@ when defined(MACROS):

 when defined(MACROS): 
  proc XDestroyImage(ximage: PXImage): cint = 
-    XDestroyImage = ximage^ .f.destroy_image(ximage)
+    XDestroyImage = ximage[] .f.destroy_image(ximage)

  proc XGetPixel(ximage: PXImage, x, y: cint): culong = 
-    XGetPixel = ximage^ .f.get_pixel(ximage, x, y)
+    XGetPixel = ximage[] .f.get_pixel(ximage, x, y)

  proc XPutPixel(ximage: PXImage, x, y: cint, pixel: culong): cint = 
-    XPutPixel = ximage^ .f.put_pixel(ximage, x, y, pixel)
+    XPutPixel = ximage[] .f.put_pixel(ximage, x, y, pixel)

  proc XSubImage(ximage: PXImage, x, y: cint, width, height: cuint): PXImage = 
-    XSubImage = ximage^ .f.sub_image(ximage, x, y, width, height)
+    XSubImage = ximage[] .f.sub_image(ximage, x, y, width, height)

  proc XAddPixel(ximage: PXImage, value: clong): cint = 
-    XAddPixel = ximage^ .f.add_pixel(ximage, value)
+    XAddPixel = ximage[] .f.add_pixel(ximage, value)

  proc IsKeypadKey(keysym: TKeySym): bool = 
    IsKeypadKey = (keysym >= XK_KP_Space) and (keysym <= XK_KP_Equal)
--- a/rod/c2nim/cparse.nim
+++ b/rod/c2nim/cparse.nim
@@ -107,13 +107,13 @@ proc rawGetTok(p: var TParser) =
    p.tok = p.tok.next
  elif p.backtrack.len == 0: 
    p.tok.next = nil
-    getTok(p.lex, p.tok^)
+    getTok(p.lex, p.tok[])
  else: 
    # We need the next token and must be able to backtrack. So we need to 
    # allocate a new token.
    var t: ref TToken
    new(t)
-    getTok(p.lex, t^)
+    getTok(p.lex, t[])
    p.tok.next = t
    p.tok = t

@@ -217,7 +217,7 @@ proc getTok(p: var TParser, n: PNode) =
  skipCom(p, n)

 proc ExpectIdent(p: TParser) = 
-  if p.tok.xkind != pxSymbol: parMessage(p, errIdentifierExpected, $(p.tok^))
+  if p.tok.xkind != pxSymbol: parMessage(p, errIdentifierExpected, $(p.tok[]))
  
 proc Eat(p: var TParser, xkind: TTokKind, n: PNode) = 
  if p.tok.xkind == xkind: getTok(p, n)
--- a/rod/evals.nim
+++ b/rod/evals.nim
@@ -99,7 +99,7 @@ proc isSpecial(n: PNode): bool {.inline.} =
  # few programs

 proc myreset(n: PNode) {.inline.} =
-  when defined(system.reset): reset(n^)
+  when defined(system.reset): reset(n[])

 proc evalIf(c: PEvalContext, n: PNode): PNode = 
  var i = 0
--- a/rod/main.nim
+++ b/rod/main.nim
@@ -169,7 +169,7 @@ proc CommandScan(filename: string) =
    new(tok)
    openLexer(L, f, stream)
    while true: 
-      rawGetTok(L, tok^)
+      rawGetTok(L, tok[])
      PrintTok(tok)
      if tok.tokType == tkEof: break 
    CloseLexer(L)
--- a/rod/nimconf.nim
+++ b/rod/nimconf.nim
@@ -21,10 +21,10 @@ proc LoadSpecialConfig*(configfilename: string)

 proc ppGetTok(L: var TLexer, tok: PToken) = 
  # simple filter
-  rawGetTok(L, tok^ )
+  rawGetTok(L, tok[] )
  while (tok.tokType == tkInd) or (tok.tokType == tkSad) or
      (tok.tokType == tkDed) or (tok.tokType == tkComment): 
-    rawGetTok(L, tok^ )
+    rawGetTok(L, tok[] )
  
 proc parseExpr(L: var TLexer, tok: PToken): bool
 proc parseAtom(L: var TLexer, tok: PToken): bool = 
--- a/rod/pbraces.nim
+++ b/rod/pbraces.nim
@@ -843,7 +843,7 @@ proc parseSection(p: var TParser, kind: TNodeKind, defparser: TDefParser): PNode
  skipComment(p, result)
  case p.tok.tokType
  of tkInd: 
-    pushInd(p.lex^ , p.tok.indent)
+    pushInd(p.lex[] , p.tok.indent)
    getTok(p)
    skipComment(p, result)
    while true: 
@@ -866,7 +866,7 @@ proc parseSection(p: var TParser, kind: TNodeKind, defparser: TDefParser): PNode
      else: 
        parMessage(p, errIdentifierExpected, tokToStr(p.tok))
        break 
-    popInd(p.lex^ )
+    popInd(p.lex[] )
  of tkSymbol, tkAccent, tkParLe: 
    # tkParLe is allowed for ``var (x, y) = ...`` tuple parsing
    addSon(result, defparser(p))
@@ -985,7 +985,7 @@ proc parseObjectPart(p: var TParser): PNode =
  case p.tok.tokType
  of tkInd: 
    result = newNodeP(nkRecList, p)
-    pushInd(p.lex^ , p.tok.indent)
+    pushInd(p.lex[] , p.tok.indent)
    getTok(p)
    skipComment(p, result)
    while true: 
@@ -1002,7 +1002,7 @@ proc parseObjectPart(p: var TParser): PNode =
      else: 
        parMessage(p, errIdentifierExpected, tokToStr(p.tok))
        break 
-    popInd(p.lex^ )
+    popInd(p.lex[] )
  of tkWhen: 
    result = parseObjectWhen(p)
  of tkCase: 
--- a/rod/pnimsyn.nim
+++ b/rod/pnimsyn.nim
@@ -61,18 +61,18 @@ proc initParser(p: var TParser) =
  new(p.tok)

 proc getTok(p: var TParser) = 
-  rawGetTok(p.lex^, p.tok^)
+  rawGetTok(p.lex[], p.tok[])

 proc OpenParser(p: var TParser, filename: string, inputStream: PLLStream) = 
  initParser(p)
-  OpenLexer(p.lex^, filename, inputstream)
+  OpenLexer(p.lex[], filename, inputstream)
  getTok(p)                   # read the first token
  
 proc CloseParser(p: var TParser) = 
-  CloseLexer(p.lex^)
+  CloseLexer(p.lex[])

 proc parMessage(p: TParser, msg: TMsgKind, arg: string = "") = 
-  lexMessage(p.lex^, msg, arg)
+  lexMessage(p.lex[], msg, arg)

 proc skipComment(p: var TParser, node: PNode) = 
  if p.tok.tokType == tkComment: 
@@ -95,22 +95,22 @@ proc optInd(p: var TParser, n: PNode) =

 proc expectIdentOrKeyw(p: TParser) = 
  if p.tok.tokType != tkSymbol and not isKeyword(p.tok.tokType): 
-    lexMessage(p.lex^, errIdentifierExpected, tokToStr(p.tok))
+    lexMessage(p.lex[], errIdentifierExpected, tokToStr(p.tok))
  
 proc ExpectIdent(p: TParser) = 
  if p.tok.tokType != tkSymbol: 
-    lexMessage(p.lex^, errIdentifierExpected, tokToStr(p.tok))
+    lexMessage(p.lex[], errIdentifierExpected, tokToStr(p.tok))
  
 proc expectIdentOrOpr(p: TParser) = 
  if not (p.tok.tokType in tokOperators): 
-    lexMessage(p.lex^, errOperatorExpected, tokToStr(p.tok))
+    lexMessage(p.lex[], errOperatorExpected, tokToStr(p.tok))
  
 proc Eat(p: var TParser, TokType: TTokType) = 
  if p.tok.TokType == TokType: getTok(p)
-  else: lexMessage(p.lex^, errTokenExpected, TokTypeToStr[tokType])
+  else: lexMessage(p.lex[], errTokenExpected, TokTypeToStr[tokType])
  
 proc parLineInfo(p: TParser): TLineInfo = 
-  result = getLineInfo(p.lex^)
+  result = getLineInfo(p.lex[])

 proc indAndComment(p: var TParser, n: PNode) = 
  if p.tok.tokType == tkInd: 
@@ -122,7 +122,7 @@ proc indAndComment(p: var TParser, n: PNode) =
    skipComment(p, n)
  
 proc newNodeP(kind: TNodeKind, p: TParser): PNode = 
-  result = newNodeI(kind, getLineInfo(p.lex^))
+  result = newNodeI(kind, getLineInfo(p.lex[]))

 proc newIntNodeP(kind: TNodeKind, intVal: BiggestInt, p: TParser): PNode = 
  result = newNodeP(kind, p)
@@ -1124,7 +1124,7 @@ proc parseSection(p: var TParser, kind: TNodeKind,
  skipComment(p, result)
  case p.tok.tokType
  of tkInd: 
-    pushInd(p.lex^, p.tok.indent)
+    pushInd(p.lex[], p.tok.indent)
    getTok(p)
    skipComment(p, result)
    while true: 
@@ -1147,7 +1147,7 @@ proc parseSection(p: var TParser, kind: TNodeKind,
      else: 
        parMessage(p, errIdentifierExpected, tokToStr(p.tok))
        break 
-    popInd(p.lex^)
+    popInd(p.lex[])
  of tkSymbol, tkAccent, tkParLe: 
    # tkParLe is allowed for ``var (x, y) = ...`` tuple parsing
    addSon(result, defparser(p))
@@ -1252,7 +1252,7 @@ proc parseObjectPart(p: var TParser): PNode =
  case p.tok.tokType
  of tkInd: 
    result = newNodeP(nkRecList, p)
-    pushInd(p.lex^, p.tok.indent)
+    pushInd(p.lex[], p.tok.indent)
    getTok(p)
    skipComment(p, result)
    while true: 
@@ -1269,7 +1269,7 @@ proc parseObjectPart(p: var TParser): PNode =
      else: 
        parMessage(p, errIdentifierExpected, tokToStr(p.tok))
        break 
-    popInd(p.lex^)
+    popInd(p.lex[])
  of tkWhen: 
    result = parseObjectWhen(p)
  of tkCase: 
@@ -1386,7 +1386,7 @@ proc complexOrSimpleStmt(p: var TParser): PNode =
 proc parseStmt(p: var TParser): PNode = 
  if p.tok.tokType == tkInd: 
    result = newNodeP(nkStmtList, p)
-    pushInd(p.lex^, p.tok.indent)
+    pushInd(p.lex[], p.tok.indent)
    getTok(p)
    while true: 
      case p.tok.tokType
@@ -1399,7 +1399,7 @@ proc parseStmt(p: var TParser): PNode =
        var a = complexOrSimpleStmt(p)
        if a.kind == nkEmpty: break 
        addSon(result, a)
-    popInd(p.lex^ )
+    popInd(p.lex[] )
  else: 
    # the case statement is only needed for better error messages:
    case p.tok.tokType
--- a/rod/rnimsyn.nim
+++ b/rod/rnimsyn.nim
@@ -289,18 +289,18 @@ proc atom(n: PNode): string =
  of nkInt64Lit: result = litAux(n, n.intVal, 8) & "\'i64"
  of nkFloatLit: 
    if n.flags * {nfBase2, nfBase8, nfBase16} == {}: result = $(n.floatVal)
-    else: result = litAux(n, (cast[PInt64](addr(n.floatVal)))^ , 8)
+    else: result = litAux(n, (cast[PInt64](addr(n.floatVal)))[] , 8)
  of nkFloat32Lit: 
    if n.flags * {nfBase2, nfBase8, nfBase16} == {}: 
      result = $(n.floatVal) & "\'f32"
    else: 
      f = n.floatVal
-      result = litAux(n, (cast[PInt32](addr(f)))^ , 4) & "\'f32"
+      result = litAux(n, (cast[PInt32](addr(f)))[] , 4) & "\'f32"
  of nkFloat64Lit: 
    if n.flags * {nfBase2, nfBase8, nfBase16} == {}: 
      result = $(n.floatVal) & "\'f64"
    else: 
-      result = litAux(n, (cast[PInt64](addr(n.floatVal)))^ , 8) & "\'f64"
+      result = litAux(n, (cast[PInt64](addr(n.floatVal)))[] , 8) & "\'f64"
  of nkNilLit: result = "nil"
  of nkType: 
    if (n.typ != nil) and (n.typ.sym != nil): result = n.typ.sym.name.s
--- a/rod/scanner.nim
+++ b/rod/scanner.nim
@@ -382,10 +382,10 @@ proc GetNumber(L: var TLexer): TToken =
      of tkInt16Lit: result.iNumber = biggestInt(toU16(int(xi)))
      of tkInt32Lit: result.iNumber = biggestInt(toU32(xi))
      of tkFloat32Lit: 
-        result.fNumber = (cast[PFloat32](addr(xi)))^ 
+        result.fNumber = (cast[PFloat32](addr(xi)))[] 
        # note: this code is endian neutral!
        # XXX: Test this on big endian machine!
-      of tkFloat64Lit: result.fNumber = (cast[PFloat64](addr(xi)))^ 
+      of tkFloat64Lit: result.fNumber = (cast[PFloat64](addr(xi)))[] 
      else: InternalError(getLineInfo(L), "getNumber")
    elif isFloatLiteral(result.literal) or (result.tokType == tkFloat32Lit) or
        (result.tokType == tkFloat64Lit): 
--- a/rod/semtypes.nim
+++ b/rod/semtypes.nim
@@ -183,7 +183,7 @@ proc semTypeIdent(c: PContext, n: PNode): PSym =
      if result.kind != skType: GlobalError(n.info, errTypeExpected)
      if result.typ.kind != tyGenericParam:
        # XXX get rid of this hack!
-        reset(n^)
+        reset(n[])
        n.kind = nkSym
        n.sym = result
    else:
--- a/tests/accept/compile/trepr.nim
+++ b/tests/accept/compile/trepr.nim
@@ -22,7 +22,7 @@ p.s[1] = "xyz"
 p.e = en6

 new(q)
-q^ = p
+q[] = p

 s = @[q, q, q, q]

--- a/tests/accept/compile/tstrace.nim
+++ b/tests/accept/compile/tstrace.nim
@@ -8,7 +8,7 @@ proc recTest(i: int) =
    recTest(i+1)
  else: # should printStackTrace()
    var p: ptr int = nil
-    p^ = 12
+    p[] = 12
  # leave

 {.pop.}
--- a/tests/accept/run/tnewderef.nim
+++ b/tests/accept/run/tnewderef.nim
@@ -0,0 +1,11 @@
+discard """
+  output: 3
+
+"""
+
+var x: ref int
+new(x)
+x[] = 3
+
+echo x[] 
+
--- a/tests/accept/run/tpegs.nim
+++ b/tests/accept/run/tpegs.nim
@@ -115,7 +115,7 @@ proc charSet*(s: set[char]): TPeg {.rtl, extern: "npegs$1".} =
  assert '\0' notin s
  result.kind = pkCharChoice
  new(result.charChoice)
-  result.charChoice^ = s
+  result.charChoice[] = s

 proc len(a: TPeg): int {.inline.} = return a.sons.len
 proc add(d: var TPeg, s: TPeg) {.inline.} = add(d.sons, s)
@@ -130,7 +130,7 @@ proc copyPeg(a: TPeg): TPeg =
    result.ch = a.ch
  of pkCharChoice, pkGreedyRepSet: 
    new(result.charChoice)
-    result.charChoice^ = a.charChoice^
+    result.charChoice[] = a.charChoice[]
  of pkNonTerminal: result.nt = a.nt
  of pkBackRef..pkBackRefIgnoreStyle: 
    result.index = a.index
@@ -143,9 +143,9 @@ proc addChoice(dest: var TPeg, elem: TPeg) =
    # caution! Do not introduce false aliasing here!
    case elem.kind
    of pkCharChoice:
-      dest.sons[L] = charSet(dest.sons[L].charChoice^ + elem.charChoice^)
+      dest.sons[L] = charSet(dest.sons[L].charChoice[] + elem.charChoice[])
    of pkChar: 
-      dest.sons[L] = charSet(dest.sons[L].charChoice^ + {elem.ch})
+      dest.sons[L] = charSet(dest.sons[L].charChoice[] + {elem.ch})
    else: add(dest, elem)
  else: add(dest, elem)

@@ -447,7 +447,7 @@ proc toStrAux(r: TPeg, res: var string) =
    add(res, 'y')
    add(res, singleQuoteEsc(r.term))
  of pkChar: add(res, singleQuoteEsc(r.ch))
-  of pkCharChoice: add(res, charSetEsc(r.charChoice^))
+  of pkCharChoice: add(res, charSetEsc(r.charChoice[]))
  of pkNonTerminal: add(res, r.nt.name)
  of pkSequence:
    add(res, '(')
@@ -470,7 +470,7 @@ proc toStrAux(r: TPeg, res: var string) =
    add(res, singleQuoteEsc(r.ch))
    add(res, '*')
  of pkGreedyRepSet:
-    add(res, charSetEsc(r.charChoice^))
+    add(res, charSetEsc(r.charChoice[]))
    add(res, '*')
  of pkGreedyAny:
    add(res, ".*")
@@ -652,7 +652,7 @@ proc rawMatch*(s: string, p: TPeg, start: int, c: var TCaptures): int {.
    if p.ch == s[start]: result = 1
    else: result = -1
  of pkCharChoice:
-    if contains(p.charChoice^, s[start]): result = 1
+    if contains(p.charChoice[], s[start]): result = 1
    else: result = -1
  of pkNonTerminal:
    var oldMl = c.ml
@@ -719,7 +719,7 @@ proc rawMatch*(s: string, p: TPeg, start: int, c: var TCaptures): int {.
    while ch == s[start+result]: inc(result)
  of pkGreedyRepSet:
    result = 0
-    while contains(p.charChoice^, s[start+result]): inc(result)
+    while contains(p.charChoice[], s[start+result]): inc(result)
  of pkOption:
    result = max(0, rawMatch(s, p.sons[0], start, c))
  of pkAndPredicate:
--- a/todo.txt
+++ b/todo.txt
@@ -1,8 +1,4 @@
 - clean up the tests!
- GC: marker procs for native Nimrod GC and Boehm GC
- thread support: threadvar on Windows seems broken; 
-  add --deadlock_prevention:on|off switch
- built-in serialization


 High priority (version 0.9.0)
@@ -12,7 +8,7 @@ High priority (version 0.9.0)
 - fix the streams implementation so that it uses methods
 - fix overloading resolution
 - wrong co-/contravariance
- deprecate ^ and make it available as operator; new other notation: p[]
+- make ^ available as operator


 Bugs
@@ -35,7 +31,10 @@ To implement
 * constant sequences

 * implement closures for the C code generator
-
+* GC: marker procs for native Nimrod GC and Boehm GC
+* thread support: threadvar on Windows seems broken; 
+  add --deadlock_prevention:on|off switch
+* built-in serialization


 Low priority