mirrors/Nim
1
0
Fork 0
mirror of https://github.com/nim-lang/Nim.git synced 2026-06-10 05:38:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

unsafeAddr => addr (stdlib)

Browse Source
This commit is contained in:
flywind
2022-01-13 08:55:35 +08:00
parent a4ff401f50
commit ab83c99c50
20 changed files with 42 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
lib/impure/db_sqlite.nim
View File

@@ -121,7 +121,7 @@
## var id = 1
## ## Data needs to be converted to seq[byte] to be interpreted as binary by bindParams
## var dbuf = newSeq[byte](orig.len*sizeof(float64))
## copyMem(unsafeAddr(dbuf[0]), unsafeAddr(orig[0]), dbuf.len)
## copyMem(addr(dbuf[0]), addr(orig[0]), dbuf.len)
##
## ## Use prepared statement to insert binary data into database
## var insertStmt = db.prepare("INSERT INTO test (id, data) VALUES (?, ?)")
@@ -138,7 +138,7 @@
## let seqSize = int(dataTest.len*sizeof(byte)/sizeof(float64))
## ## Copy binary string data in dataTest into a seq
## var res: seq[float64] = newSeq[float64](seqSize)
## copyMem(unsafeAddr(res[0]), addr(dataTest[0]), dataTest.len)
## copyMem(addr(res[0]), addr(dataTest[0]), dataTest.len)
##
## ## Check datas obtained is identical
## doAssert res == orig
@@ -827,7 +827,7 @@ proc bindParam*(ps: SqlPrepared, paramIdx: int,val: openArray[byte], copy = true
## binds a blob to the specified paramIndex.
## if copy is true then SQLite makes its own private copy of the data immediately
let len = val.len
if bind_blob(ps.PStmt, paramIdx.int32, val[0].unsafeAddr, len.int32, if copy: SQLITE_TRANSIENT else: SQLITE_STATIC) != SQLITE_OK:
if bind_blob(ps.PStmt, paramIdx.int32, val[0].addr, len.int32, if copy: SQLITE_TRANSIENT else: SQLITE_STATIC) != SQLITE_OK:
dbBindParamError(paramIdx, val)
macro bindParams*(ps: SqlPrepared, params: varargs[untyped]): untyped {.since: (1, 3).} =

4
lib/impure/re.nim
View File

@@ -122,7 +122,7 @@ proc bufSubstr(b: cstring, sPos, ePos: int): string {.inline.} =
## Don't assume cstring is '\0' terminated
let sz = ePos - sPos
result = newString(sz+1)
copyMem(addr(result[0]), unsafeAddr(b[sPos]), sz)
copyMem(addr(result[0]), addr(b[sPos]), sz)
result.setLen(sz)
proc matchOrFind(buf: cstring, pattern: Regex, matches: var openArray[string],
@@ -427,7 +427,7 @@ iterator findAll*(buf: cstring, pattern: Regex, start = 0, bufSize: int): string
let b = rawMatches[1]
if a == b and a == i: break
var str = newString(b-a)
copyMem(str[0].addr, unsafeAddr(buf[a]), b-a)
copyMem(str[0].addr, addr(buf[a]), b-a)
yield str
i = b

2
lib/pure/asyncdispatch.nim
View File

@@ -1920,7 +1920,7 @@ proc send*(socket: AsyncFD, data: string,
## data has been sent.
var retFuture = newFuture[void]("send")
if data.len > 0:
let sendFut = socket.send(unsafeAddr data[0], data.len, flags)
let sendFut = socket.send(addr data[0], data.len, flags)
sendFut.callback =
proc () =
keepAlive(data)

2
lib/pure/base64.nim
View File

@@ -138,7 +138,7 @@ template encodeImpl() {.dirty.} =
encodeInternal(s, lookupTableVM)
else:
block:
let lookupTable = if safe: unsafeAddr(cb64safe) else: unsafeAddr(cb64)
let lookupTable = if safe: addr(cb64safe) else: addr(cb64)
encodeInternal(s, lookupTable)
proc encode*[T: SomeInteger|char](s: openArray[T], safe = false): string =

2
lib/pure/hashes.nim
View File

@@ -324,7 +324,7 @@ proc murmurHash(x: openArray[byte]): Hash =
dec j
k1 = (k1 shl 8) or (ord(x[i+j])).uint32
else:
k1 = cast[ptr uint32](unsafeAddr x[i])[]
k1 = cast[ptr uint32](addr x[i])[]
inc i, stepSize
k1 = imul(k1, c1)

2
lib/pure/nativesockets.nim
View File

@@ -663,7 +663,7 @@ when useNimNetLite:
return ""
proc sockAddrToStr(sa: var Sockaddr_in | var Sockaddr_in6): string =
result = sockAddrToStr(cast[ptr SockAddr](unsafeAddr(sa)))
result = sockAddrToStr(cast[ptr SockAddr](addr(sa)))
proc getAddrString*(sockAddr: ptr SockAddr): string =
result = sockAddrToStr(sockAddr)

6
lib/pure/net.nim
View File

@@ -484,14 +484,14 @@ proc toSockAddr*(address: IpAddress, port: Port, sa: var Sockaddr_storage,
let s = cast[ptr Sockaddr_in](addr sa)
s.sin_family = typeof(s.sin_family)(toInt(AF_INET))
s.sin_port = port
copyMem(addr s.sin_addr, unsafeAddr address.address_v4[0],
copyMem(addr s.sin_addr, addr address.address_v4[0],
sizeof(s.sin_addr))
of IpAddressFamily.IPv6:
sl = sizeof(Sockaddr_in6).SockLen
let s = cast[ptr Sockaddr_in6](addr sa)
s.sin6_family = typeof(s.sin6_family)(toInt(AF_INET6))
s.sin6_port = port
copyMem(addr s.sin6_addr, unsafeAddr address.address_v6[0],
copyMem(addr s.sin6_addr, addr address.address_v6[0],
sizeof(s.sin6_addr))
proc fromSockAddrAux(sa: ptr Sockaddr_storage, sl: SockLen,
@@ -516,7 +516,7 @@ proc fromSockAddr*(sa: Sockaddr_storage | SockAddr | Sockaddr_in | Sockaddr_in6,
sl: SockLen, address: var IpAddress, port: var Port) {.inline.} =
## Converts `SockAddr` and `SockLen` to `IpAddress` and `Port`. Raises
## `ObjectConversionDefect` in case of invalid `sa` and `sl` arguments.
fromSockAddrAux(cast[ptr Sockaddr_storage](unsafeAddr sa), sl, address, port)
fromSockAddrAux(cast[ptr Sockaddr_storage](addr sa), sl, address, port)
when defineSsl:
CRYPTO_malloc_init()

6
lib/pure/streams.nim
View File

@@ -333,7 +333,7 @@ proc write*[T](s: Stream, x: T) =
##
## .. code-block:: Nim
##
## s.writeData(s, unsafeAddr(x), sizeof(x))
## s.writeData(s, addr(x), sizeof(x))
runnableExamples:
var strm = newStringStream("")
strm.write("abcde")
@@ -341,7 +341,7 @@ proc write*[T](s: Stream, x: T) =
doAssert strm.readAll() == "abcde"
strm.close()
writeData(s, unsafeAddr(x), sizeof(x))
writeData(s, addr(x), sizeof(x))
proc write*(s: Stream, x: string) =
## Writes the string `x` to the stream `s`. No length field or
@@ -1196,7 +1196,7 @@ else: # after 1.3 or JS not defined
jsOrVmBlock:
buffer[slice.a..<slice.a+result] = s.data[s.pos..<s.pos+result]
do:
copyMem(unsafeAddr buffer[slice.a], addr s.data[s.pos], result)
copyMem(addr buffer[slice.a], addr s.data[s.pos], result)
inc(s.pos, result)
else:
result = 0

4
lib/pure/strutils.nim
View File

@@ -1875,7 +1875,7 @@ func find*(s: string, sub: char, start: Natural = 0, last = 0): int {.rtl,
when hasCStringBuiltin:
let L = last-start+1
if L > 0:
let found = c_memchr(s[start].unsafeAddr, sub, cast[csize_t](L))
let found = c_memchr(s[start].addr, sub, cast[csize_t](L))
if not found.isNil:
return cast[ByteAddress](found) -% cast[ByteAddress](s.cstring)
else:
@@ -1928,7 +1928,7 @@ func find*(s, sub: string, start: Natural = 0, last = 0): int {.rtl,
else:
when hasCStringBuiltin:
if last == 0 and s.len > start:
let found = c_strstr(s[start].unsafeAddr, sub)
let found = c_strstr(s[start].addr, sub)
if not found.isNil:
result = cast[ByteAddress](found) -% cast[ByteAddress](s.cstring)
else:

4
lib/std/private/digitsutils.nim
View File

@@ -31,7 +31,7 @@ const
proc utoa2Digits*(buf: var openArray[char]; pos: int; digits: uint32) {.inline.} =
buf[pos] = digits100[2 * digits]
buf[pos+1] = digits100[2 * digits + 1]
#copyMem(buf, unsafeAddr(digits100[2 * digits]), 2 * sizeof((char)))
#copyMem(buf, addr(digits100[2 * digits]), 2 * sizeof((char)))
proc trailingZeros2Digits*(digits: uint32): int32 {.inline.} =
return trailingZeros100[digits]
@@ -49,7 +49,7 @@ func addChars[T](result: var string, x: T, start: int, n: int) {.inline.} =
when defined(js) or defined(nimscript): impl
else:
{.noSideEffect.}:
copyMem result[old].addr, x[start].unsafeAddr, n
copyMem result[old].addr, x[start].addr, n
func addChars[T](result: var string, x: T) {.inline.} =
addChars(result, x, 0, x.len)

4
lib/std/sha1.nim
View File

@@ -152,7 +152,7 @@ proc update*(ctx: var Sha1State, data: openArray[char]) =
# Gather 64-bytes worth of data in order to perform a round with the leftover
# data we had stored (but not processed yet)
if len > 64 - i:
copyMem(addr ctx.buf[i], unsafeAddr data[j], 64 - i)
copyMem(addr ctx.buf[i], addr data[j], 64 - i)
len -= 64 - i
j += 64 - i
transform(ctx)
@@ -161,7 +161,7 @@ proc update*(ctx: var Sha1State, data: openArray[char]) =
i = 0
# Process the bulk of the payload
while len >= 64:
copyMem(addr ctx.buf[0], unsafeAddr data[j], 64)
copyMem(addr ctx.buf[0], addr data[j], 64)
len -= 64
j += 64
transform(ctx)

4
lib/system/ansi_c.nim
View File

@@ -111,11 +111,11 @@ elif defined(nimBuiltinSetjmp):
proc c_builtin_longjmp(jmpb: ptr pointer, retval: cint) {.
importc: "__builtin_longjmp", nodecl.}
# The second parameter needs to be 1 and sometimes the C/C++ compiler checks it.
c_builtin_longjmp(unsafeAddr jmpb[0], 1)
c_builtin_longjmp(addr jmpb[0], 1)
proc c_setjmp*(jmpb: C_JmpBuf): cint =
proc c_builtin_setjmp(jmpb: ptr pointer): cint {.
importc: "__builtin_setjmp", nodecl.}
c_builtin_setjmp(unsafeAddr jmpb[0])
c_builtin_setjmp(addr jmpb[0])
elif defined(nimRawSetjmp) and not defined(nimStdSetjmp):
when defined(windows):
# No `_longjmp()` on Windows.

2
lib/system/atomics.nim
View File

@@ -308,7 +308,7 @@ static int __tcc_cas(int *ptr, int oldVal, int newVal)
tcc_cas(cast[ptr int](p), cast[int](oldValue), cast[int](newValue))
elif declared(atomicCompareExchangeN):
proc cas*[T: bool|int|ptr](p: ptr T; oldValue, newValue: T): bool =
atomicCompareExchangeN(p, oldValue.unsafeAddr, newValue, false, ATOMIC_SEQ_CST, ATOMIC_SEQ_CST)
atomicCompareExchangeN(p, oldValue.addr, newValue, false, ATOMIC_SEQ_CST, ATOMIC_SEQ_CST)
else:
# this is valid for GCC and Intel C++
proc cas*[T: bool|int|ptr](p: ptr T; oldValue, newValue: T): bool

4
lib/system/channels_builtin.nim
View File

@@ -366,7 +366,7 @@ proc sendImpl(q: PRawChannel, typ: PNimType, msg: pointer, noBlock: bool): bool
proc send*[TMsg](c: var Channel[TMsg], msg: sink TMsg) {.inline.} =
## Sends a message to a thread. `msg` is deeply copied.
discard sendImpl(cast[PRawChannel](addr c), cast[PNimType](getTypeInfo(msg)), unsafeAddr(msg), false)
discard sendImpl(cast[PRawChannel](addr c), cast[PNimType](getTypeInfo(msg)), addr(msg), false)
when defined(gcDestructors):
wasMoved(msg)
@@ -377,7 +377,7 @@ proc trySend*[TMsg](c: var Channel[TMsg], msg: sink TMsg): bool {.inline.} =
##
## Returns `false` if the message was not sent because number of pending items
## in the channel exceeded `maxItems`.
result = sendImpl(cast[PRawChannel](addr c), cast[PNimType](getTypeInfo(msg)), unsafeAddr(msg), true)
result = sendImpl(cast[PRawChannel](addr c), cast[PNimType](getTypeInfo(msg)), addr(msg), true)
when defined(gcDestructors):
if result:
wasMoved(msg)

4
lib/system/io.nim
View File

@@ -251,7 +251,7 @@ when defined(windows):
break
inc i
else:
let w = c_fprintf(f, "%s", unsafeAddr s[i])
let w = c_fprintf(f, "%s", addr s[i])
if w <= 0:
if doRaise: raiseEIO("cannot write string to file")
break
@@ -896,7 +896,7 @@ proc writeFile*(filename: string, content: openArray[byte]) {.since: (1, 1).} =
var f: File = nil
if open(f, filename, fmWrite):
try:
f.writeBuffer(unsafeAddr content[0], content.len)
f.writeBuffer(addr content[0], content.len)
finally:
close(f)
else:

2
lib/system/repr_v2.nim
View File

@@ -90,7 +90,7 @@ proc repr*(p: pointer): string =
proc repr*(p: proc): string =
## repr of a proc as its address
repr(cast[ptr pointer](unsafeAddr p)[])
repr(cast[ptr pointer](addr p)[])
template repr*(x: distinct): string =
repr(distinctBase(typeof(x))(x))

2
lib/system/sets.nim
View File

@@ -18,7 +18,7 @@ proc cardSet(s: NimSet, len: int): int {.compilerproc, inline.} =
result = 0
when defined(x86) or defined(amd64):
while i < len - 8:
inc(result, countBits64((cast[ptr uint64](s[i].unsafeAddr))[]))
inc(result, countBits64((cast[ptr uint64](s[i].addr))[]))
inc(i, 8)
while i < len:

4
lib/system/strmantle.nim
View File

@@ -17,7 +17,7 @@ proc cmpStrings(a, b: string): int {.inline, compilerproc.} =
let blen = b.len
let minlen = min(alen, blen)
if minlen > 0:
result = c_memcmp(unsafeAddr a[0], unsafeAddr b[0], cast[csize_t](minlen))
result = c_memcmp(addr a[0], addr b[0], cast[csize_t](minlen))
if result == 0:
result = alen - blen
else:
@@ -28,7 +28,7 @@ proc eqStrings(a, b: string): bool {.inline, compilerproc.} =
let blen = b.len
if alen == blen:
if alen == 0: return true
return equalMem(unsafeAddr(a[0]), unsafeAddr(b[0]), alen)
return equalMem(addr(a[0]), addr(b[0]), alen)
proc hashString(s: string): int {.compilerproc.} =
# the compiler needs exactly the same hash function!

14
lib/system/strs_v2.nim
View File

@@ -51,7 +51,7 @@ proc prepareAdd(s: var NimStringV2; addlen: int) {.compilerRtl.} =
s.p.cap = newLen
if s.len > 0:
# we are about to append, so there is no need to copy the \0 terminator:
copyMem(unsafeAddr s.p.data[0], unsafeAddr oldP.data[0], min(s.len, newLen))
copyMem(addr s.p.data[0], addr oldP.data[0], min(s.len, newLen))
else:
let oldCap = s.p.cap and not strlitFlag
if newLen > oldCap:
@@ -80,7 +80,7 @@ proc toNimStr(str: cstring, len: int): NimStringV2 {.compilerproc.} =
p.cap = len
if len > 0:
# we are about to append, so there is no need to copy the \0 terminator:
copyMem(unsafeAddr p.data[0], str, len)
copyMem(addr p.data[0], str, len)
result = NimStringV2(len: len, p: p)
proc cstrToNimstr(str: cstring): NimStringV2 {.compilerRtl.} =
@@ -89,12 +89,12 @@ proc cstrToNimstr(str: cstring): NimStringV2 {.compilerRtl.} =
proc nimToCStringConv(s: NimStringV2): cstring {.compilerproc, nonReloadable, inline.} =
if s.len == 0: result = cstring""
else: result = cstring(unsafeAddr s.p.data)
else: result = cstring(addr s.p.data)
proc appendString(dest: var NimStringV2; src: NimStringV2) {.compilerproc, inline.} =
if src.len > 0:
# also copy the \0 terminator:
copyMem(unsafeAddr dest.p.data[dest.len], unsafeAddr src.p.data[0], src.len+1)
copyMem(addr dest.p.data[dest.len], addr src.p.data[0], src.len+1)
inc dest.len, src.len
proc appendChar(dest: var NimStringV2; c: char) {.compilerproc, inline.} =
@@ -153,7 +153,7 @@ proc nimAsgnStrV2(a: var NimStringV2, b: NimStringV2) {.compilerRtl.} =
a.p = cast[ptr NimStrPayload](alloc0(contentSize(b.len)))
a.p.cap = b.len
a.len = b.len
copyMem(unsafeAddr a.p.data[0], unsafeAddr b.p.data[0], b.len+1)
copyMem(addr a.p.data[0], addr b.p.data[0], b.len+1)
proc nimPrepareStrMutationImpl(s: var NimStringV2) =
let oldP = s.p
@@ -163,7 +163,7 @@ proc nimPrepareStrMutationImpl(s: var NimStringV2) =
else:
s.p = cast[ptr NimStrPayload](alloc0(contentSize(s.len)))
s.p.cap = s.len
copyMem(unsafeAddr s.p.data[0], unsafeAddr oldP.data[0], s.len+1)
copyMem(addr s.p.data[0], addr oldP.data[0], s.len+1)
proc nimPrepareStrMutationV2(s: var NimStringV2) {.compilerRtl, inline.} =
if s.p != nil and (s.p.cap and strlitFlag) == strlitFlag:
@@ -173,5 +173,5 @@ proc prepareMutation*(s: var string) {.inline.} =
# string literals are "copy on write", so you need to call
# `prepareMutation` before modifying the strings via `addr`.
{.cast(noSideEffect).}:
let s = unsafeAddr s
let s = addr s
nimPrepareStrMutationV2(cast[ptr NimStringV2](s)[])

6
lib/system/sysstr.nim
View File

@@ -163,7 +163,7 @@ proc addChar(s: NimString, c: char): NimString =
when defined(nimIncrSeqV3):
result = rawNewStringNoInit(r)
result.len = s.len
copyMem(addr result.data[0], unsafeAddr(s.data[0]), s.len+1)
copyMem(addr result.data[0], addr(s.data[0]), s.len+1)
else:
result = cast[NimString](growObj(result,
sizeof(TGenericSeq) + r + 1))
@@ -213,7 +213,7 @@ proc resizeString(dest: NimString, addlen: int): NimString {.compilerRtl.} =
when defined(nimIncrSeqV3):
result = rawNewStringNoInit(sp)
result.len = dest.len
copyMem(addr result.data[0], unsafeAddr(dest.data[0]), dest.len+1)
copyMem(addr result.data[0], addr(dest.data[0]), dest.len+1)
else:
result = cast[NimString](growObj(dest, sizeof(TGenericSeq) + sp + 1))
result.reserved = sp
@@ -242,7 +242,7 @@ proc setLengthStr(s: NimString, newLen: int): NimString {.compilerRtl.} =
when defined(nimIncrSeqV3):
result = rawNewStringNoInit(sp)
result.len = s.len
copyMem(addr result.data[0], unsafeAddr(s.data[0]), s.len+1)
copyMem(addr result.data[0], addr(s.data[0]), s.len+1)
zeroMem(addr result.data[s.len], newLen - s.len)
result.reserved = sp
else: