cbuilder: use constants for type names, some cleanups (#24438)

As described in #24432
2025-12-28 08:54:53 +00:00 · 2024-11-18 19:34:37 +03:00
parent f053767132
commit 712f5be7eb
13 changed files with 383 additions and 348 deletions
--- a/compiler/cbuilderbase.nim
+++ b/compiler/cbuilderbase.nim
@@ -120,6 +120,43 @@ proc cIntLiteral*(i: BiggestInt): Snippet =
 proc cIntLiteral*(i: Int128): Snippet =
  result = cIntLiteral(toInt64(i))

+const
+  NimInt* = "NI"
+  NimInt8* = "NI8"
+  NimInt16* = "NI16"
+  NimInt32* = "NI32"
+  NimInt64* = "NI64"
+  CInt* = "int"
+  NimUint* = "NU"
+  NimUint8* = "NU8"
+  NimUint16* = "NU16"
+  NimUint32* = "NU32"
+  NimUint64* = "NU64"
+  NimFloat* = "NF"
+  NimFloat32* = "NF32"
+  NimFloat64* = "NF64"
+  NimFloat128* = "NF128" # not actually defined
+  NimNan* = "NAN"
+  NimInf* = "INF"
+  NimBool* = "NIM_BOOL"
+  NimTrue* = "NIM_TRUE"
+  NimFalse* = "NIM_FALSE"
+  NimChar* = "NIM_CHAR"
+  CChar* = "char"
+  NimCstring* = "NCSTRING"
+  NimNil* = "NIM_NIL"
+  CNil* = "NULL"
+  NimStrlitFlag* = "NIM_STRLIT_FLAG"
+  CVoid* = "void"
+  CPointer* = "void*"
+  CConstPointer* = "NIM_CONST void*"
+
+proc cIntType*(bits: int): Snippet =
+  "NI" & $bits
+
+proc cUintType*(bits: int): Snippet =
+  "NU" & $bits
+
 type
  IfBuilderState* = enum
    WaitingIf, WaitingElseIf, InBlock
--- a/compiler/cbuilderdecls.nim
+++ b/compiler/cbuilderdecls.nim
@@ -271,7 +271,7 @@ proc startSimpleStruct(obj: var Builder; m: BModule; name: string; baseType: Sni
 proc finishSimpleStruct(obj: var Builder; m: BModule; info: StructBuilderInfo) =
  if info.baseKind == bcNone and info.preFieldsLen == obj.buf.len:
    # no fields were added, add dummy field
-    obj.addField(name = "dummy", typ = "char")
+    obj.addField(name = "dummy", typ = CChar)
  if info.named:
    obj.add("};\n")
  else:
@@ -330,7 +330,7 @@ proc startStruct(obj: var Builder; m: BModule; t: PType; name: string; baseType:
        t.n != nil and t.n.len == 1 and t.n[0].kind == nkSym and
        t.n[0].sym.typ.skipTypes(abstractInst).kind == tyUncheckedArray:
      # only consists of flexible array field, add *initial* dummy field
-      obj.addField(name = "dummy", typ = "char")
+      obj.addField(name = "dummy", typ = CChar)
  of bcCppInherit: discard
  of bcNoneRtti:
    obj.addField(name = "m_type", typ = ptrType(cgsymValue(m, "TNimType")))
@@ -343,7 +343,7 @@ proc finishStruct(obj: var Builder; m: BModule; t: PType; info: StructBuilderInf
  if info.baseKind == bcNone and info.preFieldsLen == obj.buf.len and
      t.itemId notin m.g.graph.memberProcsPerType:
    # no fields were added, add dummy field
-    obj.addField(name = "dummy", typ = "char")
+    obj.addField(name = "dummy", typ = CChar)
  if info.named:
    obj.add("};\n")
  else:
--- a/compiler/cbuilderexprs.nim
+++ b/compiler/cbuilderexprs.nim
@@ -1,6 +1,3 @@
-# XXX make complex ones like bitOr use builder instead
-# XXX add stuff like NI, NIM_NIL as constants
-
 proc constType(t: Snippet): Snippet =
  # needs manipulation of `t` in nifc
  "NIM_CONST " & t
@@ -87,9 +84,6 @@ proc dotField(a, b: Snippet): Snippet =
 proc derefField(a, b: Snippet): Snippet =
  a & "->" & b

-proc bitOr(a, b: Snippet): Snippet =
-  "(" & a & " | " & b & ")"
-
 type CallBuilder = object
  needsComma: bool

--- a/compiler/cbuilderstmts.nim
+++ b/compiler/cbuilderstmts.nim
@@ -322,3 +322,8 @@ template addCPragma(builder: var Builder, val: Snippet) =
  builder.add("#pragma ")
  builder.add(val)
  builder.addNewline()
+
+proc addDiscard(builder: var Builder, val: Snippet) =
+  builder.add("(void)")
+  builder.add(val)
+  builder.addLineEnd(";")
--- a/compiler/ccgcalls.nim
+++ b/compiler/ccgcalls.nim
@@ -213,20 +213,20 @@ proc genOpenArraySlice(p: BProc; q: PNode; formalType, destType: PType; prepareF
  let ra = rdLoc(a)
  let rb = rdLoc(b)
  let rc = rdLoc(c)
-  let lengthExpr = cOp(Add, "NI", cOp(Sub, "NI", rc, rb), cIntValue(1))
+  let lengthExpr = cOp(Add, NimInt, cOp(Sub, NimInt, rc, rb), cIntValue(1))
  case ty.kind
  of tyArray:
    let first = toInt64(firstOrd(p.config, ty))
    if first == 0:
-      result = (cCast(ptrType(dest), cOp(Add, "NI", ra, rb)), lengthExpr)
+      result = (cCast(ptrType(dest), cOp(Add, NimInt, ra, rb)), lengthExpr)
    else:
      let lit = cIntLiteral(first)
-      result = (cCast(ptrType(dest), cOp(Add, "NI", ra, cOp(Sub, "NI", rb, lit))), lengthExpr)
+      result = (cCast(ptrType(dest), cOp(Add, NimInt, ra, cOp(Sub, NimInt, rb, lit))), lengthExpr)
  of tyOpenArray, tyVarargs:
    let data = if reifiedOpenArray(q[1]): dotField(ra, "Field0") else: ra
-    result = (cCast(ptrType(dest), cOp(Add, "NI", data, rb)), lengthExpr)
+    result = (cCast(ptrType(dest), cOp(Add, NimInt, data, rb)), lengthExpr)
  of tyUncheckedArray, tyCstring:
-    result = (cCast(ptrType(dest), cOp(Add, "NI", ra, rb)), lengthExpr)
+    result = (cCast(ptrType(dest), cOp(Add, NimInt, ra, rb)), lengthExpr)
  of tyString, tySequence:
    let atyp = skipTypes(a.t, abstractInst)
    if formalType.skipTypes(abstractInst).kind in {tyVar} and atyp.kind == tyString and
@@ -241,8 +241,8 @@ proc genOpenArraySlice(p: BProc; q: PNode; formalType, destType: PType; prepareF
      val = ra
    result = (
      cIfExpr(dataFieldAccessor(p, val),
-        cCast(ptrType(dest), cOp(Add, "NI", dataField(p, val), rb)),
-        "NIM_NIL"),
+        cCast(ptrType(dest), cOp(Add, NimInt, dataField(p, val), rb)),
+        NimNil),
      lengthExpr)
  else:
    result = ("", "")
@@ -295,13 +295,13 @@ proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Builder) =
        let ra = a.rdLoc
        var t = TLoc(snippet: cDeref(ra))
        let lt = lenExpr(p, t)
-        result.add(cIfExpr(dataFieldAccessor(p, t.snippet), dataField(p, t.snippet), "NIM_NIL"))
+        result.add(cIfExpr(dataFieldAccessor(p, t.snippet), dataField(p, t.snippet), NimNil))
        result.addArgumentSeparator()
        result.add(lt)
      else:
        let ra = a.rdLoc
        let la = lenExpr(p, a)
-        result.add(cIfExpr(dataFieldAccessor(p, ra), dataField(p, ra), "NIM_NIL"))
+        result.add(cIfExpr(dataFieldAccessor(p, ra), dataField(p, ra), NimNil))
        result.addArgumentSeparator()
        result.add(la)
    of tyArray:
@@ -315,7 +315,7 @@ proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Builder) =
        let ra = a.rdLoc
        var t = TLoc(snippet: cDeref(ra))
        let lt = lenExpr(p, t)
-        result.add(cIfExpr(dataFieldAccessor(p, t.snippet), dataField(p, t.snippet), "NIM_NIL"))
+        result.add(cIfExpr(dataFieldAccessor(p, t.snippet), dataField(p, t.snippet), NimNil))
        result.addArgumentSeparator()
        result.add(lt)
      of tyArray:
@@ -767,7 +767,7 @@ proc genPatternCall(p: BProc; ri: PNode; pat: string; typ: PType; result: var Bu
      var idx, stars: int = 0
      if scanCppGenericSlot(pat, i, idx, stars):
        var t = resolveStarsInCppType(typ, idx, stars)
-        if t == nil: result.add("void")
+        if t == nil: result.add(CVoid)
        else: result.add(getTypeDesc(p.module, t))
    else:
      let start = i
--- a/compiler/ccgexprs.nim
+++ b/compiler/ccgexprs.nim
@@ -36,8 +36,8 @@ proc genLiteral(p: BProc, n: PNode, ty: PType; result: var Builder) =
    of tyChar, tyNil:
      result.addIntLiteral(n.intVal)
    of tyBool:
-      if n.intVal != 0: result.add "NIM_TRUE"
-      else: result.add "NIM_FALSE"
+      if n.intVal != 0: result.add NimTrue
+      else: result.add NimFalse
    of tyInt64: result.addInt64Literal(n.intVal)
    of tyUInt64: result.addUint64Literal(uint64(n.intVal))
    else:
@@ -56,14 +56,14 @@ proc genLiteral(p: BProc, n: PNode, ty: PType; result: var Builder) =
          var closureInit: StructInitializer
          p.module.s[cfsStrData].addStructInitializer(closureInit, kind = siOrderedStruct):
            p.module.s[cfsStrData].addField(closureInit, name = "ClP_0"):
-              p.module.s[cfsStrData].add("NIM_NIL")
+              p.module.s[cfsStrData].add(NimNil)
            p.module.s[cfsStrData].addField(closureInit, name = "ClE_0"):
-              p.module.s[cfsStrData].add("NIM_NIL")
+              p.module.s[cfsStrData].add(NimNil)
      result.add tmpName
    elif k in {tyPointer, tyNil, tyProc}:
-      result.add rope("NIM_NIL")
+      result.add NimNil
    else:
-      result.add cCast(getTypeDesc(p.module, ty), "NIM_NIL")
+      result.add cCast(getTypeDesc(p.module, ty), NimNil)
  of nkStrLit..nkTripleStrLit:
    let k = if ty == nil: tyString
            else: skipTypes(ty, abstractVarRange + {tyStatic, tyUserTypeClass, tyUserTypeClassInst}).kind
@@ -181,7 +181,7 @@ proc genRefAssign(p: BProc, dest, src: TLoc) =
      else: cgsymValue(p.module, "unsureAsgnRef")
    let rad = addrLoc(p.config, dest)
    let rs = rdLoc(src)
-    p.s(cpsStmts).addCallStmt(fnName, cCast("void**", rad), rs)
+    p.s(cpsStmts).addCallStmt(fnName, cCast(ptrType(CPointer), rad), rs)

 proc asgnComplexity(n: PNode): int =
  if n != nil:
@@ -256,22 +256,22 @@ proc genGenericAsgn(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) =
      let ras = addrLoc(p.config, src)
      let rd = rdLoc(dest)
      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimCopyMem"),
-        cCast("void*", rad),
-        cCast(ptrConstType("void"), ras),
+        cCast(CPointer, rad),
+        cCast(CConstPointer, ras),
        cSizeof(rd))
    else:
      let rad = addrLoc(p.config, dest)
      let ras = addrLoc(p.config, src)
      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "genericShallowAssign"),
-        cCast("void*", rad),
-        cCast("void*", ras),
+        cCast(CPointer, rad),
+        cCast(CPointer, ras),
        genTypeInfoV1(p.module, dest.t, dest.lode.info))
  else:
    let rad = addrLoc(p.config, dest)
    let ras = addrLoc(p.config, src)
    p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "genericAssign"),
-      cCast("void*", rad),
-      cCast("void*", ras),
+      cCast(CPointer, rad),
+      cCast(CPointer, ras),
      genTypeInfoV1(p.module, dest.t, dest.lode.info))

 proc genOpenArrayConv(p: BProc; d: TLoc; a: TLoc; flags: TAssignmentFlags) =
@@ -304,7 +304,7 @@ proc genOpenArrayConv(p: BProc; d: TLoc; a: TLoc; flags: TAssignmentFlags) =
    let ra = a.rdLoc
    let la = lenExpr(p, a)
    p.s(cpsStmts).addFieldAssignment(rd, "Field0",
-      cIfExpr(dataFieldAccessor(p, ra), dataField(p, ra), "NIM_NIL"))
+      cIfExpr(dataFieldAccessor(p, ra), dataField(p, ra), NimNil))
    p.s(cpsStmts).addFieldAssignment(rd, "Field1", la)
  of tyArray:
    let rd = d.rdLoc
@@ -322,7 +322,7 @@ proc genOpenArrayConv(p: BProc; d: TLoc; a: TLoc; flags: TAssignmentFlags) =
    let rd = d.rdLoc
    let ra = a.rdLoc
    p.s(cpsStmts).addFieldAssignment(rd, "Field0",
-      cIfExpr(dataFieldAccessor(p, ra), dataField(p, ra), "NIM_NIL"))
+      cIfExpr(dataFieldAccessor(p, ra), dataField(p, ra), NimNil))
    let la = lenExpr(p, a)
    p.s(cpsStmts).addFieldAssignment(rd, "Field1", la)
  else:
@@ -380,7 +380,7 @@ proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) =
        let rad = addrLoc(p.config, dest)
        let rs = rdLoc(src)
        p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "unsureAsgnRef"),
-          cCast("void**", rad),
+          cCast(ptrType(CPointer), rad),
          cgCall(p, "copyString", rs))
  of tyProc:
    if containsGarbageCollectedRef(dest.t):
@@ -422,8 +422,8 @@ proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) =
      let rd = rdLoc(dest)
      let rs = rdLoc(src)
      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimCopyMem"),
-        cCast("void*", rd),
-        cCast(ptrConstType("void"), rs),
+        cCast(CPointer, rd),
+        cCast(CConstPointer, rs),
        cSizeof(getTypeDesc(p.module, dest.t)))
  of tyOpenArray, tyVarargs:
    # open arrays are always on the stack - really? What if a sequence is
@@ -435,8 +435,8 @@ proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) =
      let ras = addrLoc(p.config, src)
      # XXX: is this correct for arrays?
      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "genericAssignOpenArray"),
-        cCast("void*", rad),
-        cCast("void*", ras),
+        cCast(CPointer, rad),
+        cCast(CPointer, ras),
        rad & "Len_0",
        genTypeInfoV1(p.module, dest.t, dest.lode.info))
    else:
@@ -449,8 +449,8 @@ proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) =
      let rd = rdLoc(dest)
      let rs = rdLoc(src)
      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimCopyMem"),
-        cCast("void*", rd),
-        cCast(ptrConstType("void"), rs),
+        cCast(CPointer, rd),
+        cCast(CConstPointer, rs),
        cIntValue(getSize(p.config, dest.t)))
    else:
      simpleAsgn(p.s(cpsStmts), dest, src)
@@ -464,7 +464,7 @@ proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) =
    #echo p.currLineInfo, " requesting"
    let rad = addrLoc(p.config, dest)
    p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "memTrackerWrite"),
-      cCast("void*", rad),
+      cCast(CPointer, rad),
      cIntValue(getSize(p.config, dest.t)),
      makeCString(toFullPath(p.config, p.currLineInfo)),
      cIntValue(p.currLineInfo.safeLineNm))
@@ -485,16 +485,16 @@ proc genDeepCopy(p: BProc; dest, src: TLoc) =
    let rad = addrLoc(p.config, dest)
    let rats = addrLocOrTemp(src)
    p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "genericDeepCopy"),
-      cCast("void*", rad),
-      cCast("void*", rats),
+      cCast(CPointer, rad),
+      cCast(CPointer, rats),
      genTypeInfoV1(p.module, dest.t, dest.lode.info))
  of tySequence, tyString:
    if optTinyRtti in p.config.globalOptions:
      let rad = addrLoc(p.config, dest)
      let rats = addrLocOrTemp(src)
      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "genericDeepCopy"),
