From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: PJ Reiniger Date: Tue, 26 Apr 2022 15:01:25 -0400 Subject: [PATCH 02/10] Fix missing casts --- src/fs-poll.c | 10 ++++---- src/inet.c | 11 ++++---- src/strscpy.c | 2 +- src/thread-common.c | 2 +- src/threadpool.c | 2 +- src/unix/bsd-ifaddrs.c | 2 +- src/unix/core.c | 18 ++++++------- src/unix/darwin-proctitle.c | 5 ++-- src/unix/darwin.c | 2 +- src/unix/freebsd.c | 4 +-- src/unix/fs.c | 20 +++++++-------- src/unix/fsevents.c | 34 ++++++++++++------------- src/unix/getaddrinfo.c | 8 +++--- src/unix/ibmi.c | 2 +- src/unix/kqueue.c | 6 ++--- src/unix/linux.c | 46 +++++++++++++++++----------------- src/unix/loop.c | 2 +- src/unix/netbsd.c | 4 +-- src/unix/openbsd.c | 4 +-- src/unix/pipe.c | 4 +-- src/unix/poll.c | 4 +-- src/unix/posix-poll.c | 2 +- src/unix/process.c | 4 +-- src/unix/proctitle.c | 2 +- src/unix/random-sysctl-linux.c | 2 +- src/unix/stream.c | 31 ++++++++++++----------- src/unix/thread.c | 5 ++-- src/unix/udp.c | 8 +++--- src/uv-common.c | 16 ++++++------ src/win/core.c | 8 +++--- src/win/fs-event.c | 4 +-- src/win/fs-fd-hash-inl.h | 2 +- src/win/fs.c | 28 ++++++++++----------- src/win/pipe.c | 12 ++++----- src/win/process.c | 12 ++++----- src/win/tcp.c | 2 +- src/win/thread.c | 4 +-- src/win/util.c | 27 ++++++++++---------- 38 files changed, 183 insertions(+), 178 deletions(-) diff --git a/src/fs-poll.c b/src/fs-poll.c index 1bac1c568e36cadd0b68451926c6f045f88342d2..5a39daed095502b2db34f23fcaf0ab04f31f96ff 100644 --- a/src/fs-poll.c +++ b/src/fs-poll.c @@ -77,7 +77,7 @@ int uv_fs_poll_start(uv_fs_poll_t* handle, loop = handle->loop; len = strlen(path); - ctx = uv__calloc(1, sizeof(*ctx) + len); + ctx = (struct poll_ctx*)uv__calloc(1, sizeof(*ctx) + len); if (ctx == NULL) return UV_ENOMEM; @@ -101,7 +101,7 @@ int uv_fs_poll_start(uv_fs_poll_t* handle, goto error; if (handle->poll_ctx != NULL) - ctx->previous = handle->poll_ctx; + ctx->previous = (struct poll_ctx*)handle->poll_ctx; handle->poll_ctx = ctx; uv__handle_start(handle); @@ -119,7 +119,7 @@ int uv_fs_poll_stop(uv_fs_poll_t* handle) { if (!uv_is_active((uv_handle_t*)handle)) return 0; - ctx = handle->poll_ctx; + ctx = (struct poll_ctx*)handle->poll_ctx; assert(ctx != NULL); assert(ctx->parent_handle == handle); @@ -144,7 +144,7 @@ int uv_fs_poll_getpath(uv_fs_poll_t* handle, char* buffer, size_t* size) { return UV_EINVAL; } - ctx = handle->poll_ctx; + ctx = (struct poll_ctx*)handle->poll_ctx; assert(ctx != NULL); required_len = strlen(ctx->path); @@ -244,7 +244,7 @@ static void timer_close_cb(uv_handle_t* timer) { if (handle->poll_ctx == NULL && uv__is_closing(handle)) uv__make_close_pending((uv_handle_t*)handle); } else { - for (last = handle->poll_ctx, it = last->previous; + for (last = (struct poll_ctx*)handle->poll_ctx, it = last->previous; it != ctx; last = it, it = it->previous) { assert(last->previous != NULL); diff --git a/src/inet.c b/src/inet.c index cd77496846e90e8b8e61c63c10f498f153344fe5..dd94bea3886ca37945fcad7909d765e3700e3c21 100644 --- a/src/inet.c +++ b/src/inet.c @@ -35,9 +35,9 @@ static int inet_pton6(const char *src, unsigned char *dst); int uv_inet_ntop(int af, const void* src, char* dst, size_t size) { switch (af) { case AF_INET: - return (inet_ntop4(src, dst, size)); + return (inet_ntop4((const unsigned char*)src, dst, size)); case AF_INET6: - return (inet_ntop6(src, dst, size)); + return (inet_ntop6((const unsigned char*)src, dst, size)); default: return UV_EAFNOSUPPORT; } @@ -149,10 +149,11 @@ int uv_inet_pton(int af, const char* src, void* dst) { switch (af) { case AF_INET: - return (inet_pton4(src, dst)); + return (inet_pton4(src, (unsigned char*)dst)); case AF_INET6: { int len; - char tmp[UV__INET6_ADDRSTRLEN], *s, *p; + char tmp[UV__INET6_ADDRSTRLEN], *s; + const char *p; s = (char*) src; p = strchr(src, '%'); if (p != NULL) { @@ -163,7 +164,7 @@ int uv_inet_pton(int af, const char* src, void* dst) { memcpy(s, src, len); s[len] = '\0'; } - return inet_pton6(s, dst); + return inet_pton6(s, (unsigned char*)dst); } default: return UV_EAFNOSUPPORT; diff --git a/src/strscpy.c b/src/strscpy.c index 20df6fcbed29e9d944c866ddbcd5c09345a426b3..6b4cc3bc741b40b9c2b13d4c06e7090f8083a7ba 100644 --- a/src/strscpy.c +++ b/src/strscpy.c @@ -27,7 +27,7 @@ ssize_t uv__strscpy(char* d, const char* s, size_t n) { for (i = 0; i < n; i++) if ('\0' == (d[i] = s[i])) - return i > SSIZE_MAX ? UV_E2BIG : (ssize_t) i; + return i > SSIZE_MAX ? (ssize_t) UV_E2BIG : (ssize_t) i; if (i == 0) return 0; diff --git a/src/thread-common.c b/src/thread-common.c index c67c0a7dd7279af6c67b7d5d4a623c47bdf3fff2..c0e39b543df229dd8cb8492bb695e61e40911453 100644 --- a/src/thread-common.c +++ b/src/thread-common.c @@ -49,7 +49,7 @@ int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) { if (barrier == NULL || count == 0) return UV_EINVAL; - b = uv__malloc(sizeof(*b)); + b = (struct _uv_barrier *)uv__malloc(sizeof(*b)); if (b == NULL) return UV_ENOMEM; #endif diff --git a/src/threadpool.c b/src/threadpool.c index dbef67f2f10f1df498f228c21eba2a71ceceee29..f572de5aaf1a1b150e58c7b989949441cac279c4 100644 --- a/src/threadpool.c +++ b/src/threadpool.c @@ -207,7 +207,7 @@ static void init_threads(void) { threads = default_threads; if (nthreads > ARRAY_SIZE(default_threads)) { - threads = uv__malloc(nthreads * sizeof(threads[0])); + threads = (uv_thread_t*)uv__malloc(nthreads * sizeof(threads[0])); if (threads == NULL) { nthreads = ARRAY_SIZE(default_threads); threads = default_threads; diff --git a/src/unix/bsd-ifaddrs.c b/src/unix/bsd-ifaddrs.c index 11ca95591fc38244e931fecd9dd4038d3968af7a..c3dd71a1889bfae08cfdf95acda61e6c3472bd2c 100644 --- a/src/unix/bsd-ifaddrs.c +++ b/src/unix/bsd-ifaddrs.c @@ -92,7 +92,7 @@ int uv_interface_addresses(uv_interface_address_t** addresses, int* count) { } /* Make sure the memory is initiallized to zero using calloc() */ - *addresses = uv__calloc(*count, sizeof(**addresses)); + *addresses = (uv_interface_address_t*)uv__calloc(*count, sizeof(**addresses)); if (*addresses == NULL) { freeifaddrs(addrs); diff --git a/src/unix/core.c b/src/unix/core.c index 25c5181f370e94983e8a5f797f02f7a8dc207e00..28c036f94f3e76717afa651451969f128c5a573c 100644 --- a/src/unix/core.c +++ b/src/unix/core.c @@ -855,7 +855,7 @@ static unsigned int next_power_of_two(unsigned int val) { } static void maybe_resize(uv_loop_t* loop, unsigned int len) { - uv__io_t** watchers; + void** watchers; void* fake_watcher_list; void* fake_watcher_count; unsigned int nwatchers; @@ -874,8 +874,8 @@ static void maybe_resize(uv_loop_t* loop, unsigned int len) { } nwatchers = next_power_of_two(len + 2) - 2; - watchers = uv__reallocf(loop->watchers, - (nwatchers + 2) * sizeof(loop->watchers[0])); + watchers = (void**) + uv__reallocf(loop->watchers, (nwatchers + 2) * sizeof(loop->watchers[0])); if (watchers == NULL) abort(); @@ -884,7 +884,7 @@ static void maybe_resize(uv_loop_t* loop, unsigned int len) { watchers[nwatchers] = fake_watcher_list; watchers[nwatchers + 1] = fake_watcher_count; - loop->watchers = watchers; + loop->watchers = (uv__io_t**)watchers; loop->nwatchers = nwatchers; } @@ -1216,7 +1216,7 @@ static int uv__getpwuid_r(uv_passwd_t *pwd, uid_t uid) { * is frequently 1024 or 4096, so we can just use that directly. The pwent * will not usually be large. */ for (bufsize = 2000;; bufsize *= 2) { - buf = uv__malloc(bufsize); + buf = (char*)uv__malloc(bufsize); if (buf == NULL) return UV_ENOMEM; @@ -1242,7 +1242,7 @@ static int uv__getpwuid_r(uv_passwd_t *pwd, uid_t uid) { name_size = strlen(pw.pw_name) + 1; homedir_size = strlen(pw.pw_dir) + 1; shell_size = strlen(pw.pw_shell) + 1; - pwd->username = uv__malloc(name_size + homedir_size + shell_size); + pwd->username = (char*)uv__malloc(name_size + homedir_size + shell_size); if (pwd->username == NULL) { uv__free(buf); @@ -1292,7 +1292,7 @@ int uv_os_get_group(uv_group_t* grp, uv_uid_t gid) { * is frequently 1024 or 4096, so we can just use that directly. The pwent * will not usually be large. */ for (bufsize = 2000;; bufsize *= 2) { - buf = uv__malloc(bufsize); + buf = (char*)uv__malloc(bufsize); if (buf == NULL) return UV_ENOMEM; @@ -1323,7 +1323,7 @@ int uv_os_get_group(uv_group_t* grp, uv_uid_t gid) { members++; } - gr_mem = uv__malloc(name_size + mem_size); + gr_mem = (char*)uv__malloc(name_size + mem_size); if (gr_mem == NULL) { uv__free(buf); return UV_ENOMEM; @@ -1380,7 +1380,7 @@ int uv_os_environ(uv_env_item_t** envitems, int* count) { for (i = 0; environ[i] != NULL; i++); - *envitems = uv__calloc(i, sizeof(**envitems)); + *envitems = (uv_env_item_s*)uv__calloc(i, sizeof(**envitems)); if (*envitems == NULL) return UV_ENOMEM; diff --git a/src/unix/darwin-proctitle.c b/src/unix/darwin-proctitle.c index 5288083ef04fd78d90c34071cc76281adbc310d8..9bd55dd764b845cf8ea441d525b4e136699eb52e 100644 --- a/src/unix/darwin-proctitle.c +++ b/src/unix/darwin-proctitle.c @@ -128,8 +128,9 @@ int uv__set_process_title(const char* title) { if (pLSSetApplicationInformationItem == NULL) goto out; - display_name_key = pCFBundleGetDataPointerForName(launch_services_bundle, - S("_kLSDisplayNameKey")); + display_name_key = (CFStringRef*) + pCFBundleGetDataPointerForName(launch_services_bundle, + S("_kLSDisplayNameKey")); if (display_name_key == NULL || *display_name_key == NULL) goto out; diff --git a/src/unix/darwin.c b/src/unix/darwin.c index 90790d701c4327518d17230c5aa69b9a74112e73..9ee5cd8eb9d02fb8b71986c47fe8a686f0983847 100644 --- a/src/unix/darwin.c +++ b/src/unix/darwin.c @@ -217,7 +217,7 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { return UV_EINVAL; /* FIXME(bnoordhuis) Translate error. */ } - *cpu_infos = uv__malloc(numcpus * sizeof(**cpu_infos)); + *cpu_infos = (uv_cpu_info_t*)uv__malloc(numcpus * sizeof(**cpu_infos)); if (!(*cpu_infos)) { vm_deallocate(mach_task_self(), (vm_address_t)info, msg_type); return UV_ENOMEM; diff --git a/src/unix/freebsd.c b/src/unix/freebsd.c index 191bc8bc213ffddb15c5e04baa66e2a0a8d69a3d..1bd63886b823be6451ac013d94e29885795375b7 100644 --- a/src/unix/freebsd.c +++ b/src/unix/freebsd.c @@ -220,7 +220,7 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { if (sysctlbyname("hw.ncpu", &numcpus, &size, NULL, 0)) return UV__ERR(errno); - *cpu_infos = uv__malloc(numcpus * sizeof(**cpu_infos)); + *cpu_infos = (uv_cpu_info_t*)uv__malloc(numcpus * sizeof(**cpu_infos)); if (!(*cpu_infos)) return UV_ENOMEM; @@ -237,7 +237,7 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { size = maxcpus * CPUSTATES * sizeof(long); - cp_times = uv__malloc(size); + cp_times = (long*)uv__malloc(size); if (cp_times == NULL) { uv__free(*cpu_infos); return UV_ENOMEM; diff --git a/src/unix/fs.c b/src/unix/fs.c index 6b051c124f2fd9b0f72b41d7d7ba9c715e9686e1..e25d02e54dbe93e4b9c22b0140108c99ae2cb4f7 100644 --- a/src/unix/fs.c +++ b/src/unix/fs.c @@ -140,7 +140,7 @@ extern char *mkdtemp(char *template); /* See issue #740 on AIX < 7 */ size_t new_path_len; \ path_len = strlen(path) + 1; \ new_path_len = strlen(new_path) + 1; \ - req->path = uv__malloc(path_len + new_path_len); \ + req->path = (char*)uv__malloc(path_len + new_path_len); \ if (req->path == NULL) \ return UV_ENOMEM; \ req->new_path = req->path + path_len; \ @@ -568,7 +568,7 @@ static ssize_t uv__fs_scandir(uv_fs_t* req) { static int uv__fs_opendir(uv_fs_t* req) { uv_dir_t* dir; - dir = uv__malloc(sizeof(*dir)); + dir = (uv_dir_t*)uv__malloc(sizeof(*dir)); if (dir == NULL) goto error; @@ -592,7 +592,7 @@ static int uv__fs_readdir(uv_fs_t* req) { unsigned int dirent_idx; unsigned int i; - dir = req->ptr; + dir = (uv_dir_t*)req->ptr; dirent_idx = 0; while (dirent_idx < dir->nentries) { @@ -634,7 +634,7 @@ error: static int uv__fs_closedir(uv_fs_t* req) { uv_dir_t* dir; - dir = req->ptr; + dir = (uv_dir_t*)req->ptr; if (dir->dir != NULL) { closedir(dir->dir); @@ -663,7 +663,7 @@ static int uv__fs_statfs(uv_fs_t* req) { #endif /* defined(__sun) */ return -1; - stat_fs = uv__malloc(sizeof(*stat_fs)); + stat_fs = (uv_statfs_t*)uv__malloc(sizeof(*stat_fs)); if (stat_fs == NULL) { errno = ENOMEM; return -1; @@ -727,7 +727,7 @@ static ssize_t uv__fs_readlink(uv_fs_t* req) { maxlen = uv__fs_pathmax_size(req->path); #endif - buf = uv__malloc(maxlen); + buf = (char*)uv__malloc(maxlen); if (buf == NULL) { errno = ENOMEM; @@ -747,7 +747,7 @@ static ssize_t uv__fs_readlink(uv_fs_t* req) { /* Uncommon case: resize to make room for the trailing nul byte. */ if (len == maxlen) { - buf = uv__reallocf(buf, len + 1); + buf = (char*)uv__reallocf(buf, len + 1); if (buf == NULL) return -1; @@ -770,7 +770,7 @@ static ssize_t uv__fs_realpath(uv_fs_t* req) { ssize_t len; len = uv__fs_pathmax_size(req->path); - buf = uv__malloc(len + 1); + buf = (char*)uv__malloc(len + 1); if (buf == NULL) { errno = ENOMEM; @@ -1984,7 +1984,7 @@ int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, req->nbufs = nbufs; req->bufs = req->bufsml; if (nbufs > ARRAY_SIZE(req->bufsml)) - req->bufs = uv__malloc(nbufs * sizeof(*bufs)); + req->bufs = (uv_buf_t*)uv__malloc(nbufs * sizeof(*bufs)); if (req->bufs == NULL) return UV_ENOMEM; @@ -2171,7 +2171,7 @@ int uv_fs_write(uv_loop_t* loop, req->nbufs = nbufs; req->bufs = req->bufsml; if (nbufs > ARRAY_SIZE(req->bufsml)) - req->bufs = uv__malloc(nbufs * sizeof(*bufs)); + req->bufs = (uv_buf_t*)uv__malloc(nbufs * sizeof(*bufs)); if (req->bufs == NULL) return UV_ENOMEM; diff --git a/src/unix/fsevents.c b/src/unix/fsevents.c index df703f3635fc95bab21debc9697dba06a2a44827..c31d08ba37cfd10672ab6a7a8fd38a1c79b952fe 100644 --- a/src/unix/fsevents.c +++ b/src/unix/fsevents.c @@ -183,7 +183,7 @@ static void (*pFSEventStreamStop)(FSEventStreamRef); static void uv__fsevents_cb(uv_async_t* cb) { uv_fs_event_t* handle; - handle = cb->data; + handle = (uv_fs_event_t*)cb->data; UV__FSEVENTS_PROCESS(handle, { handle->cb(handle, event->path[0] ? event->path : NULL, event->events, 0); @@ -231,10 +231,10 @@ static void uv__fsevents_event_cb(const FSEventStreamRef streamRef, FSEventStreamEventFlags flags; struct uv__queue head; - loop = info; - state = loop->cf_state; + loop = (uv_loop_t*)info; + state = (uv__cf_loop_state_t*)loop->cf_state; assert(state != NULL); - paths = eventPaths; + paths = (char**)eventPaths; /* For each handle */ uv_mutex_lock(&state->fsevent_mutex); @@ -304,7 +304,7 @@ static void uv__fsevents_event_cb(const FSEventStreamRef streamRef, continue; } - event = uv__malloc(sizeof(*event) + len); + event = (uv__fsevents_event_t*)uv__malloc(sizeof(*event) + len); if (event == NULL) break; @@ -438,7 +438,7 @@ static void uv__fsevents_reschedule(uv__cf_loop_state_t* state, uv_mutex_lock(&state->fsevent_mutex); path_count = state->fsevent_handle_count; if (path_count != 0) { - paths = uv__malloc(sizeof(*paths) * path_count); + paths = (CFStringRef*)uv__malloc(sizeof(*paths) * path_count); if (paths == NULL) { uv_mutex_unlock(&state->fsevent_mutex); goto final; @@ -594,7 +594,7 @@ static int uv__fsevents_loop_init(uv_loop_t* loop) { if (err) return err; - state = uv__calloc(1, sizeof(*state)); + state = (uv__cf_loop_state_t*)uv__calloc(1, sizeof(*state)); if (state == NULL) return UV_ENOMEM; @@ -696,7 +696,7 @@ void uv__fsevents_loop_delete(uv_loop_t* loop) { } /* Destroy state */ - state = loop->cf_state; + state = (uv__cf_loop_state_t*)loop->cf_state; uv_sem_destroy(&state->fsevent_sem); uv_mutex_destroy(&state->fsevent_mutex); pCFRelease(state->signal_source); @@ -710,8 +710,8 @@ static void* uv__cf_loop_runner(void* arg) { uv_loop_t* loop; uv__cf_loop_state_t* state; - loop = arg; - state = loop->cf_state; + loop = (uv_loop_t*)arg; + state = (uv__cf_loop_state_t*)loop->cf_state; state->loop = pCFRunLoopGetCurrent(); pCFRunLoopAddSource(state->loop, @@ -739,8 +739,8 @@ static void uv__cf_loop_cb(void* arg) { struct uv__queue split_head; uv__cf_loop_signal_t* s; - loop = arg; - state = loop->cf_state; + loop = (uv_loop_t*)arg; + state = (uv__cf_loop_state_t*)loop->cf_state; uv_mutex_lock(&loop->cf_mutex); uv__queue_move(&loop->cf_signals, &split_head); @@ -770,7 +770,7 @@ int uv__cf_loop_signal(uv_loop_t* loop, uv__cf_loop_signal_t* item; uv__cf_loop_state_t* state; - item = uv__malloc(sizeof(*item)); + item = (uv__cf_loop_signal_t*)uv__malloc(sizeof(*item)); if (item == NULL) return UV_ENOMEM; @@ -780,7 +780,7 @@ int uv__cf_loop_signal(uv_loop_t* loop, uv_mutex_lock(&loop->cf_mutex); uv__queue_insert_tail(&loop->cf_signals, &item->member); - state = loop->cf_state; + state = (uv__cf_loop_state_t*)loop->cf_state; assert(state != NULL); pCFRunLoopSourceSignal(state->signal_source); pCFRunLoopWakeUp(state->loop); @@ -814,7 +814,7 @@ int uv__fsevents_init(uv_fs_event_t* handle) { * Events will occur in other thread. * Initialize callback for getting them back into event loop's thread */ - handle->cf_cb = uv__malloc(sizeof(*handle->cf_cb)); + handle->cf_cb = (uv_async_t*)uv__malloc(sizeof(*handle->cf_cb)); if (handle->cf_cb == NULL) { err = UV_ENOMEM; goto fail_cf_cb_malloc; @@ -830,7 +830,7 @@ int uv__fsevents_init(uv_fs_event_t* handle) { goto fail_cf_mutex_init; /* Insert handle into the list */ - state = handle->loop->cf_state; + state = (uv__cf_loop_state_t*)handle->loop->cf_state; uv_mutex_lock(&state->fsevent_mutex); uv__queue_insert_tail(&state->fsevent_handles, &handle->cf_member); state->fsevent_handle_count++; @@ -870,7 +870,7 @@ int uv__fsevents_close(uv_fs_event_t* handle) { return UV_EINVAL; /* Remove handle from the list */ - state = handle->loop->cf_state; + state = (uv__cf_loop_state_t*)handle->loop->cf_state; uv_mutex_lock(&state->fsevent_mutex); uv__queue_remove(&handle->cf_member); state->fsevent_handle_count--; diff --git a/src/unix/getaddrinfo.c b/src/unix/getaddrinfo.c index 77337ace9454e032a392c97cb9aa311f15518956..41dc3909969a643e129847ae3a3252d51feadb27 100644 --- a/src/unix/getaddrinfo.c +++ b/src/unix/getaddrinfo.c @@ -172,7 +172,7 @@ int uv_getaddrinfo(uv_loop_t* loop, hostname_len = hostname ? strlen(hostname) + 1 : 0; service_len = service ? strlen(service) + 1 : 0; hints_len = hints ? sizeof(*hints) : 0; - buf = uv__malloc(hostname_len + service_len + hints_len); + buf = (char*)uv__malloc(hostname_len + service_len + hints_len); if (buf == NULL) return UV_ENOMEM; @@ -190,17 +190,17 @@ int uv_getaddrinfo(uv_loop_t* loop, len = 0; if (hints) { - req->hints = memcpy(buf + len, hints, sizeof(*hints)); + req->hints = (struct addrinfo*)memcpy(buf + len, hints, sizeof(*hints)); len += sizeof(*hints); } if (service) { - req->service = memcpy(buf + len, service, service_len); + req->service = (char*)memcpy(buf + len, service, service_len); len += service_len; } if (hostname) - req->hostname = memcpy(buf + len, hostname, hostname_len); + req->hostname = (char*)memcpy(buf + len, hostname, hostname_len); if (cb) { uv__work_submit(loop, diff --git a/src/unix/ibmi.c b/src/unix/ibmi.c index 837bba6e2fef7b834a8d104d263bef47eaed0950..5e0fa98d104428534e5264a1c6358e3f68c58b82 100644 --- a/src/unix/ibmi.c +++ b/src/unix/ibmi.c @@ -293,7 +293,7 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { numcpus = sysconf(_SC_NPROCESSORS_ONLN); - *cpu_infos = uv__malloc(numcpus * sizeof(uv_cpu_info_t)); + *cpu_infos = (uv_cpu_info_t*)uv__malloc(numcpus * sizeof(uv_cpu_info_t)); if (!*cpu_infos) { return UV_ENOMEM; } diff --git a/src/unix/kqueue.c b/src/unix/kqueue.c index b78242d3be4e3cf6b7b998f56dc65213982d4bc7..28e55aae6c613576ede7024a5c73d746e134d865 100644 --- a/src/unix/kqueue.c +++ b/src/unix/kqueue.c @@ -299,8 +299,8 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { nevents = 0; assert(loop->watchers != NULL); - loop->watchers[loop->nwatchers] = (void*) events; - loop->watchers[loop->nwatchers + 1] = (void*) (uintptr_t) nfds; + loop->watchers[loop->nwatchers] = (uv__io_t*) events; + loop->watchers[loop->nwatchers + 1] = (uv__io_t*) (uintptr_t) nfds; for (i = 0; i < nfds; i++) { ev = events + i; fd = ev->ident; @@ -322,7 +322,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { /* Skip invalidated events, see uv__platform_invalidate_fd */ if (fd == -1) continue; - w = loop->watchers[fd]; + w = (uv__io_t*)loop->watchers[fd]; if (w == NULL) { /* File descriptor that we've stopped watching, disarm it. */ diff --git a/src/unix/linux.c b/src/unix/linux.c index 48b9c2c43e104079d3ccb5d830d1d79f891fb1a3..9173850bd158eaf9c41deca38f9ba84762a027a1 100644 --- a/src/unix/linux.c +++ b/src/unix/linux.c @@ -456,8 +456,8 @@ static void uv__iou_init(int epollfd, char* sqe; int ringfd; - sq = MAP_FAILED; - sqe = MAP_FAILED; + sq = (char*)MAP_FAILED; + sqe = (char*)MAP_FAILED; if (!uv__use_io_uring()) return; @@ -496,14 +496,14 @@ static void uv__iou_init(int epollfd, maxlen = sqlen < cqlen ? cqlen : sqlen; sqelen = params.sq_entries * sizeof(struct uv__io_uring_sqe); - sq = mmap(0, + sq = (char*)mmap(0, maxlen, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, ringfd, 0); /* IORING_OFF_SQ_RING */ - sqe = mmap(0, + sqe = (char*)mmap(0, sqelen, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, @@ -643,7 +643,7 @@ void uv__platform_invalidate_fd(uv_loop_t* loop, int fd) { int i; lfields = uv__get_internal_fields(loop); - inv = lfields->inv; + inv = (uv__invalidate*)lfields->inv; /* Invalidate events with same file descriptor */ if (inv != NULL) @@ -718,7 +718,7 @@ static struct uv__io_uring_sqe* uv__iou_get_sqe(struct uv__iou* iou, return NULL; /* No room in ring buffer. TODO(bnoordhuis) maybe flush it? */ slot = tail & mask; - sqe = iou->sqe; + sqe = (uv__io_uring_sqe*)iou->sqe; sqe = &sqe[slot]; memset(sqe, 0, sizeof(*sqe)); sqe->user_data = (uintptr_t) req; @@ -986,7 +986,7 @@ int uv__iou_fs_statx(uv_loop_t* loop, struct uv__statx* statxbuf; struct uv__iou* iou; - statxbuf = uv__malloc(sizeof(*statxbuf)); + statxbuf = (struct uv__statx*)uv__malloc(sizeof(*statxbuf)); if (statxbuf == NULL) return 0; @@ -1050,7 +1050,7 @@ static void uv__iou_fs_statx_post(uv_fs_t* req) { uv_stat_t* buf; buf = &req->statbuf; - statxbuf = req->ptr; + statxbuf = (struct uv__statx*)req->ptr; req->ptr = NULL; if (req->result == 0) { @@ -1079,7 +1079,7 @@ static void uv__poll_io_uring(uv_loop_t* loop, struct uv__iou* iou) { tail = atomic_load_explicit((_Atomic uint32_t*) iou->cqtail, memory_order_acquire); mask = iou->cqmask; - cqe = iou->cqe; + cqe = (uv__io_uring_cqe*)iou->cqe; nevents = 0; for (i = head; i != tail; i++) { @@ -1170,7 +1170,7 @@ static void uv__epoll_ctl_prep(int epollfd, pe = &(*events)[slot]; *pe = *e; - sqe = ctl->sqe; + sqe = (uv__io_uring_sqe*)ctl->sqe; sqe = &sqe[slot]; memset(sqe, 0, sizeof(*sqe)); @@ -1226,7 +1226,7 @@ static void uv__epoll_ctl_flush(int epollfd, while (*ctl->cqhead != *ctl->cqtail) { slot = (*ctl->cqhead)++ & ctl->cqmask; - cqe = ctl->cqe; + cqe = (uv__io_uring_cqe*)ctl->cqe; cqe = &cqe[slot]; if (cqe->res == 0) @@ -1708,7 +1708,7 @@ int uv_cpu_info(uv_cpu_info_t** ci, int* count) { snprintf(*models, sizeof(*models), "unknown"); maxcpu = 0; - cpus = uv__calloc(ARRAY_SIZE(*cpus), sizeof(**cpus)); + cpus = (decltype(cpus))uv__calloc(ARRAY_SIZE(*cpus), sizeof(**cpus)); if (cpus == NULL) return UV_ENOMEM; @@ -1764,9 +1764,9 @@ int uv_cpu_info(uv_cpu_info_t** ci, int* count) { /* arm64: translate CPU part code to model name. */ if (*parts) { - p = memmem(parts, sizeof(parts) - 1, p, n + 1); + p = (char*)memmem(parts, sizeof(parts) - 1, p, n + 1); if (p == NULL) - p = "unknown"; + p = const_cast("unknown"); else p += n + 1; n = (int) strcspn(p, "\n"); @@ -1815,7 +1815,7 @@ nocpuinfo: } size = n * sizeof(**ci) + sizeof(models); - *ci = uv__malloc(size); + *ci = (uv_cpu_info_t*)uv__malloc(size); *count = 0; if (*ci == NULL) { @@ -1824,7 +1824,7 @@ nocpuinfo: } *count = n; - p = memcpy(*ci + n, models, sizeof(models)); + p = (char*)memcpy(*ci + n, models, sizeof(models)); i = 0; for (cpu = 0; cpu < maxcpu; cpu++) { @@ -1833,19 +1833,19 @@ nocpuinfo: c = *cpus + cpu; - (*ci)[i++] = (uv_cpu_info_t) { + (*ci)[i++] = uv_cpu_info_t{ .model = p + c->model * sizeof(*model), - .speed = c->freq / 1000, + .speed = (int)(c->freq / 1000), /* Note: sysconf(_SC_CLK_TCK) is fixed at 100 Hz, * therefore the multiplier is always 1000/100 = 10. */ - .cpu_times = (struct uv_cpu_times_s) { + .cpu_times = { .user = 10 * c->user, .nice = 10 * c->nice, .sys = 10 * c->sys, .idle = 10 * c->idle, .irq = 10 * c->irq, - }, + } }; } @@ -1902,7 +1902,7 @@ int uv_interface_addresses(uv_interface_address_t** addresses, int* count) { } /* Make sure the memory is initiallized to zero using calloc() */ - *addresses = uv__calloc(*count, sizeof(**addresses)); + *addresses = (uv_interface_address_t*)uv__calloc(*count, sizeof(**addresses)); if (!(*addresses)) { freeifaddrs(addrs); return UV_ENOMEM; @@ -2470,12 +2470,12 @@ int uv_fs_event_start(uv_fs_event_t* handle, goto no_insert; len = strlen(path) + 1; - w = uv__malloc(sizeof(*w) + len); + w = (watcher_list*)uv__malloc(sizeof(*w) + len); if (w == NULL) return UV_ENOMEM; w->wd = wd; - w->path = memcpy(w + 1, path, len); + w->path = (char*)memcpy(w + 1, path, len); uv__queue_init(&w->watchers); w->iterating = 0; RB_INSERT(watcher_root, uv__inotify_watchers(loop), w); diff --git a/src/unix/loop.c b/src/unix/loop.c index a9468e8e19cbede795032980c47eb83aee1e0c68..3babe4d701949ebc69d74f7dedee33c777d89892 100644 --- a/src/unix/loop.c +++ b/src/unix/loop.c @@ -148,7 +148,7 @@ int uv_loop_fork(uv_loop_t* loop) { /* Rearm all the watchers that aren't re-queued by the above. */ for (i = 0; i < loop->nwatchers; i++) { - w = loop->watchers[i]; + w = (uv__io_t*)loop->watchers[i]; if (w == NULL) continue; diff --git a/src/unix/netbsd.c b/src/unix/netbsd.c index fa21e98e41aec8b7d8bc46c299c4c20a7a0c3f0c..4c6d5a24fe896d89e3b2f1db1dc2b1dd7d010aec 100644 --- a/src/unix/netbsd.c +++ b/src/unix/netbsd.c @@ -211,14 +211,14 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { cpuspeed = 0; size = numcpus * CPUSTATES * sizeof(*cp_times); - cp_times = uv__malloc(size); + cp_times = (u_int64_t*)uv__malloc(size); if (cp_times == NULL) return UV_ENOMEM; if (sysctlbyname("kern.cp_time", cp_times, &size, NULL, 0)) return UV__ERR(errno); - *cpu_infos = uv__malloc(numcpus * sizeof(**cpu_infos)); + *cpu_infos = (uv_cpu_info_t*)uv__malloc(numcpus * sizeof(**cpu_infos)); if (!(*cpu_infos)) { uv__free(cp_times); uv__free(*cpu_infos); diff --git a/src/unix/openbsd.c b/src/unix/openbsd.c index 9c863b6c90dad9864cb8341c2b6203c1390a9487..2aa61e2ee3321d91ba84887c7ed6dcfa23d00ccf 100644 --- a/src/unix/openbsd.c +++ b/src/unix/openbsd.c @@ -72,7 +72,7 @@ int uv_exepath(char* buffer, size_t* size) { mypid = getpid(); for (;;) { err = UV_ENOMEM; - argsbuf = uv__reallocf(argsbuf, argsbuf_size); + argsbuf = (char**)uv__reallocf(argsbuf, argsbuf_size); if (argsbuf == NULL) goto out; mib[0] = CTL_KERN; @@ -202,7 +202,7 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { if (sysctl(which, ARRAY_SIZE(which), &numcpus, &size, NULL, 0)) return UV__ERR(errno); - *cpu_infos = uv__malloc(numcpus * sizeof(**cpu_infos)); + *cpu_infos = (uv_cpu_info_t*)uv__malloc(numcpus * sizeof(**cpu_infos)); if (!(*cpu_infos)) return UV_ENOMEM; diff --git a/src/unix/pipe.c b/src/unix/pipe.c index d332f3518303d6ef1dee1d835c392bb60b935bad..a60b1a0e442bb3c482575da117f30e9f119f55d3 100644 --- a/src/unix/pipe.c +++ b/src/unix/pipe.c @@ -377,7 +377,7 @@ int uv_pipe_pending_count(uv_pipe_t* handle) { if (handle->queued_fds == NULL) return 1; - queued_fds = handle->queued_fds; + queued_fds = (uv__stream_queued_fds_t*)(handle->queued_fds); return queued_fds->offset + 1; } @@ -414,7 +414,7 @@ int uv_pipe_chmod(uv_pipe_t* handle, int mode) { if (r != UV_ENOBUFS) return r; - name_buffer = uv__malloc(name_len); + name_buffer = (char*)uv__malloc(name_len); if (name_buffer == NULL) return UV_ENOMEM; diff --git a/src/unix/poll.c b/src/unix/poll.c index 7a12e2d1488a9d48712439e62c6637b9e1161f69..c21722b2e8eef4d16c523f7319fb57c3167d8dd9 100644 --- a/src/unix/poll.c +++ b/src/unix/poll.c @@ -117,7 +117,7 @@ int uv_poll_stop(uv_poll_t* handle) { int uv_poll_start(uv_poll_t* handle, int pevents, uv_poll_cb poll_cb) { - uv__io_t** watchers; + void** watchers; uv__io_t* w; int events; @@ -125,7 +125,7 @@ int uv_poll_start(uv_poll_t* handle, int pevents, uv_poll_cb poll_cb) { UV_PRIORITIZED)) == 0); assert(!uv__is_closing(handle)); - watchers = handle->loop->watchers; + watchers = (void**)handle->loop->watchers; w = &handle->io_watcher; if (uv__fd_exists(handle->loop, w->fd)) diff --git a/src/unix/posix-poll.c b/src/unix/posix-poll.c index 2e016c2fbaed2eeccd78080969a86aff821a4251..b71eee3f01a3f30b3b5efef539194139f258009a 100644 --- a/src/unix/posix-poll.c +++ b/src/unix/posix-poll.c @@ -61,7 +61,7 @@ static void uv__pollfds_maybe_resize(uv_loop_t* loop) { return; n = loop->poll_fds_size ? loop->poll_fds_size * 2 : 64; - p = uv__reallocf(loop->poll_fds, n * sizeof(*loop->poll_fds)); + p = (struct pollfd*)uv__reallocf(loop->poll_fds, n * sizeof(*loop->poll_fds)); if (p == NULL) abort(); diff --git a/src/unix/process.c b/src/unix/process.c index dd58c18d9b9359fca1a924698c39bd6390dafbe0..2d622c956de6d7b6f8a04be3ecd311f39602b241 100644 --- a/src/unix/process.c +++ b/src/unix/process.c @@ -423,7 +423,7 @@ static int posix_spawn_can_use_setsid; static void uv__spawn_init_posix_spawn_fncs(void) { /* Try to locate all non-portable functions at runtime */ posix_spawn_fncs.file_actions.addchdir_np = - dlsym(RTLD_DEFAULT, "posix_spawn_file_actions_addchdir_np"); + (int (*)(void* const*, const char*)) dlsym(RTLD_DEFAULT, "posix_spawn_file_actions_addchdir_np"); } @@ -988,7 +988,7 @@ int uv_spawn(uv_loop_t* loop, err = UV_ENOMEM; pipes = pipes_storage; if (stdio_count > (int) ARRAY_SIZE(pipes_storage)) - pipes = uv__malloc(stdio_count * sizeof(*pipes)); + pipes = (int (*)[2])uv__malloc(stdio_count * sizeof(*pipes)); if (pipes == NULL) goto error; diff --git a/src/unix/proctitle.c b/src/unix/proctitle.c index 9d1f00ddf66e291abd40d0c0052a7f9bd5c03017..8cdec753d003ebe16485db2b47ffb3863a9473ff 100644 --- a/src/unix/proctitle.c +++ b/src/unix/proctitle.c @@ -65,7 +65,7 @@ char** uv_setup_args(int argc, char** argv) { /* Add space for the argv pointers. */ size += (argc + 1) * sizeof(char*); - new_argv = uv__malloc(size); + new_argv = (char**)uv__malloc(size); if (new_argv == NULL) return argv; diff --git a/src/unix/random-sysctl-linux.c b/src/unix/random-sysctl-linux.c index 66ba8d74ec22b72d318b91d82365f5b9693feb3c..9ef18df01a51aa6a26ae6d1d9660a819d18604d0 100644 --- a/src/unix/random-sysctl-linux.c +++ b/src/unix/random-sysctl-linux.c @@ -48,7 +48,7 @@ int uv__random_sysctl(void* buf, size_t buflen) { char* pe; size_t n; - p = buf; + p = (char*)buf; pe = p + buflen; while (p < pe) { diff --git a/src/unix/stream.c b/src/unix/stream.c index 28c4d5463c4622725a433b8807e5e7bde580dadd..265ddade7aec129eb9dbf07cde2a16a0e341d1a7 100644 --- a/src/unix/stream.c +++ b/src/unix/stream.c @@ -123,7 +123,7 @@ static void uv__stream_osx_interrupt_select(uv_stream_t* stream) { uv__stream_select_t* s; int r; - s = stream->select; + s = (uv__stream_select_t*)stream->select; if (s == NULL) return; @@ -152,8 +152,8 @@ static void uv__stream_osx_select(void* arg) { int r; int max_fd; - stream = arg; - s = stream->select; + stream = (uv_stream_t*)arg; + s = (uv__stream_select_t*)stream->select; fd = s->fd; if (fd > s->int_fd) @@ -330,7 +330,7 @@ int uv__stream_try_select(uv_stream_t* stream, int* fd) { sread_sz = ROUND_UP(max_fd + 1, sizeof(uint32_t) * NBBY) / NBBY; swrite_sz = sread_sz; - s = uv__malloc(sizeof(*s) + sread_sz + swrite_sz); + s = (uv__stream_select_t*)uv__malloc(sizeof(*s) + sread_sz + swrite_sz); if (s == NULL) { err = UV_ENOMEM; goto failed_malloc; @@ -573,7 +573,7 @@ done: if (server->queued_fds != NULL) { uv__stream_queued_fds_t* queued_fds; - queued_fds = server->queued_fds; + queued_fds = (uv__stream_queued_fds_t*)(server->queued_fds); /* Read first */ server->accepted_fd = queued_fds->fds[0]; @@ -942,11 +942,12 @@ static int uv__stream_queue_fd(uv_stream_t* stream, int fd) { uv__stream_queued_fds_t* queued_fds; unsigned int queue_size; - queued_fds = stream->queued_fds; + queued_fds = (uv__stream_queued_fds_t*)stream->queued_fds; if (queued_fds == NULL) { queue_size = 8; - queued_fds = uv__malloc((queue_size - 1) * sizeof(*queued_fds->fds) + - sizeof(*queued_fds)); + queued_fds = (uv__stream_queued_fds_t*) + uv__malloc((queue_size - 1) * sizeof(*queued_fds->fds) + + sizeof(*queued_fds)); if (queued_fds == NULL) return UV_ENOMEM; queued_fds->size = queue_size; @@ -956,9 +957,9 @@ static int uv__stream_queue_fd(uv_stream_t* stream, int fd) { /* Grow */ } else if (queued_fds->size == queued_fds->offset) { queue_size = queued_fds->size + 8; - queued_fds = uv__realloc(queued_fds, - (queue_size - 1) * sizeof(*queued_fds->fds) + - sizeof(*queued_fds)); + queued_fds = (uv__stream_queued_fds_t*) + uv__realloc(queued_fds, (queue_size - 1) * sizeof(*queued_fds->fds) + + sizeof(*queued_fds)); /* * Allocation failure, report back. @@ -1356,7 +1357,7 @@ int uv_write2(uv_write_t* req, req->bufs = req->bufsml; if (nbufs > ARRAY_SIZE(req->bufsml)) - req->bufs = uv__malloc(nbufs * sizeof(bufs[0])); + req->bufs = (uv_buf_t*)uv__malloc(nbufs * sizeof(bufs[0])); if (req->bufs == NULL) return UV_ENOMEM; @@ -1490,7 +1491,7 @@ int uv___stream_fd(const uv_stream_t* handle) { handle->type == UV_TTY || handle->type == UV_NAMED_PIPE); - s = handle->select; + s = (const uv__stream_select_t*)handle->select; if (s != NULL) return s->fd; @@ -1508,7 +1509,7 @@ void uv__stream_close(uv_stream_t* handle) { if (handle->select != NULL) { uv__stream_select_t* s; - s = handle->select; + s = (uv__stream_select_t*)handle->select; uv_sem_post(&s->close_sem); uv_sem_post(&s->async_sem); @@ -1543,7 +1544,7 @@ void uv__stream_close(uv_stream_t* handle) { /* Close all queued fds */ if (handle->queued_fds != NULL) { - queued_fds = handle->queued_fds; + queued_fds = (uv__stream_queued_fds_t*)(handle->queued_fds); for (i = 0; i < queued_fds->offset; i++) uv__close(queued_fds->fds[i]); uv__free(handle->queued_fds); diff --git a/src/unix/thread.c b/src/unix/thread.c index 4d6f4b8232ec6dc0bd27258a1315340e3e272ae9..531c6211bb4321e5f11031a0644b4e3ab9174396 100644 --- a/src/unix/thread.c +++ b/src/unix/thread.c @@ -168,8 +168,7 @@ int uv_thread_create_ex(uv_thread_t* tid, abort(); } - f.in = entry; - err = pthread_create(tid, attr, f.out, arg); + err = pthread_create(tid, attr, (void*(*)(void*)) (void(*)(void)) entry, arg); if (attr != NULL) pthread_attr_destroy(attr); @@ -540,7 +539,7 @@ static int uv__custom_sem_init(uv_sem_t* sem_, unsigned int value) { int err; uv_semaphore_t* sem; - sem = uv__malloc(sizeof(*sem)); + sem = (uv_semaphore_t*)uv__malloc(sizeof(*sem)); if (sem == NULL) return UV_ENOMEM; diff --git a/src/unix/udp.c b/src/unix/udp.c index c2814512a5f507ceb9e764cdb7c6ff3d36e77974..cbee16b22a36b1c82e74f6a81c3811052e9b8482 100644 --- a/src/unix/udp.c +++ b/src/unix/udp.c @@ -191,11 +191,11 @@ static int uv__udp_recvmmsg(uv_udp_t* handle, uv_buf_t* buf) { if (msgs[k].msg_hdr.msg_flags & MSG_TRUNC) flags |= UV_UDP_PARTIAL; - chunk_buf = uv_buf_init(iov[k].iov_base, iov[k].iov_len); + chunk_buf = uv_buf_init((char*) iov[k].iov_base, iov[k].iov_len); handle->recv_cb(handle, msgs[k].msg_len, &chunk_buf, - msgs[k].msg_hdr.msg_name, + (const sockaddr*) msgs[k].msg_hdr.msg_name, flags); } @@ -245,7 +245,7 @@ static void uv__udp_recvmsg(uv_udp_t* handle) { memset(&peer, 0, sizeof(peer)); h.msg_name = &peer; h.msg_namelen = sizeof(peer); - h.msg_iov = (void*) &buf; + h.msg_iov = (iovec*) &buf; h.msg_iovlen = 1; do { @@ -719,7 +719,7 @@ int uv__udp_send(uv_udp_send_t* req, req->bufs = req->bufsml; if (nbufs > ARRAY_SIZE(req->bufsml)) - req->bufs = uv__malloc(nbufs * sizeof(bufs[0])); + req->bufs = (uv_buf_t*)uv__malloc(nbufs * sizeof(bufs[0])); if (req->bufs == NULL) { uv__req_unregister(handle->loop, req); diff --git a/src/uv-common.c b/src/uv-common.c index 916f3f4e00664ab47f94d2a6ee7c6a9ef0461389..c04f93596ab1f730576256d86e216ccb7f258b72 100644 --- a/src/uv-common.c +++ b/src/uv-common.c @@ -54,10 +54,10 @@ static uv__allocator_t uv__allocator = { char* uv__strdup(const char* s) { size_t len = strlen(s) + 1; - char* m = uv__malloc(len); + char* m = (char*)uv__malloc(len); if (m == NULL) return NULL; - return memcpy(m, s, len); + return (char*)memcpy(m, s, len); } char* uv__strndup(const char* s, size_t n) { @@ -65,11 +65,11 @@ char* uv__strndup(const char* s, size_t n) { size_t len = strlen(s); if (n < len) len = n; - m = uv__malloc(len + 1); + m = (char*)uv__malloc(len + 1); if (m == NULL) return NULL; m[len] = '\0'; - return memcpy(m, s, len); + return (char*)memcpy(m, s, len); } void* uv__malloc(size_t size) { @@ -688,7 +688,7 @@ void uv__fs_scandir_cleanup(uv_fs_t* req) { unsigned int n; if (req->result >= 0) { - dents = req->ptr; + dents = (uv__dirent_t**)(req->ptr); nbufs = uv__get_nbufs(req); i = 0; @@ -721,7 +721,7 @@ int uv_fs_scandir_next(uv_fs_t* req, uv_dirent_t* ent) { nbufs = uv__get_nbufs(req); assert(nbufs); - dents = req->ptr; + dents = (uv__dirent_t**)(req->ptr); /* Free previous entity */ if (*nbufs > 0) @@ -786,7 +786,7 @@ void uv__fs_readdir_cleanup(uv_fs_t* req) { if (req->ptr == NULL) return; - dir = req->ptr; + dir = (uv_dir_t*)req->ptr; dirents = dir->dirents; req->ptr = NULL; @@ -832,7 +832,7 @@ uv_loop_t* uv_default_loop(void) { uv_loop_t* uv_loop_new(void) { uv_loop_t* loop; - loop = uv__malloc(sizeof(*loop)); + loop = (uv_loop_t*)uv__malloc(sizeof(*loop)); if (loop == NULL) return NULL; diff --git a/src/win/core.c b/src/win/core.c index e9885a0f1ff3890a8d957c8793e22b01cedc0e97..87ade7ad65243ee3ff940320f84e1960390300e1 100644 --- a/src/win/core.c +++ b/src/win/core.c @@ -98,7 +98,8 @@ static int uv__loops_add(uv_loop_t* loop) { if (uv__loops_size == uv__loops_capacity) { new_capacity = uv__loops_capacity + UV__LOOPS_CHUNK_SIZE; - new_loops = uv__realloc(uv__loops, sizeof(uv_loop_t*) * new_capacity); + new_loops = (uv_loop_t**) + uv__realloc(uv__loops, sizeof(uv_loop_t*) * new_capacity); if (!new_loops) goto failed_loops_realloc; uv__loops = new_loops; @@ -152,7 +153,8 @@ static void uv__loops_remove(uv_loop_t* loop) { smaller_capacity = uv__loops_capacity / 2; if (uv__loops_size >= smaller_capacity) goto loop_removed; - new_loops = uv__realloc(uv__loops, sizeof(uv_loop_t*) * smaller_capacity); + new_loops = (uv_loop_t**) + uv__realloc(uv__loops, sizeof(uv_loop_t*) * smaller_capacity); if (!new_loops) goto loop_removed; uv__loops = new_loops; @@ -264,7 +266,7 @@ int uv_loop_init(uv_loop_t* loop) { loop->endgame_handles = NULL; - loop->timer_heap = timer_heap = uv__malloc(sizeof(*timer_heap)); + loop->timer_heap = timer_heap = (heap*)uv__malloc(sizeof(*timer_heap)); if (timer_heap == NULL) { err = UV_ENOMEM; goto fail_timers_alloc; diff --git a/src/win/fs-event.c b/src/win/fs-event.c index 6758c7c78bc1d6a5316a8ae7dc2d1e23cd0f32bc..150467313d576bfe2966b55f3d8cffa23cbb8ea3 100644 --- a/src/win/fs-event.c +++ b/src/win/fs-event.c @@ -73,7 +73,7 @@ static void uv__relative_path(const WCHAR* filename, if (dirlen > 0 && dir[dirlen - 1] == '\\') dirlen--; relpathlen = filenamelen - dirlen - 1; - *relpath = uv__malloc((relpathlen + 1) * sizeof(WCHAR)); + *relpath = (WCHAR*)uv__malloc((relpathlen + 1) * sizeof(WCHAR)); if (!*relpath) uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc"); wcsncpy(*relpath, filename + dirlen + 1, relpathlen); @@ -242,7 +242,7 @@ int uv_fs_event_start(uv_fs_event_t* handle, if (short_path_buffer_len == 0) { goto short_path_done; } - short_path_buffer = uv__malloc(short_path_buffer_len * sizeof(WCHAR)); + short_path_buffer = (WCHAR*)uv__malloc(short_path_buffer_len * sizeof(WCHAR)); if (short_path_buffer == NULL) { goto short_path_done; } diff --git a/src/win/fs-fd-hash-inl.h b/src/win/fs-fd-hash-inl.h index 0b532af12d4371c2311bd50a66913287a0716f43..703a8d8f87de1089ac8b18bd817d416d48dc442e 100644 --- a/src/win/fs-fd-hash-inl.h +++ b/src/win/fs-fd-hash-inl.h @@ -146,7 +146,7 @@ INLINE static void uv__fd_hash_add(int fd, struct uv__fd_info_s* info) { if (bucket_ptr->size != 0 && i == 0) { struct uv__fd_hash_entry_group_s* new_group_ptr = - uv__malloc(sizeof(*new_group_ptr)); + (struct uv__fd_hash_entry_group_s*)uv__malloc(sizeof(*new_group_ptr)); if (new_group_ptr == NULL) { uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc"); } diff --git a/src/win/fs.c b/src/win/fs.c index fc209c54f470edaa031009979061cff071cbf66d..328c8f2e0513562b53c948ffea59d0841e14b264 100644 --- a/src/win/fs.c +++ b/src/win/fs.c @@ -258,7 +258,7 @@ INLINE static int fs__capture_path(uv_fs_t* req, const char* path, return 0; } - buf = uv__malloc(buf_sz); + buf = (WCHAR *)uv__malloc(buf_sz); if (buf == NULL) { return ERROR_OUTOFMEMORY; } @@ -376,7 +376,7 @@ static int fs__wide_to_wtf8(WCHAR* w_source_ptr, return 0; if (*target_ptr == NULL) { - target = uv__malloc(target_len + 1); + target = (char *)uv__malloc(target_len + 1); if (target == NULL) { SetLastError(ERROR_OUTOFMEMORY); return -1; @@ -1575,7 +1575,7 @@ void fs__scandir(uv_fs_t* req) { if (dirents_used >= dirents_size) { size_t new_dirents_size = dirents_size == 0 ? dirents_initial_size : dirents_size << 1; - uv__dirent_t** new_dirents = + uv__dirent_t** new_dirents = (uv__dirent_t**) uv__realloc(dirents, new_dirents_size * sizeof *dirents); if (new_dirents == NULL) @@ -1589,7 +1589,7 @@ void fs__scandir(uv_fs_t* req) { * includes room for the first character of the filename, but `utf8_len` * doesn't count the NULL terminator at this point. */ - dirent = uv__malloc(sizeof *dirent + wtf8_len); + dirent = (uv__dirent_t*)uv__malloc(sizeof *dirent + wtf8_len); if (dirent == NULL) goto out_of_memory_error; @@ -1691,7 +1691,7 @@ void fs__opendir(uv_fs_t* req) { goto error; } - dir = uv__malloc(sizeof(*dir)); + dir = (uv_dir_t*)uv__malloc(sizeof(*dir)); if (dir == NULL) { SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY); goto error; @@ -1706,7 +1706,7 @@ void fs__opendir(uv_fs_t* req) { else fmt = L"%s\\*"; - find_path = uv__malloc(sizeof(WCHAR) * (len + 4)); + find_path = (WCHAR*)uv__malloc(sizeof(WCHAR) * (len + 4)); if (find_path == NULL) { SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY); goto error; @@ -1743,7 +1743,7 @@ void fs__readdir(uv_fs_t* req) { int r; req->flags |= UV_FS_FREE_PTR; - dir = req->ptr; + dir = (uv_dir_t*)req->ptr; dirents = dir->dirents; memset(dirents, 0, dir->nentries * sizeof(*dir->dirents)); find_data = &dir->find_data; @@ -1800,7 +1800,7 @@ error: void fs__closedir(uv_fs_t* req) { uv_dir_t* dir; - dir = req->ptr; + dir = (uv_dir_t*)req->ptr; FindClose(dir->dir_handle); uv__free(req->ptr); SET_REQ_RESULT(req, 0); @@ -2791,7 +2791,7 @@ static ssize_t fs__realpath_handle(HANDLE handle, char** realpath_ptr) { return -1; } - w_realpath_buf = uv__malloc((w_realpath_len + 1) * sizeof(WCHAR)); + w_realpath_buf = (WCHAR*)uv__malloc((w_realpath_len + 1) * sizeof(WCHAR)); if (w_realpath_buf == NULL) { SetLastError(ERROR_OUTOFMEMORY); return -1; @@ -2904,7 +2904,7 @@ retry_get_disk_free_space: } len = MAX_PATH + 1; - pathw = uv__malloc(len * sizeof(*pathw)); + pathw = (WCHAR*)uv__malloc(len * sizeof(*pathw)); if (pathw == NULL) { SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY); return; @@ -2920,7 +2920,7 @@ retry_get_full_path_name: return; } else if (ret > len) { len = ret; - pathw = uv__reallocf(pathw, len * sizeof(*pathw)); + pathw = (WCHAR*)uv__reallocf(pathw, len * sizeof(*pathw)); if (pathw == NULL) { SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY); return; @@ -2936,7 +2936,7 @@ retry_get_full_path_name: uv__free(pathw); } - stat_fs = uv__malloc(sizeof(*stat_fs)); + stat_fs = (uv_statfs_t*)uv__malloc(sizeof(*stat_fs)); if (stat_fs == NULL) { SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY); return; @@ -3095,7 +3095,7 @@ int uv_fs_read(uv_loop_t* loop, req->fs.info.nbufs = nbufs; req->fs.info.bufs = req->fs.info.bufsml; if (nbufs > ARRAY_SIZE(req->fs.info.bufsml)) - req->fs.info.bufs = uv__malloc(nbufs * sizeof(*bufs)); + req->fs.info.bufs = (uv_buf_t*)uv__malloc(nbufs * sizeof(*bufs)); if (req->fs.info.bufs == NULL) { SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY); @@ -3128,7 +3128,7 @@ int uv_fs_write(uv_loop_t* loop, req->fs.info.nbufs = nbufs; req->fs.info.bufs = req->fs.info.bufsml; if (nbufs > ARRAY_SIZE(req->fs.info.bufsml)) - req->fs.info.bufs = uv__malloc(nbufs * sizeof(*bufs)); + req->fs.info.bufs = (uv_buf_t*)uv__malloc(nbufs * sizeof(*bufs)); if (req->fs.info.bufs == NULL) { SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY); diff --git a/src/win/pipe.c b/src/win/pipe.c index f0cac3822564e14052feb5e1934f54c57c78160d..c1739efe82b8755999145860b4da6b50c73518a2 100644 --- a/src/win/pipe.c +++ b/src/win/pipe.c @@ -756,7 +756,7 @@ int uv_pipe_bind2(uv_pipe_t* handle, /* Convert name to UTF16. */ nameSize = MultiByteToWideChar(CP_UTF8, 0, name, -1, NULL, 0) * sizeof(WCHAR); - handle->name = uv__malloc(nameSize); + handle->name = (WCHAR*)uv__malloc(nameSize); if (!handle->name) { uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc"); } @@ -906,7 +906,7 @@ int uv_pipe_connect2(uv_connect_t* req, /* Convert name to UTF16. */ nameSize = MultiByteToWideChar(CP_UTF8, 0, name, -1, NULL, 0) * sizeof(WCHAR); - handle->name = uv__malloc(nameSize); + handle->name = (WCHAR*)uv__malloc(nameSize); if (!handle->name) { uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc"); } @@ -924,7 +924,7 @@ int uv_pipe_connect2(uv_connect_t* req, pipeHandle = open_named_pipe(handle->name, &duplex_flags); if (pipeHandle == INVALID_HANDLE_VALUE) { if (GetLastError() == ERROR_PIPE_BUSY) { - req->u.connect.name = uv__malloc(nameSize); + req->u.connect.name = (WCHAR *)uv__malloc(nameSize); if (!req->u.connect.name) { uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc"); } @@ -1528,7 +1528,7 @@ static int uv__build_coalesced_write_req(uv_write_t* user_req, data_length; /* (c) */ /* Allocate buffer. */ - heap_buffer = uv__malloc(heap_buffer_length); + heap_buffer = (char*)uv__malloc(heap_buffer_length); if (heap_buffer == NULL) return ERROR_NOT_ENOUGH_MEMORY; /* Maps to UV_ENOMEM. */ @@ -1777,7 +1777,7 @@ int uv__pipe_write_ipc(uv_loop_t* loop, bufs = stack_bufs; } else { /* Use heap-allocated buffer array. */ - bufs = uv__calloc(buf_count, sizeof(uv_buf_t)); + bufs = (uv_buf_t*)uv__calloc(buf_count, sizeof(uv_buf_t)); if (bufs == NULL) return ERROR_NOT_ENOUGH_MEMORY; /* Maps to UV_ENOMEM. */ } @@ -2514,7 +2514,7 @@ static int uv__pipe_getname(const uv_pipe_t* handle, char* buffer, size_t* size) FileNameInformation); if (nt_status == STATUS_BUFFER_OVERFLOW) { name_size = sizeof(*name_info) + tmp_name_info.FileNameLength; - name_info = uv__malloc(name_size); + name_info = (FILE_NAME_INFORMATION*)uv__malloc(name_size); if (!name_info) { *size = 0; err = UV_ENOMEM; diff --git a/src/win/process.c b/src/win/process.c index ed44adc67c6d52785a199206d9ba0357e2d0b045..b383e8b405db56d413985b38df216d09c58ec4a0 100644 --- a/src/win/process.c +++ b/src/win/process.c @@ -615,8 +615,8 @@ error: int env_strncmp(const wchar_t* a, int na, const wchar_t* b) { - wchar_t* a_eq; - wchar_t* b_eq; + const wchar_t* a_eq; + const wchar_t* b_eq; wchar_t* A; wchar_t* B; int nb; @@ -633,8 +633,8 @@ int env_strncmp(const wchar_t* a, int na, const wchar_t* b) { assert(b_eq); nb = b_eq - b; - A = alloca((na+1) * sizeof(wchar_t)); - B = alloca((nb+1) * sizeof(wchar_t)); + A = (wchar_t*)alloca((na+1) * sizeof(wchar_t)); + B = (wchar_t*)alloca((nb+1) * sizeof(wchar_t)); r = LCMapStringW(LOCALE_INVARIANT, LCMAP_UPPERCASE, a, na, A, na); assert(r==na); @@ -717,7 +717,7 @@ int make_program_env(char* env_block[], WCHAR** dst_ptr) { if (dst_copy == NULL && env_len > 0) { return ERROR_OUTOFMEMORY; } - env_copy = alloca(env_block_count * sizeof(WCHAR*)); + env_copy = (WCHAR**)alloca(env_block_count * sizeof(WCHAR*)); ptr = dst_copy; ptr_copy = env_copy; @@ -771,7 +771,7 @@ int make_program_env(char* env_block[], WCHAR** dst_ptr) { } /* final pass: copy, in sort order, and inserting required variables */ - dst = uv__malloc((1+env_len) * sizeof(WCHAR)); + dst = (WCHAR*)uv__malloc((1+env_len) * sizeof(WCHAR)); if (!dst) { uv__free(dst_copy); return ERROR_OUTOFMEMORY; diff --git a/src/win/tcp.c b/src/win/tcp.c index 187f36e2a61c870b0d16e17e9d4a9e1161ba8851..d8da4d941a51b0625fc0c072342ec4edf74c0ea3 100644 --- a/src/win/tcp.c +++ b/src/win/tcp.c @@ -585,7 +585,7 @@ int uv__tcp_listen(uv_tcp_t* handle, int backlog, uv_connection_cb cb) { if (handle->tcp.serv.accept_reqs == NULL) { handle->tcp.serv.accept_reqs = - uv__malloc(uv_simultaneous_server_accepts * sizeof(uv_tcp_accept_t)); + (uv_tcp_accept_t*)uv__malloc(uv_simultaneous_server_accepts * sizeof(uv_tcp_accept_t)); if (!handle->tcp.serv.accept_reqs) { uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc"); } diff --git a/src/win/thread.c b/src/win/thread.c index 57c25e8f5a861c9d8a4c402c260d3ac235200423..57f1698f595e2410a51044f7f228b5a235206819 100644 --- a/src/win/thread.c +++ b/src/win/thread.c @@ -98,7 +98,7 @@ static UINT __stdcall uv__thread_start(void* arg) { struct thread_ctx *ctx_p; struct thread_ctx ctx; - ctx_p = arg; + ctx_p = (struct thread_ctx*)arg; ctx = *ctx_p; uv__free(ctx_p); @@ -141,7 +141,7 @@ int uv_thread_create_ex(uv_thread_t* tid, return UV_EINVAL; } - ctx = uv__malloc(sizeof(*ctx)); + ctx = (struct thread_ctx*)uv__malloc(sizeof(*ctx)); if (ctx == NULL) return UV_ENOMEM; diff --git a/src/win/util.c b/src/win/util.c index f6ec79cd57b5010ed5fd6829d952bcdacc8b7671..1cfd7b2caf0d4ad1a6a66df9406c21f4e2b69b04 100644 --- a/src/win/util.c +++ b/src/win/util.c @@ -160,7 +160,7 @@ static int uv__cwd(WCHAR** buf, DWORD *len) { return uv_translate_sys_error(GetLastError()); /* |t| is the size of the buffer _including_ nul. */ - p = uv__malloc(t * sizeof(*p)); + p = (WCHAR *)uv__malloc(t * sizeof(*p)); if (p == NULL) return UV_ENOMEM; @@ -265,7 +265,7 @@ int uv_chdir(const char* dir) { if (utf16_len == 0) { return uv_translate_sys_error(GetLastError()); } - utf16_buffer = uv__malloc(utf16_len * sizeof(WCHAR)); + utf16_buffer = (WCHAR*)uv__malloc(utf16_len * sizeof(WCHAR)); if (utf16_buffer == NULL) { return UV_ENOMEM; } @@ -623,14 +623,14 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos_ptr, int* cpu_count_ptr) { GetSystemInfo(&system_info); cpu_count = system_info.dwNumberOfProcessors; - cpu_infos = uv__calloc(cpu_count, sizeof *cpu_infos); + cpu_infos = (uv_cpu_info_t*)uv__calloc(cpu_count, sizeof *cpu_infos); if (cpu_infos == NULL) { err = ERROR_OUTOFMEMORY; goto error; } sppi_size = cpu_count * sizeof(*sppi); - sppi = uv__malloc(sppi_size); + sppi = (SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION*)uv__malloc(sppi_size); if (sppi == NULL) { err = ERROR_OUTOFMEMORY; goto error; @@ -774,7 +774,8 @@ int uv_interface_addresses(uv_interface_address_t** addresses_ptr, case ERROR_BUFFER_OVERFLOW: /* This happens when win_address_buf is NULL or too small to hold all * adapters. */ - win_address_buf = uv__malloc(win_address_buf_size); + win_address_buf = + (IP_ADAPTER_ADDRESSES*)uv__malloc(win_address_buf_size); if (win_address_buf == NULL) return UV_ENOMEM; @@ -782,7 +783,7 @@ int uv_interface_addresses(uv_interface_address_t** addresses_ptr, case ERROR_NO_DATA: { /* No adapters were found. */ - uv_address_buf = uv__malloc(1); + uv_address_buf = (uv_interface_address_t*)uv__malloc(1); if (uv_address_buf == NULL) return UV_ENOMEM; @@ -859,7 +860,7 @@ int uv_interface_addresses(uv_interface_address_t** addresses_ptr, } /* Allocate space to store interface data plus adapter names. */ - uv_address_buf = uv__malloc(uv_address_buf_size); + uv_address_buf = (uv_interface_address_t*)uv__malloc(uv_address_buf_size); if (uv_address_buf == NULL) { uv__free(win_address_buf); return UV_ENOMEM; @@ -1074,7 +1075,7 @@ int uv_os_tmpdir(char* buffer, size_t* size) { } /* Include space for terminating null char. */ len += 1; - path = uv__malloc(len * sizeof(wchar_t)); + path = (wchar_t*)uv__malloc(len * sizeof(wchar_t)); if (path == NULL) { return UV_ENOMEM; } @@ -1153,7 +1154,7 @@ int uv__convert_utf16_to_utf8(const WCHAR* utf16, int utf16len, char** utf8) { /* Allocate the destination buffer adding an extra byte for the terminating * NULL. If utf16len is not -1 WideCharToMultiByte will not add it, so * we do it ourselves always, just in case. */ - *utf8 = uv__malloc(bufsize + 1); + *utf8 = (char*)uv__malloc(bufsize + 1); if (*utf8 == NULL) return UV_ENOMEM; @@ -1201,7 +1202,7 @@ int uv__convert_utf8_to_utf16(const char* utf8, int utf8len, WCHAR** utf16) { /* Allocate the destination buffer adding an extra byte for the terminating * NULL. If utf8len is not -1 MultiByteToWideChar will not add it, so * we do it ourselves always, just in case. */ - *utf16 = uv__malloc(sizeof(WCHAR) * (bufsize + 1)); + *utf16 = (WCHAR*)uv__malloc(sizeof(WCHAR) * (bufsize + 1)); if (*utf16 == NULL) return UV_ENOMEM; @@ -1242,7 +1243,7 @@ static int uv__getpwuid_r(uv_passwd_t* pwd) { return uv_translate_sys_error(r); } - path = uv__malloc(bufsize * sizeof(wchar_t)); + path = (wchar_t*)uv__malloc(bufsize * sizeof(wchar_t)); if (path == NULL) { CloseHandle(token); return UV_ENOMEM; @@ -1323,7 +1324,7 @@ int uv_os_environ(uv_env_item_t** envitems, int* count) { for (penv = env, i = 0; *penv != L'\0'; penv += wcslen(penv) + 1, i++); - *envitems = uv__calloc(i, sizeof(**envitems)); + *envitems = (uv_env_item_t*)uv__calloc(i, sizeof(**envitems)); if (*envitems == NULL) { FreeEnvironmentStringsW(env); return UV_ENOMEM; @@ -1413,7 +1414,7 @@ int uv_os_getenv(const char* name, char* buffer, size_t* size) { uv__free(var); varlen = 1 + len; - var = uv__malloc(varlen * sizeof(*var)); + var = (wchar_t*)uv__malloc(varlen * sizeof(*var)); if (var == NULL) { r = UV_ENOMEM;