diff options
Diffstat (limited to 'compiler/ccgexprs.nim')
| -rwxr-xr-x | compiler/ccgexprs.nim | 234 |
1 files changed, 120 insertions, 114 deletions
diff --git a/compiler/ccgexprs.nim b/compiler/ccgexprs.nim index 7781040d9..20636f122 100755 --- a/compiler/ccgexprs.nim +++ b/compiler/ccgexprs.nim @@ -19,15 +19,15 @@ proc intLiteral(i: biggestInt): PRope = result = toRope(i) elif i == low(int32): # Nimrod has the same bug for the same reasons :-) - result = toRope("(-2147483647 -1)") + result = ~"(-2147483647 -1)" elif i > low(int64): - result = ropef("IL64($1)", [toRope(i)]) + result = rfmt(nil, "IL64($1)", toRope(i)) else: - result = toRope("(IL64(-9223372036854775807) - IL64(1))") + result = ~"(IL64(-9223372036854775807) - IL64(1))" proc int32Literal(i: Int): PRope = if i == int(low(int32)): - result = toRope("(-2147483647 -1)") + result = ~"(-2147483647 -1)" else: result = toRope(i) @@ -57,8 +57,8 @@ proc genLiteral(p: BProc, n: PNode, ty: PType): PRope = else: result = intLiteral(n.intVal) of tyBool: - if n.intVal != 0: result = toRope("NIM_TRUE") - else: result = toRope("NIM_FALSE") + if n.intVal != 0: result = ~"NIM_TRUE" + else: result = ~"NIM_FALSE" else: result = ropef("(($1) $2)", [getTypeDesc(p.module, skipTypes(ty, abstractVarRange)), intLiteral(n.intVal)]) @@ -165,7 +165,7 @@ proc getStorageLoc(n: PNode): TStorageLoc = proc genRefAssign(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) = if dest.s == OnStack or optRefcGC notin gGlobalOptions: - lineF(p, cpsStmts, "$1 = $2;$n", [rdLoc(dest), rdLoc(src)]) + linefmt(p, cpsStmts, "$1 = $2;$n", rdLoc(dest), rdLoc(src)) if needToKeepAlive in flags: keepAlive(p, dest) elif dest.s == OnHeap: # location is on heap @@ -185,14 +185,14 @@ proc genRefAssign(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) = # lineF(p, cpsStmts, 'if ($1) nimGCunref($1);$n', [rdLoc(dest)]) # lineF(p, cpsStmts, '$1 = $2;$n', [rdLoc(dest), rdLoc(src)]) if canFormAcycle(dest.t): - lineCg(p, cpsStmts, "#asgnRef((void**) $1, $2);$n", - [addrLoc(dest), rdLoc(src)]) + linefmt(p, cpsStmts, "#asgnRef((void**) $1, $2);$n", + addrLoc(dest), rdLoc(src)) else: - lineCg(p, cpsStmts, "#asgnRefNoCycle((void**) $1, $2);$n", - [addrLoc(dest), rdLoc(src)]) + linefmt(p, cpsStmts, "#asgnRefNoCycle((void**) $1, $2);$n", + addrLoc(dest), rdLoc(src)) else: - lineCg(p, cpsStmts, "#unsureAsgnRef((void**) $1, $2);$n", - [addrLoc(dest), rdLoc(src)]) + linefmt(p, cpsStmts, "#unsureAsgnRef((void**) $1, $2);$n", + addrLoc(dest), rdLoc(src)) if needToKeepAlive in flags: keepAlive(p, dest) proc genGenericAsgn(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) = @@ -205,23 +205,23 @@ proc genGenericAsgn(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) = if needToCopy notin flags or tfShallow in skipTypes(dest.t, abstractVarRange).flags: if dest.s == OnStack or optRefcGC notin gGlobalOptions: - lineCg(p, cpsStmts, + linefmt(p, cpsStmts, "memcpy((void*)$1, (NIM_CONST void*)$2, sizeof($3));$n", - [addrLoc(dest), addrLoc(src), rdLoc(dest)]) + addrLoc(dest), addrLoc(src), rdLoc(dest)) if needToKeepAlive in flags: keepAlive(p, dest) else: - lineCg(p, cpsStmts, "#genericShallowAssign((void*)$1, (void*)$2, $3);$n", - [addrLoc(dest), addrLoc(src), genTypeInfo(p.module, dest.t)]) + linefmt(p, cpsStmts, "#genericShallowAssign((void*)$1, (void*)$2, $3);$n", + addrLoc(dest), addrLoc(src), genTypeInfo(p.module, dest.t)) else: - lineCg(p, cpsStmts, "#genericAssign((void*)$1, (void*)$2, $3);$n", - [addrLoc(dest), addrLoc(src), genTypeInfo(p.module, dest.t)]) + linefmt(p, cpsStmts, "#genericAssign((void*)$1, (void*)$2, $3);$n", + addrLoc(dest), addrLoc(src), genTypeInfo(p.module, dest.t)) proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) = # This function replaces all other methods for generating # the assignment operation in C. if src.t != nil and src.t.kind == tyPtr: # little HACK to support the new 'var T' as return type: - lineCg(p, cpsStmts, "$1 = $2;$n", [rdLoc(dest), rdLoc(src)]) + linefmt(p, cpsStmts, "$1 = $2;$n", rdLoc(dest), rdLoc(src)) return var ty = skipTypes(dest.t, abstractRange) case ty.kind @@ -231,59 +231,59 @@ proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) = if needToCopy notin flags: genRefAssign(p, dest, src, flags) else: - lineCg(p, cpsStmts, "#genericSeqAssign($1, $2, $3);$n", - [addrLoc(dest), rdLoc(src), genTypeInfo(p.module, dest.t)]) + linefmt(p, cpsStmts, "#genericSeqAssign($1, $2, $3);$n", + addrLoc(dest), rdLoc(src), genTypeInfo(p.module, dest.t)) of tyString: if needToCopy notin flags: genRefAssign(p, dest, src, flags) else: if dest.s == OnStack or optRefcGC notin gGlobalOptions: - lineCg(p, cpsStmts, "$1 = #copyString($2);$n", [dest.rdLoc, src.rdLoc]) + linefmt(p, cpsStmts, "$1 = #copyString($2);$n", dest.rdLoc, src.rdLoc) if needToKeepAlive in flags: keepAlive(p, dest) elif dest.s == OnHeap: # we use a temporary to care for the dreaded self assignment: var tmp: TLoc getTemp(p, ty, tmp) - lineCg(p, cpsStmts, "$3 = $1; $1 = #copyStringRC1($2);$n", - [dest.rdLoc, src.rdLoc, tmp.rdLoc]) - lineCg(p, cpsStmts, "if ($1) #nimGCunrefNoCycle($1);$n", tmp.rdLoc) + linefmt(p, cpsStmts, "$3 = $1; $1 = #copyStringRC1($2);$n", + dest.rdLoc, src.rdLoc, tmp.rdLoc) + linefmt(p, cpsStmts, "if ($1) #nimGCunrefNoCycle($1);$n", tmp.rdLoc) else: - lineCg(p, cpsStmts, "#unsureAsgnRef((void**) $1, #copyString($2));$n", - [addrLoc(dest), rdLoc(src)]) + linefmt(p, cpsStmts, "#unsureAsgnRef((void**) $1, #copyString($2));$n", + addrLoc(dest), rdLoc(src)) if needToKeepAlive in flags: keepAlive(p, dest) of tyTuple, tyObject, tyProc: # XXX: check for subtyping? if needsComplexAssignment(dest.t): genGenericAsgn(p, dest, src, flags) else: - lineCg(p, cpsStmts, "$1 = $2;$n", [rdLoc(dest), rdLoc(src)]) + linefmt(p, cpsStmts, "$1 = $2;$n", rdLoc(dest), rdLoc(src)) of tyArray, tyArrayConstr: if needsComplexAssignment(dest.t): genGenericAsgn(p, dest, src, flags) else: - lineCg(p, cpsStmts, + linefmt(p, cpsStmts, "memcpy((void*)$1, (NIM_CONST void*)$2, sizeof($1));$n", - [rdLoc(dest), rdLoc(src)]) + rdLoc(dest), rdLoc(src)) of tyOpenArray, tyVarargs: # open arrays are always on the stack - really? What if a sequence is # passed to an open array? if needsComplexAssignment(dest.t): - lineCg(p, cpsStmts, # XXX: is this correct for arrays? + linefmt(p, cpsStmts, # XXX: is this correct for arrays? "#genericAssignOpenArray((void*)$1, (void*)$2, $1Len0, $3);$n", - [addrLoc(dest), addrLoc(src), genTypeInfo(p.module, dest.t)]) + addrLoc(dest), addrLoc(src), genTypeInfo(p.module, dest.t)) else: - lineCg(p, cpsStmts, + linefmt(p, cpsStmts, "memcpy((void*)$1, (NIM_CONST void*)$2, sizeof($1[0])*$1Len0);$n", - [rdLoc(dest), rdLoc(src)]) + rdLoc(dest), rdLoc(src)) of tySet: if mapType(ty) == ctArray: - lineCg(p, cpsStmts, "memcpy((void*)$1, (NIM_CONST void*)$2, $3);$n", - [rdLoc(dest), rdLoc(src), toRope(getSize(dest.t))]) + linefmt(p, cpsStmts, "memcpy((void*)$1, (NIM_CONST void*)$2, $3);$n", + rdLoc(dest), rdLoc(src), toRope(getSize(dest.t))) else: - lineCg(p, cpsStmts, "$1 = $2;$n", [rdLoc(dest), rdLoc(src)]) + linefmt(p, cpsStmts, "$1 = $2;$n", rdLoc(dest), rdLoc(src)) of tyPtr, tyPointer, tyChar, tyBool, tyEnum, tyCString, tyInt..tyUInt64, tyRange, tyVar: - lineCg(p, cpsStmts, "$1 = $2;$n", [rdLoc(dest), rdLoc(src)]) + linefmt(p, cpsStmts, "$1 = $2;$n", rdLoc(dest), rdLoc(src)) else: InternalError("genAssignment(" & $ty.kind & ')') proc expr(p: BProc, e: PNode, d: var TLoc) @@ -322,7 +322,7 @@ proc binaryStmt(p: BProc, e: PNode, d: var TLoc, frmt: string) = if d.k != locNone: InternalError(e.info, "binaryStmt") InitLocExpr(p, e.sons[1], d) InitLocExpr(p, e.sons[2], b) - lineCg(p, cpsStmts, frmt, [rdLoc(d), rdLoc(b)]) + lineCg(p, cpsStmts, frmt, rdLoc(d), rdLoc(b)) proc unaryStmt(p: BProc, e: PNode, d: var TLoc, frmt: string) = var a: TLoc @@ -387,12 +387,12 @@ proc binaryArithOverflow(p: BProc, e: PNode, d: var TLoc, m: TMagic) = else: storage = getTypeDesc(p.module, t) var tmp = getTempName() - lineCg(p, cpsLocals, "$1 $2;$n", [storage, tmp]) - lineCg(p, cpsStmts, "$1 = #$2($3, $4);$n", [tmp, toRope(prc[m]), - rdLoc(a), rdLoc(b)]) + linefmt(p, cpsLocals, "$1 $2;$n", storage, tmp) + lineCg(p, cpsStmts, "$1 = #$2($3, $4);$n", + tmp, toRope(prc[m]), rdLoc(a), rdLoc(b)) if size < platform.IntSize or t.kind in {tyRange, tyEnum, tySet}: - lineCg(p, cpsStmts, "if ($1 < $2 || $1 > $3) #raiseOverflow();$n", - [tmp, intLiteral(firstOrd(t)), intLiteral(lastOrd(t))]) + linefmt(p, cpsStmts, "if ($1 < $2 || $1 > $3) #raiseOverflow();$n", + tmp, intLiteral(firstOrd(t)), intLiteral(lastOrd(t))) putIntoDest(p, d, e.typ, ropef("(NI$1)($2)", [toRope(getSize(t)*8), tmp])) proc unaryArithOverflow(p: BProc, e: PNode, d: var TLoc, m: TMagic) = @@ -409,8 +409,8 @@ proc unaryArithOverflow(p: BProc, e: PNode, d: var TLoc, m: TMagic) = InitLocExpr(p, e.sons[1], a) t = skipTypes(e.typ, abstractRange) if optOverflowCheck in p.options: - lineCg(p, cpsStmts, "if ($1 == $2) #raiseOverflow();$n", - [rdLoc(a), intLiteral(firstOrd(t))]) + linefmt(p, 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) = @@ -562,10 +562,15 @@ proc genAddr(p: BProc, e: PNode, d: var TLoc) = InitLocExpr(p, e.sons[0], a) putIntoDest(p, d, e.typ, addrLoc(a)) +template inheritLocation(d: var TLoc, a: TLoc) = + if d.k == locNone: d.s = a.s + if d.heapRoot == nil: + d.heapRoot = if a.heapRoot != nil: a.heapRoot else: a.r + 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 + d.inheritLocation(a) discard getTypeDesc(p.module, a.t) # fill the record's fields.loc result = a.t @@ -598,7 +603,7 @@ proc genTupleElem(p: BProc, e: PNode, d: var TLoc) = a: TLoc i: int initLocExpr(p, e.sons[0], a) - if d.k == locNone: d.s = a.s + d.inheritLocation(a) discard getTypeDesc(p.module, a.t) # fill the record's fields.loc var ty = a.t var r = rdLoc(a) @@ -655,14 +660,14 @@ proc genCheckedRecordField(p: BProc, e: PNode, d: var TLoc) = if id == gBackendId: strLit = getStrLit(p.module, field.name.s) else: strLit = con("TMP", toRope(id)) if op.magic == mNot: - lineCg(p, cpsStmts, - "if ($1) #raiseFieldError(((#NimStringDesc*) &$2));$n", - [rdLoc(test), strLit]) + linefmt(p, cpsStmts, + "if ($1) #raiseFieldError(((#NimStringDesc*) &$2));$n", + rdLoc(test), strLit) else: - lineCg(p, cpsStmts, - "if (!($1)) #raiseFieldError(((#NimStringDesc*) &$2));$n", - [rdLoc(test), strLit]) - appf(r, ".$1", [field.loc.r]) + linefmt(p, cpsStmts, + "if (!($1)) #raiseFieldError(((#NimStringDesc*) &$2));$n", + rdLoc(test), strLit) + app(r, rfmt(nil, ".$1", field.loc.r)) putIntoDest(p, d, field.typ, r) else: genRecordField(p, e.sons[0], d) @@ -679,18 +684,18 @@ proc genArrayElem(p: BProc, e: PNode, d: var TLoc) = # semantic pass has already checked for const index expressions if firstOrd(ty) == 0: if (firstOrd(b.t) < firstOrd(ty)) or (lastOrd(b.t) > lastOrd(ty)): - lineCg(p, cpsStmts, "if ((NU)($1) > (NU)($2)) #raiseIndexError();$n", - [rdCharLoc(b), intLiteral(lastOrd(ty))]) + linefmt(p, cpsStmts, "if ((NU)($1) > (NU)($2)) #raiseIndexError();$n", + rdCharLoc(b), intLiteral(lastOrd(ty))) else: - lineCg(p, cpsStmts, "if ($1 < $2 || $1 > $3) #raiseIndexError();$n", - [rdCharLoc(b), first, intLiteral(lastOrd(ty))]) + linefmt(p, cpsStmts, "if ($1 < $2 || $1 > $3) #raiseIndexError();$n", + rdCharLoc(b), first, intLiteral(lastOrd(ty))) else: let idx = getOrdValue(e.sons[1]) if idx < firstOrd(ty) or idx > lastOrd(ty): localError(e.info, errIndexOutOfBounds) - if d.k == locNone: d.s = a.s + d.inheritLocation(a) putIntoDest(p, d, elemType(skipTypes(ty, abstractVar)), - ropef("$1[($2)- $3]", [rdLoc(a), rdCharLoc(b), first])) + rfmt(nil, "$1[($2)- $3]", rdLoc(a), rdCharLoc(b), first)) proc genCStringElem(p: BProc, e: PNode, d: var TLoc) = var a, b: TLoc @@ -699,18 +704,18 @@ proc genCStringElem(p: BProc, e: PNode, d: var TLoc) = var 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)])) + rfmt(nil, "$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: - lineCg(p, cpsStmts, "if ((NU)($1) >= (NU)($2Len0)) #raiseIndexError();$n", - [rdLoc(b), rdLoc(a)]) # BUGFIX: ``>=`` and not ``>``! + linefmt(p, 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)])) + rfmt(nil, "$1[$2]", rdLoc(a), rdCharLoc(b))) proc genSeqElem(p: BPRoc, e: PNode, d: var TLoc) = var a, b: TLoc @@ -721,18 +726,19 @@ proc genSeqElem(p: BPRoc, e: PNode, d: var TLoc) = ty = skipTypes(ty.sons[0], abstractVarRange) # emit range check: if optBoundsCheck in p.options: if ty.kind == tyString: - lineCg(p, cpsStmts, + linefmt(p, cpsStmts, "if ((NU)($1) > (NU)($2->$3)) #raiseIndexError();$n", - [rdLoc(b), rdLoc(a), lenField()]) + rdLoc(b), rdLoc(a), lenField()) else: - lineCg(p, cpsStmts, + linefmt(p, cpsStmts, "if ((NU)($1) >= (NU)($2->$3)) #raiseIndexError();$n", - [rdLoc(b), rdLoc(a), lenField()]) + rdLoc(b), rdLoc(a), lenField()) if d.k == locNone: d.s = OnHeap + d.heapRoot = a.r if skipTypes(a.t, abstractVar).kind in {tyRef, tyPtr}: - a.r = ropef("(*$1)", [a.r]) + a.r = rfmt(nil, "(*$1)", a.r) putIntoDest(p, d, elemType(skipTypes(a.t, abstractVar)), - ropef("$1->data[$2]", [rdLoc(a), rdCharLoc(b)])) + rfmt(nil, "$1->data[$2]", rdLoc(a), rdCharLoc(b))) proc genAndOr(p: BProc, e: PNode, d: var TLoc, m: TMagic) = # how to generate code? @@ -818,8 +824,8 @@ proc genEcho(p: BProc, n: PNode) = for i in countup(1, n.len-1): initLocExpr(p, n.sons[i], a) appf(args, ", ($1)->data", [rdLoc(a)]) - lineCg(p, cpsStmts, "printf($1$2);$n", [ - makeCString(repeatStr(n.len-1, "%s") & tnl), args]) + linefmt(p, cpsStmts, "printf($1$2);$n", + makeCString(repeatStr(n.len-1, "%s") & tnl), args) include ccgcalls @@ -850,14 +856,14 @@ proc genStrConcat(p: BProc, e: PNode, d: var TLoc) = initLocExpr(p, e.sons[i + 1], a) if skipTypes(e.sons[i + 1].Typ, abstractVarRange).kind == tyChar: Inc(L) - appLineCg(p, appends, "#appendChar($1, $2);$n", [tmp.r, rdLoc(a)]) + app(appends, rfmt(p.module, "#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->$2 + ", [rdLoc(a), lenField()]) - appLineCg(p, appends, "#appendString($1, $2);$n", [tmp.r, rdLoc(a)]) - lineCg(p, cpsStmts, "$1 = #rawNewString($2$3);$n", [tmp.r, lens, toRope(L)]) + app(appends, rfmt(p.module, "#appendString($1, $2);$n", tmp.r, rdLoc(a))) + linefmt(p, cpsStmts, "$1 = #rawNewString($2$3);$n", tmp.r, lens, toRope(L)) app(p.s(cpsStmts), appends) if d.k == locNone: d = tmp @@ -888,17 +894,17 @@ proc genStrAppend(p: BProc, e: PNode, d: var TLoc) = initLocExpr(p, e.sons[i + 2], a) if skipTypes(e.sons[i + 2].Typ, abstractVarRange).kind == tyChar: Inc(L) - appLineCg(p, appends, "#appendChar($1, $2);$n", - [rdLoc(dest), rdLoc(a)]) + app(appends, rfmt(p.module, "#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->$2 + ", [rdLoc(a), lenField()]) - appLineCg(p, appends, "#appendString($1, $2);$n", - [rdLoc(dest), rdLoc(a)]) - lineCg(p, cpsStmts, "$1 = #resizeString($1, $2$3);$n", - [rdLoc(dest), lens, toRope(L)]) + app(appends, rfmt(p.module, "#appendString($1, $2);$n", + rdLoc(dest), rdLoc(a))) + linefmt(p, cpsStmts, "$1 = #resizeString($1, $2$3);$n", + rdLoc(dest), lens, toRope(L)) keepAlive(p, dest) app(p.s(cpsStmts), appends) @@ -920,14 +926,14 @@ proc genSeqElemAppend(p: BProc, e: PNode, d: var TLoc) = getTypeDesc(p.module, skipTypes(e.sons[2].Typ, abstractVar))]) keepAlive(p, a) initLoc(dest, locExpr, b.t, OnHeap) - dest.r = ropef("$1->data[$1->$2-1]", [rdLoc(a), lenField()]) + dest.r = rfmt(nil, "$1->data[$1->$2-1]", rdLoc(a), lenField()) genAssignment(p, dest, b, {needToCopy, afDestIsNil}) proc genReset(p: BProc, n: PNode) = var a: TLoc InitLocExpr(p, n.sons[1], a) - lineCg(p, cpsStmts, "#genericReset((void*)$1, $2);$n", - [addrLoc(a), genTypeInfo(p.module, skipTypes(a.t, abstractVarRange))]) + linefmt(p, cpsStmts, "#genericReset((void*)$1, $2);$n", + addrLoc(a), genTypeInfo(p.module, skipTypes(a.t, abstractVarRange))) proc genNew(p: BProc, e: PNode) = var @@ -951,11 +957,11 @@ proc genNew(p: BProc, e: PNode) = if a.s == OnHeap and optRefcGc in gGlobalOptions: # use newObjRC1 as an optimization; and we don't need 'keepAlive' either if canFormAcycle(a.t): - lineCg(p, cpsStmts, "if ($1) #nimGCunref($1);$n", a.rdLoc) + linefmt(p, cpsStmts, "if ($1) #nimGCunref($1);$n", a.rdLoc) else: - lineCg(p, cpsStmts, "if ($1) #nimGCunrefNoCycle($1);$n", a.rdLoc) + linefmt(p, cpsStmts, "if ($1) #nimGCunrefNoCycle($1);$n", a.rdLoc) b.r = ropecg(p.module, "($1) #newObjRC1($2, $3)", args) - lineCg(p, cpsStmts, "$1 = $2;$n", a.rdLoc, b.rdLoc) + linefmt(p, cpsStmts, "$1 = $2;$n", a.rdLoc, b.rdLoc) else: b.r = ropecg(p.module, "($1) #newObj($2, $3)", args) genAssignment(p, a, b, {needToKeepAlive}) # set the object type: @@ -969,9 +975,9 @@ proc genNewSeqAux(p: BProc, dest: TLoc, length: PRope) = var call: TLoc initLoc(call, locExpr, dest.t, OnHeap) if dest.s == OnHeap and optRefcGc in gGlobalOptions: - lineCg(p, cpsStmts, "if ($1) #nimGCunrefNoCycle($1);$n", dest.rdLoc) + linefmt(p, cpsStmts, "if ($1) #nimGCunrefNoCycle($1);$n", dest.rdLoc) call.r = ropecg(p.module, "($1) #newSeqRC1($2, $3)", args) - lineCg(p, cpsStmts, "$1 = $2;$n", dest.rdLoc, call.rdLoc) + linefmt(p, cpsStmts, "$1 = $2;$n", dest.rdLoc, call.rdLoc) else: call.r = ropecg(p.module, "($1) #newSeq($2, $3)", args) genAssignment(p, dest, call, {needToKeepAlive}) @@ -990,7 +996,7 @@ proc genSeqConstr(p: BProc, t: PNode, d: var TLoc) = genNewSeqAux(p, d, intLiteral(sonsLen(t))) 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.r = rfmt(nil, "$1->data[$2]", rdLoc(d), intLiteral(i)) arr.s = OnHeap # we know that sequences are on the heap expr(p, t.sons[i], arr) @@ -1009,10 +1015,10 @@ proc genArrToSeq(p: BProc, t: PNode, d: var TLoc) = 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.r = rfmt(nil, "$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)]) + arr.r = rfmt(nil, "$1[$2]", rdLoc(a), intLiteral(i)) genAssignment(p, elem, arr, {afDestIsNil, needToCopy}) proc genNewFinalize(p: BProc, e: PNode) = @@ -1043,21 +1049,21 @@ proc genOf(p: BProc, x: PNode, typ: PType, d: var TLoc) = var t = skipTypes(a.t, abstractInst) while t.kind in {tyVar, tyPtr, tyRef}: if t.kind != tyVar: nilCheck = r - r = ropef("(*$1)", [r]) + r = rfmt(nil, "(*$1)", r) t = skipTypes(t.sons[0], typedescInst) if gCmd != cmdCompileToCpp: while (t.kind == tyObject) and (t.sons[0] != nil): - app(r, ".Sup") + app(r, ~".Sup") t = skipTypes(t.sons[0], typedescInst) if isObjLackingTypeField(t): GlobalError(x.info, errGenerated, "no 'of' operator available for pure objects") if nilCheck != nil: - r = ropecg(p.module, "(($1) && #isObj($2.m_type, $3))", - [nilCheck, r, genTypeInfo(p.module, dest)]) + r = rfmt(p.module, "(($1) && #isObj($2.m_type, $3))", + nilCheck, r, genTypeInfo(p.module, dest)) else: - r = ropecg(p.module, "#isObj($1.m_type, $2)", - [r, genTypeInfo(p.module, dest)]) + r = rfmt(p.module, "#isObj($1.m_type, $2)", + r, genTypeInfo(p.module, dest)) putIntoDest(p, d, getSysType(tyBool), r) proc genOf(p: BProc, n: PNode, d: var TLoc) = @@ -1373,12 +1379,12 @@ proc genStrEquals(p: BProc, e: PNode, d: var TLoc) = 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)->$2 == 0)", [rdLoc(x), lenField()])) + putIntoDest(p, d, e.typ, + rfmt(nil, "(($1) && ($1)->$2 == 0)", rdLoc(x), lenField())) elif (b.kind in {nkStrLit..nkTripleStrLit}) and (b.strVal == ""): initLocExpr(p, e.sons[1], x) - putIntoDest(p, d, e.typ, - ropef("(($1) && ($1)->$2 == 0)", [rdLoc(x), lenField()])) + putIntoDest(p, d, e.typ, + rfmt(nil, "(($1) && ($1)->$2 == 0)", rdLoc(x), lenField())) else: binaryExpr(p, e, d, "#eqStrings($1, $2)") @@ -1390,12 +1396,12 @@ proc binaryFloatArith(p: BProc, e: PNode, d: var TLoc, m: TMagic) = assert(e.sons[2].typ != nil) InitLocExpr(p, e.sons[1], a) InitLocExpr(p, e.sons[2], b) - putIntoDest(p, d, e.typ, ropef("($2 $1 $3)", [ - toRope(opr[m]), rdLoc(a), rdLoc(b)])) + putIntoDest(p, d, e.typ, rfmt(nil, "($2 $1 $3)", + toRope(opr[m]), rdLoc(a), rdLoc(b))) if optNanCheck in p.options: - lineCg(p, cpsStmts, "#nanCheck($1);$n", [rdLoc(d)]) + linefmt(p, cpsStmts, "#nanCheck($1);$n", rdLoc(d)) if optInfCheck in p.options: - lineCg(p, cpsStmts, "#infCheck($1);$n", [rdLoc(d)]) + linefmt(p, cpsStmts, "#infCheck($1);$n", rdLoc(d)) else: binaryArith(p, e, d, m) @@ -1586,8 +1592,8 @@ proc genClosure(p: BProc, n: PNode, d: var TLoc) = initLocExpr(p, n.sons[0], a) initLocExpr(p, n.sons[1], b) getTemp(p, n.typ, tmp) - lineCg(p, cpsStmts, "$1.ClPrc = $2; $1.ClEnv = $3;$n", - tmp.rdLoc, a.rdLoc, b.rdLoc) + linefmt(p, cpsStmts, "$1.ClPrc = $2; $1.ClEnv = $3;$n", + tmp.rdLoc, a.rdLoc, b.rdLoc) putLocIntoDest(p, d, tmp) proc genArrayConstr(p: BProc, n: PNode, d: var TLoc) = @@ -1626,11 +1632,11 @@ proc upConv(p: BProc, n: PNode, d: var TLoc) = app(r, ".Sup") t = skipTypes(t.sons[0], abstractInst) if nilCheck != nil: - lineCg(p, cpsStmts, "if ($1) #chckObj($2.m_type, $3);$n", - [nilCheck, r, genTypeInfo(p.module, dest)]) + linefmt(p, cpsStmts, "if ($1) #chckObj($2.m_type, $3);$n", + nilCheck, r, genTypeInfo(p.module, dest)) else: - lineCg(p, cpsStmts, "#chckObj($1.m_type, $2);$n", - [r, genTypeInfo(p.module, dest)]) + linefmt(p, 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)])) |