-        cCast("void*", rad),
-        cCast("void*", rats),
+        cCast(CPointer, rad),
+        cCast(CPointer, rats),
        genTypeInfoV1(p.module, dest.t, dest.lode.info))
    else:
      let rad = addrLoc(p.config, dest)
@@ -507,8 +507,8 @@ proc genDeepCopy(p: BProc; dest, src: TLoc) =
    let source = addrLocOrTemp(src)
    let rad = addrLoc(p.config, dest)
    p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "genericDeepCopyOpenArray"),
-      cCast("void*", rad),
-      cCast("void*", source),
+      cCast(CPointer, rad),
+      cCast(CPointer, source),
      derefField(source, "Field1"),
      genTypeInfoV1(p.module, dest.t, dest.lode.info))
  of tySet:
@@ -516,8 +516,8 @@ proc genDeepCopy(p: BProc; dest, src: TLoc) =
      let rd = rdLoc(dest)
      let rs = rdLoc(src)
      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimCopyMem"),
-        cCast("void*", rd),
-        cCast(ptrConstType("void"), rs),
+        cCast(CPointer, rd),
+        cCast(CConstPointer, rs),
        cIntValue(getSize(p.config, dest.t)))
    else:
      simpleAsgn(p.s(cpsStmts), dest, src)
@@ -612,7 +612,7 @@ template unaryExprChar(p: BProc, e: PNode, d: var TLoc, frmt: untyped) =
 template binaryArithOverflowRaw(p: BProc, t: PType, a, b: TLoc;
                            cpname: string): Rope =
  var size = getSize(p.config, t)
-  let storage = if size < p.config.target.intSize: rope("NI")
+  let storage = if size < p.config.target.intSize: NimInt
                else: getTypeDesc(p.module, t)
  var result = getTempName(p.module)
  p.s(cpsLocals).addVar(kind = Local, name = result, typ = storage)
@@ -703,7 +703,7 @@ proc unaryArithOverflow(p: BProc, e: PNode, d: var TLoc, m: TMagic) =

  case m
  of mUnaryMinusI:
-    let typ = "NI" & rope(getSize(p.config, t) * 8)
+    let typ = cIntType(getSize(p.config, t) * 8)
    putIntoDest(p, d, e, cCast(typ, cOp(Neg, typ, ra)))
  of mUnaryMinusI64:
    putIntoDest(p, d, e, cOp(Neg, getTypeDesc(p.module, t), ra))
@@ -747,17 +747,17 @@ proc binaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
    res = cOp(Div, t, cCast(t, ra), cCast(t, rb))
  of mShrI:
    let t = getType()
-    let at = "NU" & $k
-    let bt = "NU" & $s
+    let at = cUintType(k)
+    let bt = cUintType(s)
    res = cCast(t, cOp(Shr, at, cCast(at, ra), cCast(bt, rb)))
  of mShlI:
    let t = getType()
-    let at = "NU" & $s
+    let at = cUintType(s)
    res = cCast(t, cOp(Shl, at, cCast(at, ra), cCast(at, rb)))
  of mAshrI:
    let t = getType()
-    let at = "NI" & $s
-    let bt = "NU" & $s
+    let at = cIntType(s)
+    let bt = cUintType(s)
    res = cCast(t, cOp(Shr, at, cCast(at, ra), cCast(bt, rb)))
  of mBitandI:
    let t = getType()
@@ -774,23 +774,23 @@ proc binaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
    res = cIfExpr(cOp(GreaterEqual, ra, rb), ra, rb)
  of mAddU:
    let t = getType()
-    let ot = "NU" & $s
+    let ot = cUintType(s)
    res = cCast(t, cOp(Add, ot, cCast(ot, ra), cCast(ot, rb)))
  of mSubU:
    let t = getType()
-    let ot = "NU" & $s
+    let ot = cUintType(s)
    res = cCast(t, cOp(Sub, ot, cCast(ot, ra), cCast(ot, rb)))
  of mMulU:
    let t = getType()
-    let ot = "NU" & $s
+    let ot = cUintType(s)
    res = cCast(t, cOp(Mul, ot, cCast(ot, ra), cCast(ot, rb)))
  of mDivU:
    let t = getType()
-    let ot = "NU" & $s
+    let ot = cUintType(s)
    res = cCast(t, cOp(Div, ot, cCast(ot, ra), cCast(ot, rb)))
  of mModU:
    let t = getType()
-    let ot = "NU" & $s
+    let ot = cUintType(s)
    res = cCast(t, cOp(Mod, ot, cCast(ot, ra), cCast(ot, rb)))
  of mEqI:
    res = cOp(Equal, ra, rb)
@@ -805,10 +805,10 @@ proc binaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
  of mLtF64:
    res = cOp(LessThan, ra, rb)
  of mLeU:
-    let ot = "NU" & $s
+    let ot = cUintType(s)
    res = cOp(LessEqual, cCast(ot, ra), cCast(ot, rb))
  of mLtU:
-    let ot = "NU" & $s
+    let ot = cUintType(s)
    res = cOp(LessThan, cCast(ot, ra), cCast(ot, rb))
  of mEqEnum:
    res = cOp(Equal, ra, rb)
@@ -817,11 +817,11 @@ proc binaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
  of mLtEnum:
    res = cOp(LessThan, ra, rb)
  of mEqCh:
-    res = cOp(Equal, cCast("NU8", ra), cCast("NU8", rb))
+    res = cOp(Equal, cCast(NimUint8, ra), cCast(NimUint8, rb))
  of mLeCh:
-    res = cOp(LessEqual, cCast("NU8", ra), cCast("NU8", rb))
+    res = cOp(LessEqual, cCast(NimUint8, ra), cCast(NimUint8, rb))
  of mLtCh:
-    res = cOp(LessThan, cCast("NU8", ra), cCast("NU8", rb))
+    res = cOp(LessThan, cCast(NimUint8, ra), cCast(NimUint8, rb))
  of mEqB:
    res = cOp(Equal, ra, rb)
  of mLeB:
@@ -881,7 +881,7 @@ proc unaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
  of mUnaryPlusI:
    res = ra
  of mBitnotI:
-    let at = "NU" & $(getSize(p.config, t) * 8)
+    let at = cUintType(getSize(p.config, t) * 8)
    let t = getSimpleTypeDesc(p.module, e.typ)
    res = cCast(t, cCast(at, cOp(BitNot, t, ra)))
  of mUnaryPlusF64:
@@ -1101,7 +1101,7 @@ proc genFieldCheck(p: BProc, e: PNode, obj: Rope, field: PSym) =
        else:
          p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "raiseFieldError2"),
            strLit,
-            cCast("NI", discIndex))
+            cCast(NimInt, discIndex))

      else:
        # complication needed for signed types
@@ -1115,7 +1115,7 @@ proc genFieldCheck(p: BProc, e: PNode, obj: Rope, field: PSym) =
              p.s(cpsStmts).add(strLit)
            p.s(cpsStmts).addArgument(raiseCall):
              p.s(cpsStmts).addCall(cgsymValue(p.module, "reprDiscriminant"),
-                cOp(Add, "NI", cCast("NI", discIndex), cCast("NI", firstLit)),
+                cOp(Add, NimInt, cCast(NimInt, discIndex), cCast(NimInt, firstLit)),
                discName)

      raiseInstr(p, p.s(cpsStmts))
@@ -1160,7 +1160,7 @@ proc genArrayElem(p: BProc, n, x, y: PNode, d: var TLoc) =
          let last = cIntLiteral(lastOrd(p.config, ty))
          let rcb = rdCharLoc(b)
          p.s(cpsStmts).addSingleIfStmt(
-              cOp(GreaterThan, cCast("NU", rcb), cCast("NU", last))):
+              cOp(GreaterThan, cCast(NimUint, rcb), cCast(NimUint, last))):
            p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "raiseIndexError2"),
              rcb,
              last)
@@ -1183,7 +1183,7 @@ proc genArrayElem(p: BProc, n, x, y: PNode, d: var TLoc) =
  d.inheritLocation(a)
  let ra = rdLoc(a)
  let rcb = rdCharLoc(b)
-  putIntoDest(p, d, n, subscript(ra, cOp(Sub, "NI", rcb, first)), a.storage)
+  putIntoDest(p, d, n, subscript(ra, cOp(Sub, NimInt, rcb, first)), a.storage)

 proc genCStringElem(p: BProc, n, x, y: PNode, d: var TLoc) =
  var a = initLocExpr(p, x)
@@ -1206,7 +1206,7 @@ proc genBoundsCheck(p: BProc; arr, a, b: TLoc; arrTyp: PType) =
      else:
        rarr & "Len_0"
    p.s(cpsStmts).addSingleIfStmt(cOp(And,
-      cOp(NotEqual, cOp(Sub, "NI", rb, ra), cIntValue(-1)),
+      cOp(NotEqual, cOp(Sub, NimInt, rb, ra), cIntValue(-1)),
      cOp(Or,
        cOp(Or, cOp(LessThan, ra, cIntValue(0)), cOp(GreaterEqual, ra, arrlen)),
        cOp(Or, cOp(LessThan, rb, cIntValue(0)), cOp(GreaterEqual, rb, arrlen))))):
@@ -1220,9 +1220,9 @@ proc genBoundsCheck(p: BProc; arr, a, b: TLoc; arrTyp: PType) =
    let rca = rdCharLoc(a)
    let rcb = rdCharLoc(b)
    p.s(cpsStmts).addSingleIfStmt(cOp(And,
-      cOp(NotEqual, cOp(Sub, "NI", rcb, rca), cIntValue(-1)),
+      cOp(NotEqual, cOp(Sub, NimInt, rcb, rca), cIntValue(-1)),
      cOp(Or,
-        cOp(LessThan, cOp(Sub, "NI", rcb, rca), cIntValue(-1)),
+        cOp(LessThan, cOp(Sub, NimInt, rcb, rca), cIntValue(-1)),
        cOp(Or,
          cOp(Or, cOp(LessThan, rca, first), cOp(GreaterThan, rca, last)),
          cOp(Or, cOp(LessThan, rcb, first), cOp(GreaterThan, rcb, last)))))):
@@ -1234,7 +1234,7 @@ proc genBoundsCheck(p: BProc; arr, a, b: TLoc; arrTyp: PType) =
    let rb = rdLoc(b)
    let arrlen = lenExpr(p, arr)
    p.s(cpsStmts).addSingleIfStmt(cOp(And,
-      cOp(NotEqual, cOp(Sub, "NI", rb, ra), cIntValue(-1)),
+      cOp(NotEqual, cOp(Sub, NimInt, rb, ra), cIntValue(-1)),
      cOp(Or,
        cOp(Or, cOp(LessThan, ra, cIntValue(0)), cOp(GreaterEqual, ra, arrlen)),
        cOp(Or, cOp(LessThan, rb, cIntValue(0)), cOp(GreaterEqual, rb, arrlen))))):
@@ -1264,7 +1264,7 @@ proc genOpenArrayElem(p: BProc, n, x, y: PNode, d: var TLoc) =
        cOp(GreaterEqual, rcb, arrLen))): # BUGFIX: ``>=`` and not ``>``!
      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "raiseIndexError2"),
        rcb,
-        cOp(Sub, "NI", arrLen, cIntValue(1)))
+        cOp(Sub, NimInt, arrLen, cIntValue(1)))
      raiseInstr(p, p.s(cpsStmts))

  inheritLocation(d, a)
@@ -1285,7 +1285,7 @@ proc genSeqElem(p: BProc, n, x, y: PNode, d: var TLoc) =
        cOp(GreaterEqual, rcb, arrLen))):
      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "raiseIndexError2"),
        rcb,
-        cOp(Sub, "NI", arrLen, cIntValue(1)))
+        cOp(Sub, NimInt, arrLen, cIntValue(1)))
      raiseInstr(p, p.s(cpsStmts))

  if d.k == locNone: d.storage = OnHeap
@@ -1418,7 +1418,7 @@ proc genEcho(p: BProc, n: PNode) =
  else:
    if n.len == 0:
      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "echoBinSafe"),
-        "NIM_NIL",
+        NimNil,
        cIntValue(n.len))
    else:
      var a: TLoc = initLocExpr(p, n)
@@ -1479,7 +1479,7 @@ proc genStrConcat(p: BProc, e: PNode, d: var TLoc) =
      appends.add(cgCall(p, "appendString", rstmp, ra))
  var exprL = cIntValue(L)
  for len in lens:
-    exprL = cOp(Add, "NI", exprL, len)
+    exprL = cOp(Add, NimInt, exprL, len)
  p.s(cpsStmts).addAssignmentWithValue(tmp.snippet):
    p.s(cpsStmts).addCall(cgsymValue(p.module, "rawNewString"), exprL)
  for append in appends:
@@ -1526,7 +1526,7 @@ proc genStrAppend(p: BProc, e: PNode, d: var TLoc) =
      appends.add(cgCall(p, "appendString", rsd, ra))
  var exprL = cIntValue(L)
  for len in lens:
-    exprL = cOp(Add, "NI", exprL, len)
+    exprL = cOp(Add, NimInt, exprL, len)
  if optSeqDestructors in p.config.globalOptions:
    let brd = byRefLoc(p, dest)
    p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "prepareAdd"),
@@ -1605,7 +1605,7 @@ proc rawGenNew(p: BProc, a: var TLoc, sizeExpr: Rope; needsInit: bool) =
      var f: TLoc = initLocExpr(p, newSymNode(op))
      let rf = rdLoc(f)
      p.module.s[cfsTypeInit3].addDerefFieldAssignment(ti, "finalizer",
-        cCast("void*", rf))
+        cCast(CPointer, rf))

    if a.storage == OnHeap and usesWriteBarrier(p.config):
      let unrefFnName = cgsymValue(p.module,
@@ -1616,7 +1616,7 @@ proc rawGenNew(p: BProc, a: var TLoc, sizeExpr: Rope; needsInit: bool) =
      let ra = a.rdLoc
      p.s(cpsStmts).addSingleIfStmt(ra):
        p.s(cpsStmts).addCallStmt(unrefFnName, ra)
-        p.s(cpsStmts).addAssignment(ra, "NIM_NIL")
+        p.s(cpsStmts).addAssignment(ra, NimNil)
      if p.config.selectedGC == gcGo:
        # newObjRC1() would clash with unsureAsgnRef() - which is used by gcGo to
        # implement the write barrier
@@ -1627,7 +1627,7 @@ proc rawGenNew(p: BProc, a: var TLoc, sizeExpr: Rope; needsInit: bool) =
        let raa = addrLoc(p.config, a)
        let rb = b.rdLoc
        p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "unsureAsgnRef"),
-          cCast("void**", raa),
+          cCast(ptrType(CPointer), raa),
          rb)
      else:
        # use newObjRC1 as an optimization
@@ -1669,7 +1669,7 @@ proc genNewSeqAux(p: BProc, dest: TLoc, length: Rope; lenIsZero: bool) =
    let rd = dest.rdLoc
    p.s(cpsStmts).addSingleIfStmt(rd):
      p.s(cpsStmts).addCallStmt(unrefFnName, rd)
-      p.s(cpsStmts).addAssignment(rd, "NIM_NIL")
+      p.s(cpsStmts).addAssignment(rd, NimNil)
    if not lenIsZero:
      let st = getTypeDesc(p.module, seqtype)
      let typinfo = genTypeInfoV1(p.module, seqtype, dest.lode.info)
@@ -1680,7 +1680,7 @@ proc genNewSeqAux(p: BProc, dest: TLoc, length: Rope; lenIsZero: bool) =
        let rad = addrLoc(p.config, dest)
        let rc = call.rdLoc
        p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "unsureAsgnRef"),
