[ViewVC] Diff of: cvs/libev/event.c

Comparing libev/event.c (file contents):
Revision 1.6 by root, Sat Nov 3 20:24:42 2007 UTC vs.
Revision 1.32 by root, Thu Nov 29 12:21:06 2007 UTC

…		…
29	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	29	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30	*/	30	*/
31		31
32	#include <stddef.h>	32	#include <stddef.h>
33	#include <stdlib.h>	33	#include <stdlib.h>
		34	#include <assert.h>
		35
		36	#ifndef WIN32
34	#include <sys/time.h>	37	# include <sys/time.h>
		38	#endif
35		39
		40	#ifdef EV_EVENT_H
		41	# include EV_EVENT_H
		42	#else
36	#include "event.h"	43	# include "event.h"
		44	#endif
37		45
		46	#if EV_MULTIPLICITY
		47	# define dLOOPev struct ev_loop loop = (struct ev_loop )ev->ev_base
		48	# define dLOOPbase struct ev_loop loop = (struct ev_loop )base
		49	#else
		50	# define dLOOPev
		51	# define dLOOPbase
		52	#endif
		53
		54	/* never accessed, will always be cast from/to ev_loop */
38	struct event_base	55	struct event_base
39	{	56	{
40	int dummy;	57	int dummy;
41	};	58	};
42		59
43	static int x_actives;
44
45	static struct event_base x_base, *x_cur;	60	static struct event_base *x_cur;
46		61
47	static void	62	static void
48	tv_set (struct timeval *tv, ev_tstamp at)	63	tv_set (struct timeval *tv, ev_tstamp at)
49	{	64	{
50	tv->tv_sec = (long)at;	65	tv->tv_sec = (long)at;
…		…
72	return "libev";	87	return "libev";
73	}	88	}
74		89
75	void *event_init (void)	90	void *event_init (void)
76	{	91	{
77	if (!x_cur && ev_init (0))	92	#if EV_MULTIPLICITY
78	return x_cur = &x_base;	93	if (x_cur)
		94	x_cur = (struct event_base *)ev_loop_new (EVFLAG_AUTO);
		95	else
		96	x_cur = (struct event_base *)ev_default_loop (EVFLAG_AUTO);
		97	#else
		98	assert (("multiple event bases not supported when not compiled with EV_MULTIPLICITY", !x_cur));
79		99
		100	x_cur = (struct event_base *)(long)ev_default_loop (EVFLAG_AUTO);
		101	#endif
		102
80	return 0;	103	return x_cur;
81	}	104	}
82		105
83	void event_base_free (struct event_base *base)	106	void event_base_free (struct event_base *base)
84	{	107	{
85	/* nop */	108	dLOOPbase;
		109
		110	#if EV_MULTIPLICITY
		111	if (ev_default_loop (EVFLAG_AUTO) != loop)
		112	ev_loop_destroy (loop);
		113	#endif
86	}	114	}
87		115
88	int event_dispatch (void)	116	int event_dispatch (void)
89	{	117	{
90	return event_base_dispatch (x_cur);	118	return event_base_dispatch (x_cur);
…		…
108	}	136	}
109		137
110	static void	138	static void
111	x_cb (struct event *ev, int revents)	139	x_cb (struct event *ev, int revents)
112	{	140	{
		141	revents &= EV_READ \| EV_WRITE \| EV_TIMEOUT \| EV_SIGNAL;
		142
		143	ev->ev_res = revents;
		144	ev->ev_callback (ev->ev_fd, (short)revents, ev->ev_arg);
		145	}
		146
		147	static void
		148	x_cb_sig (EV_P_ struct ev_signal *w, int revents)
		149	{
		150	struct event ev = (struct event )(((char *)w) - offsetof (struct event, iosig.sig));
		151
		152	if (revents & EV_ERROR)
		153	event_del (ev);
		154
		155	x_cb (ev, revents);
		156	}
		157
		158	static void
		159	x_cb_io (EV_P_ struct ev_io *w, int revents)
		160	{
		161	struct event ev = (struct event )(((char *)w) - offsetof (struct event, iosig.io));
		162
		163	if ((revents & EV_ERROR) \|\| !(ev->ev_events & EV_PERSIST))
		164	event_del (ev);
		165
		166	x_cb (ev, revents);
		167	}
		168
		169	static void
		170	x_cb_to (EV_P_ struct ev_timer *w, int revents)
		171	{
		172	struct event ev = (struct event )(((char *)w) - offsetof (struct event, to));
		173
		174	event_del (ev);
		175
		176	x_cb (ev, revents);
		177	}
		178
		179	void event_set (struct event ev, int fd, short events, void (cb)(int, short, void ), void arg)
		180	{
113	if (ev->ev_events & EV_SIGNAL)	181	if (events & EV_SIGNAL)
114	{	182	ev_init (&ev->iosig.sig, x_cb_sig);
115	/* sig */
116	if (ev_is_active (&ev->iosig.sig))
117	{
118	ev_signal_stop (&ev->iosig.sig);
119	--x_actives;
120	}
121	}
122	else	183	else
123	{
124	/* io */
125	if (!(ev->ev_events & EV_PERSIST) && ev_is_active (&ev->iosig.io))
126	{
127	ev_io_stop (&ev->iosig.io);
128	--x_actives;
129	}
130	}
131
132	revents &= EV_READ \| EV_WRITE \| EV_TIMEOUT \| EV_SIGNAL;
133
134	if (revents & EV_TIMEOUT)
135	--x_actives;
136
137	ev->ev_res = revents;
138	ev->ev_callback (ev->ev_fd, revents, ev->ev_arg);
139	}
140
141	static void
142	x_cb_io (struct ev_io *w, int revents)
143	{
144	x_cb ((struct event )(((char )w) - offsetof (struct event, iosig.io)), revents);
145	}
146
147	static void
148	x_cb_to (struct ev_timer *w, int revents)
149	{
150	x_cb ((struct event )(((char )w) - offsetof (struct event, to)), revents);
151	}
152
153	static void
154	x_cb_sig (struct ev_signal *w, int revents)
155	{
156	x_cb ((struct event )(((char )w) - offsetof (struct event, iosig.sig)), revents);
157	}
158
159	void event_set (struct event ev, int fd, short events, void (cb)(int, short, void ), void arg)
160	{
161	if (events & EV_SIGNAL)
162	ev_watcher_init (&ev->iosig.sig, x_cb_sig);
163	else
164	ev_watcher_init (&ev->iosig.io, x_cb_io);	184	ev_init (&ev->iosig.io, x_cb_io);
165		185
166	ev_watcher_init (&ev->to, x_cb_to);	186	ev_init (&ev->to, x_cb_to);
167		187
168	ev->ev_base = x_cur;	188	ev->ev_base = x_cur; /* not threadsafe, but its like libevent works */
169	ev->ev_fd = fd;	189	ev->ev_fd = fd;
170	ev->ev_events = events;	190	ev->ev_events = events;
171	ev->ev_pri = 0;	191	ev->ev_pri = 0;
172	ev->ev_callback = cb;	192	ev->ev_callback = cb;
173	ev->ev_arg = arg;	193	ev->ev_arg = arg;
174	ev->ev_res = 0;	194	ev->ev_res = 0;
		195	ev->ev_flags = EVLIST_INIT;
175	}	196	}
176		197
177	int event_once (int fd, short events, void (cb)(int, short, void ), void arg, struct timeval tv)	198	int event_once (int fd, short events, void (cb)(int, short, void ), void arg, struct timeval tv)
178	{	199	{
179	return event_base_once (x_cur, fd, events, cb, arg, tv);	200	return event_base_once (x_cur, fd, events, cb, arg, tv);
180	}	201	}
181		202
182	int event_add (struct event ev, struct timeval tv)	203	int event_add (struct event ev, struct timeval tv)
183	{	204	{
184	/* disable all watchers */	205	dLOOPev;
185	event_del (ev);
186		206
187	if (ev->ev_events & EV_SIGNAL)	207	if (ev->ev_events & EV_SIGNAL)
188	{	208	{
		209	if (!ev_is_active (&ev->iosig.sig))
		210	{
189	ev_signal_set (&ev->iosig.sig, ev->ev_fd);	211	ev_signal_set (&ev->iosig.sig, ev->ev_fd);
190	ev_signal_start (&ev->iosig.sig);	212	ev_signal_start (EV_A_ &ev->iosig.sig);
191	++x_actives;	213
		214	ev->ev_flags \|= EVLIST_SIGNAL;
		215	}
192	}	216	}
193	else if (ev->ev_events & (EV_READ \| EV_WRITE))	217	else if (ev->ev_events & (EV_READ \| EV_WRITE))
194	{	218	{
		219	if (!ev_is_active (&ev->iosig.io))
		220	{
195	ev_io_set (&ev->iosig.io, ev->ev_fd, ev->ev_events & (EV_READ \| EV_WRITE));	221	ev_io_set (&ev->iosig.io, ev->ev_fd, ev->ev_events & (EV_READ \| EV_WRITE));
196	ev_io_start (&ev->iosig.io);	222	ev_io_start (EV_A_ &ev->iosig.io);
197	++x_actives;	223
		224	ev->ev_flags \|= EVLIST_INSERTED;
		225	}
198	}	226	}
199		227
200	if (tv)	228	if (tv)
201	{	229	{
202	ev_timer_set (&ev->to, tv_get (tv), 0.);	230	ev->to.repeat = tv_get (tv);
		231	ev_timer_again (EV_A_ &ev->to);
		232	ev->ev_flags \|= EVLIST_TIMEOUT;
		233	}
		234	else
		235	{
203	ev_timer_start (&ev->to);	236	ev_timer_stop (EV_A_ &ev->to);
204	++x_actives;	237	ev->ev_flags &= ~EVLIST_TIMEOUT;
205	}	238	}
		239
		240	ev->ev_flags \|= EVLIST_ACTIVE;
206		241
207	return 0;	242	return 0;
208	}	243	}
209		244
210	int event_del (struct event *ev)	245	int event_del (struct event *ev)
211	{	246	{
		247	dLOOPev;
		248
212	if (ev->ev_events & EV_SIGNAL)	249	if (ev->ev_events & EV_SIGNAL)
		250	ev_signal_stop (EV_A_ &ev->iosig.sig);
		251	else if (ev->ev_events & (EV_READ \| EV_WRITE))
		252	ev_io_stop (EV_A_ &ev->iosig.io);
		253
		254	if (ev_is_active (&ev->to))
		255	ev_timer_stop (EV_A_ &ev->to);
		256
		257	ev->ev_flags = EVLIST_INIT;
		258
		259	return 0;
		260	}
		261
		262	void event_active (struct event *ev, int res, short ncalls)
		263	{
		264	dLOOPev;
		265
		266	if (res & EV_TIMEOUT)
		267	ev_feed_event (EV_A_ &ev->to, res & EV_TIMEOUT);
		268
		269	if (res & EV_SIGNAL)
		270	ev_feed_event (EV_A_ &ev->iosig.sig, res & EV_SIGNAL);
		271
		272	if (res & (EV_READ \| EV_WRITE))
		273	ev_feed_event (EV_A_ &ev->iosig.io, res & (EV_READ \| EV_WRITE));
		274	}
		275
		276	int event_pending (struct event ev, short events, struct timeval tv)
		277	{
		278	short revents = 0;
		279	dLOOPev;
		280
		281
		282	if (ev->ev_events & EV_SIGNAL)
213	{	283	{
214	/* sig */	284	/* sig */
215	if (ev_is_active (&ev->iosig.sig))	285	if (ev_is_active (&ev->iosig.sig) \|\| ev_is_pending (&ev->iosig.sig))
216	{	286	revents \|= EV_SIGNAL;
217	ev_signal_stop (&ev->iosig.sig);
218	--x_actives;
219	}
220	}	287	}
221	else	288	else if (ev->ev_events & (EV_READ \| EV_WRITE))
222	{	289	{
223	/* io */	290	/* io */
224	if (ev_is_active (&ev->iosig.io))	291	if (ev_is_active (&ev->iosig.io) \|\| ev_is_pending (&ev->iosig.io))
225	{
226	ev_io_stop (&ev->iosig.io);
227	--x_actives;
228	}
229	}
230
231	if (ev_is_active (&ev->to))
232	{
233	ev_timer_stop (&ev->to);
234	--x_actives;
235	}
236
237	return 0;
238	}
239
240	int event_pending (struct event ev, short events, struct timeval tv)
241	{
242	short revents = 0;
243
244	if (ev->ev_events & EV_SIGNAL)
245	{
246	/* sig */
247	if (ev->iosig.sig.pending)
248	revents \|= EV_SIGNAL;
249	}
250	else
251	{
252	/* io */
253	if (ev->iosig.io.pending)
254	revents \|= ev->ev_events & (EV_READ \| EV_WRITE);	292	revents \|= ev->ev_events & (EV_READ \| EV_WRITE);
255	}	293	}
256		294
257	if (ev->to.pending)	295	if (ev->ev_events & EV_TIMEOUT \|\| ev_is_active (&ev->to) \|\| ev_is_pending (&ev->to))
258	{	296	{
259	revents \|= EV_TIMEOUT;	297	revents \|= EV_TIMEOUT;
260		298
261	if (tv)	299	if (tv)
262	tv_set (tv, ev_now); /* not sure if this is right :) */	300	tv_set (tv, ev_now (EV_A)); /* not sure if this is right :) */
263	}	301	}
264		302
265	return events & revents;	303	return events & revents;
266	}	304	}
267		305
…		…
284	return 0;	322	return 0;
285	}	323	}
286		324
287	int event_base_loop (struct event_base *base, int flags)	325	int event_base_loop (struct event_base *base, int flags)
288	{	326	{
289	do	327	dLOOPbase;
290	{	328
291	ev_loop (flags \| EVLOOP_ONESHOT);	329	ev_loop (EV_A_ flags);
292	}
293	while (!(flags & (EVLOOP_ONESHOT \| EVLOOP_NONBLOCK)) && x_actives && !ev_loop_done);
294		330
295	return 0;	331	return 0;
296	}	332	}
297		333
298	int event_base_dispatch (struct event_base *base)	334	int event_base_dispatch (struct event_base *base)
299	{	335	{
300	return event_base_loop (base, 0);	336	return event_base_loop (base, 0);
301	}	337	}
302		338
303	static void	339	static void
304	x_loopexit_cb (int revents, void *arg)	340	x_loopexit_cb (int revents, void *base)
305	{	341	{
306	ev_loop_done = 2;	342	dLOOPbase;
		343
		344	ev_unloop (EV_A_ EVUNLOOP_ONE);
307	}	345	}
308		346
309	int event_base_loopexit (struct event_base base, struct timeval tv)	347	int event_base_loopexit (struct event_base base, struct timeval tv)
310	{	348	{
311	ev_tstamp after = tv_get (tv);	349	ev_tstamp after = tv_get (tv);
		350	dLOOPbase;
312		351
313	ev_once (-1, 0, after >= 0. ? after : 0., x_loopexit_cb, (void *)base);	352	ev_once (EV_A_ -1, 0, after >= 0. ? after : 0., x_loopexit_cb, (void *)base);
314		353
315	return -1;	354	return -1;
316	}	355	}
317		356
318	struct x_once	357	struct x_once
…		…
323	};	362	};
324		363
325	static void	364	static void
326	x_once_cb (int revents, void *arg)	365	x_once_cb (int revents, void *arg)
327	{	366	{
328	struct x_once *once = arg;	367	struct x_once once = (struct x_once )arg;
329		368
330	once->cb (once->fd, revents, once->arg);	369	once->cb (once->fd, (short)revents, once->arg);
331	free (once);	370	free (once);
332	}	371	}
333		372
334	int event_base_once (struct event_base base, int fd, short events, void (cb)(int, short, void ), void arg, struct timeval *tv)	373	int event_base_once (struct event_base base, int fd, short events, void (cb)(int, short, void ), void arg, struct timeval *tv)
335	{	374	{
336	struct x_once *once = malloc (sizeof (struct x_once));	375	struct x_once once = (struct x_once )malloc (sizeof (struct x_once));
		376	dLOOPbase;
337		377
338	if (!once)	378	if (!once)
339	return -1;	379	return -1;
340		380
341	once->fd = fd;	381	once->fd = fd;
342	once->cb = cb;	382	once->cb = cb;
343	once->arg = arg;	383	once->arg = arg;
344		384
345	ev_once (fd, events & (EV_READ \| EV_WRITE), tv_get (tv), x_once_cb, (void *)once);	385	ev_once (EV_A_ fd, events & (EV_READ \| EV_WRITE), tv_get (tv), x_once_cb, (void *)once);
346		386
347	return 0;	387	return 0;
348	}	388	}
349		389
350	int event_base_priority_init (struct event_base *base, int npri)	390	int event_base_priority_init (struct event_base *base, int npri)
351	{	391	{
352	return 0;	392	/dLOOPbase;/
353	}
354		393
		394	return 0;
		395	}
		396

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libev/event.c (file contents): Revision 1.6 by root, Sat Nov 3 20:24:42 2007 UTC vs. Revision 1.32 by root, Thu Nov 29 12:21:06 2007 UTC

Diff Legend

Comparing libev/event.c (file contents):
Revision 1.6 by root, Sat Nov 3 20:24:42 2007 UTC vs.
Revision 1.32 by root, Thu Nov 29 12:21:06 2007 UTC