SAFE_ALLOC=>HV_ALLOC SAFE_FREE=>HV_FREE

base/array.h

@@ -63,7 +63,7 @@ static inline type* atype##_back(atype* p) {\
 static inline void atype##_init(atype* p, int maxsize) {\
     p->size = 0;\
     p->maxsize = maxsize;\
-    SAFE_ALLOC(p->ptr, sizeof(type) * maxsize);\
+    HV_ALLOC(p->ptr, sizeof(type) * maxsize);\
 }\
 \
 static inline void atype##_clear(atype* p) {\
@@ -72,7 +72,7 @@ static inline void atype##_clear(atype* p) {\
 }\
 \
 static inline void atype##_cleanup(atype* p) {\
-    SAFE_FREE(p->ptr);\
+    HV_FREE(p->ptr);\
     p->size = p->maxsize = 0;\
 }\
 \

base/hbase.h

@@ -14,18 +14,16 @@ void* safe_realloc(void* oldptr, size_t newsize, size_t oldsize);
 void* safe_calloc(size_t nmemb, size_t size);
 void* safe_zalloc(size_t size);
 
-#undef  SAFE_ALLOC
-#define SAFE_ALLOC(ptr, size)\
+#define HV_ALLOC(ptr, size)\
     do {\
         void** pptr = (void**)&(ptr);\
         *pptr = safe_zalloc(size);\
         printd("alloc(%p, size=%llu)\tat [%s:%d:%s]\n", ptr, (unsigned long long)size, __FILE__, __LINE__, __FUNCTION__);\
     } while(0)
 
-#define SAFE_ALLOC_SIZEOF(ptr)  SAFE_ALLOC(ptr, sizeof(*(ptr)))
+#define HV_ALLOC_SIZEOF(ptr)  HV_ALLOC(ptr, sizeof(*(ptr)))
 
-#undef  SAFE_FREE
-#define SAFE_FREE(ptr)\
+#define HV_FREE(ptr)\
     do {\
         if (ptr) {\
             printd("free( %p )\tat [%s:%d:%s]\n", ptr, __FILE__, __LINE__, __FUNCTION__);\
@@ -35,11 +33,11 @@ void* safe_zalloc(size_t size);
         }\
     } while(0)
 
-static inline void memcheck() {
+static inline void hv_memcheck() {
     printf("Memcheck => alloc:%u free:%u\n", g_alloc_cnt, g_free_cnt);
 }
 
-#define MEMCHECK    atexit(memcheck);
+#define HV_MEMCHECK    atexit(hv_memcheck);
 
 //-----------------------------safe string-----------------------
 char* strupper(char* str);

base/hbuf.h

@@ -66,7 +66,7 @@ public:
 
     void cleanup() {
         if (cleanup_) {
-            SAFE_FREE(base);
+            HV_FREE(base);
             len = 0;
             cleanup_ = false;
         }
@@ -76,7 +76,7 @@ public:
         if (cap == len) return;
 
         if (base == NULL) {
-            SAFE_ALLOC(base, cap);
+            HV_ALLOC(base, cap);
         }
         else {
             base = (char*)safe_realloc(base, cap, len);

base/queue.h

@@ -55,7 +55,7 @@ static inline void qtype##_init(qtype* p, int maxsize) {\
     p->_offset = 0;\
     p->size = 0;\
     p->maxsize = maxsize;\
-    SAFE_ALLOC(p->ptr, sizeof(type) * maxsize);\
+    HV_ALLOC(p->ptr, sizeof(type) * maxsize);\
 }\
 \
 static inline void qtype##_clear(qtype* p) {\
@@ -65,7 +65,7 @@ static inline void qtype##_clear(qtype* p) {\
 }\
 \
 static inline void qtype##_cleanup(qtype* p) {\
-    SAFE_FREE(p->ptr);\
+    HV_FREE(p->ptr);\
     p->_offset = p->size = p->maxsize = 0;\
 }\
 \

event/epoll.c