-          cCast("void**", rad),
+          cCast(ptrType(CPointer), rad),
          rc)
      else:
        call.snippet = cCast(st,
@@ -1690,7 +1690,7 @@ proc genNewSeqAux(p: BProc, dest: TLoc, length: Rope; lenIsZero: bool) =
        p.s(cpsStmts).addAssignment(rd, rc)
  else:
    if lenIsZero:
-      call.snippet = rope"NIM_NIL"
+      call.snippet = NimNil
    else:
      let st = getTypeDesc(p.module, seqtype)
      let typinfo = genTypeInfoV1(p.module, seqtype, dest.lode.info)
@@ -1954,7 +1954,7 @@ proc genNewFinalize(p: BProc, e: PNode) =
  var f = initLocExpr(p, e[2])
  b = initLoc(locExpr, a.lode, OnHeap)
  ti = genTypeInfo(p.config, p.module, refType, e.info)
-  p.module.s[cfsTypeInit3].addDerefFieldAssignment(ti, "finalizer", cCast("void*", rdLoc(f)))
+  p.module.s[cfsTypeInit3].addDerefFieldAssignment(ti, "finalizer", cCast(CPointer, rdLoc(f)))
  b.snippet = cCast(getTypeDesc(p.module, refType),
    cgCall(p, "newObj",
      ti,
@@ -2032,7 +2032,7 @@ proc genRepr(p: BProc, e: PNode, d: var TLoc) =
  case t.kind
  of tyInt..tyInt64, tyUInt..tyUInt64:
    let ra = rdLoc(a)
-    putIntoDest(p, d, e, cgCall("reprInt", cCast("NI64", ra)), a.storage)
+    putIntoDest(p, d, e, cgCall("reprInt", cCast(NimInt64, ra)), a.storage)
  of tyFloat..tyFloat128:
    let ra = rdLoc(a)
    putIntoDest(p, d, e, cgCall("reprFloat", ra), a.storage)
@@ -2045,7 +2045,7 @@ proc genRepr(p: BProc, e: PNode, d: var TLoc) =
  of tyEnum, tyOrdinal:
    let ra = rdLoc(a)
    let rti = genTypeInfoV1(p.module, t, e.info)
-    putIntoDest(p, d, e, cgCall("reprEnum", cCast("NI", ra), rti), a.storage)
+    putIntoDest(p, d, e, cgCall("reprEnum", cCast(NimInt, ra), rti), a.storage)
  of tyString:
    let ra = rdLoc(a)
    putIntoDest(p, d, e, cgCall("reprStr", ra), a.storage)
@@ -2063,7 +2063,7 @@ proc genRepr(p: BProc, e: PNode, d: var TLoc) =
      let ra = rdLoc(a)
      let la = lenExpr(p, a)
      putIntoDest(p, b, e,
-        cIfExpr(dataFieldAccessor(p, ra), dataField(p, ra), "NIM_NIL") &
+        cIfExpr(dataFieldAccessor(p, ra), dataField(p, ra), NimNil) &
          cArgumentSeparator & la,
        a.storage)
    of tyArray:
@@ -2156,12 +2156,12 @@ proc genArrayLen(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
      if optBoundsCheck in p.options:
        genBoundsCheck(p, m, b, c, skipTypes(m.t, abstractVarRange))
      if op == mHigh:
-        putIntoDest(p, d, e, cOp(Sub, "NI", rdLoc(c), rdLoc(b)))
+        putIntoDest(p, d, e, cOp(Sub, NimInt, rdLoc(c), rdLoc(b)))
      else:
-        putIntoDest(p, d, e, cOp(Add, "NI", cOp(Sub, "NI", rdLoc(c), rdLoc(b)), cIntValue(1)))
+        putIntoDest(p, d, e, cOp(Add, NimInt, cOp(Sub, NimInt, rdLoc(c), rdLoc(b)), cIntValue(1)))
    else:
      if not reifiedOpenArray(a):
-        if op == mHigh: unaryExpr(p, e, d, cOp(Sub, "NI", ra & "Len_0", cIntValue(1)))
+        if op == mHigh: unaryExpr(p, e, d, cOp(Sub, NimInt, ra & "Len_0", cIntValue(1)))
        else: unaryExpr(p, e, d, ra & "Len_0")
      else:
        let isDeref = a.kind in {nkHiddenDeref, nkDerefExpr}
@@ -2171,25 +2171,25 @@ proc genArrayLen(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
          else:
            dotField(ra, "Field1")
        if op == mHigh:
-          unaryExpr(p, e, d, cOp(Sub, "NI", lenA, cIntValue(1)))
+          unaryExpr(p, e, d, cOp(Sub, NimInt, lenA, cIntValue(1)))
        else:
          unaryExpr(p, e, d, lenA)
  of tyCstring:
    if op == mHigh:
-      unaryExpr(p, e, d, cOp(Sub, "NI", cgCall(p, "nimCStrLen", ra), cIntValue(1)))
+      unaryExpr(p, e, d, cOp(Sub, NimInt, cgCall(p, "nimCStrLen", ra), cIntValue(1)))
    else:
      unaryExpr(p, e, d, cgCall(p, "nimCStrLen", ra))
  of tyString:
    var a: TLoc = initLocExpr(p, e[1])
    var x = lenExpr(p, a)
-    if op == mHigh: x = cOp(Sub, "NI", x, cIntValue(1))
+    if op == mHigh: x = cOp(Sub, NimInt, x, cIntValue(1))
    putIntoDest(p, d, e, x)
  of tySequence:
    # we go through a temporary here because people write bullshit code.
    var tmp: TLoc = getIntTemp(p)
    var a = initLocExpr(p, e[1])
    var x = lenExpr(p, a)
-    if op == mHigh: x = cOp(Sub, "NI", x, cIntValue(1))
+    if op == mHigh: x = cOp(Sub, NimInt, x, cIntValue(1))
    p.s(cpsStmts).addAssignment(tmp.snippet, x)
    putIntoDest(p, d, e, tmp.snippet)
  of tyArray:
@@ -2217,7 +2217,7 @@ proc genSetLengthSeq(p: BProc, e: PNode, d: var TLoc) =
  let rti = genTypeInfoV1(p.module, t.skipTypes(abstractInst), e.info)
  var pExpr: Snippet
  if not p.module.compileToCpp:
-    pExpr = cIfExpr(ra, cAddr(derefField(ra, "Sup")), "NIM_NIL")
+    pExpr = cIfExpr(ra, cAddr(derefField(ra, "Sup")), NimNil)
  else:
    pExpr = ra
  call.snippet = cCast(rt, cgCall(p, "setLengthSeqV2", pExpr, rti, rb))
@@ -2259,7 +2259,7 @@ proc rdSetElemLoc(conf: ConfigRef; a: TLoc, typ: PType; result: var Snippet) =
  let setType = typ.skipTypes(abstractPtrs)
  assert(setType.kind == tySet)
  if firstOrd(conf, setType) != 0:
-    result = cOp(Sub, "NU", result, cIntValue(firstOrd(conf, setType)))
+    result = cOp(Sub, NimUint, result, cIntValue(firstOrd(conf, setType)))

 proc fewCmps(conf: ConfigRef; s: PNode): bool =
  # this function estimates whether it is better to emit code
@@ -2283,7 +2283,7 @@ proc genInExprAux(p: BProc, e: PNode, a, b, d: var TLoc) =
  case s
  of 1, 2, 4, 8:
    let mask = s * 8 - 1
-    let rt = "NU" & $(s * 8)
+    let rt = cUintType(s * 8)
    binaryExprIn(p, e, a, b, d,
      # ((a & ((NU8) 1 << ((NU) elem & 7U))) != 0)
      # ((a & ((NU16) 1 << ((NU) elem & 15U))) != 0)
@@ -2292,18 +2292,18 @@ proc genInExprAux(p: BProc, e: PNode, a, b, d: var TLoc) =
      cOp(NotEqual,
        cOp(BitAnd, rt, ra,
          cOp(Shl, rt, cCast(rt, cIntValue(1)),
-            cOp(BitAnd, "NU", cCast("NU", elem), cUintValue(mask.uint)))),
+            cOp(BitAnd, NimUint, cCast(NimUint, elem), cUintValue(mask.uint)))),
        cIntValue(0)))
  else:
    # ((a[(NU)(elem)>>3] &(1U<<((NU)(elem)&7U)))!=0)
    binaryExprIn(p, e, a, b, d,
      cOp(NotEqual,
-        cOp(BitAnd, "NU8",
-          subscript(ra, cOp(Shr, "NU", cCast("NU", elem), cIntValue(3))),
-          cOp(Shl, "NU8",
+        cOp(BitAnd, NimUint8,
+          subscript(ra, cOp(Shr, NimUint, cCast(NimUint, elem), cIntValue(3))),
+          cOp(Shl, NimUint8,
            cUintValue(1),
-            cOp(BitAnd, "NU",
-              cCast("NU", elem),
+            cOp(BitAnd, NimUint,
+              cCast(NimUint, elem),
              cUintValue(7)))),
        cIntValue(0)))

@@ -2372,20 +2372,20 @@ proc genSetOp(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
  case size
  of 1, 2, 4, 8:
    let bits = size * 8
-    let rt = "NU" & $bits
+    let rt = cUintType(bits)
    case op
    of mIncl:
      let mask = bits - 1
      binaryStmtInExcl(p, e, d,
        cInPlaceOp(BitOr, rt, ra,
          cOp(Shl, rt, cCast(rt, cIntValue(1)),
-            cOp(BitAnd, "NU", elem, cIntValue(mask)))))
+            cOp(BitAnd, NimUint, elem, cIntValue(mask)))))
    of mExcl:
      let mask = bits - 1
      binaryStmtInExcl(p, e, d,
        cInPlaceOp(BitAnd, rt, ra, cOp(BitNot, rt,
          cOp(Shl, rt, cCast(rt, cIntValue(1)),
-            cOp(BitAnd, "NU", elem, cIntValue(mask))))))
+            cOp(BitAnd, NimUint, elem, cIntValue(mask))))))
    of mCard:
      let name = if size <= 4: "countBits32" else: "countBits64"
      unaryExprChar(p, e, d, cgCall(p, name, ra))
@@ -2407,14 +2407,14 @@ proc genSetOp(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
  else:
    case op
    of mIncl:
-      binaryStmtInExcl(p, e, d, cInPlaceOp(BitOr, "NU8",
-        subscript(ra, cOp(Shr, "NU", cCast("NU", elem), cIntValue(3))),
-        cOp(Shl, "NU8", cUintValue(1), cOp(BitAnd, "NU", elem, cUintValue(7)))))
+      binaryStmtInExcl(p, e, d, cInPlaceOp(BitOr, NimUint8,
+        subscript(ra, cOp(Shr, NimUint, cCast(NimUint, elem), cIntValue(3))),
+        cOp(Shl, NimUint8, cUintValue(1), cOp(BitAnd, NimUint, elem, cUintValue(7)))))
    of mExcl:
-      binaryStmtInExcl(p, e, d, cInPlaceOp(BitAnd, "NU8",
-        subscript(ra, cOp(Shr, "NU", cCast("NU", elem), cIntValue(3))),
-        cOp(BitNot, "NU8",
-          cOp(Shl, "NU8", cUintValue(1), cOp(BitAnd, "NU", elem, cUintValue(7))))))
+      binaryStmtInExcl(p, e, d, cInPlaceOp(BitAnd, NimUint8,
+        subscript(ra, cOp(Shr, NimUint, cCast(NimUint, elem), cIntValue(3))),
+        cOp(BitNot, NimUint8,
+          cOp(Shl, NimUint8, cUintValue(1), cOp(BitAnd, NimUint, elem, cUintValue(7))))))
    of mCard:
      var a: TLoc = initLocExpr(p, e[1])
      let rca = rdCharLoc(a)
@@ -2433,9 +2433,9 @@ proc genSetOp(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
      let rb = rdLoc(b)
      p.s(cpsStmts).addForRangeExclusive(ri, cIntValue(0), cIntValue(size)):
        p.s(cpsStmts).addAssignment(rd, cOp(Equal,
-          cOp(BitAnd, "NU8",
+          cOp(BitAnd, NimUint8,
            subscript(ra, ri),
-            cOp(BitNot, "NU8", subscript(rb, ri))),
+            cOp(BitNot, NimUint8, subscript(rb, ri))),
          cIntValue(0)))
        p.s(cpsStmts).addSingleIfStmt(cOp(Not, rd)):
          p.s(cpsStmts).addBreak()
@@ -2471,10 +2471,10 @@ proc genSetOp(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
          let y = subscript(rb, ri)
          let lookup =
            case op
-            of mMulSet: cOp(BitAnd, "NU8", x, y)
-            of mPlusSet: cOp(BitOr, "NU8", x, y)
-            of mMinusSet: cOp(BitAnd, "NU8", x, cOp(BitNot, "NU8", y))
-            of mXorSet: cOp(BitXor, "NU8", x, y)
+            of mMulSet: cOp(BitAnd, NimUint8, x, y)
+            of mPlusSet: cOp(BitOr, NimUint8, x, y)
+            of mMinusSet: cOp(BitAnd, NimUint8, x, cOp(BitNot, NimUint8, y))
+            of mXorSet: cOp(BitXor, NimUint8, x, y)
            else: "" # unreachable
          p.s(cpsStmts).add(lookup)
    of mInSet: genInOp(p, e, d)
@@ -2606,7 +2606,7 @@ proc genRangeChck(p: BProc, n: PNode, d: var TLoc) =
      let rca = rdCharLoc(a)
      let boundRca =
        if n0t.skipTypes(abstractVarRange).kind in {tyUInt, tyUInt32, tyUInt64}:
-          cCast("NI64", rca)
+          cCast(NimInt64, rca)
        else:
          rca
      let firstVal = extract(first)
@@ -2645,7 +2645,7 @@ proc convCStrToStr(p: BProc, n: PNode, d: var TLoc) =
  if p.module.compileToCpp:
    # fixes for const qualifier; bug #12703; bug #19588
    putIntoDest(p, d, n,
-      cgCall(p, "cstrToNimstr", cCast("NCSTRING", rdLoc(a))),
+      cgCall(p, "cstrToNimstr", cCast(NimCstring, rdLoc(a))),
      a.storage)
  else:
    putIntoDest(p, d, n,
@@ -2767,9 +2767,9 @@ proc genDestroy(p: BProc; n: PNode) =
      let rp = dotField(ra, "p")
      p.s(cpsStmts).addSingleIfStmt(
        cOp(And, rp,
-          cOp(Not, cOp(BitAnd, "NI",
+          cOp(Not, cOp(BitAnd, NimInt,
            derefField(rp, "cap"),
-            "NIM_STRLIT_FLAG")))):
+            NimStrlitFlag)))):
        let fn = if optThreads in p.config.globalOptions: "deallocShared" else: "dealloc"
        p.s(cpsStmts).addCallStmt(cgsymValue(p.module, fn), rp)
    of tySequence:
@@ -2779,9 +2779,9 @@ proc genDestroy(p: BProc; n: PNode) =
      let rt = getTypeDesc(p.module, t.elementType)
      p.s(cpsStmts).addSingleIfStmt(
        cOp(And, rp,
-          cOp(Not, cOp(BitAnd, "NI",
+          cOp(Not, cOp(BitAnd, NimInt,
            derefField(rp, "cap"),
-            "NIM_STRLIT_FLAG")))):
+            NimStrlitFlag)))):
        p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "alignedDealloc"),
          rp,
          cAlignof(rt))
@@ -2897,7 +2897,7 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
  of mCStrToStr:
    if p.module.compileToCpp:
      # fixes for const qualifier; bug #12703; bug #19588
-      genDollarIt(p, e, d, cgCall(p, "cstrToNimstr", cCast("NCSTRING", it)))
+      genDollarIt(p, e, d, cgCall(p, "cstrToNimstr", cCast(NimCstring, it)))
    else:
      genDollarIt(p, e, d, cgCall(p, "cstrToNimstr", it))
  of mStrToStr, mUnown: expr(p, e[1], d)
@@ -2925,10 +2925,10 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
  of mNewSeqOfCap: genNewSeqOfCap(p, e, d)
  of mSizeOf:
    let t = e[1].typ.skipTypes({tyTypeDesc})
-    putIntoDest(p, d, e, cCast("NI", cSizeof(getTypeDesc(p.module, t, dkVar))))
+    putIntoDest(p, d, e, cCast(NimInt, cSizeof(getTypeDesc(p.module, t, dkVar))))
  of mAlignOf:
    let t = e[1].typ.skipTypes({tyTypeDesc})
-    putIntoDest(p, d, e, cCast("NI", cAlignof(getTypeDesc(p.module, t, dkVar))))
+    putIntoDest(p, d, e, cCast(NimInt, cAlignof(getTypeDesc(p.module, t, dkVar))))
  of mOffsetOf:
    var dotExpr: PNode
    if e[1].kind == nkDotExpr:
@@ -2944,7 +2944,7 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
      if t.kind == tyTuple:
        "Field" & rope(dotExpr[1].sym.position)
      else: dotExpr[1].sym.loc.snippet
