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

Comparing libev/ev.c (file contents):
Revision 1.419 by root, Thu Apr 12 04:10:15 2012 UTC vs.
Revision 1.420 by root, Wed Apr 18 05:44:42 2012 UTC

…		…
1105	{	1105	{
1106	write (STDERR_FILENO, msg, strlen (msg));	1106	write (STDERR_FILENO, msg, strlen (msg));
1107	}	1107	}
1108	#endif	1108	#endif
1109		1109
1110	static void (syserr_cb)(const char msg);	1110	static void (syserr_cb)(const char msg) EV_THROW;
1111		1111
1112	void ecb_cold	1112	void ecb_cold
1113	ev_set_syserr_cb (void (cb)(const char msg))	1113	ev_set_syserr_cb (void (cb)(const char msg)) EV_THROW
1114	{	1114	{
1115	syserr_cb = cb;	1115	syserr_cb = cb;
1116	}	1116	}
1117		1117
1118	static void noinline ecb_cold	1118	static void noinline ecb_cold
…		…
1154	free (ptr);	1154	free (ptr);
1155	return 0;	1155	return 0;
1156	#endif	1156	#endif
1157	}	1157	}
1158		1158
1159	static void (alloc)(void *ptr, long size) = ev_realloc_emul;	1159	static void (alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul;
1160		1160
1161	void ecb_cold	1161	void ecb_cold
1162	ev_set_allocator (void (cb)(void *ptr, long size))	1162	ev_set_allocator (void (cb)(void *ptr, long size)) EV_THROW
1163	{	1163	{
1164	alloc = cb;	1164	alloc = cb;
1165	}	1165	}
1166		1166
1167	inline_speed void *	1167	inline_speed void *
…		…
1284		1284
1285	/*****************************************************************************/	1285	/*****************************************************************************/
1286		1286
1287	#ifndef EV_HAVE_EV_TIME	1287	#ifndef EV_HAVE_EV_TIME
1288	ev_tstamp	1288	ev_tstamp
1289	ev_time (void)	1289	ev_time (void) EV_THROW
1290	{	1290	{
1291	#if EV_USE_REALTIME	1291	#if EV_USE_REALTIME
1292	if (expect_true (have_realtime))	1292	if (expect_true (have_realtime))
1293	{	1293	{
1294	struct timespec ts;	1294	struct timespec ts;
…		…
1318	return ev_time ();	1318	return ev_time ();
1319	}	1319	}
1320		1320
1321	#if EV_MULTIPLICITY	1321	#if EV_MULTIPLICITY
1322	ev_tstamp	1322	ev_tstamp
1323	ev_now (EV_P)	1323	ev_now (EV_P) EV_THROW
1324	{	1324	{
1325	return ev_rt_now;	1325	return ev_rt_now;
1326	}	1326	}
1327	#endif	1327	#endif
1328		1328
1329	void	1329	void
1330	ev_sleep (ev_tstamp delay)	1330	ev_sleep (ev_tstamp delay) EV_THROW
1331	{	1331	{
1332	if (delay > 0.)	1332	if (delay > 0.)
1333	{	1333	{
1334	#if EV_USE_NANOSLEEP	1334	#if EV_USE_NANOSLEEP
1335	struct timespec ts;	1335	struct timespec ts;
…		…
1416	pendingcb (EV_P_ ev_prepare *w, int revents)	1416	pendingcb (EV_P_ ev_prepare *w, int revents)
1417	{	1417	{
1418	}	1418	}
1419		1419
1420	void noinline	1420	void noinline
1421	ev_feed_event (EV_P_ void *w, int revents)	1421	ev_feed_event (EV_P_ void *w, int revents) EV_THROW
1422	{	1422	{
1423	W w_ = (W)w;	1423	W w_ = (W)w;
1424	int pri = ABSPRI (w_);	1424	int pri = ABSPRI (w_);
1425		1425
1426	if (expect_false (w_->pending))	1426	if (expect_false (w_->pending))
…		…
1485	if (expect_true (!anfd->reify))	1485	if (expect_true (!anfd->reify))
1486	fd_event_nocheck (EV_A_ fd, revents);	1486	fd_event_nocheck (EV_A_ fd, revents);
1487	}	1487	}
1488		1488
1489	void	1489	void
1490	ev_feed_fd_event (EV_P_ int fd, int revents)	1490	ev_feed_fd_event (EV_P_ int fd, int revents) EV_THROW
1491	{	1491	{
1492	if (fd >= 0 && fd < anfdmax)	1492	if (fd >= 0 && fd < anfdmax)
1493	fd_event_nocheck (EV_A_ fd, revents);	1493	fd_event_nocheck (EV_A_ fd, revents);
1494	}	1494	}
1495		1495
…		…
1941	}	1941	}
1942		1942
1943	/*****************************************************************************/	1943	/*****************************************************************************/
1944		1944
1945	void	1945	void
1946	ev_feed_signal (int signum)	1946	ev_feed_signal (int signum) EV_THROW
1947	{	1947	{
1948	#if EV_MULTIPLICITY	1948	#if EV_MULTIPLICITY
1949	EV_P = signals [signum - 1].loop;	1949	EV_P = signals [signum - 1].loop;
1950		1950
1951	if (!EV_A)	1951	if (!EV_A)
…		…
1968		1968
1969	ev_feed_signal (signum);	1969	ev_feed_signal (signum);
1970	}	1970	}
1971		1971
1972	void noinline	1972	void noinline
1973	ev_feed_signal_event (EV_P_ int signum)	1973	ev_feed_signal_event (EV_P_ int signum) EV_THROW
1974	{	1974	{
1975	WL w;	1975	WL w;
1976		1976
1977	if (expect_false (signum <= 0 \|\| signum > EV_NSIG))	1977	if (expect_false (signum <= 0 \|\| signum > EV_NSIG))
1978	return;	1978	return;
…		…
2094	#if EV_USE_SELECT	2094	#if EV_USE_SELECT
2095	# include "ev_select.c"	2095	# include "ev_select.c"
2096	#endif	2096	#endif
2097		2097
2098	int ecb_cold	2098	int ecb_cold
2099	ev_version_major (void)	2099	ev_version_major (void) EV_THROW
2100	{	2100	{
2101	return EV_VERSION_MAJOR;	2101	return EV_VERSION_MAJOR;
2102	}	2102	}
2103		2103
2104	int ecb_cold	2104	int ecb_cold
2105	ev_version_minor (void)	2105	ev_version_minor (void) EV_THROW
2106	{	2106	{
2107	return EV_VERSION_MINOR;	2107	return EV_VERSION_MINOR;
2108	}	2108	}
2109		2109
2110	/* return true if we are running with elevated privileges and should ignore env variables */	2110	/* return true if we are running with elevated privileges and should ignore env variables */
…		…
2118	\|\| getgid () != getegid ();	2118	\|\| getgid () != getegid ();
2119	#endif	2119	#endif
2120	}	2120	}
2121		2121
2122	unsigned int ecb_cold	2122	unsigned int ecb_cold
2123	ev_supported_backends (void)	2123	ev_supported_backends (void) EV_THROW
2124	{	2124	{
2125	unsigned int flags = 0;	2125	unsigned int flags = 0;
2126		2126
2127	if (EV_USE_PORT ) flags \|= EVBACKEND_PORT;	2127	if (EV_USE_PORT ) flags \|= EVBACKEND_PORT;
2128	if (EV_USE_KQUEUE) flags \|= EVBACKEND_KQUEUE;	2128	if (EV_USE_KQUEUE) flags \|= EVBACKEND_KQUEUE;
…		…
2132		2132
2133	return flags;	2133	return flags;
2134	}	2134	}
2135		2135
2136	unsigned int ecb_cold	2136	unsigned int ecb_cold
2137	ev_recommended_backends (void)	2137	ev_recommended_backends (void) EV_THROW
2138	{	2138	{
2139	unsigned int flags = ev_supported_backends ();	2139	unsigned int flags = ev_supported_backends ();
2140		2140
2141	#ifndef __NetBSD__	2141	#ifndef __NetBSD__
2142	/* kqueue is borked on everything but netbsd apparently */	2142	/* kqueue is borked on everything but netbsd apparently */
…		…
2154		2154
2155	return flags;	2155	return flags;
2156	}	2156	}
2157		2157
2158	unsigned int ecb_cold	2158	unsigned int ecb_cold
2159	ev_embeddable_backends (void)	2159	ev_embeddable_backends (void) EV_THROW
2160	{	2160	{
2161	int flags = EVBACKEND_EPOLL \| EVBACKEND_KQUEUE \| EVBACKEND_PORT;	2161	int flags = EVBACKEND_EPOLL \| EVBACKEND_KQUEUE \| EVBACKEND_PORT;
2162		2162
2163	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */	2163	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */
2164	if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */	2164	if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
…		…
2166		2166
2167	return flags;	2167	return flags;
2168	}	2168	}
2169		2169
2170	unsigned int	2170	unsigned int
2171	ev_backend (EV_P)	2171	ev_backend (EV_P) EV_THROW
2172	{	2172	{
2173	return backend;	2173	return backend;
2174	}	2174	}
2175		2175
2176	#if EV_FEATURE_API	2176	#if EV_FEATURE_API
2177	unsigned int	2177	unsigned int
2178	ev_iteration (EV_P)	2178	ev_iteration (EV_P) EV_THROW
2179	{	2179	{
2180	return loop_count;	2180	return loop_count;
2181	}	2181	}
2182		2182
2183	unsigned int	2183	unsigned int
2184	ev_depth (EV_P)	2184	ev_depth (EV_P) EV_THROW
2185	{	2185	{
2186	return loop_depth;	2186	return loop_depth;
2187	}	2187	}
2188		2188
2189	void	2189	void
2190	ev_set_io_collect_interval (EV_P_ ev_tstamp interval)	2190	ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_THROW
2191	{	2191	{
2192	io_blocktime = interval;	2192	io_blocktime = interval;
2193	}	2193	}
2194		2194
2195	void	2195	void
2196	ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval)	2196	ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_THROW
2197	{	2197	{
2198	timeout_blocktime = interval;	2198	timeout_blocktime = interval;
2199	}	2199	}
2200		2200
2201	void	2201	void
2202	ev_set_userdata (EV_P_ void *data)	2202	ev_set_userdata (EV_P_ void *data) EV_THROW
2203	{	2203	{
2204	userdata = data;	2204	userdata = data;
2205	}	2205	}
2206		2206
2207	void *	2207	void *
2208	ev_userdata (EV_P)	2208	ev_userdata (EV_P) EV_THROW
2209	{	2209	{
2210	return userdata;	2210	return userdata;
2211	}	2211	}
2212		2212
2213	void	2213	void
2214	ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P))	2214	ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) EV_THROW
2215	{	2215	{
2216	invoke_cb = invoke_pending_cb;	2216	invoke_cb = invoke_pending_cb;
2217	}	2217	}
2218		2218
2219	void	2219	void
2220	ev_set_loop_release_cb (EV_P_ void (release)(EV_P), void (acquire)(EV_P))	2220	ev_set_loop_release_cb (EV_P_ void (release)(EV_P), void (acquire)(EV_P)) EV_THROW
2221	{	2221	{
2222	release_cb = release;	2222	release_cb = release;
2223	acquire_cb = acquire;	2223	acquire_cb = acquire;
2224	}	2224	}
2225	#endif	2225	#endif
2226		2226
2227	/* initialise a loop structure, must be zero-initialised */	2227	/* initialise a loop structure, must be zero-initialised */
2228	static void noinline ecb_cold	2228	static void noinline ecb_cold
2229	loop_init (EV_P_ unsigned int flags)	2229	loop_init (EV_P_ unsigned int flags) EV_THROW
2230	{	2230	{
2231	if (!backend)	2231	if (!backend)
2232	{	2232	{
2233	origflags = flags;	2233	origflags = flags;
2234		2234
…		…
2319	}	2319	}
2320	}	2320	}
2321		2321
2322	/* free up a loop structure */	2322	/* free up a loop structure */
2323	void ecb_cold	2323	void ecb_cold
2324	ev_loop_destroy (EV_P)	2324	ev_loop_destroy (EV_P) EV_THROW
2325	{	2325	{
2326	int i;	2326	int i;
2327		2327
2328	#if EV_MULTIPLICITY	2328	#if EV_MULTIPLICITY
2329	/* mimic free (0) */	2329	/* mimic free (0) */
…		…
2487	}	2487	}
2488		2488
2489	#if EV_MULTIPLICITY	2489	#if EV_MULTIPLICITY
2490		2490
2491	struct ev_loop * ecb_cold	2491	struct ev_loop * ecb_cold
2492	ev_loop_new (unsigned int flags)	2492	ev_loop_new (unsigned int flags) EV_THROW
2493	{	2493	{
2494	EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));	2494	EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
2495		2495
2496	memset (EV_A, 0, sizeof (struct ev_loop));	2496	memset (EV_A, 0, sizeof (struct ev_loop));
2497	loop_init (EV_A_ flags);	2497	loop_init (EV_A_ flags);
…		…
2541	}	2541	}
2542	#endif	2542	#endif
2543		2543
2544	#if EV_FEATURE_API	2544	#if EV_FEATURE_API
2545	void ecb_cold	2545	void ecb_cold
2546	ev_verify (EV_P)	2546	ev_verify (EV_P) EV_THROW
2547	{	2547	{
2548	#if EV_VERIFY	2548	#if EV_VERIFY
2549	int i;	2549	int i;
2550	WL w;	2550	WL w;
2551		2551
…		…
2620	#if EV_MULTIPLICITY	2620	#if EV_MULTIPLICITY
2621	struct ev_loop * ecb_cold	2621	struct ev_loop * ecb_cold
2622	#else	2622	#else
2623	int	2623	int
2624	#endif	2624	#endif
2625	ev_default_loop (unsigned int flags)	2625	ev_default_loop (unsigned int flags) EV_THROW
2626	{	2626	{
2627	if (!ev_default_loop_ptr)	2627	if (!ev_default_loop_ptr)
2628	{	2628	{
2629	#if EV_MULTIPLICITY	2629	#if EV_MULTIPLICITY
2630	EV_P = ev_default_loop_ptr = &default_loop_struct;	2630	EV_P = ev_default_loop_ptr = &default_loop_struct;
…		…
2649		2649
2650	return ev_default_loop_ptr;	2650	return ev_default_loop_ptr;
2651	}	2651	}
2652		2652
2653	void	2653	void
2654	ev_loop_fork (EV_P)	2654	ev_loop_fork (EV_P) EV_THROW
2655	{	2655	{
2656	postfork = 1; /* must be in line with ev_default_fork */	2656	postfork = 1; /* must be in line with ev_default_fork */
2657	}	2657	}
2658		2658
2659	/*****************************************************************************/	2659	/*****************************************************************************/
…		…
2663	{	2663	{
2664	EV_CB_INVOKE ((W)w, revents);	2664	EV_CB_INVOKE ((W)w, revents);
2665	}	2665	}
2666		2666
2667	unsigned int	2667	unsigned int
2668	ev_pending_count (EV_P)	2668	ev_pending_count (EV_P) EV_THROW
2669	{	2669	{
2670	int pri;	2670	int pri;
2671	unsigned int count = 0;	2671	unsigned int count = 0;
2672		2672
2673	for (pri = NUMPRI; pri--; )	2673	for (pri = NUMPRI; pri--; )
…		…
3104		3104
3105	return activecnt;	3105	return activecnt;
3106	}	3106	}
3107		3107
3108	void	3108	void
3109	ev_break (EV_P_ int how)	3109	ev_break (EV_P_ int how) EV_THROW
3110	{	3110	{
3111	loop_done = how;	3111	loop_done = how;
3112	}	3112	}
3113		3113
3114	void	3114	void
3115	ev_ref (EV_P)	3115	ev_ref (EV_P) EV_THROW
3116	{	3116	{
3117	++activecnt;	3117	++activecnt;
3118	}	3118	}
3119		3119
3120	void	3120	void
3121	ev_unref (EV_P)	3121	ev_unref (EV_P) EV_THROW
3122	{	3122	{
3123	--activecnt;	3123	--activecnt;
3124	}	3124	}
3125		3125
3126	void	3126	void
3127	ev_now_update (EV_P)	3127	ev_now_update (EV_P) EV_THROW
3128	{	3128	{
3129	time_update (EV_A_ 1e100);	3129	time_update (EV_A_ 1e100);
3130	}	3130	}
3131		3131
3132	void	3132	void
3133	ev_suspend (EV_P)	3133	ev_suspend (EV_P) EV_THROW
3134	{	3134	{
3135	ev_now_update (EV_A);	3135	ev_now_update (EV_A);
3136	}	3136	}
3137		3137
3138	void	3138	void
3139	ev_resume (EV_P)	3139	ev_resume (EV_P) EV_THROW
3140	{	3140	{
3141	ev_tstamp mn_prev = mn_now;	3141	ev_tstamp mn_prev = mn_now;
3142		3142
3143	ev_now_update (EV_A);	3143	ev_now_update (EV_A);
3144	timers_reschedule (EV_A_ mn_now - mn_prev);	3144	timers_reschedule (EV_A_ mn_now - mn_prev);
…		…
3183	w->pending = 0;	3183	w->pending = 0;
3184	}	3184	}
3185	}	3185	}
3186		3186
3187	int	3187	int
3188	ev_clear_pending (EV_P_ void *w)	3188	ev_clear_pending (EV_P_ void *w) EV_THROW
3189	{	3189	{
3190	W w_ = (W)w;	3190	W w_ = (W)w;
3191	int pending = w_->pending;	3191	int pending = w_->pending;
3192		3192
3193	if (expect_true (pending))	3193	if (expect_true (pending))
…		…
3226	}	3226	}
3227		3227
3228	/*****************************************************************************/	3228	/*****************************************************************************/
3229		3229
3230	void noinline	3230	void noinline
3231	ev_io_start (EV_P_ ev_io *w)	3231	ev_io_start (EV_P_ ev_io *w) EV_THROW
3232	{	3232	{
3233	int fd = w->fd;	3233	int fd = w->fd;
3234		3234
3235	if (expect_false (ev_is_active (w)))	3235	if (expect_false (ev_is_active (w)))
3236	return;	3236	return;
…		…
3249		3249
3250	EV_FREQUENT_CHECK;	3250	EV_FREQUENT_CHECK;
3251	}	3251	}
3252		3252
3253	void noinline	3253	void noinline
3254	ev_io_stop (EV_P_ ev_io *w)	3254	ev_io_stop (EV_P_ ev_io *w) EV_THROW
3255	{	3255	{
3256	clear_pending (EV_A_ (W)w);	3256	clear_pending (EV_A_ (W)w);
3257	if (expect_false (!ev_is_active (w)))	3257	if (expect_false (!ev_is_active (w)))
3258	return;	3258	return;
3259		3259
…		…
3268		3268
3269	EV_FREQUENT_CHECK;	3269	EV_FREQUENT_CHECK;
3270	}	3270	}
3271		3271
3272	void noinline	3272	void noinline
3273	ev_timer_start (EV_P_ ev_timer *w)	3273	ev_timer_start (EV_P_ ev_timer *w) EV_THROW
3274	{	3274	{
3275	if (expect_false (ev_is_active (w)))	3275	if (expect_false (ev_is_active (w)))
3276	return;	3276	return;
3277		3277
3278	ev_at (w) += mn_now;	3278	ev_at (w) += mn_now;
…		…
3292		3292
3293	/assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));/	3293	/assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));/
3294	}	3294	}
3295		3295
3296	void noinline	3296	void noinline
3297	ev_timer_stop (EV_P_ ev_timer *w)	3297	ev_timer_stop (EV_P_ ev_timer *w) EV_THROW
3298	{	3298	{
3299	clear_pending (EV_A_ (W)w);	3299	clear_pending (EV_A_ (W)w);
3300	if (expect_false (!ev_is_active (w)))	3300	if (expect_false (!ev_is_active (w)))
3301	return;	3301	return;
3302		3302
…		…
3322		3322
3323	EV_FREQUENT_CHECK;	3323	EV_FREQUENT_CHECK;
3324	}	3324	}
3325		3325
3326	void noinline	3326	void noinline
3327	ev_timer_again (EV_P_ ev_timer *w)	3327	ev_timer_again (EV_P_ ev_timer *w) EV_THROW
3328	{	3328	{
3329	EV_FREQUENT_CHECK;	3329	EV_FREQUENT_CHECK;
3330		3330
3331	clear_pending (EV_A_ (W)w);	3331	clear_pending (EV_A_ (W)w);
3332		3332
…		…
3349		3349
3350	EV_FREQUENT_CHECK;	3350	EV_FREQUENT_CHECK;
3351	}	3351	}
3352		3352
3353	ev_tstamp	3353	ev_tstamp
3354	ev_timer_remaining (EV_P_ ev_timer *w)	3354	ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW
3355	{	3355	{
3356	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);	3356	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
3357	}	3357	}
3358		3358
3359	#if EV_PERIODIC_ENABLE	3359	#if EV_PERIODIC_ENABLE
3360	void noinline	3360	void noinline
3361	ev_periodic_start (EV_P_ ev_periodic *w)	3361	ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW
3362	{	3362	{
3363	if (expect_false (ev_is_active (w)))	3363	if (expect_false (ev_is_active (w)))
3364	return;	3364	return;
3365		3365
3366	if (w->reschedule_cb)	3366	if (w->reschedule_cb)
…		…
3386		3386
3387	/assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));/	3387	/assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));/
3388	}	3388	}
3389		3389
3390	void noinline	3390	void noinline
3391	ev_periodic_stop (EV_P_ ev_periodic *w)	3391	ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW
3392	{	3392	{
3393	clear_pending (EV_A_ (W)w);	3393	clear_pending (EV_A_ (W)w);
3394	if (expect_false (!ev_is_active (w)))	3394	if (expect_false (!ev_is_active (w)))
3395	return;	3395	return;
3396		3396
…		…
3414		3414
3415	EV_FREQUENT_CHECK;	3415	EV_FREQUENT_CHECK;
3416	}	3416	}
3417		3417
3418	void noinline	3418	void noinline
3419	ev_periodic_again (EV_P_ ev_periodic *w)	3419	ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW
3420	{	3420	{
3421	/* TODO: use adjustheap and recalculation */	3421	/* TODO: use adjustheap and recalculation */
3422	ev_periodic_stop (EV_A_ w);	3422	ev_periodic_stop (EV_A_ w);
3423	ev_periodic_start (EV_A_ w);	3423	ev_periodic_start (EV_A_ w);
3424	}	3424	}
…		…
3429	#endif	3429	#endif
3430		3430
3431	#if EV_SIGNAL_ENABLE	3431	#if EV_SIGNAL_ENABLE
3432		3432
3433	void noinline	3433	void noinline
3434	ev_signal_start (EV_P_ ev_signal *w)	3434	ev_signal_start (EV_P_ ev_signal *w) EV_THROW
3435	{	3435	{
3436	if (expect_false (ev_is_active (w)))	3436	if (expect_false (ev_is_active (w)))
3437	return;	3437	return;
3438		3438
3439	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));	3439	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
…		…
3510		3510
3511	EV_FREQUENT_CHECK;	3511	EV_FREQUENT_CHECK;
3512	}	3512	}
3513		3513
3514	void noinline	3514	void noinline
3515	ev_signal_stop (EV_P_ ev_signal *w)	3515	ev_signal_stop (EV_P_ ev_signal *w) EV_THROW
3516	{	3516	{
3517	clear_pending (EV_A_ (W)w);	3517	clear_pending (EV_A_ (W)w);
3518	if (expect_false (!ev_is_active (w)))	3518	if (expect_false (!ev_is_active (w)))
3519	return;	3519	return;
3520		3520
…		…
3551	#endif	3551	#endif
3552		3552
3553	#if EV_CHILD_ENABLE	3553	#if EV_CHILD_ENABLE
3554		3554
3555	void	3555	void
3556	ev_child_start (EV_P_ ev_child *w)	3556	ev_child_start (EV_P_ ev_child *w) EV_THROW
3557	{	3557	{
3558	#if EV_MULTIPLICITY	3558	#if EV_MULTIPLICITY
3559	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));	3559	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
3560	#endif	3560	#endif
3561	if (expect_false (ev_is_active (w)))	3561	if (expect_false (ev_is_active (w)))
…		…
3568		3568
3569	EV_FREQUENT_CHECK;	3569	EV_FREQUENT_CHECK;
3570	}	3570	}
3571		3571
3572	void	3572	void
3573	ev_child_stop (EV_P_ ev_child *w)	3573	ev_child_stop (EV_P_ ev_child *w) EV_THROW
3574	{	3574	{
3575	clear_pending (EV_A_ (W)w);	3575	clear_pending (EV_A_ (W)w);
3576	if (expect_false (!ev_is_active (w)))	3576	if (expect_false (!ev_is_active (w)))
3577	return;	3577	return;
3578		3578
…		…
3830	#else	3830	#else
3831	# define EV_LSTAT(p,b) lstat (p, b)	3831	# define EV_LSTAT(p,b) lstat (p, b)
3832	#endif	3832	#endif
3833		3833
3834	void	3834	void
3835	ev_stat_stat (EV_P_ ev_stat *w)	3835	ev_stat_stat (EV_P_ ev_stat *w) EV_THROW
3836	{	3836	{
3837	if (lstat (w->path, &w->attr) < 0)	3837	if (lstat (w->path, &w->attr) < 0)
3838	w->attr.st_nlink = 0;	3838	w->attr.st_nlink = 0;
3839	else if (!w->attr.st_nlink)	3839	else if (!w->attr.st_nlink)
3840	w->attr.st_nlink = 1;	3840	w->attr.st_nlink = 1;
…		…
3879	ev_feed_event (EV_A_ w, EV_STAT);	3879	ev_feed_event (EV_A_ w, EV_STAT);
3880	}	3880	}
3881	}	3881	}
3882		3882
3883	void	3883	void
3884	ev_stat_start (EV_P_ ev_stat *w)	3884	ev_stat_start (EV_P_ ev_stat *w) EV_THROW
3885	{	3885	{
3886	if (expect_false (ev_is_active (w)))	3886	if (expect_false (ev_is_active (w)))
3887	return;	3887	return;
3888		3888
3889	ev_stat_stat (EV_A_ w);	3889	ev_stat_stat (EV_A_ w);
…		…
3910		3910
3911	EV_FREQUENT_CHECK;	3911	EV_FREQUENT_CHECK;
3912	}	3912	}
3913		3913
3914	void	3914	void
3915	ev_stat_stop (EV_P_ ev_stat *w)	3915	ev_stat_stop (EV_P_ ev_stat *w) EV_THROW
3916	{	3916	{
3917	clear_pending (EV_A_ (W)w);	3917	clear_pending (EV_A_ (W)w);
3918	if (expect_false (!ev_is_active (w)))	3918	if (expect_false (!ev_is_active (w)))
3919	return;	3919	return;
3920		3920
…		…
3936	}	3936	}
3937	#endif	3937	#endif
3938		3938
3939	#if EV_IDLE_ENABLE	3939	#if EV_IDLE_ENABLE
3940	void	3940	void
3941	ev_idle_start (EV_P_ ev_idle *w)	3941	ev_idle_start (EV_P_ ev_idle *w) EV_THROW
3942	{	3942	{
3943	if (expect_false (ev_is_active (w)))	3943	if (expect_false (ev_is_active (w)))
3944	return;	3944	return;
3945		3945
3946	pri_adjust (EV_A_ (W)w);	3946	pri_adjust (EV_A_ (W)w);
…		…
3959		3959
3960	EV_FREQUENT_CHECK;	3960	EV_FREQUENT_CHECK;
3961	}	3961	}
3962		3962
3963	void	3963	void
3964	ev_idle_stop (EV_P_ ev_idle *w)	3964	ev_idle_stop (EV_P_ ev_idle *w) EV_THROW
3965	{	3965	{
3966	clear_pending (EV_A_ (W)w);	3966	clear_pending (EV_A_ (W)w);
3967	if (expect_false (!ev_is_active (w)))	3967	if (expect_false (!ev_is_active (w)))
3968	return;	3968	return;
3969		3969
…		…
3983	}	3983	}
3984	#endif	3984	#endif
3985		3985
3986	#if EV_PREPARE_ENABLE	3986	#if EV_PREPARE_ENABLE
3987	void	3987	void
3988	ev_prepare_start (EV_P_ ev_prepare *w)	3988	ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW
3989	{	3989	{
3990	if (expect_false (ev_is_active (w)))	3990	if (expect_false (ev_is_active (w)))
3991	return;	3991	return;
3992		3992
3993	EV_FREQUENT_CHECK;	3993	EV_FREQUENT_CHECK;
…		…
3998		3998
3999	EV_FREQUENT_CHECK;	3999	EV_FREQUENT_CHECK;
4000	}	4000	}
4001		4001
4002	void	4002	void
4003	ev_prepare_stop (EV_P_ ev_prepare *w)	4003	ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW
4004	{	4004	{
4005	clear_pending (EV_A_ (W)w);	4005	clear_pending (EV_A_ (W)w);
4006	if (expect_false (!ev_is_active (w)))	4006	if (expect_false (!ev_is_active (w)))
4007	return;	4007	return;
4008		4008
…		…
4021	}	4021	}
4022	#endif	4022	#endif
4023		4023
4024	#if EV_CHECK_ENABLE	4024	#if EV_CHECK_ENABLE
4025	void	4025	void
4026	ev_check_start (EV_P_ ev_check *w)	4026	ev_check_start (EV_P_ ev_check *w) EV_THROW
4027	{	4027	{
4028	if (expect_false (ev_is_active (w)))	4028	if (expect_false (ev_is_active (w)))
4029	return;	4029	return;
4030		4030
4031	EV_FREQUENT_CHECK;	4031	EV_FREQUENT_CHECK;
…		…
4036		4036
4037	EV_FREQUENT_CHECK;	4037	EV_FREQUENT_CHECK;
4038	}	4038	}
4039		4039
4040	void	4040	void
4041	ev_check_stop (EV_P_ ev_check *w)	4041	ev_check_stop (EV_P_ ev_check *w) EV_THROW
4042	{	4042	{
4043	clear_pending (EV_A_ (W)w);	4043	clear_pending (EV_A_ (W)w);
4044	if (expect_false (!ev_is_active (w)))	4044	if (expect_false (!ev_is_active (w)))
4045	return;	4045	return;
4046		4046
…		…
4059	}	4059	}
4060	#endif	4060	#endif
4061		4061
4062	#if EV_EMBED_ENABLE	4062	#if EV_EMBED_ENABLE
4063	void noinline	4063	void noinline
4064	ev_embed_sweep (EV_P_ ev_embed *w)	4064	ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW
4065	{	4065	{
4066	ev_run (w->other, EVRUN_NOWAIT);	4066	ev_run (w->other, EVRUN_NOWAIT);
4067	}	4067	}
4068		4068
4069	static void	4069	static void
…		…
4117	ev_idle_stop (EV_A_ idle);	4117	ev_idle_stop (EV_A_ idle);
4118	}	4118	}
4119	#endif	4119	#endif
4120		4120
4121	void	4121	void
4122	ev_embed_start (EV_P_ ev_embed *w)	4122	ev_embed_start (EV_P_ ev_embed *w) EV_THROW
4123	{	4123	{
4124	if (expect_false (ev_is_active (w)))	4124	if (expect_false (ev_is_active (w)))
4125	return;	4125	return;
4126		4126
4127	{	4127	{
…		…
4148		4148
4149	EV_FREQUENT_CHECK;	4149	EV_FREQUENT_CHECK;
4150	}	4150	}
4151		4151
4152	void	4152	void
4153	ev_embed_stop (EV_P_ ev_embed *w)	4153	ev_embed_stop (EV_P_ ev_embed *w) EV_THROW
4154	{	4154	{
4155	clear_pending (EV_A_ (W)w);	4155	clear_pending (EV_A_ (W)w);
4156	if (expect_false (!ev_is_active (w)))	4156	if (expect_false (!ev_is_active (w)))
4157	return;	4157	return;
4158		4158
…		…
4168	}	4168	}
4169	#endif	4169	#endif
4170		4170
4171	#if EV_FORK_ENABLE	4171	#if EV_FORK_ENABLE
4172	void	4172	void
4173	ev_fork_start (EV_P_ ev_fork *w)	4173	ev_fork_start (EV_P_ ev_fork *w) EV_THROW
4174	{	4174	{
4175	if (expect_false (ev_is_active (w)))	4175	if (expect_false (ev_is_active (w)))
4176	return;	4176	return;
4177		4177
4178	EV_FREQUENT_CHECK;	4178	EV_FREQUENT_CHECK;
…		…
4183		4183
4184	EV_FREQUENT_CHECK;	4184	EV_FREQUENT_CHECK;
4185	}	4185	}
4186		4186
4187	void	4187	void
4188	ev_fork_stop (EV_P_ ev_fork *w)	4188	ev_fork_stop (EV_P_ ev_fork *w) EV_THROW
4189	{	4189	{
4190	clear_pending (EV_A_ (W)w);	4190	clear_pending (EV_A_ (W)w);
4191	if (expect_false (!ev_is_active (w)))	4191	if (expect_false (!ev_is_active (w)))
4192	return;	4192	return;
4193		4193
…		…
4206	}	4206	}
4207	#endif	4207	#endif
4208		4208
4209	#if EV_CLEANUP_ENABLE	4209	#if EV_CLEANUP_ENABLE
4210	void	4210	void
4211	ev_cleanup_start (EV_P_ ev_cleanup *w)	4211	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW
4212	{	4212	{
4213	if (expect_false (ev_is_active (w)))	4213	if (expect_false (ev_is_active (w)))
4214	return;	4214	return;
4215		4215
4216	EV_FREQUENT_CHECK;	4216	EV_FREQUENT_CHECK;
…		…
4223	ev_unref (EV_A);	4223	ev_unref (EV_A);
4224	EV_FREQUENT_CHECK;	4224	EV_FREQUENT_CHECK;
4225	}	4225	}
4226		4226
4227	void	4227	void
4228	ev_cleanup_stop (EV_P_ ev_cleanup *w)	4228	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW
4229	{	4229	{
4230	clear_pending (EV_A_ (W)w);	4230	clear_pending (EV_A_ (W)w);
4231	if (expect_false (!ev_is_active (w)))	4231	if (expect_false (!ev_is_active (w)))
4232	return;	4232	return;
4233		4233
…		…
4247	}	4247	}
4248	#endif	4248	#endif
4249		4249
4250	#if EV_ASYNC_ENABLE	4250	#if EV_ASYNC_ENABLE
4251	void	4251	void
4252	ev_async_start (EV_P_ ev_async *w)	4252	ev_async_start (EV_P_ ev_async *w) EV_THROW
4253	{	4253	{
4254	if (expect_false (ev_is_active (w)))	4254	if (expect_false (ev_is_active (w)))
4255	return;	4255	return;
4256		4256
4257	w->sent = 0;	4257	w->sent = 0;
…		…
4266		4266
4267	EV_FREQUENT_CHECK;	4267	EV_FREQUENT_CHECK;
4268	}	4268	}
4269		4269
4270	void	4270	void
4271	ev_async_stop (EV_P_ ev_async *w)	4271	ev_async_stop (EV_P_ ev_async *w) EV_THROW
4272	{	4272	{
4273	clear_pending (EV_A_ (W)w);	4273	clear_pending (EV_A_ (W)w);
4274	if (expect_false (!ev_is_active (w)))	4274	if (expect_false (!ev_is_active (w)))
4275	return;	4275	return;
4276		4276
…		…
4287		4287
4288	EV_FREQUENT_CHECK;	4288	EV_FREQUENT_CHECK;
4289	}	4289	}
4290		4290
4291	void	4291	void
4292	ev_async_send (EV_P_ ev_async *w)	4292	ev_async_send (EV_P_ ev_async *w) EV_THROW
4293	{	4293	{
4294	w->sent = 1;	4294	w->sent = 1;
4295	evpipe_write (EV_A_ &async_pending);	4295	evpipe_write (EV_A_ &async_pending);
4296	}	4296	}
4297	#endif	4297	#endif
…		…
4334		4334
4335	once_cb (EV_A_ once, revents \| ev_clear_pending (EV_A_ &once->io));	4335	once_cb (EV_A_ once, revents \| ev_clear_pending (EV_A_ &once->io));
4336	}	4336	}
4337		4337
4338	void	4338	void
4339	ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (cb)(int revents, void arg), void *arg)	4339	ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (cb)(int revents, void arg), void *arg) EV_THROW
4340	{	4340	{
4341	struct ev_once once = (struct ev_once )ev_malloc (sizeof (struct ev_once));	4341	struct ev_once once = (struct ev_once )ev_malloc (sizeof (struct ev_once));
4342		4342
4343	if (expect_false (!once))	4343	if (expect_false (!once))
4344	{	4344	{
…		…
4366		4366
4367	/*****************************************************************************/	4367	/*****************************************************************************/
4368		4368
4369	#if EV_WALK_ENABLE	4369	#if EV_WALK_ENABLE
4370	void ecb_cold	4370	void ecb_cold
4371	ev_walk (EV_P_ int types, void (cb)(EV_P_ int type, void w))	4371	ev_walk (EV_P_ int types, void (cb)(EV_P_ int type, void w)) EV_THROW
4372	{	4372	{
4373	int i, j;	4373	int i, j;
4374	ev_watcher_list wl, wn;	4374	ev_watcher_list wl, wn;
4375		4375
4376	if (types & (EV_IO \| EV_EMBED))	4376	if (types & (EV_IO \| EV_EMBED))

Diff Legend

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

Comparing libev/ev.c (file contents): Revision 1.419 by root, Thu Apr 12 04:10:15 2012 UTC vs. Revision 1.420 by root, Wed Apr 18 05:44:42 2012 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.419 by root, Thu Apr 12 04:10:15 2012 UTC vs.
Revision 1.420 by root, Wed Apr 18 05:44:42 2012 UTC