Hello community, here is the log from the commit of package libuev for openSUSE:Factory checked in at 2018-10-08 17:49:24 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/libuev (Old) and /work/SRC/openSUSE:Factory/.libuev.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "libuev" Mon Oct 8 17:49:24 2018 rev:4 rq:640584 version:2.2.0 Changes: -------- --- /work/SRC/openSUSE:Factory/libuev/libuev.changes 2018-09-11 17:15:31.615573559 +0200 +++ /work/SRC/openSUSE:Factory/.libuev.new/libuev.changes 2018-10-08 17:50:55.802062840 +0200 @@ -1,0 +2,17 @@ +Mon Oct 8 09:05:24 UTC 2018 - [email protected] + +- Update to 2.2.0: + Note: + * You now have to explicitly include sys/queue.h, or provide + a local version of queue.h, if your application depends on it. + Changes: + * Replaced BSD queue.h doubly-linked lst API with own + implementation. Making libuEv stand-alone, no longer imposing + any particular version of queue.h on the user + * Enforce -std=gnu11 to unlock typeof() in older GCC versions + * Code cleanup + Fixes: + * Fix missing header deps. in Makefile.am, library did not rebuild + properly if any of the local header files were changed + +------------------------------------------------------------------- Old: ---- libuev-2.1.3.tar.gz New: ---- libuev-2.2.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ libuev.spec ++++++ --- /var/tmp/diff_new_pack.4PB0LE/_old 2018-10-08 17:50:56.138062411 +0200 +++ /var/tmp/diff_new_pack.4PB0LE/_new 2018-10-08 17:50:56.142062407 +0200 @@ -19,7 +19,7 @@ %define sover 2 Name: libuev -Version: 2.1.3 +Version: 2.2.0 Release: 0 Summary: Event loop library License: MIT ++++++ libuev-2.1.3.tar.gz -> libuev-2.2.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/API.md new/libuev-2.2.0/API.md --- old/libuev-2.1.3/API.md 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/API.md 2018-10-04 21:06:51.000000000 +0200 @@ -57,6 +57,7 @@ /* Event loop: Notice the use of flags! */ int uev_init (uev_ctx_t *ctx); +int uev_init1 (uev_ctx_t *ctx, int maxevents); int uev_exit (uev_ctx_t *ctx); int uev_run (uev_ctx_t *ctx, int flags); /* UEV_NONE, UEV_ONCE, and/or UEV_NONBLOCK */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/ChangeLog.md new/libuev-2.2.0/ChangeLog.md --- old/libuev-2.1.3/ChangeLog.md 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/ChangeLog.md 2018-10-04 21:06:51.000000000 +0200 @@ -4,6 +4,24 @@ All notable changes to the project are documented in this file. +[v2.2.0][] - 2018-10-04 +----------------------- + +**NOTE:** You now have to explicitly include `sys/queue.h`, or provide a + local version of `queue.h`, if your application depends on it. + +### Changes +- Replaced BSD `queue.h` doubly-linked lst API with own implementation. + Making libuEv stand-alone, no longer imposing any particular version + of `queue.h` on the user +- Enforce `-std=gnu11` to unlock `typeof()` in older GCC versions +- Code cleanup + +### Fixes +- Fix missing header deps. in `Makefile.am`, library did not rebuild + properly if any of the local header files were changed + + [v2.1.3][] - 2018-09-06 ----------------------- @@ -366,7 +384,8 @@ Lua users mailing list. -[UNRELEASED]: https://github.com/troglobit/libuev/compare/v2.1.3...HEAD +[UNRELEASED]: https://github.com/troglobit/libuev/compare/v2.2.0...HEAD +[v2.2.0]: https://github.com/troglobit/libuev/compare/v2.1.3...v2.2.0 [v2.1.3]: https://github.com/troglobit/libuev/compare/v2.1.2...v2.1.3 [v2.1.2]: https://github.com/troglobit/libuev/compare/v2.1.1...v2.1.2 [v2.1.1]: https://github.com/troglobit/libuev/compare/v2.1.0...v2.1.1 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/configure.ac new/libuev-2.2.0/configure.ac --- old/libuev-2.1.3/configure.ac 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/configure.ac 2018-10-04 21:06:51.000000000 +0200 @@ -1,4 +1,4 @@ -AC_INIT(libuev, 2.1.3, https://github.com/troglobit/libuev/issues) +AC_INIT(libuev, 2.2.0, https://github.com/troglobit/libuev/issues) AM_INIT_AUTOMAKE([1.11 foreign no-dist-gzip dist-xz]) AM_SILENT_RULES([yes]) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/debian/changelog new/libuev-2.2.0/debian/changelog --- old/libuev-2.1.3/debian/changelog 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/debian/changelog 2018-10-04 21:06:51.000000000 +0200 @@ -1,3 +1,11 @@ +libuev (2.2.0) unstable; urgency=medium + + * Replaced BSD queue.h with own linked list implementation. This means + applications relying on any of the queue.h APIs now need to provide + their own version, or use the system sys/queue.h + + -- Joachim Nilsson <[email protected]> Thu, 04 Oct 2018 21:03:48 +0200 + libuev (2.1.3) unstable; urgency=medium * Minor bugfix release diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/src/Makefile.am new/libuev-2.2.0/src/Makefile.am --- old/libuev-2.1.3/src/Makefile.am 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/src/Makefile.am 2018-10-04 21:06:51.000000000 +0200 @@ -1,8 +1,8 @@ lib_LTLIBRARIES = libuev.la -libuev_la_SOURCES = uev.c io.c timer.c signal.c cron.c +libuev_la_SOURCES = uev.c uev.h private.h io.c timer.c signal.c cron.c libuev_la_CPPFLAGS = -D_GNU_SOURCE -D_TIME_BITS=64 -libuev_la_CFLAGS = -W -Wall -Wextra -libuev_la_LDFLAGS = $(AM_LDFLAGS) -version-info 2:2:0 +libuev_la_CFLAGS = -W -Wall -Wextra -std=gnu11 +libuev_la_LDFLAGS = $(AM_LDFLAGS) -version-info 3:0:1 noinst_PROGRAMS = bench bench_CPPFLAGS = -D_GNU_SOURCE @@ -11,4 +11,4 @@ pkgconfigdir = $(libdir)/pkgconfig pkgincludedir = $(includedir)/uev pkgconfig_DATA = libuev.pc -pkginclude_HEADERS = uev.h private.h queue.h +pkginclude_HEADERS = uev.h private.h diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/src/bench.c new/libuev-2.2.0/src/bench.c --- old/libuev-2.1.3/src/bench.c 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/src/bench.c 2018-10-04 21:06:51.000000000 +0200 @@ -57,8 +57,6 @@ #include "uev.h" -#define UNUSED(arg) arg __attribute__ ((unused)) - typedef struct { int index; } myarg_t; @@ -70,7 +68,7 @@ static uev_t *evio; static uev_t *evto; -static void read_cb(uev_t *w, void *arg, int UNUSED(events)) +static void read_cb(uev_t *w, void *arg, int events) { int idx, widx; u_char ch; @@ -96,7 +94,7 @@ } } -static void timer_cb(uev_t UNUSED(*w), void UNUSED(*arg), int UNUSED(events)) +static void timer_cb(uev_t *w, void *arg, int events) { /* nop */ } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/src/cron.c new/libuev-2.2.0/src/cron.c --- old/libuev-2.1.3/src/cron.c 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/src/cron.c 2018-10-04 21:06:51.000000000 +0200 @@ -112,9 +112,6 @@ if (!when && !interval) return 0; - /* Remove from internal list */ - LIST_REMOVE(w, link); - if (uev_cron_init(w->ctx, w, (uev_cb_t *)w->cb, w->arg, when, interval)) return -1; } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/src/private.h new/libuev-2.2.0/src/private.h --- old/libuev-2.1.3/src/private.h 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/src/private.h 2018-10-04 21:06:51.000000000 +0200 @@ -27,7 +27,38 @@ #include <stdio.h> #include <sys/epoll.h> -#include "queue.h" /* OpenBSD queue.h > old GLIBC version */ + +/* + * List functions. + */ +#define _UEV_FOREACH(node, list) \ + for (typeof (node) next, node = list; \ + node && (next = node->next, 1); \ + node = next) + +#define _UEV_INSERT(node, list) do { \ + typeof (node) next; \ + next = list; \ + list = node; \ + if (next) \ + next->prev = node; \ + node->next = next; \ + node->prev = NULL; \ +} while (0) + +#define _UEV_REMOVE(node, list) do { \ + typeof (node) prev, next; \ + prev = node->prev; \ + next = node->next; \ + if (prev) \ + prev->next = next; \ + if (next) \ + next->prev = prev; \ + node->prev = NULL; \ + node->next = NULL; \ + if (list == node) \ + list = next; \ +} while (0) /* I/O, timer, or signal watcher */ typedef enum { @@ -38,13 +69,15 @@ } uev_type_t; /* Event mask, used internally only. */ -#define UEV_EVENT_MASK (UEV_ERROR | UEV_READ | UEV_WRITE | UEV_PRI | UEV_HUP | UEV_RDHUP | UEV_EDGE | UEV_ONESHOT) +#define UEV_EVENT_MASK (UEV_ERROR | UEV_READ | UEV_WRITE | UEV_PRI | \ + UEV_RDHUP | UEV_HUP | UEV_EDGE | UEV_ONESHOT) /* Main libuEv context type */ typedef struct { int running; - int fd; /* For epoll() */ - LIST_HEAD(,uev) watchers; + int fd; /* For epoll() */ + int maxevents; /* For epoll() */ + struct uev *watchers; uint32_t workaround; /* For workarounds, e.g. redirected stdin */ } uev_ctx_t; @@ -53,7 +86,7 @@ /* This is used to hide all private data members in uev_t */ #define uev_private_t \ - LIST_ENTRY(uev) link; /* For queue.h linked list */ \ + struct uev *next, *prev; \ \ int active; \ int events; \ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/src/queue.h new/libuev-2.2.0/src/queue.h --- old/libuev-2.1.3/src/queue.h 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/src/queue.h 1970-01-01 01:00:00.000000000 +0100 @@ -1,648 +0,0 @@ -/* $OpenBSD: queue.h,v 1.38 2013/07/03 15:05:21 fgsch Exp $ */ -/* $NetBSD: queue.h,v 1.11 1996/05/16 05:17:14 mycroft Exp $ */ - -/* - * Copyright (c) 1991, 1993 - * The Regents of the University of California. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. - * - * @(#)queue.h 8.5 (Berkeley) 8/20/94 - */ - -#ifndef _SYS_QUEUE_H_ -#define _SYS_QUEUE_H_ - -/* - * This file defines five types of data structures: singly-linked lists, - * lists, simple queues, tail queues, and circular queues. - * - * - * A singly-linked list is headed by a single forward pointer. The elements - * are singly linked for minimum space and pointer manipulation overhead at - * the expense of O(n) removal for arbitrary elements. New elements can be - * added to the list after an existing element or at the head of the list. - * Elements being removed from the head of the list should use the explicit - * macro for this purpose for optimum efficiency. A singly-linked list may - * only be traversed in the forward direction. Singly-linked lists are ideal - * for applications with large datasets and few or no removals or for - * implementing a LIFO queue. - * - * A list is headed by a single forward pointer (or an array of forward - * pointers for a hash table header). The elements are doubly linked - * so that an arbitrary element can be removed without a need to - * traverse the list. New elements can be added to the list before - * or after an existing element or at the head of the list. A list - * may only be traversed in the forward direction. - * - * A simple queue is headed by a pair of pointers, one the head of the - * list and the other to the tail of the list. The elements are singly - * linked to save space, so elements can only be removed from the - * head of the list. New elements can be added to the list before or after - * an existing element, at the head of the list, or at the end of the - * list. A simple queue may only be traversed in the forward direction. - * - * A tail queue is headed by a pair of pointers, one to the head of the - * list and the other to the tail of the list. The elements are doubly - * linked so that an arbitrary element can be removed without a need to - * traverse the list. New elements can be added to the list before or - * after an existing element, at the head of the list, or at the end of - * the list. A tail queue may be traversed in either direction. - * - * A circle queue is headed by a pair of pointers, one to the head of the - * list and the other to the tail of the list. The elements are doubly - * linked so that an arbitrary element can be removed without a need to - * traverse the list. New elements can be added to the list before or after - * an existing element, at the head of the list, or at the end of the list. - * A circle queue may be traversed in either direction, but has a more - * complex end of list detection. - * - * For details on the use of these macros, see the queue(3) manual page. - */ - -#if defined(QUEUE_MACRO_DEBUG) || (defined(_KERNEL) && defined(DIAGNOSTIC)) -#define _Q_INVALIDATE(a) (a) = ((void *)-1) -#else -#define _Q_INVALIDATE(a) -#endif - -/* - * Singly-linked List definitions. - */ -#define SLIST_HEAD(name, type) \ -struct name { \ - struct type *slh_first; /* first element */ \ -} - -#define SLIST_HEAD_INITIALIZER(head) \ - { NULL } - -#define SLIST_ENTRY(type) \ -struct { \ - struct type *sle_next; /* next element */ \ -} - -/* - * Singly-linked List access methods. - */ -#define SLIST_FIRST(head) ((head)->slh_first) -#define SLIST_END(head) NULL -#define SLIST_EMPTY(head) (SLIST_FIRST(head) == SLIST_END(head)) -#define SLIST_NEXT(elm, field) ((elm)->field.sle_next) - -#define SLIST_FOREACH(var, head, field) \ - for((var) = SLIST_FIRST(head); \ - (var) != SLIST_END(head); \ - (var) = SLIST_NEXT(var, field)) - -#define SLIST_FOREACH_SAFE(var, head, field, tvar) \ - for ((var) = SLIST_FIRST(head); \ - (var) && ((tvar) = SLIST_NEXT(var, field), 1); \ - (var) = (tvar)) - -/* - * Singly-linked List functions. - */ -#define SLIST_INIT(head) { \ - SLIST_FIRST(head) = SLIST_END(head); \ -} - -#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ - (elm)->field.sle_next = (slistelm)->field.sle_next; \ - (slistelm)->field.sle_next = (elm); \ -} while (0) - -#define SLIST_INSERT_HEAD(head, elm, field) do { \ - (elm)->field.sle_next = (head)->slh_first; \ - (head)->slh_first = (elm); \ -} while (0) - -#define SLIST_REMOVE_AFTER(elm, field) do { \ - (elm)->field.sle_next = (elm)->field.sle_next->field.sle_next; \ -} while (0) - -#define SLIST_REMOVE_HEAD(head, field) do { \ - (head)->slh_first = (head)->slh_first->field.sle_next; \ -} while (0) - -#define SLIST_REMOVE(head, elm, type, field) do { \ - if ((head)->slh_first == (elm)) { \ - SLIST_REMOVE_HEAD((head), field); \ - } else { \ - struct type *curelm = (head)->slh_first; \ - \ - while (curelm->field.sle_next != (elm)) \ - curelm = curelm->field.sle_next; \ - curelm->field.sle_next = \ - curelm->field.sle_next->field.sle_next; \ - _Q_INVALIDATE((elm)->field.sle_next); \ - } \ -} while (0) - -/* - * List definitions. - */ -#define LIST_HEAD(name, type) \ -struct name { \ - struct type *lh_first; /* first element */ \ -} - -#define LIST_HEAD_INITIALIZER(head) \ - { NULL } - -#define LIST_ENTRY(type) \ -struct { \ - struct type *le_next; /* next element */ \ - struct type **le_prev; /* address of previous next element */ \ -} - -/* - * List access methods - */ -#define LIST_FIRST(head) ((head)->lh_first) -#define LIST_END(head) NULL -#define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head)) -#define LIST_NEXT(elm, field) ((elm)->field.le_next) - -#define LIST_FOREACH(var, head, field) \ - for((var) = LIST_FIRST(head); \ - (var)!= LIST_END(head); \ - (var) = LIST_NEXT(var, field)) - -#define LIST_FOREACH_SAFE(var, head, field, tvar) \ - for ((var) = LIST_FIRST(head); \ - (var) && ((tvar) = LIST_NEXT(var, field), 1); \ - (var) = (tvar)) - -/* - * List functions. - */ -#define LIST_INIT(head) do { \ - LIST_FIRST(head) = LIST_END(head); \ -} while (0) - -#define LIST_INSERT_AFTER(listelm, elm, field) do { \ - if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \ - (listelm)->field.le_next->field.le_prev = \ - &(elm)->field.le_next; \ - (listelm)->field.le_next = (elm); \ - (elm)->field.le_prev = &(listelm)->field.le_next; \ -} while (0) - -#define LIST_INSERT_BEFORE(listelm, elm, field) do { \ - (elm)->field.le_prev = (listelm)->field.le_prev; \ - (elm)->field.le_next = (listelm); \ - *(listelm)->field.le_prev = (elm); \ - (listelm)->field.le_prev = &(elm)->field.le_next; \ -} while (0) - -#define LIST_INSERT_HEAD(head, elm, field) do { \ - if (((elm)->field.le_next = (head)->lh_first) != NULL) \ - (head)->lh_first->field.le_prev = &(elm)->field.le_next;\ - (head)->lh_first = (elm); \ - (elm)->field.le_prev = &(head)->lh_first; \ -} while (0) - -#define LIST_REMOVE(elm, field) do { \ - if ((elm)->field.le_next != NULL) \ - (elm)->field.le_next->field.le_prev = \ - (elm)->field.le_prev; \ - *(elm)->field.le_prev = (elm)->field.le_next; \ - _Q_INVALIDATE((elm)->field.le_prev); \ - _Q_INVALIDATE((elm)->field.le_next); \ -} while (0) - -#define LIST_REPLACE(elm, elm2, field) do { \ - if (((elm2)->field.le_next = (elm)->field.le_next) != NULL) \ - (elm2)->field.le_next->field.le_prev = \ - &(elm2)->field.le_next; \ - (elm2)->field.le_prev = (elm)->field.le_prev; \ - *(elm2)->field.le_prev = (elm2); \ - _Q_INVALIDATE((elm)->field.le_prev); \ - _Q_INVALIDATE((elm)->field.le_next); \ -} while (0) - -/* - * Simple queue definitions. - */ -#define SIMPLEQ_HEAD(name, type) \ -struct name { \ - struct type *sqh_first; /* first element */ \ - struct type **sqh_last; /* addr of last next element */ \ -} - -#define SIMPLEQ_HEAD_INITIALIZER(head) \ - { NULL, &(head).sqh_first } - -#define SIMPLEQ_ENTRY(type) \ -struct { \ - struct type *sqe_next; /* next element */ \ -} - -/* - * Simple queue access methods. - */ -#define SIMPLEQ_FIRST(head) ((head)->sqh_first) -#define SIMPLEQ_END(head) NULL -#define SIMPLEQ_EMPTY(head) (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head)) -#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next) - -#define SIMPLEQ_FOREACH(var, head, field) \ - for((var) = SIMPLEQ_FIRST(head); \ - (var) != SIMPLEQ_END(head); \ - (var) = SIMPLEQ_NEXT(var, field)) - -#define SIMPLEQ_FOREACH_SAFE(var, head, field, tvar) \ - for ((var) = SIMPLEQ_FIRST(head); \ - (var) && ((tvar) = SIMPLEQ_NEXT(var, field), 1); \ - (var) = (tvar)) - -/* - * Simple queue functions. - */ -#define SIMPLEQ_INIT(head) do { \ - (head)->sqh_first = NULL; \ - (head)->sqh_last = &(head)->sqh_first; \ -} while (0) - -#define SIMPLEQ_INSERT_HEAD(head, elm, field) do { \ - if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \ - (head)->sqh_last = &(elm)->field.sqe_next; \ - (head)->sqh_first = (elm); \ -} while (0) - -#define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \ - (elm)->field.sqe_next = NULL; \ - *(head)->sqh_last = (elm); \ - (head)->sqh_last = &(elm)->field.sqe_next; \ -} while (0) - -#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ - if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\ - (head)->sqh_last = &(elm)->field.sqe_next; \ - (listelm)->field.sqe_next = (elm); \ -} while (0) - -#define SIMPLEQ_REMOVE_HEAD(head, field) do { \ - if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \ - (head)->sqh_last = &(head)->sqh_first; \ -} while (0) - -#define SIMPLEQ_REMOVE_AFTER(head, elm, field) do { \ - if (((elm)->field.sqe_next = (elm)->field.sqe_next->field.sqe_next) \ - == NULL) \ - (head)->sqh_last = &(elm)->field.sqe_next; \ -} while (0) - -/* - * XOR Simple queue definitions. - */ -#define XSIMPLEQ_HEAD(name, type) \ -struct name { \ - struct type *sqx_first; /* first element */ \ - struct type **sqx_last; /* addr of last next element */ \ - unsigned long sqx_cookie; \ -} - -#define XSIMPLEQ_ENTRY(type) \ -struct { \ - struct type *sqx_next; /* next element */ \ -} - -/* - * XOR Simple queue access methods. - */ -#define XSIMPLEQ_XOR(head, ptr) ((__typeof(ptr))((head)->sqx_cookie ^ \ - (unsigned long)(ptr))) -#define XSIMPLEQ_FIRST(head) XSIMPLEQ_XOR(head, ((head)->sqx_first)) -#define XSIMPLEQ_END(head) NULL -#define XSIMPLEQ_EMPTY(head) (XSIMPLEQ_FIRST(head) == XSIMPLEQ_END(head)) -#define XSIMPLEQ_NEXT(head, elm, field) XSIMPLEQ_XOR(head, ((elm)->field.sqx_next)) - - -#define XSIMPLEQ_FOREACH(var, head, field) \ - for ((var) = XSIMPLEQ_FIRST(head); \ - (var) != XSIMPLEQ_END(head); \ - (var) = XSIMPLEQ_NEXT(head, var, field)) - -#define XSIMPLEQ_FOREACH_SAFE(var, head, field, tvar) \ - for ((var) = XSIMPLEQ_FIRST(head); \ - (var) && ((tvar) = XSIMPLEQ_NEXT(head, var, field), 1); \ - (var) = (tvar)) - -/* - * XOR Simple queue functions. - */ -#define XSIMPLEQ_INIT(head) do { \ - arc4random_buf(&(head)->sqx_cookie, sizeof((head)->sqx_cookie)); \ - (head)->sqx_first = XSIMPLEQ_XOR(head, NULL); \ - (head)->sqx_last = XSIMPLEQ_XOR(head, &(head)->sqx_first); \ -} while (0) - -#define XSIMPLEQ_INSERT_HEAD(head, elm, field) do { \ - if (((elm)->field.sqx_next = (head)->sqx_first) == \ - XSIMPLEQ_XOR(head, NULL)) \ - (head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \ - (head)->sqx_first = XSIMPLEQ_XOR(head, (elm)); \ -} while (0) - -#define XSIMPLEQ_INSERT_TAIL(head, elm, field) do { \ - (elm)->field.sqx_next = XSIMPLEQ_XOR(head, NULL); \ - *(XSIMPLEQ_XOR(head, (head)->sqx_last)) = XSIMPLEQ_XOR(head, (elm)); \ - (head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \ -} while (0) - -#define XSIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ - if (((elm)->field.sqx_next = (listelm)->field.sqx_next) == \ - XSIMPLEQ_XOR(head, NULL)) \ - (head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \ - (listelm)->field.sqx_next = XSIMPLEQ_XOR(head, (elm)); \ -} while (0) - -#define XSIMPLEQ_REMOVE_HEAD(head, field) do { \ - if (((head)->sqx_first = XSIMPLEQ_XOR(head, \ - (head)->sqx_first)->field.sqx_next) == XSIMPLEQ_XOR(head, NULL)) \ - (head)->sqx_last = XSIMPLEQ_XOR(head, &(head)->sqx_first); \ -} while (0) - -#define XSIMPLEQ_REMOVE_AFTER(head, elm, field) do { \ - if (((elm)->field.sqx_next = XSIMPLEQ_XOR(head, \ - (elm)->field.sqx_next)->field.sqx_next) \ - == XSIMPLEQ_XOR(head, NULL)) \ - (head)->sqx_last = \ - XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \ -} while (0) - - -/* - * Tail queue definitions. - */ -#define TAILQ_HEAD(name, type) \ -struct name { \ - struct type *tqh_first; /* first element */ \ - struct type **tqh_last; /* addr of last next element */ \ -} - -#define TAILQ_HEAD_INITIALIZER(head) \ - { NULL, &(head).tqh_first } - -#define TAILQ_ENTRY(type) \ -struct { \ - struct type *tqe_next; /* next element */ \ - struct type **tqe_prev; /* address of previous next element */ \ -} - -/* - * tail queue access methods - */ -#define TAILQ_FIRST(head) ((head)->tqh_first) -#define TAILQ_END(head) NULL -#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) -#define TAILQ_LAST(head, headname) \ - (*(((struct headname *)((head)->tqh_last))->tqh_last)) -/* XXX */ -#define TAILQ_PREV(elm, headname, field) \ - (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) -#define TAILQ_EMPTY(head) \ - (TAILQ_FIRST(head) == TAILQ_END(head)) - -#define TAILQ_FOREACH(var, head, field) \ - for((var) = TAILQ_FIRST(head); \ - (var) != TAILQ_END(head); \ - (var) = TAILQ_NEXT(var, field)) - -#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \ - for ((var) = TAILQ_FIRST(head); \ - (var) != TAILQ_END(head) && \ - ((tvar) = TAILQ_NEXT(var, field), 1); \ - (var) = (tvar)) - - -#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ - for((var) = TAILQ_LAST(head, headname); \ - (var) != TAILQ_END(head); \ - (var) = TAILQ_PREV(var, headname, field)) - -#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \ - for ((var) = TAILQ_LAST(head, headname); \ - (var) != TAILQ_END(head) && \ - ((tvar) = TAILQ_PREV(var, headname, field), 1); \ - (var) = (tvar)) - -/* - * Tail queue functions. - */ -#define TAILQ_INIT(head) do { \ - (head)->tqh_first = NULL; \ - (head)->tqh_last = &(head)->tqh_first; \ -} while (0) - -#define TAILQ_INSERT_HEAD(head, elm, field) do { \ - if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \ - (head)->tqh_first->field.tqe_prev = \ - &(elm)->field.tqe_next; \ - else \ - (head)->tqh_last = &(elm)->field.tqe_next; \ - (head)->tqh_first = (elm); \ - (elm)->field.tqe_prev = &(head)->tqh_first; \ -} while (0) - -#define TAILQ_INSERT_TAIL(head, elm, field) do { \ - (elm)->field.tqe_next = NULL; \ - (elm)->field.tqe_prev = (head)->tqh_last; \ - *(head)->tqh_last = (elm); \ - (head)->tqh_last = &(elm)->field.tqe_next; \ -} while (0) - -#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ - if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\ - (elm)->field.tqe_next->field.tqe_prev = \ - &(elm)->field.tqe_next; \ - else \ - (head)->tqh_last = &(elm)->field.tqe_next; \ - (listelm)->field.tqe_next = (elm); \ - (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \ -} while (0) - -#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ - (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ - (elm)->field.tqe_next = (listelm); \ - *(listelm)->field.tqe_prev = (elm); \ - (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \ -} while (0) - -#define TAILQ_REMOVE(head, elm, field) do { \ - if (((elm)->field.tqe_next) != NULL) \ - (elm)->field.tqe_next->field.tqe_prev = \ - (elm)->field.tqe_prev; \ - else \ - (head)->tqh_last = (elm)->field.tqe_prev; \ - *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ - _Q_INVALIDATE((elm)->field.tqe_prev); \ - _Q_INVALIDATE((elm)->field.tqe_next); \ -} while (0) - -#define TAILQ_REPLACE(head, elm, elm2, field) do { \ - if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL) \ - (elm2)->field.tqe_next->field.tqe_prev = \ - &(elm2)->field.tqe_next; \ - else \ - (head)->tqh_last = &(elm2)->field.tqe_next; \ - (elm2)->field.tqe_prev = (elm)->field.tqe_prev; \ - *(elm2)->field.tqe_prev = (elm2); \ - _Q_INVALIDATE((elm)->field.tqe_prev); \ - _Q_INVALIDATE((elm)->field.tqe_next); \ -} while (0) - -/* - * Circular queue definitions. - */ -#define CIRCLEQ_HEAD(name, type) \ -struct name { \ - struct type *cqh_first; /* first element */ \ - struct type *cqh_last; /* last element */ \ -} - -#define CIRCLEQ_HEAD_INITIALIZER(head) \ - { CIRCLEQ_END(&head), CIRCLEQ_END(&head) } - -#define CIRCLEQ_ENTRY(type) \ -struct { \ - struct type *cqe_next; /* next element */ \ - struct type *cqe_prev; /* previous element */ \ -} - -/* - * Circular queue access methods - */ -#define CIRCLEQ_FIRST(head) ((head)->cqh_first) -#define CIRCLEQ_LAST(head) ((head)->cqh_last) -#define CIRCLEQ_END(head) ((void *)(head)) -#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next) -#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev) -#define CIRCLEQ_EMPTY(head) \ - (CIRCLEQ_FIRST(head) == CIRCLEQ_END(head)) - -#define CIRCLEQ_FOREACH(var, head, field) \ - for((var) = CIRCLEQ_FIRST(head); \ - (var) != CIRCLEQ_END(head); \ - (var) = CIRCLEQ_NEXT(var, field)) - -#define CIRCLEQ_FOREACH_SAFE(var, head, field, tvar) \ - for ((var) = CIRCLEQ_FIRST(head); \ - (var) != CIRCLEQ_END(head) && \ - ((tvar) = CIRCLEQ_NEXT(var, field), 1); \ - (var) = (tvar)) - -#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \ - for((var) = CIRCLEQ_LAST(head); \ - (var) != CIRCLEQ_END(head); \ - (var) = CIRCLEQ_PREV(var, field)) - -#define CIRCLEQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \ - for ((var) = CIRCLEQ_LAST(head, headname); \ - (var) != CIRCLEQ_END(head) && \ - ((tvar) = CIRCLEQ_PREV(var, headname, field), 1); \ - (var) = (tvar)) - -/* - * Circular queue functions. - */ -#define CIRCLEQ_INIT(head) do { \ - (head)->cqh_first = CIRCLEQ_END(head); \ - (head)->cqh_last = CIRCLEQ_END(head); \ -} while (0) - -#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ - (elm)->field.cqe_next = (listelm)->field.cqe_next; \ - (elm)->field.cqe_prev = (listelm); \ - if ((listelm)->field.cqe_next == CIRCLEQ_END(head)) \ - (head)->cqh_last = (elm); \ - else \ - (listelm)->field.cqe_next->field.cqe_prev = (elm); \ - (listelm)->field.cqe_next = (elm); \ -} while (0) - -#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \ - (elm)->field.cqe_next = (listelm); \ - (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \ - if ((listelm)->field.cqe_prev == CIRCLEQ_END(head)) \ - (head)->cqh_first = (elm); \ - else \ - (listelm)->field.cqe_prev->field.cqe_next = (elm); \ - (listelm)->field.cqe_prev = (elm); \ -} while (0) - -#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \ - (elm)->field.cqe_next = (head)->cqh_first; \ - (elm)->field.cqe_prev = CIRCLEQ_END(head); \ - if ((head)->cqh_last == CIRCLEQ_END(head)) \ - (head)->cqh_last = (elm); \ - else \ - (head)->cqh_first->field.cqe_prev = (elm); \ - (head)->cqh_first = (elm); \ -} while (0) - -#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \ - (elm)->field.cqe_next = CIRCLEQ_END(head); \ - (elm)->field.cqe_prev = (head)->cqh_last; \ - if ((head)->cqh_first == CIRCLEQ_END(head)) \ - (head)->cqh_first = (elm); \ - else \ - (head)->cqh_last->field.cqe_next = (elm); \ - (head)->cqh_last = (elm); \ -} while (0) - -#define CIRCLEQ_REMOVE(head, elm, field) do { \ - if ((elm)->field.cqe_next == CIRCLEQ_END(head)) \ - (head)->cqh_last = (elm)->field.cqe_prev; \ - else \ - (elm)->field.cqe_next->field.cqe_prev = \ - (elm)->field.cqe_prev; \ - if ((elm)->field.cqe_prev == CIRCLEQ_END(head)) \ - (head)->cqh_first = (elm)->field.cqe_next; \ - else \ - (elm)->field.cqe_prev->field.cqe_next = \ - (elm)->field.cqe_next; \ - _Q_INVALIDATE((elm)->field.cqe_prev); \ - _Q_INVALIDATE((elm)->field.cqe_next); \ -} while (0) - -#define CIRCLEQ_REPLACE(head, elm, elm2, field) do { \ - if (((elm2)->field.cqe_next = (elm)->field.cqe_next) == \ - CIRCLEQ_END(head)) \ - (head)->cqh_last = (elm2); \ - else \ - (elm2)->field.cqe_next->field.cqe_prev = (elm2); \ - if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) == \ - CIRCLEQ_END(head)) \ - (head)->cqh_first = (elm2); \ - else \ - (elm2)->field.cqe_prev->field.cqe_next = (elm2); \ - _Q_INVALIDATE((elm)->field.cqe_prev); \ - _Q_INVALIDATE((elm)->field.cqe_next); \ -} while (0) - -#endif /* !_SYS_QUEUE_H_ */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/src/signal.c new/libuev-2.2.0/src/signal.c --- old/libuev-2.1.3/src/signal.c 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/src/signal.c 2018-10-04 21:06:51.000000000 +0200 @@ -91,9 +91,6 @@ /* Handle stopped signal watchers */ if (w->fd < 0) { - /* Remove from internal list */ - LIST_REMOVE(w, link); - if (uev_signal_init(w->ctx, w, (uev_cb_t *)w->cb, w->arg, signo)) return -1; } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/src/timer.c new/libuev-2.2.0/src/timer.c --- old/libuev-2.1.3/src/timer.c 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/src/timer.c 2018-10-04 21:06:51.000000000 +0200 @@ -121,9 +121,6 @@ if (!timeout && !period) return 0; - /* Remove from internal list */ - LIST_REMOVE(w, link); - if (uev_timer_init(w->ctx, w, (uev_cb_t *)w->cb, w->arg, timeout, period)) return -1; } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/src/uev.c new/libuev-2.2.0/src/uev.c --- old/libuev-2.1.3/src/uev.c 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/src/uev.c 2018-10-04 21:06:51.000000000 +0200 @@ -33,8 +33,6 @@ #include "uev.h" -#define UNUSED(arg) arg __attribute__ ((unused)) - static int _init(uev_ctx_t *ctx, int close_old) { @@ -92,7 +90,7 @@ { struct epoll_event ev; - if (!w || w->fd < 0) { + if (!w || w->fd < 0 || !w->ctx) { errno = EINVAL; return -1; } @@ -121,7 +119,7 @@ } /* Add to internal list for bookkeeping */ - LIST_INSERT_HEAD(&w->ctx->watchers, w, link); + _UEV_INSERT(w, w->ctx->watchers); return 0; } @@ -140,7 +138,7 @@ w->active = 0; /* Remove from internal list */ - LIST_REMOVE(w, link); + _UEV_REMOVE(w, w->ctx->watchers); /* Remove from kernel */ if (epoll_ctl(w->ctx->fd, EPOLL_CTL_DEL, w->fd, NULL) < 0) @@ -180,17 +178,46 @@ * Create an event loop context * @param ctx Pointer to an uev_ctx_t context to be initialized * + * This function calls @func uev_init1() with @param maxevents set to + * @const UEV_MAX_EVENTS. + * * @return POSIX OK(0) on success, or non-zero on error. */ int uev_init(uev_ctx_t *ctx) { - if (!ctx) { + return uev_init1(ctx, UEV_MAX_EVENTS); +} + +/** + * Create an event loop context + * @param ctx Pointer to an uev_ctx_t context to be initialized + * @param maxevents Maximum number of events in event cache + * + * This function is the same as @func uev_init() except for the + * @param maxevents argument, which controls the number of events + * in the event cache returned to the main loop. + * + * In cases where you have multiple events pending in the cache and some + * event may cause later ones, already sent by the kernel to userspace, + * to be deleted the pointer returned to the event loop for this later + * event may be deleted. + * + * There are two ways around this (accessing deleted memory); 1) use + * this function to initialize your event loop and set @param maxevents + * to 1, 2) use a free list in you application that you garbage collect + * at intervals relevant to your application. + * + * @return POSIX OK(0) on success, or non-zero on error. + */ +int uev_init1(uev_ctx_t *ctx, int maxevents) +{ + if (!ctx || maxevents < 1) { errno = EINVAL; return -1; } memset(ctx, 0, sizeof(*ctx)); - LIST_INIT(&ctx->watchers); + ctx->maxevents = maxevents; return _init(ctx, 0); } @@ -203,16 +230,16 @@ */ int uev_exit(uev_ctx_t *ctx) { - uev_t *w, *next; + uev_t *w; if (!ctx) { errno = EINVAL; return -1; } - LIST_FOREACH_SAFE(w, &ctx->watchers, link, next) { + _UEV_FOREACH(w, ctx->watchers) { /* Remove from internal list */ - LIST_REMOVE(w, link); + _UEV_REMOVE(w, ctx->watchers); if (!_uev_watcher_active(w)) continue; @@ -233,9 +260,10 @@ } } - LIST_INIT(&ctx->watchers); + ctx->watchers = NULL; ctx->running = 0; - close(ctx->fd); + if (ctx->fd > -1) + close(ctx->fd); ctx->fd = -1; return 0; @@ -272,26 +300,26 @@ ctx->running = 1; /* Start all dormant timers */ - LIST_FOREACH(w, &ctx->watchers, link) { + _UEV_FOREACH(w, ctx->watchers) { if (UEV_CRON_TYPE == w->type) uev_cron_set(w, w->u.c.when, w->u.c.interval); if (UEV_TIMER_TYPE == w->type) uev_timer_set(w, w->u.t.timeout, w->u.t.period); } - while (ctx->running && !LIST_EMPTY(&ctx->watchers)) { + while (ctx->running && ctx->watchers) { int i, nfds, rerun = 0; struct epoll_event ee[UEV_MAX_EVENTS]; /* Handle special case: `application < file.txt` */ if (ctx->workaround) { - LIST_FOREACH(w, &ctx->watchers, link) { + _UEV_FOREACH(w, ctx->watchers) { if (w->active != -1 || !w->cb) continue; if (!has_data(w->fd)) { w->active = 0; - LIST_REMOVE(w, link); + _UEV_REMOVE(w, ctx->watchers); } rerun++; @@ -303,7 +331,7 @@ continue; ctx->workaround = 0; - while ((nfds = epoll_wait(ctx->fd, ee, UEV_MAX_EVENTS, timeout)) < 0) { + while ((nfds = epoll_wait(ctx->fd, ee, ctx->maxevents, timeout)) < 0) { if (!ctx->running) break; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/src/uev.h new/libuev-2.2.0/src/uev.h --- old/libuev-2.1.3/src/uev.h 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/src/uev.h 2018-10-04 21:06:51.000000000 +0200 @@ -76,6 +76,7 @@ /* Public interface */ int uev_init (uev_ctx_t *ctx); +int uev_init1 (uev_ctx_t *ctx, int maxevents); int uev_exit (uev_ctx_t *ctx); int uev_run (uev_ctx_t *ctx, int flags); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/tests/Makefile.am new/libuev-2.2.0/tests/Makefile.am --- old/libuev-2.1.3/tests/Makefile.am 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/tests/Makefile.am 2018-10-04 21:06:51.000000000 +0200 @@ -12,6 +12,6 @@ check_PROGRAMS = $(TESTS) # Ignore warnings about unused result, in e.g. write() -CFLAGS = -W -Wall -Wextra -Wno-unused-result +CFLAGS = -W -Wall -Wextra -Wno-unused-result -Wno-unused-parameter CPPFLAGS = -D_GNU_SOURCE LDADD = -L../src ../src/libuev.la diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/tests/active.c new/libuev-2.2.0/tests/active.c --- old/libuev-2.1.3/tests/active.c 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/tests/active.c 2018-10-04 21:06:51.000000000 +0200 @@ -12,7 +12,7 @@ uev_t cron1; uev_t cron2; -static void cb(uev_t *w, void *UNUSED(arg), int events) +static void cb(uev_t *w, void *arg, int events) { if (UEV_ERROR == events) fprintf(stderr, "timer watcher failed, ignoring ...\n"); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/tests/api.c new/libuev-2.2.0/tests/api.c --- old/libuev-2.1.3/tests/api.c 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/tests/api.c 2018-10-04 21:06:51.000000000 +0200 @@ -3,7 +3,7 @@ uev_t timer, file; int counter = 10; -static void cb(uev_t *w, void *UNUSED(arg), int events) +static void cb(uev_t *w, void *arg, int events) { if (UEV_ERROR == events) fprintf(stderr, "timer watcher failed, ignoring ...\n"); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/tests/check.h new/libuev-2.2.0/tests/check.h --- old/libuev-2.1.3/tests/check.h 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/tests/check.h 2018-10-04 21:06:51.000000000 +0200 @@ -9,8 +9,6 @@ #include "../src/uev.h" -#define UNUSED(arg) arg __attribute__ ((unused)) - #define fail_unless(test) \ do { \ if (!(test)) { \ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/tests/complete.c new/libuev-2.2.0/tests/complete.c --- old/libuev-2.1.3/tests/complete.c 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/tests/complete.c 2018-10-04 21:06:51.000000000 +0200 @@ -55,12 +55,12 @@ uev_exit(w->ctx); } -static void periodic_task(uev_t UNUSED(*w), void UNUSED(*arg), int UNUSED(events)) +static void periodic_task(uev_t *w, void *arg, int events) { fprintf(stderr, "|"); } -static void signal_cb(uev_t *w, void *UNUSED(arg), int events) +static void signal_cb(uev_t *w, void *arg, int events) { if (UEV_ERROR == events) { fprintf(stderr, "Signal watcher failed, unrecoverable error.\n"); @@ -70,7 +70,7 @@ fprintf(stderr, w->signo == SIGINT ? "^Cv" : "^\v"); } -static void pipe_read_cb(uev_t *w, void UNUSED(*arg), int events) +static void pipe_read_cb(uev_t *w, void *arg, int events) { int len; char msg[50]; @@ -102,7 +102,7 @@ fprintf(stderr, "%.*s.%d ", len, msg, len); } -static void pipe_write_cb(uev_t *w, void *arg, int UNUSED(events)) +static void pipe_write_cb(uev_t *w, void *arg, int events) { my_t *my = arg; char *msg = "TESTING"; @@ -153,8 +153,10 @@ uev_io_init(&ctx, &reader, pipe_read_cb, NULL, in, UEV_READ); uev_timer_init(&ctx, &writer, pipe_write_cb, &my, 400, 0); - /* Watchdog for the above timer callback, if it doesn't wake up - * and write to the pipe within a given deadline it will bark. */ + /* + * Watchdog for the above timer callback, if it doesn't wake up + * and write to the pipe within a given deadline it will bark. + */ uev_timer_init(&ctx, &wdt, timeout_cb, (void *)(intptr_t)1, 950, 0); watchdog = &wdt; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/tests/cronrun.c new/libuev-2.2.0/tests/cronrun.c --- old/libuev-2.1.3/tests/cronrun.c 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/tests/cronrun.c 2018-10-04 21:06:51.000000000 +0200 @@ -31,7 +31,7 @@ int result = -1; struct timeval tv; -static void cron_job(uev_t *w, void *UNUSED(arg), int events) +static void cron_job(uev_t *w, void *arg, int events) { static int laps = 3; struct timeval now; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/tests/signal.c new/libuev-2.2.0/tests/signal.c --- old/libuev-2.1.3/tests/signal.c 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/tests/signal.c 2018-10-04 21:06:51.000000000 +0200 @@ -33,7 +33,6 @@ #include <sys/wait.h> #include <unistd.h> -#define UNUSED(arg) arg __attribute__ ((unused)) #define DO_SEGFAULT 1 typedef struct { @@ -66,13 +65,13 @@ return 42; } -static void sigsegv_cb(uev_t *UNUSED(w), void *UNUSED(arg), int UNUSED(events)) +static void sigsegv_cb(uev_t *w, void *arg, int events) { warnx("PID %d caused segfault.", getpid()); exit(-1); } -static void sigchld_cb(uev_t *UNUSED(w), void *UNUSED(arg), int UNUSED(events)) +static void sigchld_cb(uev_t *w, void *arg, int events) { pid_t pid = waitpid(-1, NULL, WNOHANG); @@ -80,7 +79,7 @@ warnx("PID %d exited, bye.", pid); } -static void work_cb(uev_t *UNUSED(w), void *arg, int UNUSED(events)) +static void work_cb(uev_t *w, void *arg, int events) { int status = 0; pid_t pid; @@ -106,7 +105,7 @@ printf("Child did not exit normally!\n"); } -static void exit_cb(uev_t *w, void *UNUSED(arg), int UNUSED(events)) +static void exit_cb(uev_t *w, void *arg, int events) { printf("Process deadline reached, exiting!\n"); uev_exit(w->ctx); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libuev-2.1.3/tests/timer.c new/libuev-2.2.0/tests/timer.c --- old/libuev-2.1.3/tests/timer.c 2018-09-06 22:03:16.000000000 +0200 +++ new/libuev-2.2.0/tests/timer.c 2018-10-04 21:06:51.000000000 +0200 @@ -7,7 +7,7 @@ int result = -1; struct timeval start; -static void cb(uev_t *w, void *UNUSED(arg), int events) +static void cb(uev_t *w, void *arg, int events) { struct timeval now;