-    putIntoDest(p,d,e, cCast("NI", cOffsetof(tname, member)))
+    putIntoDest(p,d,e, cCast(NimInt, cOffsetof(tname, member)))
  of mChr: genSomeCast(p, e, d)
  of mOrd: genOrd(p, e, d)
  of mLengthArray, mHigh, mLengthStr, mLengthSeq, mLengthOpenArray:
@@ -3073,22 +3073,22 @@ proc genSetConstr(p: BProc, e: PNode, d: var TLoc) =
          let ri = rdLoc(idx)
          let rd = rdLoc(d)
          p.s(cpsStmts).addForRangeInclusive(ri, aa, bb):
-            p.s(cpsStmts).addInPlaceOp(BitOr, "NU8",
-              subscript(rd, cOp(Shr, "NU", cCast("NU", ri), cIntValue(3))),
-              cOp(Shl, "NU8", cUintValue(1),
-                cOp(BitAnd, "NU", cCast("NU", ri), cUintValue(7))))
+            p.s(cpsStmts).addInPlaceOp(BitOr, NimUint8,
+              subscript(rd, cOp(Shr, NimUint, cCast(NimUint, ri), cIntValue(3))),
+              cOp(Shl, NimUint8, cUintValue(1),
+                cOp(BitAnd, NimUint, cCast(NimUint, ri), cUintValue(7))))
        else:
          a = initLocExpr(p, it)
          var aa: Snippet = ""
          rdSetElemLoc(p.config, a, e.typ, aa)
          let rd = rdLoc(d)
-          p.s(cpsStmts).addInPlaceOp(BitOr, "NU8",
-            subscript(rd, cOp(Shr, "NU", cCast("NU", aa), cIntValue(3))),
-            cOp(Shl, "NU8", cUintValue(1),
-              cOp(BitAnd, "NU", cCast("NU", aa), cUintValue(7))))
+          p.s(cpsStmts).addInPlaceOp(BitOr, NimUint8,
+            subscript(rd, cOp(Shr, NimUint, cCast(NimUint, aa), cIntValue(3))),
+            cOp(Shl, NimUint8, cUintValue(1),
+              cOp(BitAnd, NimUint, cCast(NimUint, aa), cUintValue(7))))
    else:
      # small set
-      var ts = "NU" & $(size * 8)
+      var ts = cUintType(size * 8)
      p.s(cpsStmts).addAssignment(rdLoc(d), cIntValue(0))
      for it in e.sons:
        if it.kind == nkRange:
@@ -3392,9 +3392,9 @@ proc genConstDefinition(q: BModule; p: BProc; sym: PSym) =
        q.initProc.procSec(cpsLocals).addArgument(registerCall):
          q.initProc.procSec(cpsLocals).addSizeof(rdLoc(sym.loc))
        q.initProc.procSec(cpsLocals).addArgument(registerCall):
-          q.initProc.procSec(cpsLocals).add("NULL")
+          q.initProc.procSec(cpsLocals).add(CNil)
        q.initProc.procSec(cpsLocals).addArgument(registerCall):
-          q.initProc.procSec(cpsLocals).addCast("void**"):
+          q.initProc.procSec(cpsLocals).addCast(ptrType(CPointer)):
            q.initProc.procSec(cpsLocals).add(cAddr(sym.loc.snippet))
    # always copy over the contents of the actual constant with the _const
    # suffix ==> this means that the constant is reloadable & updatable!
@@ -3403,9 +3403,9 @@ proc genConstDefinition(q: BModule; p: BProc; sym: PSym) =
      var copyCall: CallBuilder
      q.initProc.procSec(cpsLocals).addCall(copyCall, cgsymValue(q, "nimCopyMem")):
        q.initProc.procSec(cpsLocals).addArgument(copyCall):
-          q.initProc.procSec(cpsLocals).add(cCast("void*", sym.loc.snippet))
+          q.initProc.procSec(cpsLocals).add(cCast(CPointer, sym.loc.snippet))
        q.initProc.procSec(cpsLocals).addArgument(copyCall):
-          q.initProc.procSec(cpsLocals).add(cCast(ptrConstType("void"), cAddr(actualConstName)))
+          q.initProc.procSec(cpsLocals).add(cCast(CConstPointer, cAddr(actualConstName)))
        q.initProc.procSec(cpsLocals).addArgument(copyCall):
          q.initProc.procSec(cpsLocals).addSizeof(rdLoc(sym.loc))

@@ -3465,7 +3465,7 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
      # we never reach this case - as of the time of this comment,
      # skEnumField is folded to an int in semfold.nim, but this code
      # remains for robustness
-      putIntoDest(p, d, n, rope(sym.position))
+      putIntoDest(p, d, n, cIntValue(sym.position))
    of skVar, skForVar, skResult, skLet:
      if {sfGlobal, sfThread} * sym.flags != {}:
        genVarPrototype(p.module, n)
@@ -3609,8 +3609,7 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
    if ex.kind != nkEmpty:
      genLineDir(p, n)
      var a: TLoc = initLocExprSingleUse(p, ex)
-      p.s(cpsStmts).addStmt():
-        p.s(cpsStmts).add(cCast("void", a.snippet))
+      p.s(cpsStmts).addDiscard(a.snippet)
  of nkAsmStmt: genAsmStmt(p, n)
  of nkTryStmt, nkHiddenTryStmt:
    case p.config.exc
@@ -3674,12 +3673,12 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
 proc getDefaultValue(p: BProc; typ: PType; info: TLineInfo; result: var Builder) =
  var t = skipTypes(typ, abstractRange+{tyOwned}-{tyTypeDesc})
  case t.kind
-  of tyBool: result.add rope"NIM_FALSE"
+  of tyBool: result.add NimFalse
  of tyEnum, tyChar, tyInt..tyInt64, tyUInt..tyUInt64: result.addIntValue(0)
  of tyFloat..tyFloat128: result.addFloatValue(0.0)
  of tyCstring, tyVar, tyLent, tyPointer, tyPtr, tyUntyped,
     tyTyped, tyTypeDesc, tyStatic, tyRef, tyNil:
-    result.add rope"NIM_NIL"
+    result.add NimNil
  of tyString, tySequence:
    if optSeqDestructors in p.config.globalOptions:
      var seqInit: StructInitializer
@@ -3687,19 +3686,19 @@ proc getDefaultValue(p: BProc; typ: PType; info: TLineInfo; result: var Builder)
        result.addField(seqInit, name = "len"):
          result.addIntValue(0)
        result.addField(seqInit, name = "p"):
-          result.add("NIM_NIL")
+          result.add(NimNil)
    else:
-      result.add "NIM_NIL"
+      result.add NimNil
  of tyProc:
    if t.callConv != ccClosure:
-      result.add "NIM_NIL"
+      result.add NimNil
    else:
      var closureInit: StructInitializer
      result.addStructInitializer(closureInit, kind = siOrderedStruct):
        result.addField(closureInit, name = "ClP_0"):
-          result.add("NIM_NIL")
+          result.add(NimNil)
        result.addField(closureInit, name = "ClE_0"):
-          result.add("NIM_NIL")
+          result.add(NimNil)
  of tyObject:
    var objInit: StructInitializer
    result.addStructInitializer(objInit, kind = siOrderedStruct):
@@ -3724,7 +3723,7 @@ proc getDefaultValue(p: BProc; typ: PType; info: TLineInfo; result: var Builder)
    var openArrInit: StructInitializer
    result.addStructInitializer(openArrInit, kind = siOrderedStruct):
      result.addField(openArrInit, name = "Field0"):
-        result.add("NIM_NIL")
+        result.add(NimNil)
      result.addField(openArrInit, name = "Field1"):
        result.addIntValue(0)
  of tySet:
@@ -3901,9 +3900,9 @@ proc genConstSeq(p: BProc, n: PNode, t: PType; isConst: bool; result: var Builde
        var supInit: StructInitializer
        def.addStructInitializer(supInit, kind = siOrderedStruct):
          def.addField(supInit, name = "len"):
-            def.add(n.len.rope)
+            def.addIntValue(n.len)
          def.addField(supInit, name = "reserved"):
-            def.add(bitOr(rope(n.len), "NIM_STRLIT_FLAG"))
+            def.add(cOp(BitOr, NimInt, cIntValue(n.len), NimStrlitFlag))
      if n.len > 0:
        def.addField(structInit, name = "data"):
          var arrInit: StructInitializer
@@ -3925,13 +3924,13 @@ proc genConstSeqV2(p: BProc, n: PNode, t: PType; isConst: bool; result: var Buil
      if isConst: AlwaysConst else: Global,
      name = payload):
    def.addSimpleStruct(p.module, name = "", baseType = ""):
-      def.addField(name = "cap", typ = "NI")
+      def.addField(name = "cap", typ = NimInt)
      def.addArrayField(name = "data", elementType = getTypeDesc(p.module, base), len = n.len)
  do:
    var structInit: StructInitializer
    def.addStructInitializer(structInit, kind = siOrderedStruct):
      def.addField(structInit, name = "cap"):
-        def.add(bitOr(rope(n.len), "NIM_STRLIT_FLAG"))
+        def.add(cOp(BitOr, NimInt, cIntValue(n.len), NimStrlitFlag))
      if n.len > 0:
        def.addField(structInit, name = "data"):
          var arrInit: StructInitializer
@@ -3987,12 +3986,12 @@ proc genBracedInit(p: BProc, n: PNode; isConst: bool; optionalType: PType; resul
        result.addStructInitializer(closureInit, kind = siOrderedStruct):
          result.addField(closureInit, name = "ClP_0"):
            if n[0].kind == nkNilLit:
-              result.add("NIM_NIL")
+              result.add(NimNil)
            else:
              var d: TLoc = initLocExpr(p, n[0])
              result.add(cCast(typ = getClosureType(p.module, typ, clHalfWithEnv), value = rdLoc(d)))
          result.addField(closureInit, name = "ClE_0"):
-            result.add("NIM_NIL")
+            result.add(NimNil)
      else:
        var d: TLoc = initLocExpr(p, n)
        result.add rdLoc(d)
--- a/compiler/ccgliterals.nim
+++ b/compiler/ccgliterals.nim
@@ -40,7 +40,7 @@ proc genStringLiteralDataOnlyV1(m: BModule, s: string; result: var Rope) =
  res.addVarWithTypeAndInitializer(AlwaysConst, name = tmp):
    res.addSimpleStruct(m, name = "", baseType = ""):
      res.addField(name = "Sup", typ = "TGenericSeq")
-      res.addArrayField(name = "data", elementType = "NIM_CHAR", len = s.len + 1)
+      res.addArrayField(name = "data", elementType = NimChar, len = s.len + 1)
  do:
    var strInit: StructInitializer
    res.addStructInitializer(strInit, kind = siOrderedStruct):
@@ -50,14 +50,14 @@ proc genStringLiteralDataOnlyV1(m: BModule, s: string; result: var Rope) =
          res.addField(seqInit, name = "len"):
            res.addIntValue(s.len)
          res.addField(seqInit, name = "reserved"):
-            res.add(cCast("NI", bitOr(cCast("NU", rope(s.len)), "NIM_STRLIT_FLAG")))
+            res.add(cCast(NimInt, cOp(BitOr, NimUint, cCast(NimUint, cIntValue(s.len)), NimStrlitFlag)))
      res.addField(strInit, name = "data"):
        res.add(makeCString(s))
  m.s[cfsStrData].add(extract(res))

 proc genStringLiteralV1(m: BModule; n: PNode; result: var Builder) =
  if s.isNil:
-    result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), "NIM_NIL"))
+    result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), NimNil))
  else:
    let id = nodeTableTestOrSet(m.dataCache, n, m.labels)
    var name: string = ""
@@ -76,13 +76,13 @@ proc genStringLiteralDataOnlyV2(m: BModule, s: string; result: Rope; isConst: bo
      if isConst: AlwaysConst else: Global,
      name = result):
    res.addSimpleStruct(m, name = "", baseType = ""):
-      res.addField(name = "cap", typ = "NI")
-      res.addArrayField(name = "data", elementType = "NIM_CHAR", len = s.len + 1)
+      res.addField(name = "cap", typ = NimInt)
+      res.addArrayField(name = "data", elementType = NimChar, len = s.len + 1)
  do:
    var structInit: StructInitializer
    res.addStructInitializer(structInit, kind = siOrderedStruct):
      res.addField(structInit, name = "cap"):
-        res.add(bitOr(rope(s.len), "NIM_STRLIT_FLAG"))
+        res.add(cOp(BitOr, NimInt, cIntValue(s.len), NimStrlitFlag))
      res.addField(structInit, name = "data"):
        res.add(makeCString(s))
  m.s[cfsStrData].add(extract(res))
@@ -145,7 +145,7 @@ proc genStringLiteralDataOnly(m: BModule; s: string; info: TLineInfo;
    localError(m.config, info, "cannot determine how to produce code for string literal")

 proc genNilStringLiteral(m: BModule; info: TLineInfo; result: var Builder) =
-  result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), "NIM_NIL"))
+  result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), NimNil))

 proc genStringLiteral(m: BModule; n: PNode; result: var Builder) =
  case detectStrVersion(m)
--- a/compiler/ccgreset.nim
+++ b/compiler/ccgreset.nim
@@ -75,21 +75,21 @@ proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =

  of tyString, tyRef, tySequence:
    p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "unsureAsgnRef"),
-      cCast("void**", cAddr(accessor)),
-      "NIM_NIL")
+      cCast(ptrType(CPointer), cAddr(accessor)),
+      NimNil)

  of tyProc:
    if typ.callConv == ccClosure:
      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "unsureAsgnRef"),
-        cCast("void**", cAddr(dotField(accessor, "ClE_0"))),
-        "NIM_NIL")
-      p.s(cpsStmts).addFieldAssignment(accessor, "ClP_0", "NIM_NIL")
+        cCast(ptrType(CPointer), cAddr(dotField(accessor, "ClE_0"))),
+        NimNil)
+      p.s(cpsStmts).addFieldAssignment(accessor, "ClP_0", NimNil)
    else:
-      p.s(cpsStmts).addAssignment(accessor, "NIM_NIL")
+      p.s(cpsStmts).addAssignment(accessor, NimNil)
  of tyChar, tyBool, tyEnum, tyRange, tyInt..tyUInt64:
    p.s(cpsStmts).addAssignment(accessor, cIntValue(0))
  of tyCstring, tyPointer, tyPtr, tyVar, tyLent:
-    p.s(cpsStmts).addAssignment(accessor, "NIM_NIL")
+    p.s(cpsStmts).addAssignment(accessor, NimNil)
  of tySet:
    case mapSetType(p.config, typ)
    of ctArray:
--- a/compiler/ccgstmts.nim
+++ b/compiler/ccgstmts.nim
@@ -71,11 +71,11 @@ template startBlockWith(p: BProc, body: typed): int =
 proc blockBody(b: var TBlock; result: var Builder) =
  result.add extract(b.sections[cpsLocals])
  if b.frameLen > 0:
-    result.addInPlaceOp(Add, "NI", dotField("FR_", "len"), b.frameLen.rope)
+    result.addInPlaceOp(Add, NimInt, dotField("FR_", "len"), cIntValue(b.frameLen.int))
  result.add(extract(b.sections[cpsInit]))
  result.add(extract(b.sections[cpsStmts]))
  if b.frameLen > 0:
-    result.addInPlaceOp(Sub, "NI", dotField("FR_", "len"), b.frameLen.rope)
+    result.addInPlaceOp(Sub, NimInt, dotField("FR_", "len"), cIntValue(b.frameLen.int))

 proc endBlockInside(p: BProc) =
  let topBlock = p.blocks.len-1
@@ -144,7 +144,7 @@ proc genVarTuple(p: BProc, n: PNode) =
    field.snippet = dotField(rtup, fieldName)
    putLocIntoDest(p, v.loc, field)
    if forHcr or isGlobalInBlock:
-      hcrGlobals.add((loc: v.loc, tp: "NULL"))
+      hcrGlobals.add((loc: v.loc, tp: CNil))

  if forHcr:
    # end the block where the tuple gets initialized
@@ -158,18 +158,18 @@ proc genVarTuple(p: BProc, n: PNode) =
    # check if any of them is newly introduced and the initializing code has to be ran
    p.s(cpsLocals).addVar(kind = Local,
      name = hcrCond,
-      typ = "NIM_BOOL",
-      initializer = "NIM_FALSE")
+      typ = NimBool,
+      initializer = NimFalse)
    for curr in hcrGlobals:
      let rc = rdLoc(curr.loc)
