os.execShellCmd: use WEXITSTATUS to retrieve exit code (#10222) - Nim - This repository contains the Nim compiler, Nim's stdlib, tools, and documentation. (mirror)

diff options

author	alaviss <alaviss@users.noreply.github.com>	2019-01-07 18:27:07 +0700
committer	Andreas Rumpf <rumpf_a@web.de>	2019-01-07 12:27:07 +0100
commit	139fa396e8fa0e8603d4f53ac90841421e50aa3f (patch)
tree	8b6640bd50e9f5b6826f6e0fd5a6160798dadd35 /tests/cpp/tvector_iterator.nim
parent	87f8ec5b92d5647ab4b1875262e845d51dd82763 (diff)
download	Nim-139fa396e8fa0e8603d4f53ac90841421e50aa3f.tar.gz

os.execShellCmd: use WEXITSTATUS to retrieve exit code (#10222)

According to POSIX, system() shall returns the termination status in the
format specified by waitpid(), which means WEXITSTATUS should be used to
retrieve the exit code portably.

This fixes execShellCmd on Haiku.

Diffstat (limited to 'tests/cpp/tvector_iterator.nim')

0 files changed, 0 insertions, 0 deletions

# # # Nim's Runtime Library # (c) Copyright 2014 Dominik Picheta # # See the file "copying.txt", included in this # distribution, for details about the copyright. # ## This module implements asynchronous file handling. ## ## .. code-block:: Nim ## import asyncfile, asyncdispatch, os ## ## proc main() {.async.} = ## var file = openAsync(getTempDir() / "foobar.txt", fmReadWrite) ## await file.write("test") ## file.setFilePos(0) ## let data = await file.readAll() ## doAssert data == "test" ## file.close() ## ## waitFor main() import asyncdispatch, os when defined(windows): import winlean else: import posix type AsyncFile = ref object fd: TAsyncFd offset: int64 when defined(windows): proc getDesiredAccess(mode: TFileMode): int32 = case mode of fmRead: result = GENERIC_READ of fmWrite, fmAppend: result = GENERIC_WRITE of fmReadWrite, fmReadWriteExisting: result = GENERIC_READ or GENERIC_WRITE proc getCreationDisposition(mode: TFileMode, filename: string): int32 = case mode of fmRead, fmReadWriteExisting: OPEN_EXISTING of fmAppend, fmReadWrite, fmWrite: if fileExists(filename): OPEN_EXISTING else: CREATE_NEW else: proc getPosixFlags(mode: TFileMode): cint = case mode of fmRead: result = O_RDONLY of fmWrite: result = O_WRONLY or O_CREAT of fmAppend: result = O_WRONLY or O_CREAT or O_APPEND of fmReadWrite: result = O_RDWR or O_CREAT of fmReadWriteExisting: result = O_RDWR result = result or O_NONBLOCK proc getFileSize(f: AsyncFile): int64 = ## Retrieves the specified file's size. when defined(windows): var high: DWord let low = getFileSize(f.fd.THandle, addr high) if low == INVALID_FILE_SIZE: raiseOSError() return (high shl 32) or low proc openAsync*(filename: string, mode = fmRead): AsyncFile = ## Opens a file specified by the path in ``filename`` using ## the specified ``mode`` asynchronously. new result when defined(windows): let flags = FILE_FLAG_OVERLAPPED or FILE_ATTRIBUTE_NORMAL let desiredAccess = getDesiredAccess(mode) let creationDisposition = getCreationDisposition(mode, filename) when useWinUnicode: result.fd = createFileW(newWideCString(filename), desiredAccess, FILE_SHARE_READ, nil, creationDisposition, flags, 0).TAsyncFd else: result.fd = createFileA(filename, desiredAccess, FILE_SHARE_READ, nil, creationDisposition, flags, 0).TAsyncFd if result.fd.THandle == INVALID_HANDLE_VALUE: raiseOSError() register(result.fd) if mode == fmAppend: result.offset = getFileSize(result) else: let flags = getPosixFlags(mode) # RW (Owner), RW (Group), R (Other) let perm = S_IRUSR or S_IWUSR or S_IRGRP or S_IWGRP or S_IROTH result.fd = open(filename, flags, perm).TAsyncFD if result.fd.cint == -1: raiseOSError() register(result.fd) proc read*(f: AsyncFile, size: int): Future[string] = ## Read ``size`` bytes from the specified file asynchronously starting at ## the current position of the file pointer. ## ## If the file pointer is past the end of the file then an empty string is ## returned. var retFuture = newFuture[string]("asyncfile.read") when defined(windows): var buffer = alloc0(size) var ol = PCustomOverlapped() GC_ref(ol) ol.data = TCompletionData(sock: f.fd, cb: proc (fd: TAsyncFD, bytesCount: Dword, errcode: OSErrorCode) = if not retFuture.finished: if errcode == OSErrorCode(-1): assert bytesCount > 0 assert bytesCount <= size var data = newString(bytesCount) copyMem(addr data[0], buffer, bytesCount) f.offset.inc bytesCount retFuture.complete($data) else: if errcode.int32 == ERROR_HANDLE_EOF: retFuture.complete("") else: retFuture.fail(newException(OSError, osErrorMsg(errcode))) if buffer != nil: dealloc buffer buffer = nil ) ol.offset = DWord(f.offset and 0xffffffff) ol.offsetHigh = DWord(f.offset shr 32) # According to MSDN we're supposed to pass nil to lpNumberOfBytesRead. let ret = readFile(f.fd.THandle, buffer, size.int32, nil, cast[POVERLAPPED](ol)) if not ret.bool: let err = osLastError() if err.int32 != ERROR_IO_PENDING: if buffer != nil: dealloc buffer buffer = nil GC_unref(ol) retFuture.fail(newException(OSError, osErrorMsg(err))) else: # Request completed immediately. var bytesRead: DWord let overlappedRes = getOverlappedResult(f.fd.THandle, cast[POverlapped](ol)[], bytesRead, false.WinBool) if not overlappedRes.bool: let err = osLastError() if err.int32 == ERROR_HANDLE_EOF: retFuture.complete("") else: retFuture.fail(newException(OSError, osErrorMsg(osLastError()))) else: assert bytesRead > 0 assert bytesRead <= size var data = newString(bytesRead) copyMem(addr data[0], buffer, bytesRead) f.offset.inc bytesRead retFuture.complete($data) else: var readBuffer = newString(size) proc cb(fd: TAsyncFD): bool = result = true let res = read(fd.cint, addr readBuffer[0], size.cint) if res < 0: let lastError = osLastError() if lastError.int32 != EAGAIN: retFuture.fail(newException(EOS, osErrorMsg(lastError))) else: result = false # We still want this callback to be called. elif res == 0: # EOF retFuture.complete("") else: readBuffer.setLen(res) f.offset.inc(res) retFuture.complete(readBuffer) if not cb(f.fd): addRead(f.fd, cb) return retFuture proc readLine*(f: AsyncFile): Future[string] {.async.} = ## Reads a single line from the specified file asynchronously. result = "" while true: var c = await read(f, 1) if c[0] == '\c': c = await read(f, 1) break if c[0] == '\L' or c == "": break else: result.add(c) proc getFilePos*(f: AsyncFile): int64 = ## Retrieves the current position of the file pointer that is ## used to read from the specified file. The file's first byte has the ## index zero. f.offset proc setFilePos*(f: AsyncFile, pos: int64) = ## Sets the position of the file pointer that is used for read/write ## operations. The file's first byte has the index zero. f.offset = pos when not defined(windows): let ret = lseek(f.fd.cint, pos, SEEK_SET) if ret == -1: raiseOSError() proc readAll*(f: AsyncFile): Future[string] {.async.} = ## Reads all data from the specified file. result = "" while true: let data = await read(f, 4000) if data.len == 0: return result.add data proc write*(f: AsyncFile, data: string): Future[void] = ## Writes ``data`` to the file specified asynchronously. ## ## The returned Future will complete once all data has been written to the ## specified file. var retFuture = newFuture[void]("asyncfile.write") var copy = data when defined(windows): var buffer = alloc0(data.len) copyMem(buffer, addr copy[0], data.len) var ol = PCustomOverlapped() GC_ref(ol) ol.data = TCompletionData(sock: f.fd, cb: proc (fd: TAsyncFD, bytesCount: DWord, errcode: OSErrorCode) = if not retFuture.finished: if errcode == OSErrorCode(-1): assert bytesCount == data.len.int32 f.offset.inc(data.len) retFuture.complete() else: retFuture.fail(newException(OSError, osErrorMsg(errcode))) if buffer != nil: dealloc buffer buffer = nil ) ol.offset = DWord(f.offset and 0xffffffff) ol.offsetHigh = DWord(f.offset shr 32) # According to MSDN we're supposed to pass nil to lpNumberOfBytesWritten. let ret = writeFile(f.fd.THandle, buffer, data.len.int32, nil, cast[POVERLAPPED](ol)) if not ret.bool: let err = osLastError() if err.int32 != ERROR_IO_PENDING: if buffer != nil: dealloc buffer buffer = nil GC_unref(ol) retFuture.fail(newException(OSError, osErrorMsg(err))) else: # Request completed immediately. var bytesWritten: DWord let overlappedRes = getOverlappedResult(f.fd.THandle, cast[POverlapped](ol)[], bytesWritten, false.WinBool) if not overlappedRes.bool: retFuture.fail(newException(OSError, osErrorMsg(osLastError()))) else: assert bytesWritten == data.len.int32 f.offset.inc(data.len) retFuture.complete() else: var written = 0 proc cb(fd: TAsyncFD): bool = result = true let remainderSize = data.len-written let res = write(fd.cint, addr copy[written], remainderSize.cint) if res < 0: let lastError = osLastError() if lastError.int32 != EAGAIN: retFuture.fail(newException(EOS, osErrorMsg(lastError))) else: result = false # We still want this callback to be called. else: written.inc res f.offset.inc res if res != remainderSize: result = false # We still have data to write. else: retFuture.complete() if not cb(f.fd): addWrite(f.fd, cb) return retFuture proc close*(f: AsyncFile) = ## Closes the file specified. when defined(windows): if not closeHandle(f.fd.THandle).bool: raiseOSError() else: if close(f.fd.cint) == -1: raiseOSError()


context:
space:
mode: