Minor renames and fixes

Author: codepr

src/ev.c

@@ -126,10 +126,10 @@ static int ev_api_get_event_type(struct ev_ctx *ctx, int idx)
 {
     struct epoll_api *e_api = ctx->api;
     int events              = e_api->events[idx].events;
-    int ev_mask = ctx->events_monitored[e_api->events[idx].data.fd].mask;
+    int ev_mask             = ctx->monitored[e_api->events[idx].data.fd].mask;
     // We want to remember the previous events only if they're not of type
     // CLOSE or TIMER
-    int mask    = ev_mask & (EV_CLOSEFD | EV_TIMERFD) ? ev_mask : EV_NONE;
+    int mask = ev_mask & (EV_CLOSEFD | EV_TIMERFD) ? ev_mask : EV_NONE;
     if (events & (EPOLLERR | EPOLLHUP | EPOLLRDHUP))
         mask |= EV_DISCONNECT;
     if (events & EPOLLIN)
@@ -189,7 +189,7 @@ static inline struct ev *ev_api_fetch_event(const struct ev_ctx *ctx, int idx,
                                             int mask)
 {
     int fd = ((struct epoll_api *)ctx->api)->events[idx].data.fd;
-    return ctx->events_monitored + fd;
+    return ctx->monitored + fd;
 }
 
 #elif defined(POLL)
@@ -212,18 +212,18 @@ static inline struct ev *ev_api_fetch_event(const struct ev_ctx *ctx, int idx,
 
 struct poll_api {
     int nfds;
-    int events_monitored;
+    int monitored;
     struct pollfd *fds;
 };
 
 static int ev_api_init(struct ev_ctx *ctx, int events_nr)
 {
-    struct poll_api *p_api  = try_alloc(sizeof(*p_api));
-    p_api->nfds             = 0;
-    p_api->fds              = try_calloc(events_nr, sizeof(struct pollfd));
-    p_api->events_monitored = events_nr;
-    ctx->api                = p_api;
-    ctx->maxfd              = events_nr;
+    struct poll_api *p_api = try_alloc(sizeof(*p_api));
+    p_api->nfds            = 0;
+    p_api->fds             = try_calloc(events_nr, sizeof(struct pollfd));
+    p_api->monitored       = events_nr;
+    ctx->api               = p_api;
+    ctx->maxfd             = events_nr;
     return EV_OK;
 }
 
@@ -236,7 +236,7 @@ static void ev_api_destroy(struct ev_ctx *ctx)
 static int ev_api_get_event_type(struct ev_ctx *ctx, int idx)
 {
     struct poll_api *p_api = ctx->api;
-    int ev_mask            = ctx->events_monitored[p_api->fds[idx].fd].mask;
+    int ev_mask            = ctx->monitored[p_api->fds[idx].fd].mask;
     // We want to remember the previous events only if they're not of type
     // CLOSE or TIMER
     int mask               = ev_mask & (EV_CLOSEFD | EV_TIMERFD) ? ev_mask : 0;
@@ -270,10 +270,10 @@ static int ev_api_watch_fd(struct ev_ctx *ctx, int fd)
     p_api->fds[p_api->nfds].fd     = fd;
     p_api->fds[p_api->nfds].events = POLLIN;
     p_api->nfds++;
-    if (p_api->nfds >= p_api->events_monitored) {
-        p_api->events_monitored *= 2;
-        p_api->fds = try_realloc(p_api->fds, p_api->events_monitored *
-                                                 sizeof(struct pollfd));
+    if (p_api->nfds >= p_api->monitored) {
+        p_api->monitored *= 2;
+        p_api->fds =
+            try_realloc(p_api->fds, p_api->monitored * sizeof(struct pollfd));
     }
     return EV_OK;
 }
@@ -307,10 +307,10 @@ static int ev_api_register_event(struct ev_ctx *ctx, int fd, int mask)
     if (mask & EV_WRITE)
         p_api->fds[p_api->nfds].events |= POLLOUT;
     p_api->nfds++;
-    if (p_api->nfds >= p_api->events_monitored) {
-        p_api->events_monitored *= 2;
-        p_api->fds = try_realloc(p_api->fds, p_api->events_monitored *
-                                                 sizeof(struct pollfd));
+    if (p_api->nfds >= p_api->monitored) {
+        p_api->monitored *= 2;
+        p_api->fds =
+            try_realloc(p_api->fds, p_api->monitored * sizeof(struct pollfd));
     }
     return EV_OK;
 }
@@ -334,7 +334,7 @@ static int ev_api_fire_event(struct ev_ctx *ctx, int fd, int mask)
 static inline struct ev *ev_api_fetch_event(const struct ev_ctx *ctx, int idx,
                                             int mask)
 {
-    return ctx->events_monitored + ((struct poll_api *)ctx->api)->fds[idx].fd;
+    return ctx->monitored + ((struct poll_api *)ctx->api)->fds[idx].fd;
 }
 
 #elif defined(SELECT)
@@ -380,7 +380,7 @@ static void ev_api_destroy(struct ev_ctx *ctx) { free_memory(ctx->api); }
 static int ev_api_get_event_type(struct ev_ctx *ctx, int idx)
 {
     struct select_api *s_api = ctx->api;
-    int ev_mask              = ctx->events_monitored[idx].mask;
+    int ev_mask              = ctx->monitored[idx].mask;
     // We want to remember the previous events only if they're not of type
     // CLOSE or TIMER
     int mask = ev_mask & (EV_CLOSEFD | EV_TIMERFD) ? ev_mask : 0;
@@ -477,7 +477,7 @@ static int ev_api_fire_event(struct ev_ctx *ctx, int fd, int mask)
 static inline struct ev *ev_api_fetch_event(const struct ev_ctx *ctx, int idx,
                                             int mask)
 {
-    return ctx->events_monitored + idx;
+    return ctx->monitored + idx;
 }
 
 #elif defined(KQUEUE)
@@ -523,10 +523,10 @@ static int ev_api_get_event_type(struct ev_ctx *ctx, int idx)
 {
     struct kqueue_api *k_api = ctx->api;
     int events               = k_api->events[idx].flags;
-    int ev_mask = ctx->events_monitored[k_api->events[idx].ident].mask;
+    int ev_mask              = ctx->monitored[k_api->events[idx].ident].mask;
     // We want to remember the previous events only if they're not of type
     // CLOSE or TIMER
-    int mask    = ev_mask & (EV_CLOSEFD | EV_TIMERFD) ? ev_mask : EV_NONE;
+    int mask = ev_mask & (EV_CLOSEFD | EV_TIMERFD) ? ev_mask : EV_NONE;
     if (events & (EV_EOF | EV_ERROR))
         mask |= EV_DISCONNECT;
     if (events & EVFILT_READ)
@@ -551,7 +551,7 @@ static int ev_api_del_fd(struct ev_ctx *ctx, int fd)
 {
     struct kqueue_api *k_api = ctx->api;
     struct kevent ke;
-    int ev_mask = ctx->events_monitored[fd].mask;
+    int ev_mask = ctx->monitored[fd].mask;
     int mask    = 0;
     if (ev_mask & EV_READ)
         mask |= EVFILT_READ;
@@ -610,13 +610,13 @@ static inline struct ev *ev_api_fetch_event(const struct ev_ctx *ctx, int idx,
 {
     (void)mask; // silence compiler warning
     int fd = ((struct kqueue_api *)ctx->api)->events[idx].ident;
-    return ctx->events_monitored + fd;
+    return ctx->monitored + fd;
 }
 
 #endif // KQUEUE
 
 /*
- * Process the event at the position idx in the events_monitored array. Read or
+ * Process the event at the position idx in the monitored array. Read or
  * write events can be executed on the same iteration, differentiating just
  * on EV_CLOSEFD or EV_EVENTFD.
  * Returns the number of fired callbacks.
@@ -670,8 +670,7 @@ static int ev_process_event(struct ev_ctx *ctx, int idx, int mask)
  * context.
  */
 static void ev_add_monitored(struct ev_ctx *ctx, int fd, int mask,
-                             void (*callback)(struct ev_ctx *, void *),
-                             void *ptr)
+                             ev_callback cb, void *ptr)
 {
     /*
      * TODO check for fd <= 1024 if using SELECT
@@ -682,21 +681,21 @@ static void ev_add_monitored(struct ev_ctx *ctx, int fd, int mask,
         int i          = ctx->maxevents;
         ctx->maxevents = fd;
         if (fd > ctx->events_nr) {
-            ctx->events_monitored = try_realloc(ctx->events_monitored,
-                                                (fd + 1) * sizeof(struct ev));
+            ctx->monitored =
+                try_realloc(ctx->monitored, (fd + 1) * sizeof(struct ev));
             for (; i < ctx->maxevents; ++i)
-                ctx->events_monitored[i].mask = EV_NONE;
+                ctx->monitored[i].mask = EV_NONE;
         }
     }
-    ctx->events_monitored[fd].fd = fd;
-    ctx->events_monitored[fd].mask |= mask;
+    ctx->monitored[fd].fd = fd;
+    ctx->monitored[fd].mask |= mask;
     if (mask & EV_READ) {
-        ctx->events_monitored[fd].rdata     = ptr;
-        ctx->events_monitored[fd].rcallback = callback;
+        ctx->monitored[fd].rdata     = ptr;
+        ctx->monitored[fd].rcallback = cb;
     }
     if (mask & EV_WRITE) {
-        ctx->events_monitored[fd].wdata     = ptr;
-        ctx->events_monitored[fd].wcallback = callback;
+        ctx->monitored[fd].wdata     = ptr;
+        ctx->monitored[fd].wcallback = cb;
     }
 }
 
@@ -710,22 +709,22 @@ int ev_init(struct ev_ctx *ctx, int events_nr)
     int err = ev_api_init(ctx, events_nr);
     if (err < 0)
         return err;
-    ctx->stop             = 0;
-    ctx->fired_events     = 0;
-    ctx->maxevents        = events_nr;
-    ctx->events_nr        = events_nr;
-    ctx->events_monitored = try_calloc(events_nr, sizeof(struct ev));
+    ctx->stop         = 0;
+    ctx->fired_events = 0;
+    ctx->maxevents    = events_nr;
+    ctx->events_nr    = events_nr;
+    ctx->monitored    = try_calloc(events_nr, sizeof(struct ev));
     return EV_OK;
 }
 
-void ev_destroy(struct ev_ctx *ctx)
+void ev_free(struct ev_ctx *ctx)
 {
     for (int i = 0; i < ctx->maxevents; ++i) {
-        if (!(ctx->events_monitored[i].mask & EV_CLOSEFD) &&
-            ctx->events_monitored[i].mask != EV_NONE)
-            ev_del_fd(ctx, ctx->events_monitored[i].fd);
+        if (!(ctx->monitored[i].mask & EV_CLOSEFD) &&
+            ctx->monitored[i].mask != EV_NONE)
+            ev_delete(ctx, ctx->monitored[i].fd);
     }
-    free_memory(ctx->events_monitored);
+    free_memory(ctx->monitored);
     ev_api_destroy(ctx);
 }
 
@@ -761,15 +760,15 @@ int ev_run(struct ev_ctx *ctx)
 
 void ev_stop(struct ev_ctx *ctx) { ctx->stop = 1; }
 
-int ev_watch_fd(struct ev_ctx *ctx, int fd, int mask)
+int ev_watch(struct ev_ctx *ctx, int fd, int mask)
 {
     ev_add_monitored(ctx, fd, mask, NULL, NULL);
     return ev_api_watch_fd(ctx, fd);
 }
 
-int ev_del_fd(struct ev_ctx *ctx, int fd)
+int ev_delete(struct ev_ctx *ctx, int fd)
 {
-    memset(ctx->events_monitored + fd, 0x00, sizeof(struct ev));
+    memset(ctx->monitored + fd, 0x00, sizeof(struct ev));
     return ev_api_del_fd(ctx, fd);
 }
 
@@ -785,10 +784,10 @@ int ev_del_fd(struct ev_ctx *ctx, int fd)
  * - callback:  is a function pointer to the routine we want to execute
  * - data:  an opaque pointer to the arguments for the callback.
  */
-int ev_register_event(struct ev_ctx *ctx, int fd, int mask,
-                      void (*callback)(struct ev_ctx *, void *), void *data)
+int ev_register_event(struct ev_ctx *ctx, int fd, int mask, ev_callback cb,
+                      void *data)
 {
-    ev_add_monitored(ctx, fd, mask, callback, data);
+    ev_add_monitored(ctx, fd, mask, cb, data);
     int ret = 0;
     ret     = ev_api_register_event(ctx, fd, mask);
     if (ret < 0)
@@ -807,8 +806,7 @@ int ev_register_event(struct ev_ctx *ctx, int fd, int mask,
  * loop, specifying, seconds and/or nanoseconds defining how often the callback
  * should be executed.
  */
-int ev_register_cron(struct ev_ctx *ctx,
-                     void (*callback)(struct ev_ctx *, void *), void *data,
+int ev_register_cron(struct ev_ctx *ctx, ev_callback cb, void *data,
                      long long s, long long ns)
 {
 #ifdef __linux__
@@ -825,14 +823,14 @@ int ev_register_cron(struct ev_ctx *ctx,
         return -EV_ERR;
 
     // Add the timer to the event loop
-    ev_add_monitored(ctx, timerfd, EV_TIMERFD | EV_READ, callback, data);
+    ev_add_monitored(ctx, timerfd, EV_TIMERFD | EV_READ, cb, data);
     return ev_api_watch_fd(ctx, timerfd);
 #else
     struct kqueue_api *k_api = ctx->api;
     // milliseconds
     unsigned period          = (s * 1000) + (ns / 100);
     int fd                   = socket(AF_INET, SOCK_STREAM, 0);
-    ev_add_monitored(ctx, fd, EV_TIMERFD | EV_READ, callback, data);
+    ev_add_monitored(ctx, fd, EV_TIMERFD | EV_READ, cb, data);
     struct kevent ke;
     EV_SET(&ke, fd, EVFILT_TIMER, EV_ADD | EV_ENABLE, 0, period, 0);
     if (kevent(k_api->fd, &ke, 1, NULL, 0, NULL) == -1)
@@ -853,11 +851,10 @@ int ev_register_cron(struct ev_ctx *ctx,
  * - callback:  is a function pointer to the routine we want to execute
  * - data:  an opaque pointer to the arguments for the callback.
  */
-int ev_fire_event(struct ev_ctx *ctx, int fd, int mask,
-                  void (*callback)(struct ev_ctx *, void *), void *data)
+int ev_add(struct ev_ctx *ctx, int fd, int mask, ev_callback cb, void *data)
 {
     int ret = 0;
-    ev_add_monitored(ctx, fd, mask, callback, data);
+    ev_add_monitored(ctx, fd, mask, cb, data);
     ret = ev_api_fire_event(ctx, fd, mask);
     if (ret < 0)
         return -EV_ERR;

src/ev.h

@@ -50,17 +50,19 @@ enum ev_type {
 
 struct ev_ctx;
 
+typedef void (*ev_callback)(struct ev_ctx *, void *);
+
 /*
  * Event struture used as the main carrier of clients informations, it will be
  * tracked by an array in every context created
  */
 struct ev {
     int fd;
     int mask;
-    void *rdata; // opaque pointer for read callback args
-    void *wdata; // opaque pointer for write callback args
-    void (*rcallback)(struct ev_ctx *, void *); // read callback
-    void (*wcallback)(struct ev_ctx *, void *); // write callback
+    void *rdata;           // opaque pointer for read callback args
+    void *wdata;           // opaque pointer for write callback args
+    ev_callback rcallback; // read callback
+    ev_callback wcallback; // write callback
 };
 
 /*
@@ -81,13 +83,13 @@ struct ev_ctx {
     int stop;
     int maxevents;
     unsigned long long fired_events;
-    struct ev *events_monitored;
+    struct ev *monitored;
     void *api; // opaque pointer to platform defined backends
 };
 
 int ev_init(struct ev_ctx *, int);
 
-void ev_destroy(struct ev_ctx *);
+void ev_free(struct ev_ctx *);
 
 /*
  * Poll an event context for events, accepts a timeout or block forever,
@@ -113,32 +115,30 @@ void ev_stop(struct ev_ctx *);
  * ev_fire_event just without an event to be carried. Useful to add simple
  * descritors like a listening socket o message queue FD.
  */
-int ev_watch_fd(struct ev_ctx *, int, int);
+int ev_watch(struct ev_ctx *, int, int);
 
 /*
  * Remove a FD from the loop, even tho a close syscall is sufficient to remove
  * the FD from the underlying backend such as EPOLL/SELECT, this call ensure
  * that any associated events is cleaned out an set to EV_NONE
  */
-int ev_del_fd(struct ev_ctx *, int);
+int ev_delete(struct ev_ctx *, int);
 
 /*
  * Register a new event, semantically it's equal to ev_register_event but
  * it's meant to be used when an FD is not already watched by the event loop.
  * It could be easily integrated in ev_fire_event call but I prefer maintain
  * the samantic separation of responsibilities.
  */
-int ev_register_event(struct ev_ctx *, int, int,
-                      void (*callback)(struct ev_ctx *, void *), void *);
+int ev_register_event(struct ev_ctx *, int, int, ev_callback, void *);
 
-int ev_register_cron(struct ev_ctx *, void (*callback)(struct ev_ctx *, void *),
-                     void *, long long, long long);
+int ev_register_cron(struct ev_ctx *, ev_callback, void *, long long,
+                     long long);
 
 /*
  * Register a new event for the next loop cycle to a FD. Equal to ev_watch_fd
  * but allow to carry an event object for the next cycle.
  */
-int ev_fire_event(struct ev_ctx *, int, int,
-                  void (*callback)(struct ev_ctx *, void *), void *);
+int ev_add(struct ev_ctx *, int, int, ev_callback, void *);
 
 #endif