diff options
Diffstat (limited to 'rod/ccgexprs.nim')
| -rwxr-xr-x | rod/ccgexprs.nim | 1816 |
1 files changed, 1816 insertions, 0 deletions
diff --git a/rod/ccgexprs.nim b/rod/ccgexprs.nim new file mode 100755 index 000000000..1060c2343 --- /dev/null +++ b/rod/ccgexprs.nim @@ -0,0 +1,1816 @@ +# +# +# The Nimrod Compiler +# (c) Copyright 2009 Andreas Rumpf +# +# See the file "copying.txt", included in this +# distribution, for details about the copyright. +# + +# -------------------------- constant expressions ------------------------ + +proc intLiteral(i: biggestInt): PRope = + if (i > low(int32)) and (i <= high(int32)): + result = toRope(i) + elif i == low(int32): # Nimrod has the same bug for the same reasons :-) + result = toRope("(-2147483647 -1)") + elif i > low(int64): + result = ropef("IL64($1)", [toRope(i)]) + else: + result = toRope("(IL64(-9223372036854775807) - IL64(1))") + +proc int32Literal(i: Int): PRope = + if i == int(low(int32)): + result = toRope("(-2147483647 -1)") + else: + result = toRope(i) + +proc genHexLiteral(v: PNode): PRope = + # hex literals are unsigned in C + # so we don't generate hex literals any longer. + if not (v.kind in {nkIntLit..nkInt64Lit}): + internalError(v.info, "genHexLiteral") + result = intLiteral(v.intVal) + +proc getStrLit(m: BModule, s: string): PRope = + useMagic(m, "TGenericSeq") + result = con("TMP", toRope(getID())) + appf(m.s[cfsData], "STRING_LITERAL($1, $2, $3);$n", + [result, makeCString(s), ToRope(len(s))]) + +proc genLiteral(p: BProc, v: PNode, ty: PType): PRope = + var + f: biggestFloat + id: int + if ty == nil: internalError(v.info, "genLiteral: ty is nil") + case v.kind + of nkCharLit..nkInt64Lit: + case skipTypes(ty, abstractVarRange).kind + of tyChar, tyInt64, tyNil: + result = intLiteral(v.intVal) + of tyInt8: + result = ropef("((NI8) $1)", [intLiteral(biggestInt(int8(v.intVal)))]) + of tyInt16: + result = ropef("((NI16) $1)", [intLiteral(biggestInt(int16(v.intVal)))]) + of tyInt32: + result = ropef("((NI32) $1)", [intLiteral(biggestInt(int32(v.intVal)))]) + of tyInt: + if (v.intVal >= low(int32)) and (v.intVal <= high(int32)): + result = int32Literal(int32(v.intVal)) + else: + result = intLiteral(v.intVal) + of tyBool: + if v.intVal != 0: result = toRope("NIM_TRUE") + else: result = toRope("NIM_FALSE") + else: + result = ropef("(($1) $2)", [getTypeDesc(p.module, + skipTypes(ty, abstractVarRange)), intLiteral(v.intVal)]) + of nkNilLit: + result = toRope("0") + of nkStrLit..nkTripleStrLit: + if skipTypes(ty, abstractVarRange).kind == tyString: + id = NodeTableTestOrSet(p.module.dataCache, v, gid) + if id == gid: + # string literal not found in the cache: + useMagic(p.module, "NimStringDesc") + result = ropef("((NimStringDesc*) &$1)", [getStrLit(p.module, v.strVal)]) + else: + result = ropef("((NimStringDesc*) &TMP$1)", [toRope(id)]) + else: + result = makeCString(v.strVal) + of nkFloatLit..nkFloat64Lit: + f = v.floatVal + if f != f: + result = toRope("NAN") + elif f == 0.0: + result = toRopeF(f) + elif f == 0.5 * f: + if f > 0.0: result = toRope("INF") + else: result = toRope("-INF") + else: + result = toRopeF(f) + else: + InternalError(v.info, "genLiteral(" & $v.kind & ')') + result = nil + +proc genLiteral(p: BProc, v: PNode): PRope = + result = genLiteral(p, v, v.typ) + +proc bitSetToWord(s: TBitSet, size: int): BiggestInt = + result = 0 + if CPU[platform.hostCPU].endian == CPU[targetCPU].endian: + for j in countup(0, size - 1): + if j < len(s): result = result or `shl`(Ze64(s[j]), j * 8) + else: + for j in countup(0, size - 1): + if j < len(s): result = result or `shl`(Ze64(s[j]), (Size - 1 - j) * 8) + +proc genRawSetData(cs: TBitSet, size: int): PRope = + var frmt: TFormatStr + if size > 8: + result = toRope('{' & tnl) + for i in countup(0, size - 1): + if i < size - 1: + # not last iteration? + if (i + 1) mod 8 == 0: frmt = "0x$1,$n" + else: frmt = "0x$1, " + else: + frmt = "0x$1}$n" + appf(result, frmt, [toRope(toHex(Ze64(cs[i]), 2))]) + else: + result = intLiteral(bitSetToWord(cs, size)) # result := toRope('0x' + ToHex(bitSetToWord(cs, size), size * 2)) + +proc genSetNode(p: BProc, n: PNode): PRope = + var + cs: TBitSet + size, id: int + size = int(getSize(n.typ)) + toBitSet(n, cs) + if size > 8: + id = NodeTableTestOrSet(p.module.dataCache, n, gid) + result = con("TMP", toRope(id)) + if id == gid: + # not found in cache: + inc(gid) + appf(p.module.s[cfsData], "static NIM_CONST $1 $2 = $3;", + [getTypeDesc(p.module, n.typ), result, genRawSetData(cs, size)]) + else: + result = genRawSetData(cs, size) + +proc getStorageLoc(n: PNode): TStorageLoc = + case n.kind + of nkSym: + case n.sym.kind + of skParam, skForVar, skTemp: + result = OnStack + of skVar: + if sfGlobal in n.sym.flags: result = OnHeap + else: result = OnStack + else: result = OnUnknown + of nkDerefExpr, nkHiddenDeref: + case n.sons[0].typ.kind + of tyVar: result = OnUnknown + of tyPtr: result = OnStack + of tyRef: result = OnHeap + else: InternalError(n.info, "getStorageLoc") + of nkBracketExpr, nkDotExpr, nkObjDownConv, nkObjUpConv: + result = getStorageLoc(n.sons[0]) + else: result = OnUnknown + +proc rdLoc(a: TLoc): PRope = + # 'read' location (deref if indirect) + result = a.r + if lfIndirect in a.flags: result = ropef("(*$1)", [result]) + +proc addrLoc(a: TLoc): PRope = + result = a.r + if not (lfIndirect in a.flags): result = con("&", result) + +proc rdCharLoc(a: TLoc): PRope = + # read a location that may need a char-cast: + result = rdLoc(a) + if skipTypes(a.t, abstractRange).kind == tyChar: + result = ropef("((NU8)($1))", [result]) + +type + TAssignmentFlag = enum + needToCopy, needForSubtypeCheck, afDestIsNil, afDestIsNotNil, afSrcIsNil, + afSrcIsNotNil + TAssignmentFlags = set[TAssignmentFlag] + +proc genRefAssign(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) = + if (dest.s == OnStack) or not (optRefcGC in gGlobalOptions): + appf(p.s[cpsStmts], "$1 = $2;$n", [rdLoc(dest), rdLoc(src)]) + elif dest.s == OnHeap: + # location is on heap + # now the writer barrier is inlined for performance: + # + # if afSrcIsNotNil in flags then begin + # UseMagic(p.module, 'nimGCref'); + # appf(p.s[cpsStmts], 'nimGCref($1);$n', [rdLoc(src)]); + # end + # else if not (afSrcIsNil in flags) then begin + # UseMagic(p.module, 'nimGCref'); + # appf(p.s[cpsStmts], 'if ($1) nimGCref($1);$n', [rdLoc(src)]); + # end; + # if afDestIsNotNil in flags then begin + # UseMagic(p.module, 'nimGCunref'); + # appf(p.s[cpsStmts], 'nimGCunref($1);$n', [rdLoc(dest)]); + # end + # else if not (afDestIsNil in flags) then begin + # UseMagic(p.module, 'nimGCunref'); + # appf(p.s[cpsStmts], 'if ($1) nimGCunref($1);$n', [rdLoc(dest)]); + # end; + # appf(p.s[cpsStmts], '$1 = $2;$n', [rdLoc(dest), rdLoc(src)]); + if canFormAcycle(dest.t): + UseMagic(p.module, "asgnRef") + appf(p.s[cpsStmts], "asgnRef((void**) $1, $2);$n", + [addrLoc(dest), rdLoc(src)]) + else: + UseMagic(p.module, "asgnRefNoCycle") + appf(p.s[cpsStmts], "asgnRefNoCycle((void**) $1, $2);$n", + [addrLoc(dest), rdLoc(src)]) + else: + UseMagic(p.module, "unsureAsgnRef") + appf(p.s[cpsStmts], "unsureAsgnRef((void**) $1, $2);$n", + [addrLoc(dest), rdLoc(src)]) + +proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) = + # This function replaces all other methods for generating + # the assignment operation in C. + var ty: PType + ty = skipTypes(dest.t, abstractVarRange) + case ty.kind + of tyRef: + genRefAssign(p, dest, src, flags) + of tySequence: + if not (needToCopy in flags): + genRefAssign(p, dest, src, flags) + else: + useMagic(p.module, "genericSeqAssign") # BUGFIX + appf(p.s[cpsStmts], "genericSeqAssign($1, $2, $3);$n", + [addrLoc(dest), rdLoc(src), genTypeInfo(p.module, dest.t)]) + of tyString: + if not (needToCopy in flags): + genRefAssign(p, dest, src, flags) + else: + useMagic(p.module, "copyString") + if (dest.s == OnStack) or not (optRefcGC in gGlobalOptions): + appf(p.s[cpsStmts], "$1 = copyString($2);$n", [rdLoc(dest), rdLoc(src)]) + elif dest.s == OnHeap: + useMagic(p.module, "asgnRefNoCycle") + useMagic(p.module, "copyString") # BUGFIX + appf(p.s[cpsStmts], "asgnRefNoCycle((void**) $1, copyString($2));$n", + [addrLoc(dest), rdLoc(src)]) + else: + useMagic(p.module, "unsureAsgnRef") + useMagic(p.module, "copyString") # BUGFIX + appf(p.s[cpsStmts], "unsureAsgnRef((void**) $1, copyString($2));$n", + [addrLoc(dest), rdLoc(src)]) + of tyTuple: + if needsComplexAssignment(dest.t): + useMagic(p.module, "genericAssign") + appf(p.s[cpsStmts], "genericAssign((void*)$1, (void*)$2, $3);$n", + [addrLoc(dest), addrLoc(src), genTypeInfo(p.module, dest.t)]) + else: + appf(p.s[cpsStmts], "$1 = $2;$n", [rdLoc(dest), rdLoc(src)]) + of tyArray, tyArrayConstr: + if needsComplexAssignment(dest.t): + useMagic(p.module, "genericAssign") + appf(p.s[cpsStmts], "genericAssign((void*)$1, (void*)$2, $3);$n", + [addrLoc(dest), addrLoc(src), genTypeInfo(p.module, dest.t)]) + else: + appf(p.s[cpsStmts], + "memcpy((void*)$1, (NIM_CONST void*)$2, sizeof($1));$n", + [rdLoc(dest), rdLoc(src)]) + of tyObject: # XXX: check for subtyping? + if needsComplexAssignment(dest.t): + useMagic(p.module, "genericAssign") + appf(p.s[cpsStmts], "genericAssign((void*)$1, (void*)$2, $3);$n", + [addrLoc(dest), addrLoc(src), genTypeInfo(p.module, dest.t)]) + else: + appf(p.s[cpsStmts], "$1 = $2;$n", [rdLoc(dest), rdLoc(src)]) + of tyOpenArray: + # open arrays are always on the stack - really? What if a sequence is + # passed to an open array? + if needsComplexAssignment(dest.t): + useMagic(p.module, "genericAssignOpenArray") + appf(p.s[cpsStmts], # XXX: is this correct for arrays? + "genericAssignOpenArray((void*)$1, (void*)$2, $1Len0, $3);$n", + [addrLoc(dest), addrLoc(src), genTypeInfo(p.module, dest.t)]) + else: + appf(p.s[cpsStmts], + "memcpy((void*)$1, (NIM_CONST void*)$2, sizeof($1[0])*$1Len0);$n", + [rdLoc(dest), rdLoc(src)]) + of tySet: + if mapType(ty) == ctArray: + appf(p.s[cpsStmts], "memcpy((void*)$1, (NIM_CONST void*)$2, $3);$n", + [rdLoc(dest), rdLoc(src), toRope(getSize(dest.t))]) + else: + appf(p.s[cpsStmts], "$1 = $2;$n", [rdLoc(dest), rdLoc(src)]) + of tyPtr, tyPointer, tyChar, tyBool, tyProc, tyEnum, tyCString, + tyInt..tyFloat128, tyRange: + appf(p.s[cpsStmts], "$1 = $2;$n", [rdLoc(dest), rdLoc(src)]) + else: InternalError("genAssignment(" & $ty.kind & ')') + +proc expr(p: BProc, e: PNode, d: var TLoc) +proc initLocExpr(p: BProc, e: PNode, result: var TLoc) = + initLoc(result, locNone, getUniqueType(e.typ), OnUnknown) + expr(p, e, result) + +proc getDestLoc(p: BProc, d: var TLoc, typ: PType) = + if d.k == locNone: getTemp(p, typ, d) + +proc putLocIntoDest(p: BProc, d: var TLoc, s: TLoc) = + if d.k != locNone: + if lfNoDeepCopy in d.flags: genAssignment(p, d, s, {}) + else: genAssignment(p, d, s, {needToCopy}) + else: + d = s # ``d`` is free, so fill it with ``s`` + +proc putIntoDest(p: BProc, d: var TLoc, t: PType, r: PRope) = + var a: TLoc + if d.k != locNone: + # need to generate an assignment here + initLoc(a, locExpr, getUniqueType(t), OnUnknown) + a.r = r + if lfNoDeepCopy in d.flags: genAssignment(p, d, a, {}) + else: genAssignment(p, d, a, {needToCopy}) + else: + # we cannot call initLoc() here as that would overwrite + # the flags field! + d.k = locExpr + d.t = getUniqueType(t) + d.r = r + d.a = - 1 + +proc binaryStmt(p: BProc, e: PNode, d: var TLoc, magic, frmt: string) = + var a, b: TLoc + if (d.k != locNone): InternalError(e.info, "binaryStmt") + if magic != "": useMagic(p.module, magic) + InitLocExpr(p, e.sons[1], a) + InitLocExpr(p, e.sons[2], b) + appf(p.s[cpsStmts], frmt, [rdLoc(a), rdLoc(b)]) + +proc unaryStmt(p: BProc, e: PNode, d: var TLoc, magic, frmt: string) = + var a: TLoc + if (d.k != locNone): InternalError(e.info, "unaryStmt") + if magic != "": useMagic(p.module, magic) + InitLocExpr(p, e.sons[1], a) + appf(p.s[cpsStmts], frmt, [rdLoc(a)]) + +proc binaryStmtChar(p: BProc, e: PNode, d: var TLoc, magic, frmt: string) = + var a, b: TLoc + if (d.k != locNone): InternalError(e.info, "binaryStmtChar") + if magic != "": useMagic(p.module, magic) + InitLocExpr(p, e.sons[1], a) + InitLocExpr(p, e.sons[2], b) + appf(p.s[cpsStmts], frmt, [rdCharLoc(a), rdCharLoc(b)]) + +proc binaryExpr(p: BProc, e: PNode, d: var TLoc, magic, frmt: string) = + var a, b: TLoc + if magic != "": useMagic(p.module, magic) + assert(e.sons[1].typ != nil) + assert(e.sons[2].typ != nil) + InitLocExpr(p, e.sons[1], a) + InitLocExpr(p, e.sons[2], b) + putIntoDest(p, d, e.typ, ropef(frmt, [rdLoc(a), rdLoc(b)])) + +proc binaryExprChar(p: BProc, e: PNode, d: var TLoc, magic, frmt: string) = + var a, b: TLoc + if magic != "": useMagic(p.module, magic) + assert(e.sons[1].typ != nil) + assert(e.sons[2].typ != nil) + InitLocExpr(p, e.sons[1], a) + InitLocExpr(p, e.sons[2], b) + putIntoDest(p, d, e.typ, ropef(frmt, [rdCharLoc(a), rdCharLoc(b)])) + +proc unaryExpr(p: BProc, e: PNode, d: var TLoc, magic, frmt: string) = + var a: TLoc + if magic != "": useMagic(p.module, magic) + InitLocExpr(p, e.sons[1], a) + putIntoDest(p, d, e.typ, ropef(frmt, [rdLoc(a)])) + +proc unaryExprChar(p: BProc, e: PNode, d: var TLoc, magic, frmt: string) = + var a: TLoc + if magic != "": useMagic(p.module, magic) + InitLocExpr(p, e.sons[1], a) + putIntoDest(p, d, e.typ, ropef(frmt, [rdCharLoc(a)])) + +proc binaryArithOverflow(p: BProc, e: PNode, d: var TLoc, m: TMagic) = + const + prc: array[mAddi..mModi64, string] = ["addInt", "subInt", "mulInt", + "divInt", "modInt", "addInt64", "subInt64", "mulInt64", "divInt64", + "modInt64"] + opr: array[mAddi..mModi64, string] = ["+", "-", "*", "/", "%", "+", "-", + "*", "/", "%"] + var + a, b: TLoc + t: PType + assert(e.sons[1].typ != nil) + assert(e.sons[2].typ != nil) + InitLocExpr(p, e.sons[1], a) + InitLocExpr(p, e.sons[2], b) + t = skipTypes(e.typ, abstractRange) + if getSize(t) >= platform.IntSize: + if optOverflowCheck in p.options: + useMagic(p.module, prc[m]) + putIntoDest(p, d, e.typ, + ropef("$1($2, $3)", [toRope(prc[m]), rdLoc(a), rdLoc(b)])) + else: + putIntoDest(p, d, e.typ, ropef("(NI$4)($2 $1 $3)", [toRope(opr[m]), + rdLoc(a), rdLoc(b), toRope(getSize(t) * 8)])) + else: + if optOverflowCheck in p.options: + useMagic(p.module, "raiseOverflow") + if (m == mModI) or (m == mDivI): + useMagic(p.module, "raiseDivByZero") + appf(p.s[cpsStmts], "if (!$1) raiseDivByZero();$n", [rdLoc(b)]) + a.r = ropef("((NI)($2) $1 (NI)($3))", [toRope(opr[m]), rdLoc(a), rdLoc(b)]) + if d.k == locNone: getTemp(p, getSysType(tyInt), d) + genAssignment(p, d, a, {}) + appf(p.s[cpsStmts], "if ($1 < $2 || $1 > $3) raiseOverflow();$n", + [rdLoc(d), intLiteral(firstOrd(t)), intLiteral(lastOrd(t))]) + d.t = e.typ + d.r = ropef("(NI$1)($2)", [toRope(getSize(t) * 8), rdLoc(d)]) + else: + putIntoDest(p, d, e.typ, ropef("(NI$4)($2 $1 $3)", [toRope(opr[m]), + rdLoc(a), rdLoc(b), toRope(getSize(t) * 8)])) + +proc unaryArithOverflow(p: BProc, e: PNode, d: var TLoc, m: TMagic) = + const + opr: array[mUnaryMinusI..mAbsI64, string] = ["((NI$2)-($1))", # UnaryMinusI + "-($1)", # UnaryMinusI64 + "(NI$2)abs($1)", # AbsI + "($1 > 0? ($1) : -($1))"] # AbsI64 + var + a: TLoc + t: PType + assert(e.sons[1].typ != nil) + InitLocExpr(p, e.sons[1], a) + t = skipTypes(e.typ, abstractRange) + if optOverflowCheck in p.options: + useMagic(p.module, "raiseOverflow") + appf(p.s[cpsStmts], "if ($1 == $2) raiseOverflow();$n", + [rdLoc(a), intLiteral(firstOrd(t))]) + putIntoDest(p, d, e.typ, ropef(opr[m], [rdLoc(a), toRope(getSize(t) * 8)])) + +proc binaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) = + const + binArithTab: array[mShrI..mXor, string] = ["(NI$3)((NU$3)($1) >> (NU$3)($2))", # + # ShrI + "(NI$3)((NU$3)($1) << (NU$3)($2))", # ShlI + "(NI$3)($1 & $2)", # BitandI + "(NI$3)($1 | $2)", # BitorI + "(NI$3)($1 ^ $2)", # BitxorI + "(($1 <= $2) ? $1 : $2)", # MinI + "(($1 >= $2) ? $1 : $2)", # MaxI + "(NI64)((NU64)($1) >> (NU64)($2))", # ShrI64 + "(NI64)((NU64)($1) << (NU64)($2))", # ShlI64 + "($1 & $2)", # BitandI64 + "($1 | $2)", # BitorI64 + "($1 ^ $2)", # BitxorI64 + "(($1 <= $2) ? $1 : $2)", # MinI64 + "(($1 >= $2) ? $1 : $2)", # MaxI64 + "($1 + $2)", # AddF64 + "($1 - $2)", # SubF64 + "($1 * $2)", # MulF64 + "($1 / $2)", # DivF64 + "(($1 <= $2) ? $1 : $2)", # MinF64 + "(($1 >= $2) ? $1 : $2)", # MaxF64 + "(NI$3)((NU$3)($1) + (NU$3)($2))", # AddU + "(NI$3)((NU$3)($1) - (NU$3)($2))", # SubU + "(NI$3)((NU$3)($1) * (NU$3)($2))", # MulU + "(NI$3)((NU$3)($1) / (NU$3)($2))", # DivU + "(NI$3)((NU$3)($1) % (NU$3)($2))", # ModU + "(NI64)((NU64)($1) + (NU64)($2))", # AddU64 + "(NI64)((NU64)($1) - (NU64)($2))", # SubU64 + "(NI64)((NU64)($1) * (NU64)($2))", # MulU64 + "(NI64)((NU64)($1) / (NU64)($2))", # DivU64 + "(NI64)((NU64)($1) % (NU64)($2))", # ModU64 + "($1 == $2)", # EqI + "($1 <= $2)", # LeI + "($1 < $2)", # LtI + "($1 == $2)", # EqI64 + "($1 <= $2)", # LeI64 + "($1 < $2)", # LtI64 + "($1 == $2)", # EqF64 + "($1 <= $2)", # LeF64 + "($1 < $2)", # LtF64 + "((NU$3)($1) <= (NU$3)($2))", # LeU + "((NU$3)($1) < (NU$3)($2))", # LtU + "((NU64)($1) <= (NU64)($2))", # LeU64 + "((NU64)($1) < (NU64)($2))", # LtU64 + "($1 == $2)", # EqEnum + "($1 <= $2)", # LeEnum + "($1 < $2)", # LtEnum + "((NU8)($1) == (NU8)($2))", # EqCh + "((NU8)($1) <= (NU8)($2))", # LeCh + "((NU8)($1) < (NU8)($2))", # LtCh + "($1 == $2)", # EqB + "($1 <= $2)", # LeB + "($1 < $2)", # LtB + "($1 == $2)", # EqRef + "($1 == $2)", # EqProc + "($1 == $2)", # EqPtr + "($1 <= $2)", # LePtr + "($1 < $2)", # LtPtr + "($1 == $2)", # EqCString + "($1 != $2)"] # Xor + var + a, b: TLoc + s: biggestInt + assert(e.sons[1].typ != nil) + assert(e.sons[2].typ != nil) + InitLocExpr(p, e.sons[1], a) + InitLocExpr(p, e.sons[2], b) # BUGFIX: cannot use result-type here, as it may be a boolean + s = max(getSize(a.t), getSize(b.t)) * 8 + putIntoDest(p, d, e.typ, + ropef(binArithTab[op], [rdLoc(a), rdLoc(b), toRope(s)])) + +proc unaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) = + const + unArithTab: array[mNot..mToBiggestInt, string] = ["!($1)", # Not + "$1", # UnaryPlusI + "(NI$2)((NU$2) ~($1))", # BitnotI + "$1", # UnaryPlusI64 + "~($1)", # BitnotI64 + "$1", # UnaryPlusF64 + "-($1)", # UnaryMinusF64 + "($1 > 0? ($1) : -($1))", # AbsF64; BUGFIX: fabs() makes problems + # for Tiny C, so we don't use it + "((NI)(NU)(NU8)($1))", # mZe8ToI + "((NI64)(NU64)(NU8)($1))", # mZe8ToI64 + "((NI)(NU)(NU16)($1))", # mZe16ToI + "((NI64)(NU64)(NU16)($1))", # mZe16ToI64 + "((NI64)(NU64)(NU32)($1))", # mZe32ToI64 + "((NI64)(NU64)(NU)($1))", # mZeIToI64 + "((NI8)(NU8)(NU)($1))", # ToU8 + "((NI16)(NU16)(NU)($1))", # ToU16 + "((NI32)(NU32)(NU64)($1))", # ToU32 + "((double) ($1))", # ToFloat + "((double) ($1))", # ToBiggestFloat + "float64ToInt32($1)", # ToInt XXX: this is not correct! + "float64ToInt64($1)"] # ToBiggestInt + var + a: TLoc + t: PType + assert(e.sons[1].typ != nil) + InitLocExpr(p, e.sons[1], a) + t = skipTypes(e.typ, abstractRange) + putIntoDest(p, d, e.typ, + ropef(unArithTab[op], [rdLoc(a), toRope(getSize(t) * 8)])) + +proc genDeref(p: BProc, e: PNode, d: var TLoc) = + var a: TLoc + if mapType(e.sons[0].typ) == ctArray: + expr(p, e.sons[0], d) + else: + initLocExpr(p, e.sons[0], a) + case skipTypes(a.t, abstractInst).kind + of tyRef: + d.s = OnHeap + of tyVar: + d.s = OnUnknown + of tyPtr: + d.s = OnUnknown # BUGFIX! + else: InternalError(e.info, "genDeref " & $a.t.kind) + putIntoDest(p, d, a.t.sons[0], ropef("(*$1)", [rdLoc(a)])) + +proc genAddr(p: BProc, e: PNode, d: var TLoc) = + var a: TLoc + if mapType(e.sons[0].typ) == ctArray: + expr(p, e.sons[0], d) + else: + InitLocExpr(p, e.sons[0], a) + putIntoDest(p, d, e.typ, addrLoc(a)) + +proc genRecordFieldAux(p: BProc, e: PNode, d, a: var TLoc): PType = + initLocExpr(p, e.sons[0], a) + if (e.sons[1].kind != nkSym): InternalError(e.info, "genRecordFieldAux") + if d.k == locNone: d.s = a.s + discard getTypeDesc(p.module, a.t) # fill the record's fields.loc + result = getUniqueType(a.t) + +proc genRecordField(p: BProc, e: PNode, d: var TLoc) = + var + a: TLoc + f, field: PSym + ty: PType + r: PRope + ty = genRecordFieldAux(p, e, d, a) + r = rdLoc(a) + f = e.sons[1].sym + field = nil + while ty != nil: + if not (ty.kind in {tyTuple, tyObject}): + InternalError(e.info, "genRecordField") + field = lookupInRecord(ty.n, f.name) + if field != nil: break + if gCmd != cmdCompileToCpp: app(r, ".Sup") + ty = GetUniqueType(ty.sons[0]) + if field == nil: InternalError(e.info, "genRecordField") + if field.loc.r == nil: InternalError(e.info, "genRecordField") + appf(r, ".$1", [field.loc.r]) + putIntoDest(p, d, field.typ, r) + +proc genTupleElem(p: BProc, e: PNode, d: var TLoc) = + var + a: TLoc + field: PSym + ty: PType + r: PRope + i: int + initLocExpr(p, e.sons[0], a) + if d.k == locNone: d.s = a.s + discard getTypeDesc(p.module, a.t) # fill the record's fields.loc + ty = getUniqueType(a.t) + r = rdLoc(a) + case e.sons[1].kind + of nkIntLit..nkInt64Lit: i = int(e.sons[1].intVal) + else: internalError(e.info, "genTupleElem") + if ty.n != nil: + field = ty.n.sons[i].sym + if field == nil: InternalError(e.info, "genTupleElem") + if field.loc.r == nil: InternalError(e.info, "genTupleElem") + appf(r, ".$1", [field.loc.r]) + else: + appf(r, ".Field$1", [toRope(i)]) + putIntoDest(p, d, ty.sons[i], r) + +proc genInExprAux(p: BProc, e: PNode, a, b, d: var TLoc) +proc genCheckedRecordField(p: BProc, e: PNode, d: var TLoc) = + var + a, u, v, test: TLoc + f, field, op: PSym + ty: PType + r, strLit: PRope + id: int + it: PNode + if optFieldCheck in p.options: + useMagic(p.module, "raiseFieldError") + useMagic(p.module, "NimStringDesc") + ty = genRecordFieldAux(p, e.sons[0], d, a) + r = rdLoc(a) + f = e.sons[0].sons[1].sym + field = nil + while ty != nil: + assert(ty.kind in {tyTuple, tyObject}) + field = lookupInRecord(ty.n, f.name) + if field != nil: break + if gCmd != cmdCompileToCpp: app(r, ".Sup") + ty = getUniqueType(ty.sons[0]) + if field == nil: InternalError(e.info, "genCheckedRecordField") + if field.loc.r == nil: + InternalError(e.info, "genCheckedRecordField") # generate the checks: + for i in countup(1, sonsLen(e) - 1): + it = e.sons[i] + assert(it.kind == nkCall) + assert(it.sons[0].kind == nkSym) + op = it.sons[0].sym + if op.magic == mNot: it = it.sons[1] + assert(it.sons[2].kind == nkSym) + initLoc(test, locNone, it.typ, OnStack) + InitLocExpr(p, it.sons[1], u) + initLoc(v, locExpr, it.sons[2].typ, OnUnknown) + v.r = ropef("$1.$2", [r, it.sons[2].sym.loc.r]) + genInExprAux(p, it, u, v, test) + id = NodeTableTestOrSet(p.module.dataCache, + newStrNode(nkStrLit, field.name.s), gid) + if id == gid: strLit = getStrLit(p.module, field.name.s) + else: strLit = con("TMP", toRope(id)) + if op.magic == mNot: + appf(p.s[cpsStmts], + "if ($1) raiseFieldError(((NimStringDesc*) &$2));$n", + [rdLoc(test), strLit]) + else: + appf(p.s[cpsStmts], + "if (!($1)) raiseFieldError(((NimStringDesc*) &$2));$n", + [rdLoc(test), strLit]) + appf(r, ".$1", [field.loc.r]) + putIntoDest(p, d, field.typ, r) + else: + genRecordField(p, e.sons[0], d) + +proc genArrayElem(p: BProc, e: PNode, d: var TLoc) = + var + a, b: TLoc + ty: PType + first: PRope + initLocExpr(p, e.sons[0], a) + initLocExpr(p, e.sons[1], b) + ty = skipTypes(skipTypes(a.t, abstractVarRange), abstractPtrs) + first = intLiteral(firstOrd(ty)) # emit range check: + if (optBoundsCheck in p.options): + if not isConstExpr(e.sons[1]): + # semantic pass has already checked for const index expressions + useMagic(p.module, "raiseIndexError") + if firstOrd(ty) == 0: + if (firstOrd(b.t) < firstOrd(ty)) or (lastOrd(b.t) > lastOrd(ty)): + appf(p.s[cpsStmts], "if ((NU)($1) > (NU)($2)) raiseIndexError();$n", + [rdCharLoc(b), intLiteral(lastOrd(ty))]) + else: + appf(p.s[cpsStmts], "if ($1 < $2 || $1 > $3) raiseIndexError();$n", + [rdCharLoc(b), first, intLiteral(lastOrd(ty))]) + if d.k == locNone: d.s = a.s + putIntoDest(p, d, elemType(skipTypes(ty, abstractVar)), + ropef("$1[($2)-$3]", [rdLoc(a), rdCharLoc(b), first])) + +proc genCStringElem(p: BProc, e: PNode, d: var TLoc) = + var + a, b: TLoc + ty: PType + initLocExpr(p, e.sons[0], a) + initLocExpr(p, e.sons[1], b) + ty = skipTypes(a.t, abstractVarRange) + if d.k == locNone: d.s = a.s + putIntoDest(p, d, elemType(skipTypes(ty, abstractVar)), + ropef("$1[$2]", [rdLoc(a), rdCharLoc(b)])) + +proc genOpenArrayElem(p: BProc, e: PNode, d: var TLoc) = + var a, b: TLoc + initLocExpr(p, e.sons[0], a) + initLocExpr(p, e.sons[1], b) # emit range check: + if (optBoundsCheck in p.options): + useMagic(p.module, "raiseIndexError") + appf(p.s[cpsStmts], "if ((NU)($1) >= (NU)($2Len0)) raiseIndexError();$n", + [rdLoc(b), rdLoc(a)]) # BUGFIX: ``>=`` and not ``>``! + if d.k == locNone: d.s = a.s + putIntoDest(p, d, elemType(skipTypes(a.t, abstractVar)), + ropef("$1[$2]", [rdLoc(a), rdCharLoc(b)])) + +proc genSeqElem(p: BPRoc, e: PNode, d: var TLoc) = + var + a, b: TLoc + ty: PType + initLocExpr(p, e.sons[0], a) + initLocExpr(p, e.sons[1], b) + ty = skipTypes(a.t, abstractVarRange) + if ty.kind in {tyRef, tyPtr}: + ty = skipTypes(ty.sons[0], abstractVarRange) # emit range check: + if (optBoundsCheck in p.options): + useMagic(p.module, "raiseIndexError") + if ty.kind == tyString: + appf(p.s[cpsStmts], + "if ((NU)($1) > (NU)($2->Sup.len)) raiseIndexError();$n", + [rdLoc(b), rdLoc(a)]) + else: + appf(p.s[cpsStmts], + "if ((NU)($1) >= (NU)($2->Sup.len)) raiseIndexError();$n", + [rdLoc(b), rdLoc(a)]) + if d.k == locNone: d.s = OnHeap + if skipTypes(a.t, abstractVar).kind in {tyRef, tyPtr}: + a.r = ropef("(*$1)", [a.r]) + putIntoDest(p, d, elemType(skipTypes(a.t, abstractVar)), + ropef("$1->data[$2]", [rdLoc(a), rdCharLoc(b)])) + +proc genAndOr(p: BProc, e: PNode, d: var TLoc, m: TMagic) = + # how to generate code? + # 'expr1 and expr2' becomes: + # result = expr1 + # fjmp result, end + # result = expr2 + # end: + # ... (result computed) + # BUGFIX: + # a = b or a + # used to generate: + # a = b + # if a: goto end + # a = a + # end: + # now it generates: + # tmp = b + # if tmp: goto end + # tmp = a + # end: + # a = tmp + var + L: TLabel + tmp: TLoc + getTemp(p, e.typ, tmp) # force it into a temp! + expr(p, e.sons[1], tmp) + L = getLabel(p) + if m == mOr: # mAnd: + appf(p.s[cpsStmts], "if ($1) goto $2;$n", [rdLoc(tmp), L]) + else: + appf(p.s[cpsStmts], "if (!($1)) goto $2;$n", [rdLoc(tmp), L]) + expr(p, e.sons[2], tmp) + fixLabel(p, L) + if d.k == locNone: + d = tmp + else: + genAssignment(p, d, tmp, {}) # no need for deep copying + +proc genIfExpr(p: BProc, n: PNode, d: var TLoc) = + # + # if (!expr1) goto L1; + # thenPart + # goto LEnd + # L1: + # if (!expr2) goto L2; + # thenPart2 + # goto LEnd + # L2: + # elsePart + # Lend: + # + var + it: PNode + a, tmp: TLoc + Lend, Lelse: TLabel + getTemp(p, n.typ, tmp) # force it into a temp! + Lend = getLabel(p) + for i in countup(0, sonsLen(n) - 1): + it = n.sons[i] + case it.kind + of nkElifExpr: + initLocExpr(p, it.sons[0], a) + Lelse = getLabel(p) + appf(p.s[cpsStmts], "if (!$1) goto $2;$n", [rdLoc(a), Lelse]) + expr(p, it.sons[1], tmp) + appf(p.s[cpsStmts], "goto $1;$n", [Lend]) + fixLabel(p, Lelse) + of nkElseExpr: + expr(p, it.sons[0], tmp) + else: internalError(n.info, "genIfExpr()") + fixLabel(p, Lend) + if d.k == locNone: + d = tmp + else: + genAssignment(p, d, tmp, {}) # no need for deep copying + +proc genEcho(p: BProc, n: PNode) = + var a: TLoc + useMagic(p.module, "rawEcho") + useMagic(p.module, "rawEchoNL") + for i in countup(1, sonsLen(n) - 1): + initLocExpr(p, n.sons[i], a) + appf(p.s[cpsStmts], "rawEcho($1);$n", [rdLoc(a)]) + app(p.s[cpsStmts], "rawEchoNL();" & tnl) + +proc genCall(p: BProc, t: PNode, d: var TLoc) = + var + param: PSym + invalidRetType: bool + typ: PType + pl: PRope # parameter list + op, list, a: TLoc + length: int + # this is a hotspot in the compiler + initLocExpr(p, t.sons[0], op) + pl = con(op.r, "(") #typ := getUniqueType(t.sons[0].typ); + typ = t.sons[0].typ # getUniqueType() is too expensive here! + assert(typ.kind == tyProc) + invalidRetType = isInvalidReturnType(typ.sons[0]) + length = sonsLen(t) + for i in countup(1, length - 1): + initLocExpr(p, t.sons[i], a) # generate expression for param + assert(sonsLen(typ) == sonsLen(typ.n)) + if (i < sonsLen(typ)): + assert(typ.n.sons[i].kind == nkSym) + param = typ.n.sons[i].sym + if ccgIntroducedPtr(param): app(pl, addrLoc(a)) + else: app(pl, rdLoc(a)) + else: + app(pl, rdLoc(a)) + if (i < length - 1) or (invalidRetType and (typ.sons[0] != nil)): + app(pl, ", ") + if (typ.sons[0] != nil) and invalidRetType: + # XXX (detected by pegs module 64bit): p(result, result) is not + # correct here. Thus we always allocate a temporary: + if d.k == locNone: getTemp(p, typ.sons[0], d) + app(pl, addrLoc(d)) + app(pl, ")") + if (typ.sons[0] != nil) and not invalidRetType: + if d.k == locNone: getTemp(p, typ.sons[0], d) + assert(d.t != nil) # generate an assignment to d: + initLoc(list, locCall, nil, OnUnknown) + list.r = pl + genAssignment(p, d, list, {}) # no need for deep copying + else: + app(p.s[cpsStmts], pl) + app(p.s[cpsStmts], ';' & tnl) + +proc genStrConcat(p: BProc, e: PNode, d: var TLoc) = + # <Nimrod code> + # s = 'hallo ' & name & ' how do you feel?' & 'z' + # + # <generated C code> + # { + # string tmp0; + # ... + # tmp0 = rawNewString(6 + 17 + 1 + s2->len); + # // we cannot generate s = rawNewString(...) here, because + # // ``s`` may be used on the right side of the expression + # appendString(tmp0, strlit_1); + # appendString(tmp0, name); + # appendString(tmp0, strlit_2); + # appendChar(tmp0, 'z'); + # asgn(s, tmp0); + # } + var + a, tmp: TLoc + appends, lens: PRope + L: int + useMagic(p.module, "rawNewString") + getTemp(p, e.typ, tmp) + L = 0 + appends = nil + lens = nil + for i in countup(0, sonsLen(e) - 2): + # compute the length expression: + initLocExpr(p, e.sons[i + 1], a) + if skipTypes(e.sons[i + 1].Typ, abstractVarRange).kind == tyChar: + Inc(L) + useMagic(p.module, "appendChar") + appf(appends, "appendChar($1, $2);$n", [tmp.r, rdLoc(a)]) + else: + if e.sons[i + 1].kind in {nkStrLit..nkTripleStrLit}: + Inc(L, len(e.sons[i + 1].strVal)) + else: + appf(lens, "$1->Sup.len + ", [rdLoc(a)]) + useMagic(p.module, "appendString") + appf(appends, "appendString($1, $2);$n", [tmp.r, rdLoc(a)]) + appf(p.s[cpsStmts], "$1 = rawNewString($2$3);$n", [tmp.r, lens, toRope(L)]) + app(p.s[cpsStmts], appends) + if d.k == locNone: + d = tmp + else: + genAssignment(p, d, tmp, {}) # no need for deep copying + +proc genStrAppend(p: BProc, e: PNode, d: var TLoc) = + # <Nimrod code> + # s &= 'hallo ' & name & ' how do you feel?' & 'z' + # // BUG: what if s is on the left side too? + # <generated C code> + # { + # s = resizeString(s, 6 + 17 + 1 + name->len); + # appendString(s, strlit_1); + # appendString(s, name); + # appendString(s, strlit_2); + # appendChar(s, 'z'); + # } + var + a, dest: TLoc + L: int + appends, lens: PRope + assert(d.k == locNone) + useMagic(p.module, "resizeString") + L = 0 + appends = nil + lens = nil + initLocExpr(p, e.sons[1], dest) + for i in countup(0, sonsLen(e) - 3): + # compute the length expression: + initLocExpr(p, e.sons[i + 2], a) + if skipTypes(e.sons[i + 2].Typ, abstractVarRange).kind == tyChar: + Inc(L) + useMagic(p.module, "appendChar") + appf(appends, "appendChar($1, $2);$n", [rdLoc(dest), rdLoc(a)]) + else: + if e.sons[i + 2].kind in {nkStrLit..nkTripleStrLit}: + Inc(L, len(e.sons[i + 2].strVal)) + else: + appf(lens, "$1->Sup.len + ", [rdLoc(a)]) + useMagic(p.module, "appendString") + appf(appends, "appendString($1, $2);$n", [rdLoc(dest), rdLoc(a)]) + appf(p.s[cpsStmts], "$1 = resizeString($1, $2$3);$n", + [rdLoc(dest), lens, toRope(L)]) + app(p.s[cpsStmts], appends) + +proc genSeqElemAppend(p: BProc, e: PNode, d: var TLoc) = + # seq &= x --> + # seq = (typeof seq) incrSeq(&seq->Sup, sizeof(x)); + # seq->data[seq->len-1] = x; + var a, b, dest: TLoc + useMagic(p.module, "incrSeq") + InitLocExpr(p, e.sons[1], a) + InitLocExpr(p, e.sons[2], b) + appf(p.s[cpsStmts], "$1 = ($2) incrSeq(&($1)->Sup, sizeof($3));$n", [rdLoc(a), + getTypeDesc(p.module, skipTypes(e.sons[1].typ, abstractVar)), + getTypeDesc(p.module, skipTypes(e.sons[2].Typ, abstractVar))]) + initLoc(dest, locExpr, b.t, OnHeap) + dest.r = ropef("$1->data[$1->Sup.len-1]", [rdLoc(a)]) + genAssignment(p, dest, b, {needToCopy, afDestIsNil}) + +proc genObjectInit(p: BProc, t: PType, a: TLoc, takeAddr: bool) = + var + r: PRope + s: PType + case analyseObjectWithTypeField(t) + of frNone: + nil + of frHeader: + r = rdLoc(a) + if not takeAddr: r = ropef("(*$1)", [r]) + s = t + while (s.kind == tyObject) and (s.sons[0] != nil): + app(r, ".Sup") + s = skipTypes(s.sons[0], abstractInst) + appf(p.s[cpsStmts], "$1.m_type = $2;$n", [r, genTypeInfo(p.module, t)]) + of frEmbedded: + # worst case for performance: + useMagic(p.module, "objectInit") + if takeAddr: r = addrLoc(a) + else: r = rdLoc(a) + appf(p.s[cpsStmts], "objectInit($1, $2);$n", [r, genTypeInfo(p.module, t)]) + +proc genNew(p: BProc, e: PNode) = + var + a, b: TLoc + reftype, bt: PType + useMagic(p.module, "newObj") + refType = skipTypes(e.sons[1].typ, abstractVarRange) + InitLocExpr(p, e.sons[1], a) + initLoc(b, locExpr, a.t, OnHeap) + b.r = ropef("($1) newObj($2, sizeof($3))", [getTypeDesc(p.module, reftype), + genTypeInfo(p.module, refType), + getTypeDesc(p.module, skipTypes(reftype.sons[0], abstractRange))]) + genAssignment(p, a, b, {}) # set the object type: + bt = skipTypes(refType.sons[0], abstractRange) + genObjectInit(p, bt, a, false) + +proc genNewSeq(p: BProc, e: PNode) = + var + a, b, c: TLoc + seqtype: PType + useMagic(p.module, "newSeq") + seqType = skipTypes(e.sons[1].typ, abstractVarRange) + InitLocExpr(p, e.sons[1], a) + InitLocExpr(p, e.sons[2], b) + initLoc(c, locExpr, a.t, OnHeap) + c.r = ropef("($1) newSeq($2, $3)", [getTypeDesc(p.module, seqtype), + genTypeInfo(p.module, seqType), rdLoc(b)]) + genAssignment(p, a, c, {}) + +proc genIs(p: BProc, x: PNode, typ: PType, d: var TLoc) = + var + a: TLoc + dest, t: PType + r, nilcheck: PRope + initLocExpr(p, x, a) + dest = skipTypes(typ, abstractPtrs) + useMagic(p.module, "isObj") + r = rdLoc(a) + nilCheck = nil + t = skipTypes(a.t, abstractInst) + while t.kind in {tyVar, tyPtr, tyRef}: + if t.kind != tyVar: nilCheck = r + r = ropef("(*$1)", [r]) + t = skipTypes(t.sons[0], abstractInst) + if gCmd != cmdCompileToCpp: + while (t.kind == tyObject) and (t.sons[0] != nil): + app(r, ".Sup") + t = skipTypes(t.sons[0], abstractInst) + if nilCheck != nil: + r = ropef("(($1) && isObj($2.m_type, $3))", + [nilCheck, r, genTypeInfo(p.module, dest)]) + else: + r = ropef("isObj($1.m_type, $2)", [r, genTypeInfo(p.module, dest)]) + putIntoDest(p, d, getSysType(tyBool), r) + +proc genIs(p: BProc, n: PNode, d: var TLoc) = + genIs(p, n.sons[1], n.sons[2].typ, d) + +proc genNewFinalize(p: BProc, e: PNode) = + var + a, b, f: TLoc + refType, bt: PType + ti: PRope + oldModule: BModule + useMagic(p.module, "newObj") + refType = skipTypes(e.sons[1].typ, abstractVarRange) + InitLocExpr(p, e.sons[1], a) # This is a little hack: + # XXX this is also a bug, if the finalizer expression produces side-effects + oldModule = p.module + p.module = gNimDat + InitLocExpr(p, e.sons[2], f) + p.module = oldModule + initLoc(b, locExpr, a.t, OnHeap) + ti = genTypeInfo(p.module, refType) + appf(gNimDat.s[cfsTypeInit3], "$1->finalizer = (void*)$2;$n", [ti, rdLoc(f)]) + b.r = ropef("($1) newObj($2, sizeof($3))", [getTypeDesc(p.module, refType), + ti, getTypeDesc(p.module, skipTypes(reftype.sons[0], abstractRange))]) + genAssignment(p, a, b, {}) # set the object type: + bt = skipTypes(refType.sons[0], abstractRange) + genObjectInit(p, bt, a, false) + +proc genRepr(p: BProc, e: PNode, d: var TLoc) = + var + a: TLoc + t: PType + InitLocExpr(p, e.sons[1], a) + t = skipTypes(e.sons[1].typ, abstractVarRange) + case t.kind + of tyInt..tyInt64: + UseMagic(p.module, "reprInt") + putIntoDest(p, d, e.typ, ropef("reprInt($1)", [rdLoc(a)])) + of tyFloat..tyFloat128: + UseMagic(p.module, "reprFloat") + putIntoDest(p, d, e.typ, ropef("reprFloat($1)", [rdLoc(a)])) + of tyBool: + UseMagic(p.module, "reprBool") + putIntoDest(p, d, e.typ, ropef("reprBool($1)", [rdLoc(a)])) + of tyChar: + UseMagic(p.module, "reprChar") + putIntoDest(p, d, e.typ, ropef("reprChar($1)", [rdLoc(a)])) + of tyEnum, tyOrdinal: + UseMagic(p.module, "reprEnum") + putIntoDest(p, d, e.typ, + ropef("reprEnum($1, $2)", [rdLoc(a), genTypeInfo(p.module, t)])) + of tyString: + UseMagic(p.module, "reprStr") + putIntoDest(p, d, e.typ, ropef("reprStr($1)", [rdLoc(a)])) + of tySet: + useMagic(p.module, "reprSet") + putIntoDest(p, d, e.typ, + ropef("reprSet($1, $2)", [rdLoc(a), genTypeInfo(p.module, t)])) + of tyOpenArray: + useMagic(p.module, "reprOpenArray") + case a.t.kind + of tyOpenArray: + putIntoDest(p, d, e.typ, ropef("$1, $1Len0", [rdLoc(a)])) + of tyString, tySequence: + putIntoDest(p, d, e.typ, ropef("$1->data, $1->Sup.len", [rdLoc(a)])) + of tyArray, tyArrayConstr: + putIntoDest(p, d, e.typ, + ropef("$1, $2", [rdLoc(a), toRope(lengthOrd(a.t))])) + else: InternalError(e.sons[0].info, "genRepr()") + putIntoDest(p, d, e.typ, ropef("reprOpenArray($1, $2)", [rdLoc(d), + genTypeInfo(p.module, elemType(t))])) + of tyCString, tyArray, tyArrayConstr, tyRef, tyPtr, tyPointer, tyNil, + tySequence: + useMagic(p.module, "reprAny") + putIntoDest(p, d, e.typ, + ropef("reprAny($1, $2)", [rdLoc(a), genTypeInfo(p.module, t)])) + else: + useMagic(p.module, "reprAny") + putIntoDest(p, d, e.typ, ropef("reprAny($1, $2)", + [addrLoc(a), genTypeInfo(p.module, t)])) + +proc genDollar(p: BProc, n: PNode, d: var TLoc, magic, frmt: string) = + var a: TLoc + InitLocExpr(p, n.sons[1], a) + UseMagic(p.module, magic) + a.r = ropef(frmt, [rdLoc(a)]) + if d.k == locNone: getTemp(p, n.typ, d) + genAssignment(p, d, a, {}) + +proc genArrayLen(p: BProc, e: PNode, d: var TLoc, op: TMagic) = + var typ: PType + typ = skipTypes(e.sons[1].Typ, abstractPtrs) + case typ.kind + of tyOpenArray: + while e.sons[1].kind == nkPassAsOpenArray: e.sons[1] = e.sons[1].sons[0] + if op == mHigh: unaryExpr(p, e, d, "", "($1Len0-1)") + else: unaryExpr(p, e, d, "", "$1Len0") + of tyCstring: + if op == mHigh: unaryExpr(p, e, d, "", "(strlen($1)-1)") + else: unaryExpr(p, e, d, "", "strlen($1)") + of tyString, tySequence: + if op == mHigh: unaryExpr(p, e, d, "", "($1->Sup.len-1)") + else: unaryExpr(p, e, d, "", "$1->Sup.len") + of tyArray, tyArrayConstr: + # YYY: length(sideeffect) is optimized away incorrectly? + if op == mHigh: putIntoDest(p, d, e.typ, toRope(lastOrd(Typ))) + else: putIntoDest(p, d, e.typ, toRope(lengthOrd(typ))) + else: InternalError(e.info, "genArrayLen()") + +proc genSetLengthSeq(p: BProc, e: PNode, d: var TLoc) = + var + a, b: TLoc + t: PType + assert(d.k == locNone) + useMagic(p.module, "setLengthSeq") + InitLocExpr(p, e.sons[1], a) + InitLocExpr(p, e.sons[2], b) + t = skipTypes(e.sons[1].typ, abstractVar) + appf(p.s[cpsStmts], "$1 = ($3) setLengthSeq(&($1)->Sup, sizeof($4), $2);$n", [ + rdLoc(a), rdLoc(b), getTypeDesc(p.module, t), + getTypeDesc(p.module, t.sons[0])]) + +proc genSetLengthStr(p: BProc, e: PNode, d: var TLoc) = + binaryStmt(p, e, d, "setLengthStr", "$1 = setLengthStr($1, $2);$n") + +proc genSwap(p: BProc, e: PNode, d: var TLoc) = + # swap(a, b) --> + # temp = a + # a = b + # b = temp + var a, b, tmp: TLoc + getTemp(p, skipTypes(e.sons[1].typ, abstractVar), tmp) + InitLocExpr(p, e.sons[1], a) # eval a + InitLocExpr(p, e.sons[2], b) # eval b + genAssignment(p, tmp, a, {}) + genAssignment(p, a, b, {}) + genAssignment(p, b, tmp, {}) + +proc rdSetElemLoc(a: TLoc, setType: PType): PRope = + # read a location of an set element; it may need a substraction operation + # before the set operation + result = rdCharLoc(a) + assert(setType.kind == tySet) + if (firstOrd(setType) != 0): + result = ropef("($1-$2)", [result, toRope(firstOrd(setType))]) + +proc fewCmps(s: PNode): bool = + # this function estimates whether it is better to emit code + # for constructing the set or generating a bunch of comparisons directly + if s.kind != nkCurly: InternalError(s.info, "fewCmps") + if (getSize(s.typ) <= platform.intSize) and (nfAllConst in s.flags): + result = false # it is better to emit the set generation code + elif elemType(s.typ).Kind in {tyInt, tyInt16..tyInt64}: + result = true # better not emit the set if int is basetype! + else: + result = sonsLen(s) <= + 8 # 8 seems to be a good value + +proc binaryExprIn(p: BProc, e: PNode, a, b, d: var TLoc, frmt: string) = + putIntoDest(p, d, e.typ, ropef(frmt, [rdLoc(a), rdSetElemLoc(b, a.t)])) + +proc genInExprAux(p: BProc, e: PNode, a, b, d: var TLoc) = + case int(getSize(skipTypes(e.sons[1].typ, abstractVar))) + of 1: binaryExprIn(p, e, a, b, d, "(($1 &(1<<(($2)&7)))!=0)") + of 2: binaryExprIn(p, e, a, b, d, "(($1 &(1<<(($2)&15)))!=0)") + of 4: binaryExprIn(p, e, a, b, d, "(($1 &(1<<(($2)&31)))!=0)") + of 8: binaryExprIn(p, e, a, b, d, "(($1 &(IL64(1)<<(($2)&IL64(63))))!=0)") + else: binaryExprIn(p, e, a, b, d, "(($1[$2/8] &(1<<($2%8)))!=0)") + +proc binaryStmtInExcl(p: BProc, e: PNode, d: var TLoc, frmt: string) = + var a, b: TLoc + assert(d.k == locNone) + InitLocExpr(p, e.sons[1], a) + InitLocExpr(p, e.sons[2], b) + appf(p.s[cpsStmts], frmt, [rdLoc(a), rdSetElemLoc(b, a.t)]) + +proc genInOp(p: BProc, e: PNode, d: var TLoc) = + var + a, b, x, y: TLoc + length: int + if (e.sons[1].Kind == nkCurly) and fewCmps(e.sons[1]): + # a set constructor but not a constant set: + # do not emit the set, but generate a bunch of comparisons + initLocExpr(p, e.sons[2], a) + initLoc(b, locExpr, e.typ, OnUnknown) + b.r = toRope("(") + length = sonsLen(e.sons[1]) + for i in countup(0, length - 1): + if e.sons[1].sons[i].Kind == nkRange: + InitLocExpr(p, e.sons[1].sons[i].sons[0], x) + InitLocExpr(p, e.sons[1].sons[i].sons[1], y) + appf(b.r, "$1 >= $2 && $1 <= $3", + [rdCharLoc(a), rdCharLoc(x), rdCharLoc(y)]) + else: + InitLocExpr(p, e.sons[1].sons[i], x) + appf(b.r, "$1 == $2", [rdCharLoc(a), rdCharLoc(x)]) + if i < length - 1: app(b.r, " || ") + app(b.r, ")") + putIntoDest(p, d, e.typ, b.r) + else: + assert(e.sons[1].typ != nil) + assert(e.sons[2].typ != nil) + InitLocExpr(p, e.sons[1], a) + InitLocExpr(p, e.sons[2], b) + genInExprAux(p, e, a, b, d) + +proc genSetOp(p: BProc, e: PNode, d: var TLoc, op: TMagic) = + const + lookupOpr: array[mLeSet..mSymDiffSet, string] = ["for ($1 = 0; $1 < $2; $1++) { $n" & + " $3 = (($4[$1] & ~ $5[$1]) == 0);$n" & " if (!$3) break;}$n", "for ($1 = 0; $1 < $2; $1++) { $n" & + " $3 = (($4[$1] & ~ $5[$1]) == 0);$n" & " if (!$3) break;}$n" & + "if ($3) $3 = (memcmp($4, $5, $2) != 0);$n", "&", "|", "& ~", "^"] + var + size: int + setType: PType + a, b, i: TLoc + ts: string + setType = skipTypes(e.sons[1].Typ, abstractVar) + size = int(getSize(setType)) + case size + of 1, 2, 4, 8: + case op + of mIncl: + ts = "NI" & $(size * 8) + binaryStmtInExcl(p, e, d, + "$1 |=(1<<((" & ts & ")($2)%(sizeof(" & ts & ")*8)));$n") + of mExcl: + ts = "NI" & $(size * 8) + binaryStmtInExcl(p, e, d, "$1 &= ~(1 << ((" & ts & ")($2) % (sizeof(" & + ts & ")*8)));$n") + of mCard: + if size <= 4: unaryExprChar(p, e, d, "countBits32", "countBits32($1)") + else: unaryExprChar(p, e, d, "countBits64", "countBits64($1)") + of mLtSet: + binaryExprChar(p, e, d, "", "(($1 & ~ $2 ==0)&&($1 != $2))") + of mLeSet: + binaryExprChar(p, e, d, "", "(($1 & ~ $2)==0)") + of mEqSet: + binaryExpr(p, e, d, "", "($1 == $2)") + of mMulSet: + binaryExpr(p, e, d, "", "($1 & $2)") + of mPlusSet: + binaryExpr(p, e, d, "", "($1 | $2)") + of mMinusSet: + binaryExpr(p, e, d, "", "($1 & ~ $2)") + of mSymDiffSet: + binaryExpr(p, e, d, "", "($1 ^ $2)") + of mInSet: + genInOp(p, e, d) + else: internalError(e.info, "genSetOp()") + else: + case op + of mIncl: + binaryStmtInExcl(p, e, d, "$1[$2/8] |=(1<<($2%8));$n") + of mExcl: + binaryStmtInExcl(p, e, d, "$1[$2/8] &= ~(1<<($2%8));$n") + of mCard: + unaryExprChar(p, e, d, "cardSet", "cardSet($1, " & $(size) & ')') + of mLtSet, mLeSet: + getTemp(p, getSysType(tyInt), i) # our counter + initLocExpr(p, e.sons[1], a) + initLocExpr(p, e.sons[2], b) + if d.k == locNone: getTemp(p, a.t, d) + appf(p.s[cpsStmts], lookupOpr[op], + [rdLoc(i), toRope(size), rdLoc(d), rdLoc(a), rdLoc(b)]) + of mEqSet: + binaryExprChar(p, e, d, "", "(memcmp($1, $2, " & $(size) & ")==0)") + of mMulSet, mPlusSet, mMinusSet, mSymDiffSet: + # we inline the simple for loop for better code generation: + getTemp(p, getSysType(tyInt), i) # our counter + initLocExpr(p, e.sons[1], a) + initLocExpr(p, e.sons[2], b) + if d.k == locNone: getTemp(p, a.t, d) + appf(p.s[cpsStmts], + "for ($1 = 0; $1 < $2; $1++) $n" & " $3[$1] = $4[$1] $6 $5[$1];$n", [ + rdLoc(i), toRope(size), rdLoc(d), rdLoc(a), rdLoc(b), + toRope(lookupOpr[op])]) + of mInSet: + genInOp(p, e, d) + else: internalError(e.info, "genSetOp") + +proc genOrd(p: BProc, e: PNode, d: var TLoc) = + unaryExprChar(p, e, d, "", "$1") + +proc genCast(p: BProc, e: PNode, d: var TLoc) = + const + ValueTypes = {tyTuple, tyObject, tyArray, tyOpenArray, tyArrayConstr} + # we use whatever C gives us. Except if we have a value-type, we need to go + # through its address: + var a: TLoc + InitLocExpr(p, e.sons[1], a) + if (skipTypes(e.typ, abstractRange).kind in ValueTypes) and + not (lfIndirect in a.flags): + putIntoDest(p, d, e.typ, ropef("(*($1*) ($2))", + [getTypeDesc(p.module, e.typ), addrLoc(a)])) + else: + putIntoDest(p, d, e.typ, ropef("(($1) ($2))", + [getTypeDesc(p.module, e.typ), rdCharLoc(a)])) + +proc genRangeChck(p: BProc, n: PNode, d: var TLoc, magic: string) = + var + a: TLoc + dest: PType + dest = skipTypes(n.typ, abstractVar) + if not (optRangeCheck in p.options): + InitLocExpr(p, n.sons[0], a) + putIntoDest(p, d, n.typ, ropef("(($1) ($2))", + [getTypeDesc(p.module, dest), rdCharLoc(a)])) + else: + InitLocExpr(p, n.sons[0], a) + useMagic(p.module, magic) + putIntoDest(p, d, dest, ropef("(($1)$5($2, $3, $4))", [ + getTypeDesc(p.module, dest), rdCharLoc(a), + genLiteral(p, n.sons[1], dest), genLiteral(p, n.sons[2], dest), + toRope(magic)])) + +proc genConv(p: BProc, e: PNode, d: var TLoc) = + genCast(p, e, d) + +proc passToOpenArray(p: BProc, n: PNode, d: var TLoc) = + var + a: TLoc + dest: PType + while n.sons[0].kind == nkPassAsOpenArray: + n.sons[0] = n.sons[0].sons[0] # BUGFIX + dest = skipTypes(n.typ, abstractVar) + case skipTypes(n.sons[0].typ, abstractVar).kind + of tyOpenArray: + initLocExpr(p, n.sons[0], a) + putIntoDest(p, d, dest, ropef("$1, $1Len0", [rdLoc(a)])) + of tyString, tySequence: + initLocExpr(p, n.sons[0], a) + putIntoDest(p, d, dest, ropef("$1->data, $1->Sup.len", [rdLoc(a)])) + of tyArray, tyArrayConstr: + initLocExpr(p, n.sons[0], a) + putIntoDest(p, d, dest, ropef("$1, $2", [rdLoc(a), toRope(lengthOrd(a.t))])) + else: InternalError(n.sons[0].info, "passToOpenArray: " & typeToString(a.t)) + +proc convStrToCStr(p: BProc, n: PNode, d: var TLoc) = + var a: TLoc + initLocExpr(p, n.sons[0], a) + putIntoDest(p, d, skipTypes(n.typ, abstractVar), ropef("$1->data", [rdLoc(a)])) + +proc convCStrToStr(p: BProc, n: PNode, d: var TLoc) = + var a: TLoc + useMagic(p.module, "cstrToNimstr") + initLocExpr(p, n.sons[0], a) + putIntoDest(p, d, skipTypes(n.typ, abstractVar), + ropef("cstrToNimstr($1)", [rdLoc(a)])) + +proc genStrEquals(p: BProc, e: PNode, d: var TLoc) = + var + a, b: PNode + x: TLoc + a = e.sons[1] + b = e.sons[2] + if (a.kind == nkNilLit) or (b.kind == nkNilLit): + binaryExpr(p, e, d, "", "($1 == $2)") + elif (a.kind in {nkStrLit..nkTripleStrLit}) and (a.strVal == ""): + initLocExpr(p, e.sons[2], x) + putIntoDest(p, d, e.typ, ropef("(($1) && ($1)->Sup.len == 0)", [rdLoc(x)])) + elif (b.kind in {nkStrLit..nkTripleStrLit}) and (b.strVal == ""): + initLocExpr(p, e.sons[1], x) + putIntoDest(p, d, e.typ, ropef("(($1) && ($1)->Sup.len == 0)", [rdLoc(x)])) + else: + binaryExpr(p, e, d, "eqStrings", "eqStrings($1, $2)") + +proc genSeqConstr(p: BProc, t: PNode, d: var TLoc) = + var newSeq, arr: TLoc + useMagic(p.module, "newSeq") + if d.k == locNone: + getTemp(p, t.typ, d) + # generate call to newSeq before adding the elements per hand: + initLoc(newSeq, locExpr, t.typ, OnHeap) + newSeq.r = ropef("($1) newSeq($2, $3)", [getTypeDesc(p.module, t.typ), + genTypeInfo(p.module, t.typ), intLiteral(sonsLen(t))]) + genAssignment(p, d, newSeq, {afSrcIsNotNil}) + for i in countup(0, sonsLen(t) - 1): + initLoc(arr, locExpr, elemType(skipTypes(t.typ, abstractInst)), OnHeap) + arr.r = ropef("$1->data[$2]", [rdLoc(d), intLiteral(i)]) + arr.s = OnHeap # we know that sequences are on the heap + expr(p, t.sons[i], arr) + +proc genArrToSeq(p: BProc, t: PNode, d: var TLoc) = + var + newSeq, elem, a, arr: TLoc + L: int + if t.kind == nkBracket: + t.sons[1].typ = t.typ + genSeqConstr(p, t.sons[1], d) + return + useMagic(p.module, "newSeq") + if d.k == locNone: + getTemp(p, t.typ, d) + # generate call to newSeq before adding the elements per hand: + L = int(lengthOrd(t.sons[1].typ)) + initLoc(newSeq, locExpr, t.typ, OnHeap) + newSeq.r = ropef("($1) newSeq($2, $3)", [getTypeDesc(p.module, t.typ), + genTypeInfo(p.module, t.typ), intLiteral(L)]) + genAssignment(p, d, newSeq, {afSrcIsNotNil}) + initLocExpr(p, t.sons[1], a) + for i in countup(0, L - 1): + initLoc(elem, locExpr, elemType(skipTypes(t.typ, abstractInst)), OnHeap) + elem.r = ropef("$1->data[$2]", [rdLoc(d), intLiteral(i)]) + elem.s = OnHeap # we know that sequences are on the heap + initLoc(arr, locExpr, elemType(skipTypes(t.sons[1].typ, abstractInst)), a.s) + arr.r = ropef("$1[$2]", [rdLoc(a), intLiteral(i)]) + genAssignment(p, elem, arr, {afDestIsNil, needToCopy}) + +proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) = + var line, filen: PRope + case op + of mOr, mAnd: genAndOr(p, e, d, op) + of mNot..mToBiggestInt: unaryArith(p, e, d, op) + of mUnaryMinusI..mAbsI64: unaryArithOverflow(p, e, d, op) + of mShrI..mXor: binaryArith(p, e, d, op) + of mAddi..mModi64: binaryArithOverflow(p, e, d, op) + of mRepr: genRepr(p, e, d) + of mSwap: genSwap(p, e, d) + of mPred: + # XXX: range checking? + if not (optOverflowCheck in p.Options): binaryExpr(p, e, d, "", "$1 - $2") + else: binaryExpr(p, e, d, "subInt", "subInt($1, $2)") + of mSucc: + # XXX: range checking? + if not (optOverflowCheck in p.Options): binaryExpr(p, e, d, "", "$1 + $2") + else: binaryExpr(p, e, d, "addInt", "addInt($1, $2)") + of mInc: + if not (optOverflowCheck in p.Options): + binaryStmt(p, e, d, "", "$1 += $2;$n") + elif skipTypes(e.sons[1].typ, abstractVar).kind == tyInt64: + binaryStmt(p, e, d, "addInt64", "$1 = addInt64($1, $2);$n") + else: + binaryStmt(p, e, d, "addInt", "$1 = addInt($1, $2);$n") + of ast.mDec: + if not (optOverflowCheck in p.Options): + binaryStmt(p, e, d, "", "$1 -= $2;$n") + elif skipTypes(e.sons[1].typ, abstractVar).kind == tyInt64: + binaryStmt(p, e, d, "subInt64", "$1 = subInt64($1, $2);$n") + else: + binaryStmt(p, e, d, "subInt", "$1 = subInt($1, $2);$n") + of mConStrStr: genStrConcat(p, e, d) + of mAppendStrCh: binaryStmt(p, e, d, "addChar", "$1 = addChar($1, $2);$n") + of mAppendStrStr: genStrAppend(p, e, d) + of mAppendSeqElem: genSeqElemAppend(p, e, d) + of mEqStr: genStrEquals(p, e, d) + of mLeStr: binaryExpr(p, e, d, "cmpStrings", "(cmpStrings($1, $2) <= 0)") + of mLtStr: binaryExpr(p, e, d, "cmpStrings", "(cmpStrings($1, $2) < 0)") + of mIsNil: unaryExpr(p, e, d, "", "$1 == 0") + of mIntToStr: genDollar(p, e, d, "nimIntToStr", "nimIntToStr($1)") + of mInt64ToStr: genDollar(p, e, d, "nimInt64ToStr", "nimInt64ToStr($1)") + of mBoolToStr: genDollar(p, e, d, "nimBoolToStr", "nimBoolToStr($1)") + of mCharToStr: genDollar(p, e, d, "nimCharToStr", "nimCharToStr($1)") + of mFloatToStr: genDollar(p, e, d, "nimFloatToStr", "nimFloatToStr($1)") + of mCStrToStr: genDollar(p, e, d, "cstrToNimstr", "cstrToNimstr($1)") + of mStrToStr: expr(p, e.sons[1], d) + of mEnumToStr: genRepr(p, e, d) + of mAssert: + if (optAssert in p.Options): + useMagic(p.module, "internalAssert") + expr(p, e.sons[1], d) + line = toRope(toLinenumber(e.info)) + filen = makeCString(ToFilename(e.info)) + appf(p.s[cpsStmts], "internalAssert($1, $2, $3);$n", + [filen, line, rdLoc(d)]) + of mIs: genIs(p, e, d) + of mNew: genNew(p, e) + of mNewFinalize: genNewFinalize(p, e) + of mNewSeq: genNewSeq(p, e) + of mSizeOf: + putIntoDest(p, d, e.typ, ropef("((NI)sizeof($1))", + [getTypeDesc(p.module, e.sons[1].typ)])) + of mChr: genCast(p, e, d) + of mOrd: genOrd(p, e, d) + of mLengthArray, mHigh, mLengthStr, mLengthSeq, mLengthOpenArray: + genArrayLen(p, e, d, op) + of mGCref: unaryStmt(p, e, d, "nimGCref", "nimGCref($1);$n") + of mGCunref: unaryStmt(p, e, d, "nimGCunref", "nimGCunref($1);$n") + of mSetLengthStr: genSetLengthStr(p, e, d) + of mSetLengthSeq: genSetLengthSeq(p, e, d) + of mIncl, mExcl, mCard, mLtSet, mLeSet, mEqSet, mMulSet, mPlusSet, mMinusSet, + mInSet: + genSetOp(p, e, d, op) + of mNewString, mCopyStr, mCopyStrLast, mExit: genCall(p, e, d) + of mEcho: genEcho(p, e) + of mArrToSeq: genArrToSeq(p, e, d) + of mNLen..mNError: + liMessage(e.info, errCannotGenerateCodeForX, e.sons[0].sym.name.s) + else: internalError(e.info, "genMagicExpr: " & magicToStr[op]) + +proc genConstExpr(p: BProc, n: PNode): PRope +proc handleConstExpr(p: BProc, n: PNode, d: var TLoc): bool = + if (nfAllConst in n.flags) and (d.k == locNone) and (sonsLen(n) > 0): + var t = getUniqueType(n.typ) + discard getTypeDesc(p.module, t) # so that any fields are initialized + var id = NodeTableTestOrSet(p.module.dataCache, n, gid) + fillLoc(d, locData, t, con("TMP", toRope(id)), OnHeap) + if id == gid: + # expression not found in the cache: + inc(gid) + appf(p.module.s[cfsData], "NIM_CONST $1 $2 = $3;$n", + [getTypeDesc(p.module, t), d.r, genConstExpr(p, n)]) + result = true + else: + result = false + +proc genSetConstr(p: BProc, e: PNode, d: var TLoc) = + # example: { a..b, c, d, e, f..g } + # we have to emit an expression of the form: + # memset(tmp, 0, sizeof(tmp)); inclRange(tmp, a, b); incl(tmp, c); + # incl(tmp, d); incl(tmp, e); inclRange(tmp, f, g); + var + a, b, idx: TLoc + ts: string + if nfAllConst in e.flags: + putIntoDest(p, d, e.typ, genSetNode(p, e)) + else: + if d.k == locNone: getTemp(p, e.typ, d) + if getSize(e.typ) > 8: + # big set: + appf(p.s[cpsStmts], "memset($1, 0, sizeof($1));$n", [rdLoc(d)]) + for i in countup(0, sonsLen(e) - 1): + if e.sons[i].kind == nkRange: + getTemp(p, getSysType(tyInt), idx) # our counter + initLocExpr(p, e.sons[i].sons[0], a) + initLocExpr(p, e.sons[i].sons[1], b) + appf(p.s[cpsStmts], "for ($1 = $3; $1 <= $4; $1++) $n" & + "$2[$1/8] |=(1<<($1%8));$n", [rdLoc(idx), rdLoc(d), + rdSetElemLoc(a, e.typ), rdSetElemLoc(b, e.typ)]) + else: + initLocExpr(p, e.sons[i], a) + appf(p.s[cpsStmts], "$1[$2/8] |=(1<<($2%8));$n", + [rdLoc(d), rdSetElemLoc(a, e.typ)]) + else: + # small set + ts = "NI" & $(getSize(e.typ) * 8) + appf(p.s[cpsStmts], "$1 = 0;$n", [rdLoc(d)]) + for i in countup(0, sonsLen(e) - 1): + if e.sons[i].kind == nkRange: + getTemp(p, getSysType(tyInt), idx) # our counter + initLocExpr(p, e.sons[i].sons[0], a) + initLocExpr(p, e.sons[i].sons[1], b) + appf(p.s[cpsStmts], "for ($1 = $3; $1 <= $4; $1++) $n" & + "$2 |=(1<<((" & ts & ")($1)%(sizeof(" & ts & ")*8)));$n", [ + rdLoc(idx), rdLoc(d), rdSetElemLoc(a, e.typ), + rdSetElemLoc(b, e.typ)]) + else: + initLocExpr(p, e.sons[i], a) + appf(p.s[cpsStmts], + "$1 |=(1<<((" & ts & ")($2)%(sizeof(" & ts & ")*8)));$n", + [rdLoc(d), rdSetElemLoc(a, e.typ)]) + +proc genTupleConstr(p: BProc, n: PNode, d: var TLoc) = + var + rec: TLoc + it: PNode + t: PType + if not handleConstExpr(p, n, d): + t = getUniqueType(n.typ) + discard getTypeDesc(p.module, t) # so that any fields are initialized + if d.k == locNone: getTemp(p, t, d) + for i in countup(0, sonsLen(n) - 1): + it = n.sons[i] + if it.kind == nkExprColonExpr: + initLoc(rec, locExpr, it.sons[1].typ, d.s) + if (t.n.sons[i].kind != nkSym): InternalError(n.info, "genTupleConstr") + rec.r = ropef("$1.$2", + [rdLoc(d), mangleRecFieldName(t.n.sons[i].sym, t)]) + expr(p, it.sons[1], rec) + elif t.n == nil: + initLoc(rec, locExpr, it.typ, d.s) + rec.r = ropef("$1.Field$2", [rdLoc(d), toRope(i)]) + expr(p, it, rec) + else: + initLoc(rec, locExpr, it.typ, d.s) + if (t.n.sons[i].kind != nkSym): + InternalError(n.info, "genTupleConstr: 2") + rec.r = ropef("$1.$2", + [rdLoc(d), mangleRecFieldName(t.n.sons[i].sym, t)]) + expr(p, it, rec) + +proc genArrayConstr(p: BProc, n: PNode, d: var TLoc) = + var arr: TLoc + if not handleConstExpr(p, n, d): + if d.k == locNone: getTemp(p, n.typ, d) + for i in countup(0, sonsLen(n) - 1): + initLoc(arr, locExpr, elemType(skipTypes(n.typ, abstractInst)), d.s) + arr.r = ropef("$1[$2]", [rdLoc(d), intLiteral(i)]) + expr(p, n.sons[i], arr) + +proc genComplexConst(p: BProc, sym: PSym, d: var TLoc) = + genConstPrototype(p.module, sym) + assert((sym.loc.r != nil) and (sym.loc.t != nil)) + putLocIntoDest(p, d, sym.loc) + +proc genStmtListExpr(p: BProc, n: PNode, d: var TLoc) = + var length: int + length = sonsLen(n) + for i in countup(0, length - 2): genStmts(p, n.sons[i]) + if length > 0: expr(p, n.sons[length - 1], d) + +proc upConv(p: BProc, n: PNode, d: var TLoc) = + var + a: TLoc + dest, t: PType + r, nilCheck: PRope + initLocExpr(p, n.sons[0], a) + dest = skipTypes(n.typ, abstractPtrs) + if (optObjCheck in p.options) and not (isPureObject(dest)): + useMagic(p.module, "chckObj") + r = rdLoc(a) + nilCheck = nil + t = skipTypes(a.t, abstractInst) + while t.kind in {tyVar, tyPtr, tyRef}: + if t.kind != tyVar: nilCheck = r + r = ropef("(*$1)", [r]) + t = skipTypes(t.sons[0], abstractInst) + if gCmd != cmdCompileToCpp: + while (t.kind == tyObject) and (t.sons[0] != nil): + app(r, ".Sup") + t = skipTypes(t.sons[0], abstractInst) + if nilCheck != nil: + appf(p.s[cpsStmts], "if ($1) chckObj($2.m_type, $3);$n", + [nilCheck, r, genTypeInfo(p.module, dest)]) + else: + appf(p.s[cpsStmts], "chckObj($1.m_type, $2);$n", + [r, genTypeInfo(p.module, dest)]) + if n.sons[0].typ.kind != tyObject: + putIntoDest(p, d, n.typ, + ropef("(($1) ($2))", [getTypeDesc(p.module, n.typ), rdLoc(a)])) + else: + putIntoDest(p, d, n.typ, ropef("(*($1*) ($2))", + [getTypeDesc(p.module, dest), addrLoc(a)])) + +proc downConv(p: BProc, n: PNode, d: var TLoc) = + if gCmd == cmdCompileToCpp: + expr(p, n.sons[0], d) # downcast does C++ for us + else: + var dest = skipTypes(n.typ, abstractPtrs) + var src = skipTypes(n.sons[0].typ, abstractPtrs) + var a: TLoc + initLocExpr(p, n.sons[0], a) + var r = rdLoc(a) + if skipTypes(n.sons[0].typ, abstractInst).kind in {tyRef, tyPtr, tyVar}: + app(r, "->Sup") + for i in countup(2, abs(inheritanceDiff(dest, src))): app(r, ".Sup") + r = con("&", r) + else: + for i in countup(1, abs(inheritanceDiff(dest, src))): app(r, ".Sup") + putIntoDest(p, d, n.typ, r) + +proc genBlock(p: BProc, t: PNode, d: var TLoc) +proc expr(p: BProc, e: PNode, d: var TLoc) = + case e.kind + of nkSym: + var sym = e.sym + case sym.Kind + of skMethod: + if sym.ast.sons[codePos] == nil: + # we cannot produce code for the dispatcher yet: + fillProcLoc(sym) + genProcPrototype(p.module, sym) + else: + genProc(p.module, sym) + putLocIntoDest(p, d, sym.loc) + of skProc, skConverter: + genProc(p.module, sym) + if ((sym.loc.r == nil) or (sym.loc.t == nil)): + InternalError(e.info, "expr: proc not init " & sym.name.s) + putLocIntoDest(p, d, sym.loc) + of skConst: + if isSimpleConst(sym.typ): + putIntoDest(p, d, e.typ, genLiteral(p, sym.ast, sym.typ)) + else: + genComplexConst(p, sym, d) + of skEnumField: + putIntoDest(p, d, e.typ, toRope(sym.position)) + of skVar: + if (sfGlobal in sym.flags): genVarPrototype(p.module, sym) + if ((sym.loc.r == nil) or (sym.loc.t == nil)): + InternalError(e.info, "expr: var not init " & sym.name.s) + putLocIntoDest(p, d, sym.loc) + of skForVar, skTemp: + if ((sym.loc.r == nil) or (sym.loc.t == nil)): + InternalError(e.info, "expr: temp not init " & sym.name.s) + putLocIntoDest(p, d, sym.loc) + of skParam: + if ((sym.loc.r == nil) or (sym.loc.t == nil)): + InternalError(e.info, "expr: param not init " & sym.name.s) + putLocIntoDest(p, d, sym.loc) + else: InternalError(e.info, "expr(" & $sym.kind & "); unknown symbol") + of nkStrLit..nkTripleStrLit, nkIntLit..nkInt64Lit, nkFloatLit..nkFloat64Lit, + nkNilLit, nkCharLit: + putIntoDest(p, d, e.typ, genLiteral(p, e)) + of nkCall, nkHiddenCallConv, nkInfix, nkPrefix, nkPostfix, nkCommand, + nkCallStrLit: + if (e.sons[0].kind == nkSym) and (e.sons[0].sym.magic != mNone): + genMagicExpr(p, e, d, e.sons[0].sym.magic) + else: + genCall(p, e, d) + of nkCurly: + genSetConstr(p, e, d) + of nkBracket: + if (skipTypes(e.typ, abstractVarRange).kind == tySequence): + genSeqConstr(p, e, d) + else: + genArrayConstr(p, e, d) + of nkPar: genTupleConstr(p, e, d) + of nkCast: genCast(p, e, d) + of nkHiddenStdConv, nkHiddenSubConv, nkConv: genConv(p, e, d) + of nkHiddenAddr, nkAddr: genAddr(p, e, d) + of nkBracketExpr: + var ty = skipTypes(e.sons[0].typ, abstractVarRange) + if ty.kind in {tyRef, tyPtr}: ty = skipTypes(ty.sons[0], abstractVarRange) + case ty.kind + of tyArray, tyArrayConstr: genArrayElem(p, e, d) + of tyOpenArray: genOpenArrayElem(p, e, d) + of tySequence, tyString: genSeqElem(p, e, d) + of tyCString: genCStringElem(p, e, d) + of tyTuple: genTupleElem(p, e, d) + else: InternalError(e.info, "expr(nkBracketExpr, " & $ty.kind & ')') + of nkDerefExpr, nkHiddenDeref: genDeref(p, e, d) + of nkDotExpr: genRecordField(p, e, d) + of nkCheckedFieldExpr: genCheckedRecordField(p, e, d) + of nkBlockExpr: genBlock(p, e, d) + of nkStmtListExpr: genStmtListExpr(p, e, d) + of nkIfExpr: genIfExpr(p, e, d) + of nkObjDownConv: downConv(p, e, d) + of nkObjUpConv: upConv(p, e, d) + of nkChckRangeF: genRangeChck(p, e, d, "chckRangeF") + of nkChckRange64: genRangeChck(p, e, d, "chckRange64") + of nkChckRange: genRangeChck(p, e, d, "chckRange") + of nkStringToCString: convStrToCStr(p, e, d) + of nkCStringToString: convCStrToStr(p, e, d) + of nkPassAsOpenArray: passToOpenArray(p, e, d) + else: InternalError(e.info, "expr(" & $e.kind & "); unknown node kind") + +proc genNamedConstExpr(p: BProc, n: PNode): PRope = + if n.kind == nkExprColonExpr: result = genConstExpr(p, n.sons[1]) + else: result = genConstExpr(p, n) + +proc genConstSimpleList(p: BProc, n: PNode): PRope = + var length = sonsLen(n) + result = toRope("{") + for i in countup(0, length - 2): + appf(result, "$1,$n", [genNamedConstExpr(p, n.sons[i])]) + if length > 0: app(result, genNamedConstExpr(p, n.sons[length - 1])) + app(result, '}' & tnl) + +proc genConstExpr(p: BProc, n: PNode): PRope = + var + cs: TBitSet + d: TLoc + case n.Kind + of nkHiddenStdConv, nkHiddenSubConv: + result = genConstExpr(p, n.sons[1]) + of nkCurly: + toBitSet(n, cs) + result = genRawSetData(cs, int(getSize(n.typ))) + of nkBracket, nkPar: + # XXX: tySequence! + result = genConstSimpleList(p, n) + else: + # result := genLiteral(p, n) + initLocExpr(p, n, d) + result = rdLoc(d) |