diff options
| -rw-r--r-- | compiler/ccgcalls.nim | 48 | ||||
| -rwxr-xr-x | compiler/ccgexprs.nim | 74 | ||||
| -rwxr-xr-x | compiler/ccgstmts.nim | 4 | ||||
| -rwxr-xr-x | compiler/ccgtypes.nim | 32 | ||||
| -rwxr-xr-x | compiler/cgen.nim | 28 |
5 files changed, 91 insertions, 95 deletions
diff --git a/compiler/ccgcalls.nim b/compiler/ccgcalls.nim index 2673f98b8..84c56cd28 100644 --- a/compiler/ccgcalls.nim +++ b/compiler/ccgcalls.nim @@ -20,12 +20,12 @@ proc hasNoInit(call: PNode): bool {.inline.} = proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc, callee, params: PRope) = - var pl = con(callee, "(".toRope, params) + var pl = con(callee, ~"(", params) # getUniqueType() is too expensive here: var typ = skipTypes(ri.sons[0].typ, abstractInst) if typ.sons[0] != nil: if isInvalidReturnType(typ.sons[0]): - if params != nil: pl.app(", ") + if params != nil: pl.app(~", ") # beware of 'result = p(result)'. We may need to allocate a temporary: if d.k in {locTemp, locNone} or not leftAppearsOnRightSide(le, ri): # Great, we can use 'd': @@ -34,17 +34,17 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc, # reset before pass as 'result' var: resetLoc(p, d) app(pl, addrLoc(d)) - appf(pl, ");$n") + app(pl, ~");$n") line(p, cpsStmts, pl) else: var tmp: TLoc getTemp(p, typ.sons[0], tmp) app(pl, addrLoc(tmp)) - appf(pl, ");$n") + app(pl, ~");$n") line(p, cpsStmts, pl) genAssignment(p, d, tmp, {}) # no need for deep copying else: - app(pl, ")") + app(pl, ~")") if d.k == locNone: getTemp(p, typ.sons[0], d) assert(d.t != nil) # generate an assignment to d: var list: TLoc @@ -52,7 +52,7 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc, list.r = pl genAssignment(p, d, list, {}) # no need for deep copying else: - appf(pl, ");$n") + app(pl, ~");$n") line(p, cpsStmts, pl) proc isInCurrentFrame(p: BProc, n: PNode): bool = @@ -130,7 +130,7 @@ proc genPrefixCall(p: BProc, le, ri: PNode, d: var TLoc) = var length = sonsLen(ri) for i in countup(1, length - 1): if ri.sons[i].typ.isCompileTimeOnly: continue - if params != nil: app(params, ", ") + if params != nil: app(params, ~", ") if i < sonsLen(typ): assert(typ.n.sons[i].kind == nkSym) app(params, genArg(p, ri.sons[i], typ.n.sons[i].sym)) @@ -144,7 +144,7 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) = result = getClosureType(p.module, t, clHalf) proc addComma(r: PRope): PRope = - result = if r == nil: r else: con(r, ", ") + result = if r == nil: r else: con(r, ~", ") const CallPattern = "$1.ClEnv? $1.ClPrc($3$1.ClEnv) : (($4)($1.ClPrc))($2);$n" var op: TLoc @@ -161,7 +161,7 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) = app(pl, genArg(p, ri.sons[i], typ.n.sons[i].sym)) else: app(pl, genArgNoParam(p, ri.sons[i])) - if i < length - 1: app(pl, ", ") + if i < length - 1: app(pl, ~", ") template genCallPattern = lineF(p, cpsStmts, CallPattern, op.r, pl, pl.addComma, rawProc) @@ -169,7 +169,7 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) = let rawProc = getRawProcType(p, typ) if typ.sons[0] != nil: if isInvalidReturnType(typ.sons[0]): - if sonsLen(ri) > 1: app(pl, ", ") + if sonsLen(ri) > 1: app(pl, ~", ") # beware of 'result = p(result)'. We may need to allocate a temporary: if d.k in {locTemp, locNone} or not leftAppearsOnRightSide(le, ri): # Great, we can use 'd': @@ -208,12 +208,12 @@ proc genInfixCall(p: BProc, le, ri: PNode, d: var TLoc) = var param = typ.n.sons[1].sym app(pl, genArg(p, ri.sons[1], param)) - if skipTypes(param.typ, {tyGenericInst}).kind == tyPtr: app(pl, "->") - else: app(pl, ".") + if skipTypes(param.typ, {tyGenericInst}).kind == tyPtr: app(pl, ~"->") + else: app(pl, ~".") app(pl, op.r) var params: PRope for i in countup(2, length - 1): - if params != nil: params.app(", ") + if params != nil: params.app(~", ") assert(sonsLen(typ) == sonsLen(typ.n)) if i < sonsLen(typ): assert(typ.n.sons[i].kind == nkSym) @@ -226,7 +226,7 @@ proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) = # generates a crappy ObjC call var op, a: TLoc initLocExpr(p, ri.sons[0], op) - var pl = toRope"[" + var pl = ~"[" # getUniqueType() is too expensive here: var typ = skipTypes(ri.sons[0].typ, abstractInst) assert(typ.kind == tyProc) @@ -235,10 +235,10 @@ proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) = if length > 1: app(pl, genArg(p, ri.sons[1], typ.n.sons[1].sym)) - app(pl, " ") + app(pl, ~" ") app(pl, op.r) if length > 2: - app(pl, ": ") + app(pl, ~": ") app(pl, genArg(p, ri.sons[2], typ.n.sons[2].sym)) for i in countup(3, length-1): assert(sonsLen(typ) == sonsLen(typ.n)) @@ -246,30 +246,30 @@ proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) = InternalError(ri.info, "varargs for objective C method?") assert(typ.n.sons[i].kind == nkSym) var param = typ.n.sons[i].sym - app(pl, " ") + app(pl, ~" ") app(pl, param.name.s) - app(pl, ": ") + app(pl, ~": ") app(pl, genArg(p, ri.sons[i], param)) if typ.sons[0] != nil: if isInvalidReturnType(typ.sons[0]): - if sonsLen(ri) > 1: app(pl, " ") + if sonsLen(ri) > 1: app(pl, ~" ") # beware of 'result = p(result)'. We always allocate a temporary: if d.k in {locTemp, locNone}: # We already got a temp. Great, special case it: if d.k == locNone: getTemp(p, typ.sons[0], d) - app(pl, "Result: ") + app(pl, ~"Result: ") app(pl, addrLoc(d)) - appf(pl, "];$n") + app(pl, ~"];$n") line(p, cpsStmts, pl) else: var tmp: TLoc getTemp(p, typ.sons[0], tmp) app(pl, addrLoc(tmp)) - appf(pl, "];$n") + app(pl, ~"];$n") line(p, cpsStmts, pl) genAssignment(p, d, tmp, {}) # no need for deep copying else: - app(pl, "]") + app(pl, ~"]") if d.k == locNone: getTemp(p, typ.sons[0], d) assert(d.t != nil) # generate an assignment to d: var list: TLoc @@ -277,7 +277,7 @@ proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) = list.r = pl genAssignment(p, d, list, {}) # no need for deep copying else: - appf(pl, "];$n") + app(pl, ~"];$n") line(p, cpsStmts, pl) proc genCall(p: BProc, e: PNode, d: var TLoc) = diff --git a/compiler/ccgexprs.nim b/compiler/ccgexprs.nim index 57d06a988..5f8f2d5ae 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)]) @@ -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)]) + lineCg2(p, cpsStmts, "#asgnRef((void**) $1, $2);$n", + addrLoc(dest), rdLoc(src)) else: - lineCg(p, cpsStmts, "#asgnRefNoCycle((void**) $1, $2);$n", - [addrLoc(dest), rdLoc(src)]) + lineCg2(p, cpsStmts, "#asgnRefNoCycle((void**) $1, $2);$n", + addrLoc(dest), rdLoc(src)) else: - lineCg(p, cpsStmts, "#unsureAsgnRef((void**) $1, $2);$n", - [addrLoc(dest), rdLoc(src)]) + lineCg2(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, + lineCg2(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)]) + lineCg2(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)]) + lineCg2(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)]) + lineCg2(p, cpsStmts, "$1 = $2;$n", rdLoc(dest), rdLoc(src)) return var ty = skipTypes(dest.t, abstractRange) case ty.kind @@ -231,8 +231,8 @@ 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)]) + lineCg2(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) @@ -244,46 +244,46 @@ proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) = # 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]) + lineCg2(p, cpsStmts, "$3 = $1; $1 = #copyStringRC1($2);$n", + dest.rdLoc, src.rdLoc, tmp.rdLoc) lineCg(p, cpsStmts, "if ($1) #nimGCunrefNoCycle($1);$n", tmp.rdLoc) else: - lineCg(p, cpsStmts, "#unsureAsgnRef((void**) $1, #copyString($2));$n", - [addrLoc(dest), rdLoc(src)]) + lineCg2(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)]) + lineCg2(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, + lineCg2(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? + lineCg2(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, + lineCg2(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))]) + lineCg2(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)]) + lineCg2(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)]) + lineCg2(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 diff --git a/compiler/ccgstmts.nim b/compiler/ccgstmts.nim index a950c62df..192a838e0 100755 --- a/compiler/ccgstmts.nim +++ b/compiler/ccgstmts.nim @@ -72,14 +72,12 @@ proc endBlock(p: BProc, blockEnd: PRope) = # properly indented when pretty printing is enabled line(p, cpsStmts, blockEnd) -var gBlockEndBracket = ropef("}$n") - proc endBlock(p: BProc) = let topBlock = p.blocks.len - 1 let blockEnd = if p.blocks[topBlock].label != nil: ropef("} $1: ;$n", [p.blocks[topBlock].label]) else: - gBlockEndBracket + ~"}$n" endBlock(p, blockEnd) proc genSimpleBlock(p: BProc, stmts: PNode) {.inline.} = diff --git a/compiler/ccgtypes.nim b/compiler/ccgtypes.nim index 62426a435..3a4906f2f 100755 --- a/compiler/ccgtypes.nim +++ b/compiler/ccgtypes.nim @@ -70,12 +70,12 @@ proc mangleName(s: PSym): PRope = if gCmd == cmdCompileToLLVM: case s.kind of skProc, skMethod, skConverter, skConst, skIterator: - result = toRope("@") + result = ~"@" of skVar, skForVar, skResult, skLet: - if sfGlobal in s.flags: result = toRope("@") - else: result = toRope("%") + if sfGlobal in s.flags: result = ~"@" + else: result = ~"%" of skTemp, skParam, skType, skEnumField, skModule: - result = toRope("%") + result = ~"%" else: InternalError(s.info, "mangleName") when oKeepVariableNames: let keepOrigName = s.kind in skLocalVars - {skForVar} and @@ -129,11 +129,11 @@ proc mangleName(s: PSym): PRope = result = s.name.s.mangle.toRope else: app(result, toRope(mangle(s.name.s))) - app(result, "_") + app(result, ~"_") app(result, toRope(s.id)) else: app(result, toRope(mangle(s.name.s))) - app(result, "_") + app(result, ~"_") app(result, toRope(s.id)) s.loc.r = result @@ -148,11 +148,9 @@ proc containsCompileTimeOnly(t: PType): bool = return true return false -var anonTypeName = toRope"TY" - proc typeName(typ: PType): PRope = result = if typ.sym != nil: typ.sym.name.s.mangle.toRope - else: anonTypeName + else: ~"TY" proc getTypeName(typ: PType): PRope = if (typ.sym != nil) and ({sfImportc, sfExportc} * typ.sym.flags != {}) and @@ -161,7 +159,7 @@ proc getTypeName(typ: PType): PRope = else: if typ.loc.r == nil: typ.loc.r = if gCmd != cmdCompileToLLVM: con(typ.typeName, typ.id.toRope) - else: con(["%".toRope, typ.typeName, typ.id.toRope]) + else: con([~"%", typ.typeName, typ.id.toRope]) result = typ.loc.r if result == nil: InternalError("getTypeName: " & $typ.kind) @@ -249,10 +247,10 @@ proc CacheGetType(tab: TIdTable, key: PType): PRope = result = PRope(IdTableGet(tab, key)) proc getTempName(): PRope = - result = ropeff("TMP$1", "%TMP$1", [toRope(backendId())]) + result = rfmt(nil, "TMP$1", toRope(backendId())) proc getGlobalTempName(): PRope = - result = ropeff("TMP$1", "@TMP$1", [toRope(backendId())]) + result = rfmt(nil, "TMP$1", toRope(backendId())) proc ccgIntroducedPtr(s: PSym): bool = var pt = skipTypes(s.typ, abstractInst) @@ -273,7 +271,7 @@ proc ccgIntroducedPtr(s: PSym): bool = else: result = false proc fillResult(param: PSym) = - fillLoc(param.loc, locParam, param.typ, ropeff("Result", "%Result", []), + fillLoc(param.loc, locParam, param.typ, ~"Result", OnStack) if (mapReturnType(param.typ) != ctArray) and IsInvalidReturnType(param.typ): incl(param.loc.flags, lfIndirect) @@ -291,21 +289,21 @@ proc genProcParams(m: BModule, t: PType, rettype, params: var PRope, check: var TIntSet, declareEnvironment=true) = params = nil if (t.sons[0] == nil) or isInvalidReturnType(t.sons[0]): - rettype = toRope("void") + rettype = ~"void" else: rettype = getTypeDescAux(m, t.sons[0], check) for i in countup(1, sonsLen(t.n) - 1): if t.n.sons[i].kind != nkSym: InternalError(t.n.info, "genProcParams") var param = t.n.sons[i].sym if isCompileTimeOnly(param.typ): continue - if params != nil: app(params, ", ") + if params != nil: app(params, ~", ") fillLoc(param.loc, locParam, param.typ, mangleName(param), OnStack) app(params, getParamTypeDesc(m, param.typ, check)) if ccgIntroducedPtr(param): - app(params, "*") + app(params, ~"*") incl(param.loc.flags, lfIndirect) param.loc.s = OnUnknown - app(params, " ") + app(params, ~" ") app(params, param.loc.r) # declare the len field for open arrays: var arr = param.typ diff --git a/compiler/cgen.nim b/compiler/cgen.nim index 0a903f95b..728898ed9 100755 --- a/compiler/cgen.nim +++ b/compiler/cgen.nim @@ -303,11 +303,11 @@ proc genObjectInit(p: BProc, section: TCProcSection, t: PType, a: TLoc, while (s.kind == tyObject) and (s.sons[0] != nil): app(r, ".Sup") s = skipTypes(s.sons[0], abstractInst) - lineCg(p, section, "$1.m_type = $2;$n", [r, genTypeInfo(p.module, t)]) + lineCg2(p, section, "$1.m_type = $2;$n", r, genTypeInfo(p.module, t)) of frEmbedded: # worst case for performance: var r = if takeAddr: addrLoc(a) else: rdLoc(a) - lineCg(p, section, "#objectInit($1, $2);$n", [r, genTypeInfo(p.module, t)]) + lineCg2(p, section, "#objectInit($1, $2);$n", r, genTypeInfo(p.module, t)) type TAssignmentFlag = enum @@ -330,27 +330,27 @@ proc resetLoc(p: BProc, loc: var TLoc) = nilLoc.r = toRope("NIM_NIL") genRefAssign(p, loc, nilLoc, {afSrcIsNil}) else: - lineF(p, cpsStmts, "$1 = 0;$n", [rdLoc(loc)]) + lineCg2(p, cpsStmts, "$1 = 0;$n", rdLoc(loc)) else: if loc.s != OnStack: - lineCg(p, cpsStmts, "#genericReset((void*)$1, $2);$n", - [addrLoc(loc), genTypeInfo(p.module, loc.t)]) + lineCg2(p, cpsStmts, "#genericReset((void*)$1, $2);$n", + addrLoc(loc), genTypeInfo(p.module, loc.t)) # XXX: generated reset procs should not touch the m_type # field, so disabling this should be safe: genObjectInit(p, cpsStmts, loc.t, loc, true) else: - lineF(p, cpsStmts, "memset((void*)$1, 0, sizeof($2));$n", - [addrLoc(loc), rdLoc(loc)]) + lineCg2(p, cpsStmts, "memset((void*)$1, 0, sizeof($2));$n", + addrLoc(loc), rdLoc(loc)) # XXX: We can be extra clever here and call memset only # on the bytes following the m_type field? genObjectInit(p, cpsStmts, loc.t, loc, true) proc constructLoc(p: BProc, loc: TLoc, section = cpsStmts) = if not isComplexValueType(skipTypes(loc.t, abstractRange)): - lineF(p, section, "$1 = 0;$n", [rdLoc(loc)]) + lineCg2(p, section, "$1 = 0;$n", rdLoc(loc)) else: - lineF(p, section, "memset((void*)$1, 0, sizeof($2));$n", - [addrLoc(loc), rdLoc(loc)]) + lineCg2(p, section, "memset((void*)$1, 0, sizeof($2));$n", + addrLoc(loc), rdLoc(loc)) genObjectInit(p, section, loc.t, loc, true) proc initLocalVar(p: BProc, v: PSym, immediateAsgn: bool) = @@ -377,7 +377,7 @@ proc getTemp(p: BProc, t: PType, result: var TLoc) = result.r = con("%LOC", toRope(p.labels)) else: result.r = con("LOC", toRope(p.labels)) - lineF(p, cpsLocals, "$1 $2;$n", [getTypeDesc(p.module, t), result.r]) + lineCg2(p, cpsLocals, "$1 $2;$n", getTypeDesc(p.module, t), result.r) result.k = locTemp result.a = - 1 result.t = getUniqueType(t) @@ -403,11 +403,11 @@ proc keepAlive(p: BProc, toKeepAlive: TLoc) = result.flags = {} if not isComplexValueType(skipTypes(toKeepAlive.t, abstractVarRange)): - lineF(p, cpsStmts, "$1 = $2;$n", [rdLoc(result), rdLoc(toKeepAlive)]) + lineCg2(p, cpsStmts, "$1 = $2;$n", rdLoc(result), rdLoc(toKeepAlive)) else: - lineCg(p, cpsStmts, + lineCg2(p, cpsStmts, "memcpy((void*)$1, (NIM_CONST void*)$2, sizeof($3));$n", - [addrLoc(result), addrLoc(toKeepAlive), rdLoc(result)]) + addrLoc(result), addrLoc(toKeepAlive), rdLoc(result)) proc initGCFrame(p: BProc): PRope = if p.gcFrameId > 0: result = ropef("struct {$1} GCFRAME;$n", p.gcFrameType) |