@@ -19,7 +19,7 @@ typedef struct epoll_ctx_s {
 int iowatcher_init(hloop_t* loop) {
     if (loop->iowatcher) return 0;
     epoll_ctx_t* epoll_ctx;
-    SAFE_ALLOC_SIZEOF(epoll_ctx);
+    HV_ALLOC_SIZEOF(epoll_ctx);
     epoll_ctx->epfd = epoll_create(EVENTS_INIT_SIZE);
     events_init(&epoll_ctx->events, EVENTS_INIT_SIZE);
     loop->iowatcher = epoll_ctx;
@@ -31,7 +31,7 @@ int iowatcher_cleanup(hloop_t* loop) {
     epoll_ctx_t* epoll_ctx = (epoll_ctx_t*)loop->iowatcher;
     close(epoll_ctx->epfd);
     events_cleanup(&epoll_ctx->events);
-    SAFE_FREE(loop->iowatcher);
+    HV_FREE(loop->iowatcher);
     return 0;
 }
 

event/evport.c

@@ -27,12 +27,12 @@ static void evport_ctx_resize(evport_ctx_t* evport_ctx, int size) {
 int iowatcher_init(hloop_t* loop) {
     if (loop->iowatcher) return 0;
     evport_ctx_t* evport_ctx;
-    SAFE_ALLOC_SIZEOF(evport_ctx);
+    HV_ALLOC_SIZEOF(evport_ctx);
     evport_ctx->port = port_create();
     evport_ctx->capacity = EVENTS_INIT_SIZE;
     evport_ctx->nevents = 0;
     int bytes = sizeof(port_event_t) * evport_ctx->capacity;
-    SAFE_ALLOC(evport_ctx->events, bytes);
+    HV_ALLOC(evport_ctx->events, bytes);
     loop->iowatcher = evport_ctx;
     return 0;
 }
@@ -41,8 +41,8 @@ int iowatcher_cleanup(hloop_t* loop) {
     if (loop->iowatcher == NULL) return 0;
     evport_ctx_t* evport_ctx = (evport_ctx_t*)loop->iowatcher;
     close(evport_ctx->port);
-    SAFE_FREE(evport_ctx->events);
-    SAFE_FREE(loop->iowatcher);
+    HV_FREE(evport_ctx->events);
+    HV_FREE(loop->iowatcher);
     return 0;
 }
 

event/hevent.c

@@ -68,14 +68,14 @@ void hio_set_type(hio_t* io, hio_type_e type) {
 
 void hio_set_localaddr(hio_t* io, struct sockaddr* addr, int addrlen) {
     if (io->localaddr == NULL) {
-        SAFE_ALLOC(io->localaddr, sizeof(sockaddr_u));
+        HV_ALLOC(io->localaddr, sizeof(sockaddr_u));
     }
     memcpy(io->localaddr, addr, addrlen);
 }
 
 void hio_set_peeraddr (hio_t* io, struct sockaddr* addr, int addrlen) {
     if (io->peeraddr == NULL) {
-        SAFE_ALLOC(io->peeraddr, sizeof(sockaddr_u));
+        HV_ALLOC(io->peeraddr, sizeof(sockaddr_u));
     }
     memcpy(io->peeraddr, addr, addrlen);
 }

event/hevent.h

@@ -159,7 +159,7 @@ struct hio_s {
     do {\
         EVENT_INACTIVE(ev);\
         if (!ev->pending) {\
-            SAFE_FREE(ev);\
+            HV_FREE(ev);\
         }\
     } while(0)
 

event/hloop.c

@@ -191,7 +191,7 @@ static void hloop_cleanup(hloop_t* loop) {
     while (node != &loop->idles) {
         idle = IDLE_ENTRY(node);
         node = node->next;
-        SAFE_FREE(idle);
+        HV_FREE(idle);
     }
     list_init(&loop->idles);
     // timers
@@ -200,7 +200,7 @@ static void hloop_cleanup(hloop_t* loop) {
     while (loop->timers.root) {
         timer = TIMER_ENTRY(loop->timers.root);
         heap_dequeue(&loop->timers);
-        SAFE_FREE(timer);
+        HV_FREE(timer);
     }
     heap_init(&loop->timers, NULL);
     // ios
@@ -237,7 +237,7 @@ static void hloop_cleanup(hloop_t* loop) {
 
 hloop_t* hloop_new(int flags) {
     hloop_t* loop;
-    SAFE_ALLOC_SIZEOF(loop);
+    HV_ALLOC_SIZEOF(loop);
     memset(loop, 0, sizeof(hloop_t));
     hloop_init(loop);
     loop->flags |= flags;
@@ -247,7 +247,7 @@ hloop_t* hloop_new(int flags) {
 void hloop_free(hloop_t** pp) {
     if (pp && *pp) {
         hloop_cleanup(*pp);
-        SAFE_FREE(*pp);
+        HV_FREE(*pp);
         *pp = NULL;
     }
 }
@@ -271,7 +271,7 @@ int hloop_run(hloop_t* loop) {
     loop->end_hrtime = gethrtime_us();
     if (loop->flags & HLOOP_FLAG_AUTO_FREE) {
         hloop_cleanup(loop);
-        SAFE_FREE(loop);
+        HV_FREE(loop);
     }
     return 0;
 }
@@ -325,7 +325,7 @@ void* hloop_userdata(hloop_t* loop) {
 
 hidle_t* hidle_add(hloop_t* loop, hidle_cb cb, uint32_t repeat) {
     hidle_t* idle;
-    SAFE_ALLOC_SIZEOF(idle);
+    HV_ALLOC_SIZEOF(idle);
     idle->event_type = HEVENT_TYPE_IDLE;
     idle->priority = HEVENT_LOWEST_PRIORITY;
     idle->repeat = repeat;
@@ -351,7 +351,7 @@ void hidle_del(hidle_t* idle) {
 htimer_t* htimer_add(hloop_t* loop, htimer_cb cb, uint32_t timeout, uint32_t repeat) {
     if (timeout == 0)   return NULL;
     htimeout_t* timer;
-    SAFE_ALLOC_SIZEOF(timer);
+    HV_ALLOC_SIZEOF(timer);
     timer->event_type = HEVENT_TYPE_TIMEOUT;
     timer->priority = HEVENT_HIGHEST_PRIORITY;
     timer->repeat = repeat;
@@ -390,7 +390,7 @@ htimer_t* htimer_add_period(hloop_t* loop, htimer_cb cb,
         return NULL;
     }
     hperiod_t* timer;
-    SAFE_ALLOC_SIZEOF(timer);
+    HV_ALLOC_SIZEOF(timer);
     timer->event_type = HEVENT_TYPE_PERIOD;
     timer->priority = HEVENT_HIGH_PRIORITY;
     timer->repeat = repeat;
@@ -473,10 +473,10 @@ static void hio_socket_init(hio_t* io) {
     nonblocking(io->fd);
     // fill io->localaddr io->peeraddr
     if (io->localaddr == NULL) {
-        SAFE_ALLOC(io->localaddr, sizeof(sockaddr_u));
+        HV_ALLOC(io->localaddr, sizeof(sockaddr_u));
     }
     if (io->peeraddr == NULL) {
-        SAFE_ALLOC(io->peeraddr, sizeof(sockaddr_u));
+        HV_ALLOC(io->peeraddr, sizeof(sockaddr_u));
     }
     socklen_t addrlen = sizeof(sockaddr_u);
     int ret = getsockname(io->fd, io->localaddr, &addrlen);
@@ -523,7 +523,7 @@ void hio_done(hio_t* io) {
     offset_buf_t* pbuf = NULL;
     while (!write_queue_empty(&io->write_queue)) {
         pbuf = write_queue_front(&io->write_queue);
-        SAFE_FREE(pbuf->base);
+        HV_FREE(pbuf->base);
         write_queue_pop_front(&io->write_queue);
     }
     write_queue_cleanup(&io->write_queue);
@@ -532,9 +532,9 @@ void hio_done(hio_t* io) {
 void hio_free(hio_t* io) {
     if (io == NULL) return;
     hio_done(io);
-    SAFE_FREE(io->localaddr);
-    SAFE_FREE(io->peeraddr);
-    SAFE_FREE(io);
+    HV_FREE(io->localaddr);
+    HV_FREE(io->peeraddr);
+    HV_FREE(io);
 }
 
 hio_t* hio_get(hloop_t* loop, int fd) {
@@ -549,7 +549,7 @@ hio_t* hio_get(hloop_t* loop, int fd) {
 
     hio_t* io = loop->ios.ptr[fd];
     if (io == NULL) {
-        SAFE_ALLOC_SIZEOF(io);
+        HV_ALLOC_SIZEOF(io);
         hio_init(io);
         io->loop = loop;
         io->fd = fd;

event/iocp.c

@@ -14,7 +14,7 @@ typedef struct iocp_ctx_s {
 int iowatcher_init(hloop_t* loop) {
     if (loop->iowatcher)    return 0;
     iocp_ctx_t* iocp_ctx;
-    SAFE_ALLOC_SIZEOF(iocp_ctx);
+    HV_ALLOC_SIZEOF(iocp_ctx);
     iocp_ctx->iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
     loop->iowatcher = iocp_ctx;
     return 0;
@@ -24,7 +24,7 @@ int iowatcher_cleanup(hloop_t* loop) {
     if (loop->iowatcher == NULL) return 0;
     iocp_ctx_t* iocp_ctx = (iocp_ctx_t*)loop->iowatcher;
     CloseHandle(iocp_ctx->iocp);
-    SAFE_FREE(loop->iowatcher);
+    HV_FREE(loop->iowatcher);
     return 0;
 }
 

event/kqueue.c

@@ -34,13 +34,13 @@ static void kqueue_ctx_resize(kqueue_ctx_t* kqueue_ctx, int size) {
 int iowatcher_init(hloop_t* loop) {
     if (loop->iowatcher) return 0;
     kqueue_ctx_t* kqueue_ctx;
-    SAFE_ALLOC_SIZEOF(kqueue_ctx);
+    HV_ALLOC_SIZEOF(kqueue_ctx);
     kqueue_ctx->kqfd = kqueue();
     kqueue_ctx->capacity = EVENTS_INIT_SIZE;
     kqueue_ctx->nchanges = 0;
     int bytes = sizeof(struct kevent) * kqueue_ctx->capacity;
-    SAFE_ALLOC(kqueue_ctx->changes, bytes);
-    SAFE_ALLOC(kqueue_ctx->events, bytes);
+    HV_ALLOC(kqueue_ctx->changes, bytes);
+    HV_ALLOC(kqueue_ctx->events, bytes);
     loop->iowatcher = kqueue_ctx;
     return 0;
 }
@@ -49,9 +49,9 @@ int iowatcher_cleanup(hloop_t* loop) {
     if (loop->iowatcher == NULL) return 0;
     kqueue_ctx_t* kqueue_ctx = (kqueue_ctx_t*)loop->iowatcher;
     close(kqueue_ctx->kqfd);
-    SAFE_FREE(kqueue_ctx->changes);
-    SAFE_FREE(kqueue_ctx->events);
-    SAFE_FREE(loop->iowatcher);
+    HV_FREE(kqueue_ctx->changes);
+    HV_FREE(kqueue_ctx->events);
+    HV_FREE(loop->iowatcher);
     return 0;
 }
 

event/nio.c

@@ -267,7 +267,7 @@ write:
     }
     pbuf->offset += nwrite;
     if (nwrite == len) {
-        SAFE_FREE(pbuf->base);
+        HV_FREE(pbuf->base);
         write_queue_pop_front(&io->write_queue);
         // write next
         goto write;
@@ -409,7 +409,7 @@ enqueue:
         rest.len = len;
         rest.offset = nwrite;
         // NOTE: free in nio_write
-        SAFE_ALLOC(rest.base, rest.len);
+        HV_ALLOC(rest.base, rest.len);
         memcpy(rest.base, (char*)buf, rest.len);
         if (io->write_queue.maxsize == 0) {
             write_queue_init(&io->write_queue, 4);

event/nlog.c

@@ -31,7 +31,7 @@ static void on_close(hio_t* io) {
         next = next->next;
         if (client->io == io) {
             list_del(next->prev);
-            SAFE_FREE(client);
+            HV_FREE(client);
             break;
         }
     }
@@ -60,7 +60,7 @@ static void on_accept(hio_t* io) {
 
     // free on_close
     nlog_client* client;
-    SAFE_ALLOC_SIZEOF(client);
+    HV_ALLOC_SIZEOF(client);
     client->io = io;
 
     hmutex_lock(&s_mutex);

event/overlapio.c

@@ -22,9 +22,9 @@ int post_acceptex(hio_t* listenio, hoverlapped_t* hovlp) {
         return WSAGetLastError();
     }
     if (hovlp == NULL) {
-        SAFE_ALLOC_SIZEOF(hovlp);
+        HV_ALLOC_SIZEOF(hovlp);
         hovlp->buf.len = 20 + sizeof(struct sockaddr_in6) * 2;
-        SAFE_ALLOC(hovlp->buf.buf, hovlp->buf.len);
+        HV_ALLOC(hovlp->buf.buf, hovlp->buf.len);
     }
     hovlp->fd = connfd;
     hovlp->event = READ_EVENT;
@@ -42,7 +42,7 @@ int post_acceptex(hio_t* listenio, hoverlapped_t* hovlp) {
 
 int post_recv(hio_t* io, hoverlapped_t* hovlp) {
     if (hovlp == NULL) {
-        SAFE_ALLOC_SIZEOF(hovlp);
+        HV_ALLOC_SIZEOF(hovlp);
     }
     hovlp->fd = io->fd;
     hovlp->event = READ_EVENT;
@@ -52,7 +52,7 @@ int post_recv(hio_t* io, hoverlapped_t* hovlp) {
     }
     hovlp->buf.len = io->readbuf.len;
     if (io->io_type == HIO_TYPE_UDP || io->io_type == HIO_TYPE_IP) {
-        SAFE_ALLOC(hovlp->buf.buf, hovlp->buf.len);
+        HV_ALLOC(hovlp->buf.buf, hovlp->buf.len);
     }
     else {
         hovlp->buf.buf = io->readbuf.base;
@@ -68,7 +68,7 @@ int post_recv(hio_t* io, hoverlapped_t* hovlp) {
             io->io_type == HIO_TYPE_IP) {
         if (hovlp->addr == NULL) {
             hovlp->addrlen = sizeof(struct sockaddr_in6);
-            SAFE_ALLOC(hovlp->addr, sizeof(struct sockaddr_in6));
+            HV_ALLOC(hovlp->addr, sizeof(struct sockaddr_in6));
         }
         ret = WSARecvFrom(io->fd, &hovlp->buf, 1, &dwbytes, &flags, hovlp->addr, &hovlp->addrlen, &hovlp->ovlp, NULL);
     }
@@ -132,7 +132,7 @@ static void on_connectex_complete(hio_t* io) {
     printd("on_connectex_complete------\n");
     hoverlapped_t* hovlp = (hoverlapped_t*)io->hovlp;
     io->error = hovlp->error;
-    SAFE_FREE(io->hovlp);
+    HV_FREE(io->hovlp);
     if (io->error != 0) {
         hio_close(io);
         return;
@@ -184,9 +184,9 @@ static void on_wsarecv_complete(hio_t* io) {
     }
     else if (io->io_type == HIO_TYPE_UDP ||
             io->io_type == HIO_TYPE_IP) {
-        SAFE_FREE(hovlp->buf.buf);
-        SAFE_FREE(hovlp->addr);
-        SAFE_FREE(io->hovlp);
+        HV_FREE(hovlp->buf.buf);
+        HV_FREE(hovlp->addr);
+        HV_FREE(io->hovlp);
     }
 }
 
@@ -210,8 +210,8 @@ static void on_wsasend_complete(hio_t* io) {
     }
 end:
     if (io->hovlp) {
-        SAFE_FREE(hovlp->buf.buf);
-        SAFE_FREE(io->hovlp);
+        HV_FREE(hovlp->buf.buf);
+        HV_FREE(io->hovlp);
     }
 }
 
@@ -275,7 +275,7 @@ int hio_connect (hio_t* io) {
     }
     // NOTE: free on_connectex_complete
     hoverlapped_t* hovlp;
-    SAFE_ALLOC_SIZEOF(hovlp);
+    HV_ALLOC_SIZEOF(hovlp);
     hovlp->fd = io->fd;
     hovlp->event = HV_WRITE;
     hovlp->io = io;
@@ -339,12 +339,12 @@ try_send:
 WSASend:
     {
         hoverlapped_t* hovlp;
-        SAFE_ALLOC_SIZEOF(hovlp);
+        HV_ALLOC_SIZEOF(hovlp);
         hovlp->fd = io->fd;
         hovlp->event = HV_WRITE;
         hovlp->buf.len = len - nwrite;
         // NOTE: free on_send_complete
-        SAFE_ALLOC(hovlp->buf.buf, hovlp->buf.len);
+        HV_ALLOC(hovlp->buf.buf, hovlp->buf.len);
         memcpy(hovlp->buf.buf, ((char*)buf) + nwrite, hovlp->buf.len);
         hovlp->io = io;
         DWORD dwbytes = 0;
@@ -403,10 +403,10 @@ int hio_close (hio_t* io) {
         hoverlapped_t* hovlp = (hoverlapped_t*)io->hovlp;
         // NOTE: hread buf provided by caller
         if (hovlp->buf.buf != io->readbuf.base) {
-            SAFE_FREE(hovlp->buf.buf);
+            HV_FREE(hovlp->buf.buf);
         }
-        SAFE_FREE(hovlp->addr);
-        SAFE_FREE(io->hovlp);
+        HV_FREE(hovlp->addr);
+        HV_FREE(io->hovlp);
     }
     if (io->close_cb) {
         //printd("close_cb------\n");

event/poll.c

@@ -25,7 +25,7 @@ typedef struct poll_ctx_s {
 int iowatcher_init(hloop_t* loop) {
     if (loop->iowatcher)   return 0;
     poll_ctx_t* poll_ctx;
-    SAFE_ALLOC_SIZEOF(poll_ctx);
+    HV_ALLOC_SIZEOF(poll_ctx);
     pollfds_init(&poll_ctx->fds, FDS_INIT_SIZE);
     loop->iowatcher = poll_ctx;
     return 0;
@@ -35,7 +35,7 @@ int iowatcher_cleanup(hloop_t* loop) {
     if (loop->iowatcher == NULL)   return 0;
     poll_ctx_t* poll_ctx = (poll_ctx_t*)loop->iowatcher;
     pollfds_cleanup(&poll_ctx->fds);
-    SAFE_FREE(loop->iowatcher);
+    HV_FREE(loop->iowatcher);
     return 0;
 }
 

event/select.c

@@ -17,7 +17,7 @@ typedef struct select_ctx_s {
 int iowatcher_init(hloop_t* loop) {
     if (loop->iowatcher) return 0;
     select_ctx_t* select_ctx;
-    SAFE_ALLOC_SIZEOF(select_ctx);
+    HV_ALLOC_SIZEOF(select_ctx);
     select_ctx->max_fd = -1;
     FD_ZERO(&select_ctx->readfds);
     FD_ZERO(&select_ctx->writefds);
@@ -28,7 +28,7 @@ int iowatcher_init(hloop_t* loop) {
 }
 
 int iowatcher_cleanup(hloop_t* loop) {
-    SAFE_FREE(loop->iowatcher);
+    HV_FREE(loop->iowatcher);
     return 0;
 }
 

examples/hloop_test.c

@@ -53,7 +53,7 @@ void on_custom_events(hevent_t* ev) {
 
 int main() {
     // memcheck atexit
-    MEMCHECK;
+    HV_MEMCHECK;
 
     hloop_t* loop = hloop_new(0);
 

examples/htimer_test.c

@@ -32,7 +32,7 @@ void cron_hourly(htimer_t* timer) {
 }
 
 int main() {
-    MEMCHECK;
+    HV_MEMCHECK;
     hloop_t* loop = hloop_new(0);
 
     // on_timer_add triggered forever

examples/nc.c

@@ -96,7 +96,7 @@ Examples: nc 127.0.0.1 80\n\
         printf("%s %s %d\n", protocolname, host, port);
     }
 
-    MEMCHECK;
+    HV_MEMCHECK;
 
     hloop_t* loop = hloop_new(0);