-      p.s(cpsLocals).addInPlaceOp(BitOr, "NIM_BOOL",
+      p.s(cpsLocals).addInPlaceOp(BitOr, NimBool,
        hcrCond,
        cCall("hcrRegisterGlobal",
          getModuleDllPath(p.module, n[0].sym),
          '"' & curr.loc.snippet & '"',
          cSizeof(rc),
          curr.tp,
-          cCast("void**", cAddr(curr.loc.snippet))))
+          cCast(ptrType(CPointer), cAddr(curr.loc.snippet))))


 proc loadInto(p: BProc, le, ri: PNode, a: var TLoc) {.inline.} =
@@ -294,7 +294,7 @@ proc genBreakState(p: BProc, n: PNode, d: var TLoc) =
    let ra = a.rdLoc
    d.snippet = cOp(LessThan,
      subscript(
-        cCast(ptrType("NI"), ra),
+        cCast(ptrType(NimInt), ra),
        cIntValue(1)),
      cIntValue(0))
  else:
@@ -303,7 +303,7 @@ proc genBreakState(p: BProc, n: PNode, d: var TLoc) =
    # the environment is guaranteed to contain the 'state' field at offset 1:
    d.snippet = cOp(LessThan,
      subscript(
-        cCast(ptrType("NI"), dotField(ra, "ClE_0")),
+        cCast(ptrType(NimInt), dotField(ra, "ClE_0")),
        cIntValue(1)),
      cIntValue(0))

@@ -426,7 +426,7 @@ proc genSingleVar(p: BProc, v: PSym; vn, value: PNode) =
    assignLocalVar(p, vn)
    initLocalVar(p, v, imm)

-  let traverseProc = "NULL"
+  let traverseProc = CNil
  # If the var is in a block (control flow like if/while or a block) in global scope just
  # register the so called "global" so it can be used later on. There is no need to close
  # and reopen of if (nim_hcr_do_init_) blocks because we are in one already anyway.
@@ -440,7 +440,7 @@ proc genSingleVar(p: BProc, v: PSym; vn, value: PNode) =
      '"' & v.loc.snippet & '"',
      cSizeof(rv),
      traverseProc,
-      cCast("void**", cAddr(v.loc.snippet)))
+      cCast(ptrType(CPointer), cAddr(v.loc.snippet)))
    # nothing special left to do later on - let's avoid closing and reopening blocks
    forHcr = false

@@ -456,7 +456,7 @@ proc genSingleVar(p: BProc, v: PSym; vn, value: PNode) =
        '"' & v.loc.snippet & '"',
        cSizeof(rdLoc(v.loc)),
        traverseProc,
-        cCast("void**", cAddr(v.loc.snippet))))
+        cCast(ptrType(CPointer), cAddr(v.loc.snippet))))
  if value.kind != nkEmpty and valueAsRope.len == 0:
    genLineDir(targetProc, vn)
    if not isCppCtorCall:
@@ -623,7 +623,7 @@ proc genComputedGoto(p: BProc; n: PNode) =
  let tmp = "TMP$1_" % [id.rope]
  p.s(cpsStmts).addArrayVarWithInitializer(kind = Global,
      name = tmp,
-      elementType = "void*",
+      elementType = CPointer,
      len = arraySize):
    var labelsInit: StructInitializer
    p.s(cpsStmts).addStructInitializer(labelsInit, kind = siArray):
@@ -877,7 +877,7 @@ proc genRaiseStmt(p: BProc, t: PNode) =
        fName,
        cIntValue(ln))
      if optOwnedRefs in p.config.globalOptions:
-        p.s(cpsStmts).addAssignment(e, "NIM_NIL")
+        p.s(cpsStmts).addAssignment(e, NimNil)
  else:
    finallyActions(p)
    genLineDir(p, t)
@@ -990,7 +990,7 @@ proc genStringCase(p: BProc, t: PNode, stringKind: TTypeKind, d: var TLoc) =
    let fnName = if stringKind == tyCstring: "hashCstring" else: "hashString"
    let ra = rdLoc(a)
    p.s(cpsStmts).addSwitchStmt(
-      cOp(BitAnd, "NI",
+      cOp(BitAnd, NimInt,
        cCall(cgsymValue(p.module, fnName), ra),
        cIntValue(bitMask))):
      for j in 0..high(branches):
@@ -1483,7 +1483,7 @@ proc genTryGoto(p: BProc; t: PNode; d: var TLoc) =
          isScope = true
          innerScope = initScope(p.s(cpsStmts))
      # we handled the exception, remember this:
-      p.s(cpsStmts).addAssignment(cDeref("nimErr_"), "NIM_FALSE")
+      p.s(cpsStmts).addAssignment(cDeref("nimErr_"), NimFalse)
      expr(p, t[i][0], d)
    else:
      if not innerIsIf:
@@ -1518,7 +1518,7 @@ proc genTryGoto(p: BProc; t: PNode; d: var TLoc) =
      startBlockWith(p):
        initElifBranch(p.s(cpsStmts), innerIfStmt, orExpr)
      # we handled the exception, remember this:
-      p.s(cpsStmts).addAssignment(cDeref("nimErr_"), "NIM_FALSE")
+      p.s(cpsStmts).addAssignment(cDeref("nimErr_"), NimFalse)
      expr(p, t[i][^1], d)

    p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "popCurrentException"))
@@ -1549,9 +1549,9 @@ proc genTryGoto(p: BProc; t: PNode; d: var TLoc) =
      genStmts(p, t[i][0])
    else:
      # pretend we did handle the error for the safe execution of the 'finally' section:
-      p.procSec(cpsLocals).addVar(kind = Local, name = "oldNimErrFin" & $lab & "_", typ = "NIM_BOOL")
+      p.procSec(cpsLocals).addVar(kind = Local, name = "oldNimErrFin" & $lab & "_", typ = NimBool)
      p.s(cpsStmts).addAssignment("oldNimErrFin" & $lab & "_", cDeref("nimErr_"))
-      p.s(cpsStmts).addAssignment(cDeref("nimErr_"), "NIM_FALSE")
+      p.s(cpsStmts).addAssignment(cDeref("nimErr_"), NimFalse)
      genStmts(p, t[i][0])
      # this is correct for all these cases:
      # 1. finally is run during ordinary control flow
@@ -1886,8 +1886,8 @@ proc genDiscriminantCheck(p: BProc, a, tmp: TLoc, objtype: PType,
  let rtmp = rdLoc(tmp)
  let dn = discriminatorTableName(p.module, t, field)
  p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "FieldDiscriminantCheck"),
-    cCast("NI", cCast("NU", ra)),
-    cCast("NI", cCast("NU", rtmp)),
+    cCast(NimInt, cCast(NimUint, ra)),
+    cCast(NimInt, cCast(NimUint, rtmp)),
    dn,
    lit)
  if p.config.exc == excGoto:
--- a/compiler/ccgthreadvars.nim
+++ b/compiler/ccgthreadvars.nim
@@ -59,6 +59,6 @@ proc generateThreadVarsSize(m: BModule) =
                       sfCompileToCpp in m.module.flags: ExternC
                  else: None
    m.s[cfsProcs].addDeclWithVisibility(externc):
-      m.s[cfsProcs].addProcHeader("NimThreadVarsSize", "NI", cProcParams())
+      m.s[cfsProcs].addProcHeader("NimThreadVarsSize", NimInt, cProcParams())
      m.s[cfsProcs].finishProcHeaderWithBody():
-        m.s[cfsProcs].addReturn(cCast("NI", cSizeof("NimThreadVars")))
+        m.s[cfsProcs].addReturn(cCast(NimInt, cSizeof("NimThreadVars")))
--- a/compiler/ccgtrav.nim
+++ b/compiler/ccgtrav.nim
@@ -23,7 +23,7 @@ proc getTemp(p: BProc, t: PType, needsInit=false): TLoc

 proc visit(p: BProc, data, visitor: Snippet) =
  p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimGCvisit"),
-    cCast("void*", data),
+    cCast(CPointer, data),
    visitor)

 proc genTraverseProc(c: TTraversalClosure, accessor: Rope, n: PNode;
@@ -108,7 +108,7 @@ proc genTraverseProc(c: TTraversalClosure, accessor: Rope, typ: PType) =
      # destructor based seqs are themselves not traced but their data is, if
      # they contain a GC'ed type:
      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimGCvisitSeq"),
-        cCast("void*", accessor),
+        cCast(CPointer, accessor),
        c.visitorFrmt)
      #genTraverseProcSeq(c, accessor, typ)
  of tyString:
@@ -164,11 +164,11 @@ proc genTraverseProc(m: BModule, origTyp: PType; sig: SigHash): Rope =
      genTraverseProc(c, cDeref("a"), typ.elementType)

  var headerBuilder = newBuilder("")
-  headerBuilder.addProcHeaderWithParams(ccNimCall, markerName, "void"):
+  headerBuilder.addProcHeaderWithParams(ccNimCall, markerName, CVoid):
    var paramBuilder: ProcParamBuilder
    headerBuilder.addProcParams(paramBuilder):
-      headerBuilder.addParam(paramBuilder, name = "p", typ = "void*")
-      headerBuilder.addParam(paramBuilder, name = "op", typ = "NI")
+      headerBuilder.addParam(paramBuilder, name = "p", typ = CPointer)
+      headerBuilder.addParam(paramBuilder, name = "op", typ = NimInt)
  let header = extract(headerBuilder)

  m.s[cfsProcHeaders].addDeclWithVisibility(StaticProc):
@@ -185,16 +185,16 @@ proc genTraverseProc(m: BModule, origTyp: PType; sig: SigHash): Rope =
    var desc = newBuilder("")
    var unnamedParamBuilder: ProcParamBuilder
    desc.addProcParams(unnamedParamBuilder):
-      desc.addUnnamedParam(unnamedParamBuilder, "void*")
-      desc.addUnnamedParam(unnamedParamBuilder, "NI")
+      desc.addUnnamedParam(unnamedParamBuilder, CPointer)
+      desc.addUnnamedParam(unnamedParamBuilder, NimInt)
    let unnamedParams = extract(desc)
-    m.s[cfsProcHeaders].addProcVar(ccNimCall, result, unnamedParams, "void")
+    m.s[cfsProcHeaders].addProcVar(ccNimCall, result, unnamedParams, CVoid)
    m.s[cfsDynLibInit].addAssignmentWithValue(result):
-      m.s[cfsDynLibInit].addCast(procPtrTypeUnnamed(ccNimCall, "void", unnamedParams)):
+      m.s[cfsDynLibInit].addCast(procPtrTypeUnnamed(ccNimCall, CVoid, unnamedParams)):
        m.s[cfsDynLibInit].addCall("hcrRegisterProc",
          getModuleDllPath(m),
          '"' & result & '"',
-          cCast("void*", markerName))
+          cCast(CPointer, markerName))

 proc genTraverseProcForGlobal(m: BModule, s: PSym; info: TLineInfo): Rope =
  discard genTypeInfoV1(m, s.loc.t, info)
@@ -214,7 +214,7 @@ proc genTraverseProcForGlobal(m: BModule, s: PSym; info: TLineInfo): Rope =
  genTraverseProc(c, sLoc, s.loc.t)

  var headerBuilder = newBuilder("")
-  headerBuilder.addProcHeaderWithParams(ccNimCall, result, "void"):
+  headerBuilder.addProcHeaderWithParams(ccNimCall, result, CVoid):
    var paramBuilder: ProcParamBuilder
    headerBuilder.addProcParams(paramBuilder):
      # (void)
--- a/compiler/ccgtypes.nim
+++ b/compiler/ccgtypes.nim
@@ -316,12 +316,12 @@ proc typeNameOrLiteral(m: BModule; t: PType, literal: string): Rope =
 proc getSimpleTypeDesc(m: BModule; typ: PType): Rope =
  const
    NumericalTypeToStr: array[tyInt..tyUInt64, string] = [
-      "NI", "NI8", "NI16", "NI32", "NI64",
-      "NF", "NF32", "NF64", "NF128",
-      "NU", "NU8", "NU16", "NU32", "NU64"]
+      NimInt, NimInt8, NimInt16, NimInt32, NimInt64,
+      NimFloat, NimFloat32, NimFloat64, NimFloat128,
+      NimUint, NimUint8, NimUint16, NimUint32, NimUint64]
  case typ.kind
  of tyPointer:
-    result = typeNameOrLiteral(m, typ, "void*")
+    result = typeNameOrLiteral(m, typ, CPointer)
  of tyString:
    case detectStrVersion(m)
    of 2:
@@ -331,10 +331,10 @@ proc getSimpleTypeDesc(m: BModule; typ: PType): Rope =
    else:
      cgsym(m, "NimStringDesc")
      result = typeNameOrLiteral(m, typ, "NimStringDesc*")
-  of tyCstring: result = typeNameOrLiteral(m, typ, "NCSTRING")
-  of tyBool: result = typeNameOrLiteral(m, typ, "NIM_BOOL")
-  of tyChar: result = typeNameOrLiteral(m, typ, "NIM_CHAR")
-  of tyNil: result = typeNameOrLiteral(m, typ, "void*")
+  of tyCstring: result = typeNameOrLiteral(m, typ, NimCstring)
+  of tyBool: result = typeNameOrLiteral(m, typ, NimBool)
+  of tyChar: result = typeNameOrLiteral(m, typ, NimChar)
+  of tyNil: result = typeNameOrLiteral(m, typ, CPointer)
  of tyInt..tyUInt64:
    result = typeNameOrLiteral(m, typ, NumericalTypeToStr[typ.kind])
  of tyRange, tyOrdinal: result = getSimpleTypeDesc(m, typ.skipModifier)
@@ -364,7 +364,7 @@ proc pushType(m: BModule; typ: PType) =
  m.typeStack.add(typ)

 proc getTypePre(m: BModule; typ: PType; sig: SigHash): Rope =
-  if typ == nil: result = rope("void")
+  if typ == nil: result = CVoid
  else:
    result = getSimpleTypeDesc(m, typ)
    if result == "": result = cacheGetType(m.typeCache, sig)
