From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: PJ Reiniger Date: Tue, 26 Apr 2022 15:01:25 -0400 Subject: [PATCH 01/10] Fix missing casts --- include/uv/unix.h | 2 +- src/fs-poll.c | 10 ++++----- src/inet.c | 11 +++++----- src/strscpy.c | 2 +- src/threadpool.c | 2 +- src/unix/bsd-ifaddrs.c | 2 +- src/unix/core.c | 12 +++++----- src/unix/darwin-proctitle.c | 5 +++-- src/unix/darwin.c | 2 +- src/unix/epoll.c | 2 +- src/unix/freebsd.c | 4 ++-- src/unix/fs.c | 20 ++++++++--------- src/unix/fsevents.c | 40 +++++++++++++++++----------------- src/unix/getaddrinfo.c | 8 +++---- src/unix/ibmi.c | 2 +- src/unix/kqueue.c | 6 ++--- src/unix/linux-core.c | 5 ++--- src/unix/linux-inotify.c | 4 ++-- src/unix/loop.c | 2 +- src/unix/netbsd.c | 4 ++-- src/unix/openbsd.c | 4 ++-- src/unix/pipe.c | 4 ++-- src/unix/poll.c | 2 +- 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 | 35 ++++++++++++++--------------- src/unix/thread.c | 7 +++--- 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 | 26 +++++++++++----------- src/win/pipe.c | 10 ++++----- src/win/process.c | 12 +++++----- src/win/tcp.c | 2 +- src/win/thread.c | 4 ++-- src/win/util.c | 29 ++++++++++++------------ 40 files changed, 166 insertions(+), 162 deletions(-) diff --git a/include/uv/unix.h b/include/uv/unix.h index ea37d78768654eef98e10982a6b6ddce934bbbbf..420be86c6f9984486c6420ff710c9dbcad09e411 100644 --- a/include/uv/unix.h +++ b/include/uv/unix.h @@ -223,7 +223,7 @@ typedef struct { int backend_fd; \ void* pending_queue[2]; \ void* watcher_queue[2]; \ - uv__io_t** watchers; \ + void** watchers; \ unsigned int nwatchers; \ unsigned int nfds; \ void* wq[2]; \ 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 ddabf22fa52a0d4d25987c65f59e0e5456406fe3..ca8b6ac8b69779655f69da758aa63d810332c800 100644 --- a/src/inet.c +++ b/src/inet.c @@ -40,9 +40,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; } @@ -154,10 +154,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) { @@ -168,7 +169,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/threadpool.c b/src/threadpool.c index e804c7c4b6f03c843965001f4c2179d349e156d4..1241ace1cc304c14bf1b79cc2a588c1a50ef4507 100644 --- a/src/threadpool.c +++ b/src/threadpool.c @@ -206,7 +206,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 54c769f37f2331136c87a37c13fb4e3f9a8f22f9..6353b0e3cc9448aa35dc2ccc9b259277b3fae9a5 100644 --- a/src/unix/core.c +++ b/src/unix/core.c @@ -824,7 +824,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; @@ -843,8 +843,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(); @@ -1184,7 +1184,7 @@ int uv__getpwuid_r(uv_passwd_t* pwd) { * 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; @@ -1210,7 +1210,7 @@ int uv__getpwuid_r(uv_passwd_t* pwd) { 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); @@ -1274,7 +1274,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 62f04d315423d5b642294ff588b57d2babacad89..5fbf734218fa17cc61c03402c8b1dd6b66110ecb 100644 --- a/src/unix/darwin.c +++ b/src/unix/darwin.c @@ -353,7 +353,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/epoll.c b/src/unix/epoll.c index 97348e254b4556908a2d013300f3f9ee61ff230b..4c057fb3da37706906692750fc2fb42951843157 100644 --- a/src/unix/epoll.c +++ b/src/unix/epoll.c @@ -325,7 +325,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { assert(fd >= 0); assert((unsigned) fd < loop->nwatchers); - 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/freebsd.c b/src/unix/freebsd.c index 658ff262d3738e95b24d8fb8992da905635170f7..6700ff6196245bdce7f14d9edd38607f18812200 100644 --- a/src/unix/freebsd.c +++ b/src/unix/freebsd.c @@ -215,7 +215,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; @@ -232,7 +232,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 933c9c0dc2da40e5bbdc70d73d131f678cafd7fb..1a615244f50dc75e560821f5bfbf5af97e592cc7 100644 --- a/src/unix/fs.c +++ b/src/unix/fs.c @@ -137,7 +137,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; \ @@ -572,7 +572,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; @@ -596,7 +596,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) { @@ -638,7 +638,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); @@ -667,7 +667,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; @@ -731,7 +731,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; @@ -751,7 +751,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; @@ -774,7 +774,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; @@ -2010,7 +2010,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; @@ -2180,7 +2180,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 bf4f1f6a5180ab4f6ef6776bc3f854c0c9fe67cd..648c8a98b817cb9a8bd03e85bf9b2175bb53eb1a 100644 --- a/src/unix/fsevents.c +++ b/src/unix/fsevents.c @@ -185,7 +185,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); @@ -233,10 +233,10 @@ static void uv__fsevents_event_cb(const FSEventStreamRef streamRef, FSEventStreamEventFlags flags; 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); @@ -306,7 +306,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; @@ -373,7 +373,7 @@ static int uv__fsevents_create_stream(uv_loop_t* loop, CFArrayRef paths) { flags); assert(ref != NULL); - state = loop->cf_state; + state = (uv__cf_loop_state_t*)loop->cf_state; pFSEventStreamScheduleWithRunLoop(ref, state->loop, *pkCFRunLoopDefaultMode); @@ -392,7 +392,7 @@ static int uv__fsevents_create_stream(uv_loop_t* loop, CFArrayRef paths) { static void uv__fsevents_destroy_stream(uv_loop_t* loop) { uv__cf_loop_state_t* state; - state = loop->cf_state; + state = (uv__cf_loop_state_t*)loop->cf_state; if (state->fsevent_stream == NULL) return; @@ -419,7 +419,7 @@ static void uv__fsevents_reschedule(uv_fs_event_t* handle, int err; unsigned int path_count; - state = handle->loop->cf_state; + state = (uv__cf_loop_state_t*)handle->loop->cf_state; paths = NULL; cf_paths = NULL; err = 0; @@ -447,7 +447,7 @@ static void uv__fsevents_reschedule(uv_fs_event_t* handle, 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; @@ -605,7 +605,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; @@ -707,7 +707,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); @@ -721,8 +721,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, @@ -750,8 +750,8 @@ static void uv__cf_loop_cb(void* arg) { 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); QUEUE_MOVE(&loop->cf_signals, &split_head); @@ -781,7 +781,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; @@ -791,7 +791,7 @@ int uv__cf_loop_signal(uv_loop_t* loop, uv_mutex_lock(&loop->cf_mutex); 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); @@ -825,7 +825,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; @@ -841,7 +841,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); QUEUE_INSERT_TAIL(&state->fsevent_handles, &handle->cf_member); state->fsevent_handle_count++; @@ -881,7 +881,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); 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 8c6ae636329e5b2e17742fc46b5094237381712a..56af31e979f34b0182aa82dbb3a04d1c5dd747cc 100644 --- a/src/unix/ibmi.c +++ b/src/unix/ibmi.c @@ -288,7 +288,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 5dac76ae753c6caf47e2795a715cae74e6e5930c..86eb529bcdaf69591850232084c1b3b2f526f838 100644 --- a/src/unix/kqueue.c +++ b/src/unix/kqueue.c @@ -281,8 +281,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; @@ -304,7 +304,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-core.c b/src/unix/linux-core.c index 23a7dafec814f6ecbd94e66d513fafe1cf8b3e80..85f3fc0170288577d2e39030dc728de9a694a752 100644 --- a/src/unix/linux-core.c +++ b/src/unix/linux-core.c @@ -117,7 +117,6 @@ void uv__platform_loop_delete(uv_loop_t* loop) { } - uint64_t uv__hrtime(uv_clocktype_t type) { static clock_t fast_clock_id = -1; struct timespec t; @@ -283,7 +282,7 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { goto out; err = UV_ENOMEM; - ci = uv__calloc(numcpus, sizeof(*ci)); + ci = (uv_cpu_info_t*)uv__calloc(numcpus, sizeof(*ci)); if (ci == NULL) goto out; @@ -663,7 +662,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; diff --git a/src/unix/linux-inotify.c b/src/unix/linux-inotify.c index c1bd260e16e5e9fd023cd00cd673951347545d00..f5366e9626ff5eb063f89a63415a6df9eec75f53 100644 --- a/src/unix/linux-inotify.c +++ b/src/unix/linux-inotify.c @@ -281,12 +281,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); QUEUE_INIT(&w->watchers); w->iterating = 0; RB_INSERT(watcher_root, CAST(&handle->loop->inotify_watchers), w); diff --git a/src/unix/loop.c b/src/unix/loop.c index a88e71c339351f2ebcdd6c3f933fc3b1122910ed..2e819cdda71f0da2aa957148d3e6df18e027e5c8 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 c66333f522c5d43bdb6a2aea4e29d0baa278579f..b6886a1ce5ad2e04c64e0bde4e5709c3dac5a219 100644 --- a/src/unix/netbsd.c +++ b/src/unix/netbsd.c @@ -206,14 +206,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 f32a94df38765fb54e7176efe0d172a5a88bccb4..62740f7349889833689d091e8cdd8010c404c28c 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; @@ -197,7 +197,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 e8cfa1481c3648928eeebceeebb642d358f2a0a8..c8ba31daf847fc206b392327ebf6cd4a5501b2d5 100644 --- a/src/unix/pipe.c +++ b/src/unix/pipe.c @@ -309,7 +309,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; } @@ -346,7 +346,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..7364731757599d647bedc8e44d3930a32b743f5d 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; diff --git a/src/unix/posix-poll.c b/src/unix/posix-poll.c index 0f4bf93874be89f2c4deb71e7eeca0416e3bd9ff..8da038d1da6dd893a141b14a593a9cc84b7fbf2f 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 f84153687f799a201e55e465da998ea0b690da0f..0916aa458d4df07fb3b4e9e83f80b9e43c1f82a0 100644 --- a/src/unix/process.c +++ b/src/unix/process.c @@ -403,7 +403,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"); } @@ -967,7 +967,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 b1f6359e0de2c520ed71bd689956de971006bb21..c6cc50e709989f30f4393b509d859663717d1770 100644 --- a/src/unix/stream.c +++ b/src/unix/stream.c @@ -113,7 +113,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; @@ -142,8 +142,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) @@ -320,7 +320,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; @@ -605,7 +605,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]; @@ -844,7 +844,7 @@ static int uv__try_write(uv_stream_t* stream, /* silence aliasing warning */ { void* pv = CMSG_DATA(cmsg); - int* pi = pv; + int* pi = (int*)pv; *pi = fd_to_send; } @@ -975,11 +975,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; @@ -989,9 +990,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. @@ -1039,7 +1040,7 @@ static int uv__stream_recv_cmsg(uv_stream_t* stream, struct msghdr* msg) { /* silence aliasing warning */ pv = CMSG_DATA(cmsg); - pi = pv; + pi = (int*)pv; /* Count available fds */ start = (char*) cmsg; @@ -1423,7 +1424,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; @@ -1557,7 +1558,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; @@ -1575,7 +1576,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); @@ -1610,7 +1611,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 d89e5cd13ba0ad73913b74f5e5fe4b5f139eb650..759cd0c28518928127837ba82cbf8e761c6223d3 100644 --- a/src/unix/thread.c +++ b/src/unix/thread.c @@ -59,7 +59,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 = (_uv_barrier*)uv__malloc(sizeof(*b)); if (b == NULL) return UV_ENOMEM; @@ -275,8 +275,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); @@ -547,7 +546,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 4d985b88ba9304d57aea42d9c1b4a9a9e924ddc5..a130aeaa59581176147d5f060156b57ef5ad658a 100644 --- a/src/unix/udp.c +++ b/src/unix/udp.c @@ -227,11 +227,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); } @@ -281,7 +281,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 { @@ -765,7 +765,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 efc9eb50ee3b9ee204f9f16827dc800200f3d094..dfb606e3e842ccb3b2d9327e2b3048c4cfdd0314 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) { @@ -653,7 +653,7 @@ void uv__fs_scandir_cleanup(uv_fs_t* req) { unsigned int* nbufs = uv__get_nbufs(req); - dents = req->ptr; + dents = (uv__dirent_t**)(req->ptr); if (*nbufs > 0 && *nbufs != (unsigned int) req->result) (*nbufs)--; for (; *nbufs < (unsigned int) req->result; (*nbufs)++) @@ -680,7 +680,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) @@ -745,7 +745,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; @@ -791,7 +791,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 67af93e6571ed4324d80b6dfb2ff93db7b9cd9b1..0752edff3ebdf61e056157ef21109538f6e4b358 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; @@ -261,7 +263,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 792307995f60c8ac34b44c6c255102cd227354b7..8374012f0e9ee094eed5db19e5f7d12286052d70 100644 --- a/src/win/fs.c +++ b/src/win/fs.c @@ -285,7 +285,7 @@ static int fs__wide_to_utf8(WCHAR* w_source_ptr, return 0; } - target = uv__malloc(target_len + 1); + target = (char*)uv__malloc(target_len + 1); if (target == NULL) { SetLastError(ERROR_OUTOFMEMORY); return -1; @@ -1464,7 +1464,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) @@ -1478,7 +1478,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 + utf8_len); + dirent = (uv__dirent_t*)uv__malloc(sizeof *dirent + utf8_len); if (dirent == NULL) goto out_of_memory_error; @@ -1589,7 +1589,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; @@ -1604,7 +1604,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; @@ -1641,7 +1641,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; @@ -1698,7 +1698,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); @@ -2627,7 +2627,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; @@ -2738,7 +2738,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; @@ -2754,7 +2754,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; @@ -2770,7 +2770,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; @@ -2929,7 +2929,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); @@ -2962,7 +2962,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 998461811fb87fafa8ffd43bb9c9f5d88f00c6f9..cd77061a079094b11350a01ddd364e15fa3078bc 100644 --- a/src/win/pipe.c +++ b/src/win/pipe.c @@ -728,7 +728,7 @@ int uv_pipe_bind(uv_pipe_t* handle, const char* name) { /* 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"); } @@ -841,7 +841,7 @@ void uv_pipe_connect(uv_connect_t* req, 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"); } @@ -1453,7 +1453,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. */ @@ -1698,7 +1698,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. */ } @@ -2430,7 +2430,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 24c633393fd15dcf87726b174d6b027a969e0f0d..e857db3e98eb24f8de12e6b6d90ae3905cc49ce7 100644 --- a/src/win/process.c +++ b/src/win/process.c @@ -616,8 +616,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; @@ -634,8 +634,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); @@ -718,7 +718,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; @@ -772,7 +772,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 b6aa4c512050e012bdfa1395f0011a5371b11768..4cccee429223cbd6f7b876341982816e4998dc10 100644 --- a/src/win/tcp.c +++ b/src/win/tcp.c @@ -612,7 +612,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 d3b1c96b6199a7ff034d8646b76a6a21712702d8..9ad60c9164c8ff26223309a9aa388fa5e4621914 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 99432053cc3b242e514268b7aba2e2d83a9e64f2..c655f532dbcc6c63516027caf1453ca4ef817cff 100644 --- a/src/win/util.c +++ b/src/win/util.c @@ -164,7 +164,7 @@ int uv_cwd(char* buffer, size_t* size) { 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; } @@ -242,7 +242,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; } @@ -268,7 +268,7 @@ int uv_chdir(const char* dir) { new_utf16_len = GetCurrentDirectoryW(utf16_len, utf16_buffer); if (new_utf16_len > utf16_len ) { uv__free(utf16_buffer); - utf16_buffer = uv__malloc(new_utf16_len * sizeof(WCHAR)); + utf16_buffer = (WCHAR*)uv__malloc(new_utf16_len * sizeof(WCHAR)); if (utf16_buffer == NULL) { /* When updating the environment variable fails, return UV_OK anyway. * We did successfully change current working directory, only updating @@ -573,14 +573,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; @@ -802,7 +802,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; @@ -810,7 +811,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; @@ -887,7 +888,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; @@ -1131,7 +1132,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; } @@ -1221,7 +1222,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; @@ -1269,7 +1270,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; @@ -1310,7 +1311,7 @@ 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; @@ -1381,7 +1382,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; @@ -1471,7 +1472,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;