@@ -428,7 +428,7 @@ proc getTypeDescWeak(m: BModule; t: PType; check: var IntSet; kind: TypeDescKind
        m.typeCache[sig] = result
        #echo "adding ", sig, " ", typeToString(t), " ", m.module.name.s
        m.s[cfsTypes].addSimpleStruct(m, name = result, baseType = ""):
-          m.s[cfsTypes].addField(name = "len", typ = "NI")
+          m.s[cfsTypes].addField(name = "len", typ = NimInt)
          m.s[cfsTypes].addField(name = "p", typ = ptrType(result & "_Content"))
        pushType(m, t)
    else:
@@ -450,7 +450,7 @@ proc seqV2ContentType(m: BModule; t: PType; check: var IntSet) =
  else:
    let dataTyp = getTypeDescAux(m, t.skipTypes(abstractInst)[0], check, dkVar)
    m.s[cfsTypes].addSimpleStruct(m, name = result & "_Content", baseType = ""):
-      m.s[cfsTypes].addField(name = "cap", typ = "NI")
+      m.s[cfsTypes].addField(name = "cap", typ = NimInt)
      m.s[cfsTypes].addField(name = "data",
        typ = dataTyp,
        isFlexArray = true)
@@ -514,7 +514,7 @@ proc genMemberProcParams(m: BModule; prc: PSym, superCall, rettype, name, params
    # destructors can't have void
    rettype = ""
  elif t.returnType == nil or isInvalidReturnType(m.config, t):
-    rettype = "void"
+    rettype = CVoid
  else:
    if rettype == "":
      rettype = getTypeDescAux(m, t.returnType, check, dkResult)
@@ -585,7 +585,7 @@ proc genProcParams(m: BModule; t: PType, rettype: var Rope, params: var Builder,
                   check: var IntSet, declareEnvironment=true;
                   weakDep=false;) =
  if t.returnType == nil or isInvalidReturnType(m.config, t):
-    rettype = "void"
+    rettype = CVoid
  else:
    rettype = getTypeDescAux(m, t.returnType, check, dkResult)
  var paramBuilder: ProcParamBuilder
@@ -621,7 +621,7 @@ proc genProcParams(m: BModule; t: PType, rettype: var Rope, params: var Builder,
        # this fixes the 'sort' bug:
        if param.typ.kind in {tyVar, tyLent}: param.loc.storage = OnUnknown
        # need to pass hidden parameter:
-        params.addParam(paramBuilder, name = param.loc.snippet & "Len_" & $j, typ = "NI")
+        params.addParam(paramBuilder, name = param.loc.snippet & "Len_" & $j, typ = NimInt)
        inc(j)
        arr = arr[0].skipTypes({tySink})
    if t.returnType != nil and isInvalidReturnType(m.config, t):
@@ -637,7 +637,7 @@ proc genProcParams(m: BModule; t: PType, rettype: var Rope, params: var Builder,
        typ = getTypeDescAux(m, arr, check, dkResult)
      params.addParam(paramBuilder, name = "Result", typ = typ)
    if t.callConv == ccClosure and declareEnvironment:
-      params.addParam(paramBuilder, name = "ClE_0", typ = "void*")
+      params.addParam(paramBuilder, name = "ClE_0", typ = CPointer)
    if tfVarargs in t.flags:
      params.addVarargsParam(paramBuilder)

@@ -830,7 +830,7 @@ proc getOpenArrayDesc(m: BModule; t: PType, check: var IntSet; kind: TypeDescKin
      m.s[cfsTypes].addTypedef(name = result):
        m.s[cfsTypes].addSimpleStruct(m, name = "", baseType = ""):
          m.s[cfsTypes].addField(name = "Field0", typ = ptrType(elemType))
-          m.s[cfsTypes].addField(name = "Field1", typ = "NI")
+          m.s[cfsTypes].addField(name = "Field1", typ = NimInt)

 proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDescKind): Rope =
  # returns only the type's name
@@ -904,23 +904,23 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
        var size: int
        if firstOrd(m.config, t) < 0:
          m.s[cfsTypes].addTypedef(name = result):
-            m.s[cfsTypes].add("NI32")
+            m.s[cfsTypes].add(NimInt32)
          size = 4
        else:
          size = int(getSize(m.config, t))
          case size
          of 1:
            m.s[cfsTypes].addTypedef(name = result):
-              m.s[cfsTypes].add("NU8")
+              m.s[cfsTypes].add(NimUint8)
          of 2:
            m.s[cfsTypes].addTypedef(name = result):
-              m.s[cfsTypes].add("NU16")
+              m.s[cfsTypes].add(NimUint16)
          of 4:
            m.s[cfsTypes].addTypedef(name = result):
-              m.s[cfsTypes].add("NI32")
+              m.s[cfsTypes].add(NimInt32)
          of 8:
            m.s[cfsTypes].addTypedef(name = result):
-              m.s[cfsTypes].add("NI64")
+              m.s[cfsTypes].add(NimInt64)
          else: internalError(m.config, t.sym.info, "getTypeDescAux: enum")
        when false:
          let owner = hashOwner(t.sym)
@@ -946,7 +946,7 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
        m.s[cfsTypes].addTypedef(name = result):
          m.s[cfsTypes].addSimpleStruct(m, name = "", baseType = ""):
            m.s[cfsTypes].addProcField(name = "ClP_0", callConv = ccNimCall, rettype = rettype, params = params)
-            m.s[cfsTypes].addField(name = "ClE_0", typ = "void*")
+            m.s[cfsTypes].addField(name = "ClE_0", typ = CPointer)
  of tySequence:
    if optSeqDestructors in m.config.globalOptions:
      result = getTypeDescWeak(m, t, check, kind)
@@ -999,7 +999,7 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes

      template addResultType(ty: untyped) =
        if ty == nil or ty.kind == tyVoid:
-          result.add("void")
+          result.add(CVoid)
        elif ty.kind == tyStatic:
          internalAssert m.config, ty.n != nil
          result.add ty.n.renderTree
@@ -1065,10 +1065,10 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
      case s
      of 1, 2, 4, 8:
        m.s[cfsTypes].addTypedef(name = result):
-          m.s[cfsTypes].add("NU" & rope(s*8))
+          m.s[cfsTypes].add(cUintType(s*8))
      else:
        m.s[cfsTypes].addArrayTypedef(name = result, len = s):
-          m.s[cfsTypes].add("NU8")
+          m.s[cfsTypes].add(NimUint8)
  of tyGenericInst, tyDistinct, tyOrdinal, tyTypeDesc, tyAlias, tySink, tyOwned,
     tyUserTypeClass, tyUserTypeClassInst, tyInferred:
    result = getTypeDescAux(m, skipModifier(t), check, kind)
@@ -1104,7 +1104,7 @@ proc getClosureType(m: BModule; t: PType, kind: TClosureTypeKind): Rope =
      m.s[cfsTypes].addTypedef(name = result):
        m.s[cfsTypes].addSimpleStruct(m, name = "", baseType = ""):
          m.s[cfsTypes].addProcField(name = "ClP_0", callConv = ccNimCall, rettype = rettype, params = params)
-          m.s[cfsTypes].addField(name = "ClE_0", typ = "void*")
+          m.s[cfsTypes].addField(name = "ClE_0", typ = CPointer)

 proc finishTypeDescriptions(m: BModule) =
  var i = 0
@@ -1256,7 +1256,7 @@ proc genTypeInfoAuxBase(m: BModule; typ, origType: PType;

  var size: Rope
  if tfIncompleteStruct in typ.flags:
-    size = rope"void*"
+    size = CPointer
  else:
    size = getTypeDesc(m, origType, dkVar)
  m.s[cfsTypeInit3].addFieldAssignmentWithValue(nameHcr, "size"):
@@ -1296,9 +1296,9 @@ proc genTypeInfoAuxBase(m: BModule; typ, origType: PType;
        m.hcrCreateTypeInfosProc.addArgument(registerHcr):
          m.hcrCreateTypeInfosProc.addSizeof("TNimType")
        m.hcrCreateTypeInfosProc.addArgument(registerHcr):
-          m.hcrCreateTypeInfosProc.add("NULL")
+          m.hcrCreateTypeInfosProc.add(CNil)
        m.hcrCreateTypeInfosProc.addArgument(registerHcr):
-          m.hcrCreateTypeInfosProc.addCast(typ = "void**"):
+          m.hcrCreateTypeInfosProc.addCast(typ = ptrType(CPointer)):
            m.hcrCreateTypeInfosProc.add(cAddr(name))
  else:
    m.s[cfsStrData].addDeclWithVisibility(Private):
@@ -1348,11 +1348,11 @@ proc genTNimNodeArray(m: BModule; name: Rope, size: int) =
        m.hcrCreateTypeInfosProc.addArgument(registerHcr):
          m.hcrCreateTypeInfosProc.add(makeCString(name))
        m.hcrCreateTypeInfosProc.addArgument(registerHcr):
-          m.hcrCreateTypeInfosProc.addOp(Mul, "NI", cSizeof(ptrType("TNimNode")), cIntValue(size))
+          m.hcrCreateTypeInfosProc.addOp(Mul, NimInt, cSizeof(ptrType("TNimNode")), cIntValue(size))
        m.hcrCreateTypeInfosProc.addArgument(registerHcr):
-          m.hcrCreateTypeInfosProc.add("NULL")
+          m.hcrCreateTypeInfosProc.add(CNil)
        m.hcrCreateTypeInfosProc.addArgument(registerHcr):
-          m.hcrCreateTypeInfosProc.addCast(typ = "void**"):
+          m.hcrCreateTypeInfosProc.addCast(typ = ptrType(CPointer)):
            m.hcrCreateTypeInfosProc.add(cAddr(name))
  else:
    m.s[cfsTypeInit1].addArrayVar(kind = Global, name = name,
@@ -1393,7 +1393,7 @@ proc genObjectFields(m: BModule; typ, origType: PType, n: PNode, expr: Rope;
      m.s[cfsTypeInit3].addOffsetof(getTypeDesc(m, origType, dkVar), field.loc.snippet)
    m.s[cfsTypeInit3].addFieldAssignment(expr, "typ", fieldTypInfo)
    m.s[cfsTypeInit3].addFieldAssignment(expr, "name", makeCString(field.name.s))
-    m.s[cfsTypeInit3].addFieldAssignment(expr, "sons", cAddr(subscript(tmp, "0")))
+    m.s[cfsTypeInit3].addFieldAssignment(expr, "sons", cAddr(subscript(tmp, cIntValue(0))))
    m.s[cfsTypeInit3].addFieldAssignment(expr, "len", L)
    m.s[cfsData].addArrayVar(kind = Local, name = tmp,
      elementType = ptrType("TNimNode"), len = toInt(L)+1)
@@ -1502,18 +1502,18 @@ proc genEnumInfo(m: BModule; typ: PType, name: Rope; info: TLineInfo) =
        hasHoles = true
  var enumArray = getTempName(m)
  var counter = getTempName(m)
-  m.s[cfsTypeInit1].addVar(kind = Local, name = counter, typ = "NI")
+  m.s[cfsTypeInit1].addVar(kind = Local, name = counter, typ = NimInt)
  m.s[cfsTypeInit1].addArrayVarWithInitializer(
      kind = Global,
      name = enumArray,
-      elementType = constPtrType("char"),
+      elementType = constPtrType(CChar),
      len = typ.n.len):
    m.s[cfsTypeInit1].add(extract(enumNames))
  m.s[cfsTypeInit3].addForRangeExclusive(i = counter,
      start = cIntValue(0),
      bound = cIntValue(typ.n.len)):
    let nodeLoc = subscript(m.typeNodesName,
-      cOp(Add, "NI", counter, cIntValue(firstNimNode)))
+      cOp(Add, NimInt, counter, cIntValue(firstNimNode)))
    m.s[cfsTypeInit3].addFieldAssignment(nodeLoc, "kind", cIntValue(1))
    m.s[cfsTypeInit3].addFieldAssignment(nodeLoc, "offset", counter)
    m.s[cfsTypeInit3].addFieldAssignment(nodeLoc, "name",
@@ -1530,7 +1530,7 @@ proc genEnumInfo(m: BModule; typ: PType, name: Rope; info: TLineInfo) =
  if hasHoles:
    m.s[cfsTypeInit3].addFieldAssignment(tiNameForHcr(m, name), "flags",
      # 1 << 2 is {ntfEnumHole}
-      cOp(Shl, "NU8", cIntValue(1), cIntValue(2)))
+      cOp(Shl, NimUint8, cIntValue(1), cIntValue(2)))

 proc genSetInfo(m: BModule; typ: PType, name: Rope; info: TLineInfo) =
  assert(typ.elementType != nil)
@@ -1559,9 +1559,9 @@ proc genDeepCopyProc(m: BModule; s: PSym; result: Rope) =
  var desc = newBuilder("")
  var paramBuilder: ProcParamBuilder
  desc.addProcParams(paramBuilder):
-    desc.addUnnamedParam(paramBuilder, typ = "void*")
+    desc.addUnnamedParam(paramBuilder, typ = CPointer)
  let params = extract(desc)
-  let pt = procPtrTypeUnnamedNimCall(rettype = "void*", params = params)
+  let pt = procPtrTypeUnnamedNimCall(rettype = CPointer, params = params)
  m.s[cfsTypeInit3].addFieldAssignmentWithValue(result, "deepcopy"):
    m.s[cfsTypeInit3].add(cCast(pt, s.loc.snippet))

@@ -1674,7 +1674,7 @@ proc genHook(m: BModule; t: PType; info: TLineInfo; op: TTypeAttachedOp; result:
        # unfortunately this check is wrong for an object type that only contains
        # .cursor fields like 'Node' inside 'cycleleak'.
        internalError(m.config, info, "no attached trace proc found")
-    result.add rope("NIM_NIL")
+    result.add NimNil

 proc getObjDepth(t: PType): int16 =
  var x = t
@@ -1713,7 +1713,7 @@ proc genVTable(result: var Builder, seqs: seq[PSym]) =
  result.addStructInitializer(table, siArray):
    for i in 0..<seqs.len:
      result.addField(table, ""):
-        result.add(cCast("void*", seqs[i].loc.snippet))
+        result.add(cCast(CPointer, seqs[i].loc.snippet))

 proc genTypeInfoV2OldImpl(m: BModule; t, origType: PType, name: Rope; info: TLineInfo) =
  cgsym(m, "TNimTypeV2")
@@ -1725,10 +1725,10 @@ proc genTypeInfoV2OldImpl(m: BModule; t, origType: PType, name: Rope; info: TLin

  var typeEntry = newBuilder("")
  typeEntry.addFieldAssignmentWithValue(name, "destructor"):
-    typeEntry.addCast("void*"):
+    typeEntry.addCast(CPointer):
      genHook(m, t, info, attachedDestructor, typeEntry)
  typeEntry.addFieldAssignmentWithValue(name, "traceImpl"):
-    typeEntry.addCast("void*"):
+    typeEntry.addCast(CPointer):
      genHook(m, t, info, attachedTrace, typeEntry)

  let objDepth = if t.kind == tyObject: getObjDepth(t) else: -1
@@ -1738,17 +1738,17 @@ proc genTypeInfoV2OldImpl(m: BModule; t, origType: PType, name: Rope; info: TLin
              typeToString(t))

  if isDefined(m.config, "nimTypeNames"):
-    var typeName: Rope
+    var typeName: Snippet
    if t.kind in {tyObject, tyDistinct}:
      typeName = genTypeInfo2Name(m, t)
    else:
-      typeName = rope("NIM_NIL")
+      typeName = NimNil
    typeEntry.addFieldAssignment(name, "name", typeName)
  let sizeTyp = getTypeDesc(m, t)
  typeEntry.addFieldAssignmentWithValue(name, "size"):
    typeEntry.addSizeof(sizeTyp)
  typeEntry.addFieldAssignmentWithValue(name, "align"):
-    typeEntry.addCast(typ = "NI16"):
+    typeEntry.addCast(typ = NimInt16):
      typeEntry.addAlignof(sizeTyp)
  typeEntry.addFieldAssignment(name, "depth", objDepth)
  typeEntry.addFieldAssignment(name, "flags", flags)
@@ -1767,7 +1767,7 @@ proc genTypeInfoV2OldImpl(m: BModule; t, origType: PType, name: Rope; info: TLin
    let vTablePointerName = getTempName(m)
    m.s[cfsVars].addArrayVarWithInitializer(kind = Global,
        name = vTablePointerName,
-        elementType = "void*",
+        elementType = CPointer,
        len = dispatchMethods.len):
      genVTable(m.s[cfsVars], dispatchMethods)
    for i in dispatchMethods:
@@ -1793,7 +1793,7 @@ proc genTypeInfoV2Impl(m: BModule; t, origType: PType, name: Rope; info: TLineIn
      var typeInit: StructInitializer
      typeEntry.addStructInitializer(typeInit, kind = siNamedStruct):
        typeEntry.addField(typeInit, name = "destructor"):
-          typeEntry.addCast("void*"):
+          typeEntry.addCast(CPointer):
            genHook(m, t, info, attachedDestructor, typeEntry)

        let objDepth = if t.kind == tyObject: getObjDepth(t) else: -1
@@ -1806,7 +1806,7 @@ proc genTypeInfoV2Impl(m: BModule; t, origType: PType, name: Rope; info: TLineIn
        typeEntry.addField(typeInit, name = "size"):
          typeEntry.addSizeof(sizeType)
        typeEntry.addField(typeInit, name = "align"):
-          typeEntry.addCast("NI16"):
+          typeEntry.addCast(NimInt16):
            typeEntry.addAlignof(sizeType)
        typeEntry.addField(typeInit, name = "depth"):
          typeEntry.addIntValue(objDepth)
@@ -1825,11 +1825,11 @@ proc genTypeInfoV2Impl(m: BModule; t, origType: PType, name: Rope; info: TLineIn
          if t.kind in {tyObject, tyDistinct}:
            typeName = genTypeInfo2Name(m, t)
          else:
-            typeName = rope("NIM_NIL")
+            typeName = NimNil
          typeEntry.addField(typeInit, name = "name"):
            typeEntry.add(typeName)
        typeEntry.addField(typeInit, name = "traceImpl"):
-          typeEntry.addCast("void*"):
+          typeEntry.addCast(CPointer):
            genHook(m, t, info, attachedTrace, typeEntry)

        let dispatchMethods = toSeq(getMethodsPerType(m.g.graph, t))
@@ -2026,8 +2026,8 @@ proc genTypeInfoV1(m: BModule; t: PType; info: TLineInfo): Rope =

  if optTinyRtti in m.config.globalOptions and t.kind == tyObject and sfImportc notin t.sym.flags:
    let v2info = genTypeInfoV2(m, origType, info)
-    m.s[cfsTypeInit3].addDerefFieldAssignment(v2info, "typeInfoV1", cCast("void*", cAddr(result)))
-    m.s[cfsTypeInit3].addFieldAssignment(result, "typeInfoV2", cCast("void*", v2info))
+    m.s[cfsTypeInit3].addDerefFieldAssignment(v2info, "typeInfoV1", cCast(CPointer, cAddr(result)))
+    m.s[cfsTypeInit3].addFieldAssignment(result, "typeInfoV2", cCast(CPointer, v2info))

  result = prefixTI(result)

--- a/compiler/cgen.nim
+++ b/compiler/cgen.nim
@@ -425,7 +425,7 @@ proc rdCharLoc(a: TLoc): Rope =
  # read a location that may need a char-cast:
  result = rdLoc(a)
  if skipTypes(a.t, abstractRange).kind == tyChar:
-    result = cCast("NU8", result)
+    result = cCast(NimUint8, result)

 type
  TAssignmentFlag = enum
@@ -472,8 +472,8 @@ proc genObjectInit(p: BProc, section: TCProcSection, t: PType, a: var TLoc,
        let rtmp = rdLoc(tmp)
        let rt = getTypeDesc(p.module, objType, descKindFromSymKind mapTypeChooser(a))
        p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimCopyMem"),
-          cCast("void*", ra),
-          cCast(ptrConstType("void"), cAddr(rtmp)),
+          cCast(CPointer, ra),
+          cCast(CConstPointer, cAddr(rtmp)),
          cSizeof(rt))
      else:
        rawConstExpr(p, newNodeIT(nkType, a.lode.info, t), tmp)
@@ -520,14 +520,14 @@ proc resetLoc(p: BProc, loc: var TLoc) =
    let rl = rdLoc(loc)
    if atyp.kind in {tyVar, tyLent}:
      p.s(cpsStmts).addAssignment(derefField(rl, "len"), cIntValue(0))
-      p.s(cpsStmts).addAssignment(derefField(rl, "p"), "NIM_NIL")
+      p.s(cpsStmts).addAssignment(derefField(rl, "p"), NimNil)
    else:
      p.s(cpsStmts).addAssignment(dotField(rl, "len"), cIntValue(0))
-      p.s(cpsStmts).addAssignment(dotField(rl, "p"), "NIM_NIL")
+      p.s(cpsStmts).addAssignment(dotField(rl, "p"), NimNil)
  elif not isComplexValueType(typ):
    if containsGcRef:
      var nilLoc: TLoc = initLoc(locTemp, loc.lode, OnStack)
-      nilLoc.snippet = rope("NIM_NIL")
+      nilLoc.snippet = NimNil
      genRefAssign(p, loc, nilLoc)
    else:
      p.s(cpsStmts).addAssignment(rdLoc(loc), cIntValue(0))
@@ -551,13 +551,13 @@ proc resetLoc(p: BProc, loc: var TLoc) =
          let ral = addrLoc(p.config, loc)
          let ratmp = addrLoc(p.config, tmp)
          p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimCopyMem"),
-            cCast("void*", ral),
-            cCast(ptrConstType("void"), ratmp),
+            cCast(CPointer, ral),
+            cCast(CConstPointer, ratmp),
            cSizeof(tyDesc))
      else:
        let ral = addrLoc(p.config, loc)
        p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimZeroMem"),
-          cCast("void*", ral),
+          cCast(CPointer, ral),
          cSizeof(tyDesc))

      # XXX: We can be extra clever here and call memset only
@@ -569,11 +569,11 @@ proc constructLoc(p: BProc, loc: var TLoc, isTemp = false) =
  if optSeqDestructors in p.config.globalOptions and skipTypes(typ, abstractInst + {tyStatic}).kind in {tyString, tySequence}:
    let rl = rdLoc(loc)
    p.s(cpsStmts).addFieldAssignment(rl, "len", cIntValue(0))
-    p.s(cpsStmts).addFieldAssignment(rl, "p", "NIM_NIL")
+    p.s(cpsStmts).addFieldAssignment(rl, "p", NimNil)
  elif not isComplexValueType(typ):
    if containsGarbageCollectedRef(loc.t):
      var nilLoc: TLoc = initLoc(locTemp, loc.lode, OnStack)
-      nilLoc.snippet = rope("NIM_NIL")
+      nilLoc.snippet = NimNil
      genRefAssign(p, loc, nilLoc)
    else:
      let rl = rdLoc(loc)
@@ -587,7 +587,7 @@ proc constructLoc(p: BProc, loc: var TLoc, isTemp = false) =
        let ral = addrLoc(p.config, loc)
        let rt = getTypeDesc(p.module, typ, descKindFromSymKind mapTypeChooser(loc))
        p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimZeroMem"),
-          cCast("void*", ral),
+          cCast(CPointer, ral),
          cSizeof(rt))
    genObjectInit(p, cpsStmts, loc.t, loc, constructObj)

@@ -639,7 +639,7 @@ proc getIntTemp(p: BProc): TLoc =
  result = TLoc(snippet: "T" & rope(p.labels) & "_", k: locTemp,
                storage: OnStack, lode: lodeTyp getSysType(p.module.g.graph, unknownLineInfo, tyInt),
                flags: {})
-  p.s(cpsLocals).addVar(kind = Local, name = result.snippet, typ = "NI")
+  p.s(cpsLocals).addVar(kind = Local, name = result.snippet, typ = NimInt)

 proc localVarDecl(res: var Builder, p: BProc; n: PNode,
                  initializer: Snippet = "",
@@ -886,7 +886,7 @@ proc loadDynamicLib(m: BModule, lib: PLib) =
    lib.name = tmp # BUGFIX: cgsym has awful side-effects
    let loadFn = cgsymValue(m, "nimLoadLibrary")
    let loadErrorFn = cgsymValue(m, "nimLoadLibraryError")
-    m.s[cfsVars].addVar(Global, name = tmp, typ = "void*")
+    m.s[cfsVars].addVar(Global, name = tmp, typ = CPointer)
    if lib.path.kind in {nkStrLit..nkTripleStrLit}:
      var s: TStringSeq = @[]
      libCandidates(lib.path.strVal, s)
@@ -1082,7 +1082,7 @@ proc closureSetup(p: BProc, prc: PSym) =
    let renv = addrLoc(p.config, env.loc)
    let rt = getTypeDesc(p.module, env.typ)
    p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "unsureAsgnRef"),
-      cCast("void**", renv),
+      cCast(ptrType(CPointer), renv),
      cCast(rt, "ClE_0"))
  else:
    let renv = rdLoc(env.loc)
@@ -1265,7 +1265,7 @@ proc genProcBody(p: BProc; procBody: PNode) =
  if {nimErrorFlagAccessed, nimErrorFlagDeclared, nimErrorFlagDisabled} * p.flags == {nimErrorFlagAccessed}:
    p.flags.incl nimErrorFlagDeclared
    p.blocks[0].sections[cpsLocals].addVar(kind = Local,
-      name = "nimErr_", typ = ptrType("NIM_BOOL"))
+      name = "nimErr_", typ = ptrType(NimBool))
    p.blocks[0].sections[cpsInit].addAssignmentWithValue("nimErr_"):
      p.blocks[0].sections[cpsInit].addCall(cgsymValue(p.module, "nimErrorFlag"))

@@ -1393,7 +1393,7 @@ proc genProcAux*(m: BModule, prc: PSym) =
        m.s[cfsDynLibInit].addCall("hcrRegisterProc",
          getModuleDllPath(m, prc),
          '"' & prc.loc.snippet & '"',
-          cCast("void*", prc.loc.snippet & "_actual"))
+          cCast(CPointer, prc.loc.snippet & "_actual"))

 proc requiresExternC(m: BModule; sym: PSym): bool {.inline.} =
  result = (sfCompileToCpp in m.module.flags and
@@ -1471,7 +1471,7 @@ proc genProcNoForward(m: BModule, prc: PSym) =
            cCall("hcrRegisterProc",
              getModuleDllPath(m, q.module),
              '"' & prc.loc.snippet & '"',
-              cCast("void*", prc.loc.snippet))))
+              cCast(CPointer, prc.loc.snippet))))
    else:
      symInDynamicLibPartial(m, prc)
  elif prc.typ.callConv == ccInline:
@@ -1647,21 +1647,21 @@ proc isInnerMainVolatile(m: BModule): bool =

 proc genPreMain(m: BModule) =
  m.s[cfsProcs].addDeclWithVisibility(Private):
-    m.s[cfsProcs].addProcHeader(m.config.nimMainPrefix & "PreMainInner", "void", cProcParams())
+    m.s[cfsProcs].addProcHeader(m.config.nimMainPrefix & "PreMainInner", CVoid, cProcParams())
    m.s[cfsProcs].finishProcHeaderWithBody():
      m.s[cfsProcs].add(extract(m.g.otherModsInit))
  if optNoMain notin m.config.globalOptions:
    m.s[cfsProcs].addDeclWithVisibility(Private):
-      m.s[cfsProcs].addVar(name = "cmdCount", typ = "int")
+      m.s[cfsProcs].addVar(name = "cmdCount", typ = CInt)
    m.s[cfsProcs].addDeclWithVisibility(Private):
-      m.s[cfsProcs].addVar(name = "cmdLine", typ = ptrType(ptrType("char")))
+      m.s[cfsProcs].addVar(name = "cmdLine", typ = ptrType(ptrType(CChar)))
    m.s[cfsProcs].addDeclWithVisibility(Private):
-      m.s[cfsProcs].addVar(name = "gEnv", typ = ptrType(ptrType("char")))
+      m.s[cfsProcs].addVar(name = "gEnv", typ = ptrType(ptrType(CChar)))
  m.s[cfsProcs].addDeclWithVisibility(Private):
-    m.s[cfsProcs].addProcHeader(m.config.nimMainPrefix & "PreMain", "void", cProcParams())
+    m.s[cfsProcs].addProcHeader(m.config.nimMainPrefix & "PreMain", CVoid, cProcParams())
    m.s[cfsProcs].finishProcHeaderWithBody():
      if isInnerMainVolatile(m):
-        m.s[cfsProcs].addProcVar(name = "inner", rettype = "void", params = cProcParams(), isVolatile = true)
+        m.s[cfsProcs].addProcVar(name = "inner", rettype = CVoid, params = cProcParams(), isVolatile = true)
        m.s[cfsProcs].addAssignment("inner", m.config.nimMainPrefix & "PreMainInner")
        m.s[cfsProcs].add(extract(m.g.mainDatInit))
        m.s[cfsProcs].addCallStmt(cDeref("inner"))
@@ -1681,7 +1681,7 @@ proc genMainProcsWithResult(m: BModule) =

 proc genNimMainInner(m: BModule) =
  m.s[cfsProcs].addDeclWithVisibility(Private):
-    m.s[cfsProcs].addProcHeader(ccCDecl, m.config.nimMainPrefix & "NimMainInner", "void", cProcParams())
+    m.s[cfsProcs].addProcHeader(ccCDecl, m.config.nimMainPrefix & "NimMainInner", CVoid, cProcParams())
    m.s[cfsProcs].finishProcHeaderWithBody():
      m.s[cfsProcs].add(extract(m.g.mainModInit))
  m.s[cfsProcs].addNewline()
@@ -1690,20 +1690,20 @@ proc initStackBottom(m: BModule): bool =
  not (m.config.target.targetOS == osStandalone or m.config.selectedGC in {gcNone, gcArc, gcAtomicArc, gcOrc})

 proc genNimMainProc(m: BModule, preMainCode: Snippet) =
-  m.s[cfsProcs].addProcHeader(ccCDecl, m.config.nimMainPrefix & "NimMain", "void", cProcParams())
+  m.s[cfsProcs].addProcHeader(ccCDecl, m.config.nimMainPrefix & "NimMain", CVoid, cProcParams())
  m.s[cfsProcs].finishProcHeaderWithBody():
    if isInnerMainVolatile(m):
-      m.s[cfsProcs].addProcVar(name = "inner", rettype = "void", params = cProcParams(), isVolatile = true)
+      m.s[cfsProcs].addProcVar(name = "inner", rettype = CVoid, params = cProcParams(), isVolatile = true)
      m.s[cfsProcs].add(preMainCode)
      m.s[cfsProcs].addAssignment("inner", m.config.nimMainPrefix & "NimMainInner")
      if initStackBottom(m):
-        m.s[cfsProcs].addCallStmt("initStackBottomWith", cCast("void*", cAddr("inner")))
+        m.s[cfsProcs].addCallStmt("initStackBottomWith", cCast(CPointer, cAddr("inner")))
      m.s[cfsProcs].addCallStmt(cDeref("inner"))
    else:
      # not volatile
      m.s[cfsProcs].add(preMainCode)
      if initStackBottom(m):
-        m.s[cfsProcs].addCallStmt("initStackBottomWith", cCast("void*", cAddr("inner")))
+        m.s[cfsProcs].addCallStmt("initStackBottomWith", cCast(CPointer, cAddr("inner")))
      m.s[cfsProcs].addCallStmt(m.config.nimMainPrefix & "NimMainInner")
  m.s[cfsProcs].addNewline()

@@ -1712,10 +1712,10 @@ proc genNimMainBody(m: BModule, preMainCode: Snippet) =
  genNimMainProc(m, preMainCode)

 proc genPosixCMain(m: BModule) =
-  m.s[cfsProcs].addProcHeader("main", "int", cProcParams(
-    (name: "argc", typ: "int"),
-    (name: "args", typ: ptrType(ptrType("char"))),
-    (name: "env", typ: ptrType(ptrType("char")))))
+  m.s[cfsProcs].addProcHeader("main", CInt, cProcParams(
+    (name: "argc", typ: CInt),
+    (name: "args", typ: ptrType(ptrType(CChar))),
+    (name: "env", typ: ptrType(ptrType(CChar)))))
  m.s[cfsProcs].finishProcHeaderWithBody():
    m.s[cfsProcs].addAssignment("cmdLine", "args")
    m.s[cfsProcs].addAssignment("cmdCount", "argc")
@@ -1724,7 +1724,7 @@ proc genPosixCMain(m: BModule) =
  m.s[cfsProcs].addNewline()

 proc genStandaloneCMain(m: BModule) =
-  m.s[cfsProcs].addProcHeader("main", "int", cProcParams())
+  m.s[cfsProcs].addProcHeader("main", CInt, cProcParams())
  m.s[cfsProcs].finishProcHeaderWithBody():
    genMainProcs(m)
    m.s[cfsProcs].addReturn(cIntValue(0))
@@ -1734,11 +1734,11 @@ proc genWinNimMain(m: BModule, preMainCode: Snippet) =
  genNimMainBody(m, preMainCode)

 proc genWinCMain(m: BModule) =
-  m.s[cfsProcs].addProcHeader(ccStdCall, "WinMain", "int", cProcParams(
+  m.s[cfsProcs].addProcHeader(ccStdCall, "WinMain", CInt, cProcParams(
    (name: "hCurInstance", typ: "HINSTANCE"),
    (name: "hPrevInstance", typ: "HINSTANCE"),
    (name: "lpCmdLine", typ: "LPSTR"),
-    (name: "nCmdShow", typ: "int")))
+    (name: "nCmdShow", typ: CInt)))
  m.s[cfsProcs].finishProcHeaderWithBody():
    genMainProcsWithResult(m)
  m.s[cfsProcs].addNewline()
@@ -1765,7 +1765,7 @@ proc genPosixNimDllMain(m: BModule, preMainCode: Snippet) =

 proc genPosixCDllMain(m: BModule) =
  # used to use NIM_POSIX_INIT, now uses direct constructor attribute
-  m.s[cfsProcs].addProcHeader("NimMainInit", "void", cProcParams(), isConstructor = true)
+  m.s[cfsProcs].addProcHeader("NimMainInit", CVoid, cProcParams(), isConstructor = true)
  m.s[cfsProcs].finishProcHeaderWithBody():
    genMainProcs(m)
  m.s[cfsProcs].addNewline()
@@ -1775,14 +1775,14 @@ proc genGenodeNimMain(m: BModule, preMainCode: Snippet) =
  m.s[cfsProcs].addDeclWithVisibility(Extern):
    m.s[cfsProcs].addVar(name = "nim_runtime_env", typ = ptrType(typName))
  m.s[cfsProcs].addDeclWithVisibility(ExternC):
-    m.s[cfsProcs].addProcHeader("nim_component_construct", "void", cProcParams((name: "", typ: ptrType(typName))))
+    m.s[cfsProcs].addProcHeader("nim_component_construct", CVoid, cProcParams((name: "", typ: ptrType(typName))))
    m.s[cfsProcs].finishProcHeaderAsProto()
  genNimMainBody(m, preMainCode)

 proc genComponentConstruct(m: BModule) =
  let fnName = "Libc::Component::construct"
  let typName = "Libc::Env"
-  m.s[cfsProcs].addProcHeader(fnName, "void", cProcParams((name: "env", typ: cppRefType(typName))))
+  m.s[cfsProcs].addProcHeader(fnName, CVoid, cProcParams((name: "env", typ: cppRefType(typName))))
  m.s[cfsProcs].finishProcHeaderWithBody():
    m.s[cfsProcs].addLineComment("Set Env used during runtime initialization")
    m.s[cfsProcs].addAssignment("nim_runtime_env", cAddr("env"))
@@ -1820,11 +1820,11 @@ proc genMainProc(m: BModule) =
    if m.config.selectedGC in {gcArc, gcAtomicArc, gcOrc}:
      preMainBuilder.addCallStmt(m.config.nimMainPrefix & "PreMain")
    else:
-      preMainBuilder.addVar(name = "rtl_handle", typ = "void*")
+      preMainBuilder.addVar(name = "rtl_handle", typ = CPointer)
      loadLib(preMainBuilder, "rtl_handle", "nimGC_setStackBottom")
      hcrGetProcLoadCode(preMainBuilder, m, "nimGC_setStackBottom", "nimrtl_", "rtl_handle", "nimGetProcAddr")
      preMainBuilder.addAssignment("inner", m.config.nimMainPrefix & "PreMain")
-      preMainBuilder.addCallStmt("initStackBottomWith_actual", cCast("void*", cAddr("inner")))
+      preMainBuilder.addCallStmt("initStackBottomWith_actual", cCast(CPointer, cAddr("inner")))
      preMainBuilder.addCallStmt(cDeref("inner"))
  else:
    preMainBuilder.addCallStmt(m.config.nimMainPrefix & "PreMain")
@@ -1883,13 +1883,13 @@ proc registerInitProcs*(g: BModuleList; m: PSym; flags: set[ModuleBackendFlag])
  if HasDatInitProc in flags:
    let datInit = getSomeNameForModule(g.config, g.config.toFullPath(m.info.fileIndex).AbsoluteFile) & "DatInit000"
    g.mainModProcs.addDeclWithVisibility(Private):
-      g.mainModProcs.addProcHeader(ccNimCall, datInit, "void", cProcParams())
+      g.mainModProcs.addProcHeader(ccNimCall, datInit, CVoid, cProcParams())
      g.mainModProcs.finishProcHeaderAsProto()
    g.mainDatInit.addCallStmt(datInit)
  if HasModuleInitProc in flags:
    let init = getSomeNameForModule(g.config, g.config.toFullPath(m.info.fileIndex).AbsoluteFile) & "Init000"
    g.mainModProcs.addDeclWithVisibility(Private):
-      g.mainModProcs.addProcHeader(ccNimCall, init, "void", cProcParams())
+      g.mainModProcs.addProcHeader(ccNimCall, init, CVoid, cProcParams())
      g.mainModProcs.finishProcHeaderAsProto()
    if sfMainModule in m.flags:
      g.mainModInit.addCallStmt(init)
@@ -1920,7 +1920,7 @@ proc registerModuleToMain(g: BModuleList; m: BModule) =
    hcrModuleMeta.addDeclWithVisibility(Private):
      hcrModuleMeta.addArrayVarWithInitializer(kind = Local,
          name = "hcr_module_list",
-          elementType = ptrConstType("char"),
+          elementType = ptrConstType(CChar),
          len = g.graph.importDeps.getOrDefault(FileIndex(m.module.position)).len +
            ord(sfMainModule in m.module.flags) +
            1):
@@ -1936,38 +1936,38 @@ proc registerModuleToMain(g: BModuleList; m: BModule) =
          hcrModuleMeta.addField(modules, ""):
            hcrModuleMeta.add("\"\"")
    hcrModuleMeta.addDeclWithVisibility(ExportLib):
-      hcrModuleMeta.addProcHeader(ccNimCall, "HcrGetImportedModules", "void**", cProcParams())
+      hcrModuleMeta.addProcHeader(ccNimCall, "HcrGetImportedModules", ptrType(CPointer), cProcParams())
      hcrModuleMeta.finishProcHeaderWithBody():
-        hcrModuleMeta.addReturn(cCast("void**", "hcr_module_list"))
+        hcrModuleMeta.addReturn(cCast(ptrType(CPointer), "hcr_module_list"))
    hcrModuleMeta.addDeclWithVisibility(ExportLib):
-      hcrModuleMeta.addProcHeader(ccNimCall, "HcrGetSigHash", ptrType("char"), cProcParams())
+      hcrModuleMeta.addProcHeader(ccNimCall, "HcrGetSigHash", ptrType(CChar), cProcParams())
      hcrModuleMeta.finishProcHeaderWithBody():
        hcrModuleMeta.addReturn('"' & $sigHash(m.module, m.config) & '"')
    if sfMainModule in m.module.flags:
      g.mainModProcs.add(extract(hcrModuleMeta))
      g.mainModProcs.addDeclWithVisibility(StaticProc):
-        g.mainModProcs.addVar(name = "hcr_handle", typ = "void*")
+        g.mainModProcs.addVar(name = "hcr_handle", typ = CPointer)
      g.mainModProcs.addDeclWithVisibility(ExportLib):
-        g.mainModProcs.addProcHeader(ccNimCall, init, "void", cProcParams())
+        g.mainModProcs.addProcHeader(ccNimCall, init, CVoid, cProcParams())
        g.mainModProcs.finishProcHeaderAsProto()
      g.mainModProcs.addDeclWithVisibility(ExportLib):
-        g.mainModProcs.addProcHeader(ccNimCall, datInit, "void", cProcParams())
+        g.mainModProcs.addProcHeader(ccNimCall, datInit, CVoid, cProcParams())
        g.mainModProcs.finishProcHeaderAsProto()
      g.mainModProcs.addDeclWithVisibility(ExportLib):
-        g.mainModProcs.addProcHeaderWithParams(ccNimCall, m.getHcrInitName, "void"):
+        g.mainModProcs.addProcHeaderWithParams(ccNimCall, m.getHcrInitName, CVoid):
          var hcrInitParams: ProcParamBuilder
          g.mainModProcs.addProcParams(hcrInitParams):
-            g.mainModProcs.addUnnamedParam(hcrInitParams, "void*")
-            g.mainModProcs.addProcTypedParam(hcrInitParams, ccNimCall, "getProcAddr", "void*", cProcParams(
-              (name: "", typ: "void*"),
-              (name: "", typ: ptrType("char"))))
+            g.mainModProcs.addUnnamedParam(hcrInitParams, CPointer)
+            g.mainModProcs.addProcTypedParam(hcrInitParams, ccNimCall, "getProcAddr", CPointer, cProcParams(
+              (name: "", typ: CPointer),
+              (name: "", typ: ptrType(CChar))))
        g.mainModProcs.finishProcHeaderAsProto()
      g.mainModProcs.addDeclWithVisibility(ExportLib):
-        g.mainModProcs.addProcHeader(ccNimCall, "HcrCreateTypeInfos", "void", cProcParams())
+        g.mainModProcs.addProcHeader(ccNimCall, "HcrCreateTypeInfos", CVoid, cProcParams())
        g.mainModProcs.finishProcHeaderAsProto()
      g.mainModInit.addCallStmt(init)
      g.otherModsInit.addCallStmt("hcrInit",
-        cCast("void**", "hcr_module_list"),
+        cCast(ptrType(CPointer), "hcr_module_list"),
        mainModulePath,
        systemModulePath,
        datInit,
@@ -1984,22 +1984,22 @@ proc registerModuleToMain(g: BModuleList; m: BModule) =
      # bug #16265.
      let osModulePath = ($systemModulePath).replace("stdlib_system", "stdlib_os").rope
      g.mainDatInit.addCallStmt("hcrAddModule", osModulePath)
-      let cmdCountTyp = ptrType("int")
-      let cmdLineTyp = ptrType(ptrType(ptrType("char")))
+      let cmdCountTyp = ptrType(CInt)
+      let cmdLineTyp = ptrType(ptrType(ptrType(CChar)))
      g.mainDatInit.addVar(name = "cmd_count", typ = cmdCountTyp)
      g.mainDatInit.addVar(name = "cmd_line", typ = cmdLineTyp)
      g.mainDatInit.addCallStmt("hcrRegisterGlobal",
        osModulePath,
        "\"cmdCount\"",
        cSizeof(cmdCountTyp),
-        "NULL",
-        cCast("void**", cAddr("cmd_count")))
+        CNil,
+        cCast(ptrType(CPointer), cAddr("cmd_count")))
      g.mainDatInit.addCallStmt("hcrRegisterGlobal",
        osModulePath,
        "\"cmdLine\"",
        cSizeof(cmdLineTyp),
-        "NULL",
-        cCast("void**", cAddr("cmd_line")))
+        CNil,
+        cCast(ptrType(CPointer), cAddr("cmd_line")))
      g.mainDatInit.addAssignment(cDeref("cmd_count"), "cmdCount")
      g.mainDatInit.addAssignment(cDeref("cmd_line"), "cmdLine")
    else:
@@ -2008,7 +2008,7 @@ proc registerModuleToMain(g: BModuleList; m: BModule) =

  if m.s[cfsDatInitProc].buf.len > 0:
    g.mainModProcs.addDeclWithVisibility(Private):
-      g.mainModProcs.addProcHeader(ccNimCall, datInit, "void", cProcParams())
+      g.mainModProcs.addProcHeader(ccNimCall, datInit, CVoid, cProcParams())
      g.mainModProcs.finishProcHeaderAsProto()
    g.mainDatInit.addCallStmt(datInit)

@@ -2019,11 +2019,11 @@ proc registerModuleToMain(g: BModuleList; m: BModule) =
      g.mainDatInit.addCallStmt(cgsymValue(m, "initThreadVarsEmulation"))
    if m.config.target.targetOS != osStandalone and m.config.selectedGC notin {gcNone, gcArc, gcAtomicArc, gcOrc}:
      g.mainDatInit.addCallStmt(cgsymValue(m, "initStackBottomWith"),
-        cCast("void*", cAddr("inner")))
+        cCast(CPointer, cAddr("inner")))

  if m.s[cfsInitProc].buf.len > 0:
    g.mainModProcs.addDeclWithVisibility(Private):
-      g.mainModProcs.addProcHeader(ccNimCall, init, "void", cProcParams())
+      g.mainModProcs.addProcHeader(ccNimCall, init, CVoid, cProcParams())
      g.mainModProcs.finishProcHeaderAsProto()
    if sfMainModule in m.module.flags:
      g.mainModInit.addCallStmt(init)
@@ -2042,7 +2042,7 @@ proc genDatInitCode(m: BModule) =
  var prc = newBuilder("")
  let vis = if m.hcrOn: ExportLib else: Private
  prc.addDeclWithVisibility(vis):
-    prc.addProcHeader(ccNimCall, getDatInitName(m), "void", cProcParams())
+    prc.addProcHeader(ccNimCall, getDatInitName(m), CVoid, cProcParams())
    prc.finishProcHeaderWithBody():
      # we don't want to break into such init code - could happen if a line
      # directive from a function written by the user spills after itself
@@ -2093,9 +2093,9 @@ proc genInitCode(m: BModule) =
      m.s[cfsTypeInit1].addCallStmt("hcrRegisterGlobal",
        getModuleDllPath(m, m.module),
        '"' & m.typeNodesName & '_' & $m.typeNodes & '"',
-        cOp(Mul, "NI", cSizeof("TNimNode"), cIntValue(m.typeNodes)),
-        "NULL",
-        cCast("void**", cAddr(m.typeNodesName)))
+        cOp(Mul, NimInt, cSizeof("TNimNode"), cIntValue(m.typeNodes)),
+        CNil,
+        cCast(ptrType(CPointer), cAddr(m.typeNodesName)))
    else:
      m.s[cfsTypeInit1].addArrayVar(Global, name = m.typeNodesName,
        elementType = cgsymValue(m, "TNimNode"), len = m.typeNodes)
@@ -2104,14 +2104,14 @@ proc genInitCode(m: BModule) =
      elementType = cgsymValue(m, "TNimType"), len = m.nimTypes)

  if m.hcrOn:
-    prcBody.addVar(name = "nim_hcr_dummy_", typ = ptrType("int"), initializer = cIntValue(0))
-    prcBody.addVar(name = "nim_hcr_do_init_", typ = "NIM_BOOL",
+    prcBody.addVar(name = "nim_hcr_dummy_", typ = ptrType(CInt), initializer = cIntValue(0))
+    prcBody.addVar(name = "nim_hcr_do_init_", typ = NimBool,
      initializer = cCall("hcrRegisterGlobal",
        getModuleDllPath(m, m.module),
        "\"module_initialized_\"",
        cIntValue(1),
-        "NULL",
-        cCast("void**", cAddr("nim_hcr_dummy_"))))
+        CNil,
+        cCast(ptrType(CPointer), cAddr("nim_hcr_dummy_"))))

  template writeSection(thing: untyped, section: TCProcSection, addHcrGuards = false) =
    if m.thing.s(section).buf.len > 0:
@@ -2173,7 +2173,7 @@ proc genInitCode(m: BModule) =
  var procs = newBuilder("")
  let vis = if m.hcrOn: ExportLib else: Private
  procs.addDeclWithVisibility(vis):
-    procs.addProcHeader(ccNimCall, initname, "void", cProcParams())
+    procs.addProcHeader(ccNimCall, initname, CVoid, cProcParams())
    procs.finishProcHeaderWithBody():
      procs.add(extract(prcBody))

@@ -2185,13 +2185,13 @@ proc genInitCode(m: BModule) =
    var procsToLoad = @["hcrRegisterProc", "hcrGetProc", "hcrRegisterGlobal", "hcrGetGlobal"]

    m.s[cfsInitProc].addDeclWithVisibility(ExportLib):
-      m.s[cfsInitProc].addProcHeaderWithParams(ccNimCall, getHcrInitName(m), "void"):
+      m.s[cfsInitProc].addProcHeaderWithParams(ccNimCall, getHcrInitName(m), CVoid):
        var hcrInitParams: ProcParamBuilder
        m.s[cfsInitProc].addProcParams(hcrInitParams):
-          m.s[cfsInitProc].addParam(hcrInitParams, "handle", "void*")
-          m.s[cfsInitProc].addProcTypedParam(hcrInitParams, ccNimCall, "getProcAddr", "void*", cProcParams(
-            (name: "", typ: "void*"),
-            (name: "", typ: ptrType("char"))))
+          m.s[cfsInitProc].addParam(hcrInitParams, "handle", CPointer)
+          m.s[cfsInitProc].addProcTypedParam(hcrInitParams, ccNimCall, "getProcAddr", CPointer, cProcParams(
+            (name: "", typ: CPointer),
+            (name: "", typ: ptrType(CChar))))
      m.s[cfsInitProc].finishProcHeaderWithBody():
        if sfMainModule in m.module.flags:
          # additional procs to load
@@ -2205,7 +2205,7 @@ proc genInitCode(m: BModule) =
    if el.buf.len != 0:
      moduleInitRequired = true
      procs.addDeclWithVisibility(ExternC):
-        procs.addProcHeader(ccNimCall, "nimLoadProcs" & $(i.ord - '0'.ord), "void", cProcParams())
+        procs.addProcHeader(ccNimCall, "nimLoadProcs" & $(i.ord - '0'.ord), CVoid, cProcParams())
        procs.finishProcHeaderWithBody():
          procs.add(extract(el))

@@ -2217,7 +2217,7 @@ proc genInitCode(m: BModule) =

  if m.hcrOn:
    m.s[cfsInitProc].addDeclWithVisibility(ExportLib):
-      m.s[cfsInitProc].addProcHeader(ccNimCall, "HcrCreateTypeInfos", "void", cProcParams())
+      m.s[cfsInitProc].addProcHeader(ccNimCall, "HcrCreateTypeInfos", CVoid, cProcParams())
      m.s[cfsInitProc].finishProcHeaderWithBody():
        m.s[cfsInitProc].add(extract(m.hcrCreateTypeInfosProc))
    m.s[cfsInitProc].addNewline()
@@ -2376,7 +2376,7 @@ proc writeHeader(m: BModule) =

  let vis = if optGenDynLib in m.config.globalOptions: ImportLib else: None
  result.addDeclWithVisibility(vis):
-    result.addProcHeader(ccCDecl, m.config.nimMainPrefix & "NimMain", "void", cProcParams())
+    result.addProcHeader(ccCDecl, m.config.nimMainPrefix & "NimMain", CVoid, cProcParams())
    result.finishProcHeaderAsProto()
  if m.config.cppCustomNamespace.len > 0: closeNamespaceNim(result)
  result.addf("#endif /* $1 */$n", [guard])