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

Comparing libev/ev.c (file contents):
Revision 1.485 by root, Mon Aug 13 10:01:19 2018 UTC vs.
Revision 1.486 by root, Thu Oct 25 03:11:04 2018 UTC

…		…
1677	{	1677	{
1678	write (STDERR_FILENO, msg, strlen (msg));	1678	write (STDERR_FILENO, msg, strlen (msg));
1679	}	1679	}
1680	#endif	1680	#endif
1681		1681
1682	static void (syserr_cb)(const char msg) EV_THROW;	1682	static void (syserr_cb)(const char msg) EV_NOEXCEPT;
1683		1683
1684	ecb_cold	1684	ecb_cold
1685	void	1685	void
1686	ev_set_syserr_cb (void (cb)(const char msg) EV_THROW) EV_THROW	1686	ev_set_syserr_cb (void (cb)(const char msg) EV_NOEXCEPT) EV_NOEXCEPT
1687	{	1687	{
1688	syserr_cb = cb;	1688	syserr_cb = cb;
1689	}	1689	}
1690		1690
1691	noinline ecb_cold	1691	noinline ecb_cold
…		…
1710	abort ();	1710	abort ();
1711	}	1711	}
1712	}	1712	}
1713		1713
1714	static void *	1714	static void *
1715	ev_realloc_emul (void *ptr, long size) EV_THROW	1715	ev_realloc_emul (void *ptr, long size) EV_NOEXCEPT
1716	{	1716	{
1717	/* some systems, notably openbsd and darwin, fail to properly	1717	/* some systems, notably openbsd and darwin, fail to properly
1718	* implement realloc (x, 0) (as required by both ansi c-89 and	1718	* implement realloc (x, 0) (as required by both ansi c-89 and
1719	* the single unix specification, so work around them here.	1719	* the single unix specification, so work around them here.
1720	* recently, also (at least) fedora and debian started breaking it,	1720	* recently, also (at least) fedora and debian started breaking it,
…		…
1726		1726
1727	free (ptr);	1727	free (ptr);
1728	return 0;	1728	return 0;
1729	}	1729	}
1730		1730
1731	static void (alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul;	1731	static void (alloc)(void *ptr, long size) EV_NOEXCEPT = ev_realloc_emul;
1732		1732
1733	ecb_cold	1733	ecb_cold
1734	void	1734	void
1735	ev_set_allocator (void (cb)(void *ptr, long size) EV_THROW) EV_THROW	1735	ev_set_allocator (void (cb)(void *ptr, long size) EV_NOEXCEPT) EV_NOEXCEPT
1736	{	1736	{
1737	alloc = cb;	1737	alloc = cb;
1738	}	1738	}
1739		1739
1740	inline_speed void *	1740	inline_speed void *
…		…
1857		1857
1858	/*****************************************************************************/	1858	/*****************************************************************************/
1859		1859
1860	#ifndef EV_HAVE_EV_TIME	1860	#ifndef EV_HAVE_EV_TIME
1861	ev_tstamp	1861	ev_tstamp
1862	ev_time (void) EV_THROW	1862	ev_time (void) EV_NOEXCEPT
1863	{	1863	{
1864	#if EV_USE_REALTIME	1864	#if EV_USE_REALTIME
1865	if (expect_true (have_realtime))	1865	if (expect_true (have_realtime))
1866	{	1866	{
1867	struct timespec ts;	1867	struct timespec ts;
…		…
1891	return ev_time ();	1891	return ev_time ();
1892	}	1892	}
1893		1893
1894	#if EV_MULTIPLICITY	1894	#if EV_MULTIPLICITY
1895	ev_tstamp	1895	ev_tstamp
1896	ev_now (EV_P) EV_THROW	1896	ev_now (EV_P) EV_NOEXCEPT
1897	{	1897	{
1898	return ev_rt_now;	1898	return ev_rt_now;
1899	}	1899	}
1900	#endif	1900	#endif
1901		1901
1902	void	1902	void
1903	ev_sleep (ev_tstamp delay) EV_THROW	1903	ev_sleep (ev_tstamp delay) EV_NOEXCEPT
1904	{	1904	{
1905	if (delay > 0.)	1905	if (delay > 0.)
1906	{	1906	{
1907	#if EV_USE_NANOSLEEP	1907	#if EV_USE_NANOSLEEP
1908	struct timespec ts;	1908	struct timespec ts;
…		…
1994	{	1994	{
1995	}	1995	}
1996		1996
1997	noinline	1997	noinline
1998	void	1998	void
1999	ev_feed_event (EV_P_ void *w, int revents) EV_THROW	1999	ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT
2000	{	2000	{
2001	W w_ = (W)w;	2001	W w_ = (W)w;
2002	int pri = ABSPRI (w_);	2002	int pri = ABSPRI (w_);
2003		2003
2004	if (expect_false (w_->pending))	2004	if (expect_false (w_->pending))
…		…
2065	if (expect_true (!anfd->reify))	2065	if (expect_true (!anfd->reify))
2066	fd_event_nocheck (EV_A_ fd, revents);	2066	fd_event_nocheck (EV_A_ fd, revents);
2067	}	2067	}
2068		2068
2069	void	2069	void
2070	ev_feed_fd_event (EV_P_ int fd, int revents) EV_THROW	2070	ev_feed_fd_event (EV_P_ int fd, int revents) EV_NOEXCEPT
2071	{	2071	{
2072	if (fd >= 0 && fd < anfdmax)	2072	if (fd >= 0 && fd < anfdmax)
2073	fd_event_nocheck (EV_A_ fd, revents);	2073	fd_event_nocheck (EV_A_ fd, revents);
2074	}	2074	}
2075		2075
…		…
2557	}	2557	}
2558		2558
2559	/*****************************************************************************/	2559	/*****************************************************************************/
2560		2560
2561	void	2561	void
2562	ev_feed_signal (int signum) EV_THROW	2562	ev_feed_signal (int signum) EV_NOEXCEPT
2563	{	2563	{
2564	#if EV_MULTIPLICITY	2564	#if EV_MULTIPLICITY
2565	EV_P;	2565	EV_P;
2566	ECB_MEMORY_FENCE_ACQUIRE;	2566	ECB_MEMORY_FENCE_ACQUIRE;
2567	EV_A = signals [signum - 1].loop;	2567	EV_A = signals [signum - 1].loop;
…		…
2584	ev_feed_signal (signum);	2584	ev_feed_signal (signum);
2585	}	2585	}
2586		2586
2587	noinline	2587	noinline
2588	void	2588	void
2589	ev_feed_signal_event (EV_P_ int signum) EV_THROW	2589	ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT
2590	{	2590	{
2591	WL w;	2591	WL w;
2592		2592
2593	if (expect_false (signum <= 0 \|\| signum >= EV_NSIG))	2593	if (expect_false (signum <= 0 \|\| signum >= EV_NSIG))
2594	return;	2594	return;
…		…
2711	#if EV_USE_SELECT	2711	#if EV_USE_SELECT
2712	# include "ev_select.c"	2712	# include "ev_select.c"
2713	#endif	2713	#endif
2714		2714
2715	ecb_cold int	2715	ecb_cold int
2716	ev_version_major (void) EV_THROW	2716	ev_version_major (void) EV_NOEXCEPT
2717	{	2717	{
2718	return EV_VERSION_MAJOR;	2718	return EV_VERSION_MAJOR;
2719	}	2719	}
2720		2720
2721	ecb_cold int	2721	ecb_cold int
2722	ev_version_minor (void) EV_THROW	2722	ev_version_minor (void) EV_NOEXCEPT
2723	{	2723	{
2724	return EV_VERSION_MINOR;	2724	return EV_VERSION_MINOR;
2725	}	2725	}
2726		2726
2727	/* return true if we are running with elevated privileges and should ignore env variables */	2727	/* return true if we are running with elevated privileges and should ignore env variables */
…		…
2736	#endif	2736	#endif
2737	}	2737	}
2738		2738
2739	ecb_cold	2739	ecb_cold
2740	unsigned int	2740	unsigned int
2741	ev_supported_backends (void) EV_THROW	2741	ev_supported_backends (void) EV_NOEXCEPT
2742	{	2742	{
2743	unsigned int flags = 0;	2743	unsigned int flags = 0;
2744		2744
2745	if (EV_USE_PORT ) flags \|= EVBACKEND_PORT;	2745	if (EV_USE_PORT ) flags \|= EVBACKEND_PORT;
2746	if (EV_USE_KQUEUE) flags \|= EVBACKEND_KQUEUE;	2746	if (EV_USE_KQUEUE) flags \|= EVBACKEND_KQUEUE;
…		…
2751	return flags;	2751	return flags;
2752	}	2752	}
2753		2753
2754	ecb_cold	2754	ecb_cold
2755	unsigned int	2755	unsigned int
2756	ev_recommended_backends (void) EV_THROW	2756	ev_recommended_backends (void) EV_NOEXCEPT
2757	{	2757	{
2758	unsigned int flags = ev_supported_backends ();	2758	unsigned int flags = ev_supported_backends ();
2759		2759
2760	#ifndef __NetBSD__	2760	#ifndef __NetBSD__
2761	/* kqueue is borked on everything but netbsd apparently */	2761	/* kqueue is borked on everything but netbsd apparently */
…		…
2774	return flags;	2774	return flags;
2775	}	2775	}
2776		2776
2777	ecb_cold	2777	ecb_cold
2778	unsigned int	2778	unsigned int
2779	ev_embeddable_backends (void) EV_THROW	2779	ev_embeddable_backends (void) EV_NOEXCEPT
2780	{	2780	{
2781	int flags = EVBACKEND_EPOLL \| EVBACKEND_KQUEUE \| EVBACKEND_PORT;	2781	int flags = EVBACKEND_EPOLL \| EVBACKEND_KQUEUE \| EVBACKEND_PORT;
2782		2782
2783	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */	2783	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */
2784	if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */	2784	if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
…		…
2786		2786
2787	return flags;	2787	return flags;
2788	}	2788	}
2789		2789
2790	unsigned int	2790	unsigned int
2791	ev_backend (EV_P) EV_THROW	2791	ev_backend (EV_P) EV_NOEXCEPT
2792	{	2792	{
2793	return backend;	2793	return backend;
2794	}	2794	}
2795		2795
2796	#if EV_FEATURE_API	2796	#if EV_FEATURE_API
2797	unsigned int	2797	unsigned int
2798	ev_iteration (EV_P) EV_THROW	2798	ev_iteration (EV_P) EV_NOEXCEPT
2799	{	2799	{
2800	return loop_count;	2800	return loop_count;
2801	}	2801	}
2802		2802
2803	unsigned int	2803	unsigned int
2804	ev_depth (EV_P) EV_THROW	2804	ev_depth (EV_P) EV_NOEXCEPT
2805	{	2805	{
2806	return loop_depth;	2806	return loop_depth;
2807	}	2807	}
2808		2808
2809	void	2809	void
2810	ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_THROW	2810	ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT
2811	{	2811	{
2812	io_blocktime = interval;	2812	io_blocktime = interval;
2813	}	2813	}
2814		2814
2815	void	2815	void
2816	ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_THROW	2816	ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT
2817	{	2817	{
2818	timeout_blocktime = interval;	2818	timeout_blocktime = interval;
2819	}	2819	}
2820		2820
2821	void	2821	void
2822	ev_set_userdata (EV_P_ void *data) EV_THROW	2822	ev_set_userdata (EV_P_ void *data) EV_NOEXCEPT
2823	{	2823	{
2824	userdata = data;	2824	userdata = data;
2825	}	2825	}
2826		2826
2827	void *	2827	void *
2828	ev_userdata (EV_P) EV_THROW	2828	ev_userdata (EV_P) EV_NOEXCEPT
2829	{	2829	{
2830	return userdata;	2830	return userdata;
2831	}	2831	}
2832		2832
2833	void	2833	void
2834	ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_THROW	2834	ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_NOEXCEPT
2835	{	2835	{
2836	invoke_cb = invoke_pending_cb;	2836	invoke_cb = invoke_pending_cb;
2837	}	2837	}
2838		2838
2839	void	2839	void
2840	ev_set_loop_release_cb (EV_P_ void (release)(EV_P) EV_THROW, void (acquire)(EV_P) EV_THROW) EV_THROW	2840	ev_set_loop_release_cb (EV_P_ void (release)(EV_P) EV_NOEXCEPT, void (acquire)(EV_P) EV_NOEXCEPT) EV_NOEXCEPT
2841	{	2841	{
2842	release_cb = release;	2842	release_cb = release;
2843	acquire_cb = acquire;	2843	acquire_cb = acquire;
2844	}	2844	}
2845	#endif	2845	#endif
2846		2846
2847	/* initialise a loop structure, must be zero-initialised */	2847	/* initialise a loop structure, must be zero-initialised */
2848	noinline ecb_cold	2848	noinline ecb_cold
2849	static void	2849	static void
2850	loop_init (EV_P_ unsigned int flags) EV_THROW	2850	loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT
2851	{	2851	{
2852	if (!backend)	2852	if (!backend)
2853	{	2853	{
2854	origflags = flags;	2854	origflags = flags;
2855		2855
…		…
3096		3096
3097	#if EV_MULTIPLICITY	3097	#if EV_MULTIPLICITY
3098		3098
3099	ecb_cold	3099	ecb_cold
3100	struct ev_loop *	3100	struct ev_loop *
3101	ev_loop_new (unsigned int flags) EV_THROW	3101	ev_loop_new (unsigned int flags) EV_NOEXCEPT
3102	{	3102	{
3103	EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));	3103	EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
3104		3104
3105	memset (EV_A, 0, sizeof (struct ev_loop));	3105	memset (EV_A, 0, sizeof (struct ev_loop));
3106	loop_init (EV_A_ flags);	3106	loop_init (EV_A_ flags);
…		…
3153	}	3153	}
3154	#endif	3154	#endif
3155		3155
3156	#if EV_FEATURE_API	3156	#if EV_FEATURE_API
3157	void ecb_cold	3157	void ecb_cold
3158	ev_verify (EV_P) EV_THROW	3158	ev_verify (EV_P) EV_NOEXCEPT
3159	{	3159	{
3160	#if EV_VERIFY	3160	#if EV_VERIFY
3161	int i;	3161	int i;
3162	WL w, w2;	3162	WL w, w2;
3163		3163
…		…
3244	ecb_cold	3244	ecb_cold
3245	struct ev_loop *	3245	struct ev_loop *
3246	#else	3246	#else
3247	int	3247	int
3248	#endif	3248	#endif
3249	ev_default_loop (unsigned int flags) EV_THROW	3249	ev_default_loop (unsigned int flags) EV_NOEXCEPT
3250	{	3250	{
3251	if (!ev_default_loop_ptr)	3251	if (!ev_default_loop_ptr)
3252	{	3252	{
3253	#if EV_MULTIPLICITY	3253	#if EV_MULTIPLICITY
3254	EV_P = ev_default_loop_ptr = &default_loop_struct;	3254	EV_P = ev_default_loop_ptr = &default_loop_struct;
…		…
3273		3273
3274	return ev_default_loop_ptr;	3274	return ev_default_loop_ptr;
3275	}	3275	}
3276		3276
3277	void	3277	void
3278	ev_loop_fork (EV_P) EV_THROW	3278	ev_loop_fork (EV_P) EV_NOEXCEPT
3279	{	3279	{
3280	postfork = 1;	3280	postfork = 1;
3281	}	3281	}
3282		3282
3283	/*****************************************************************************/	3283	/*****************************************************************************/
…		…
3287	{	3287	{
3288	EV_CB_INVOKE ((W)w, revents);	3288	EV_CB_INVOKE ((W)w, revents);
3289	}	3289	}
3290		3290
3291	unsigned int	3291	unsigned int
3292	ev_pending_count (EV_P) EV_THROW	3292	ev_pending_count (EV_P) EV_NOEXCEPT
3293	{	3293	{
3294	int pri;	3294	int pri;
3295	unsigned int count = 0;	3295	unsigned int count = 0;
3296		3296
3297	for (pri = NUMPRI; pri--; )	3297	for (pri = NUMPRI; pri--; )
…		…
3737		3737
3738	return activecnt;	3738	return activecnt;
3739	}	3739	}
3740		3740
3741	void	3741	void
3742	ev_break (EV_P_ int how) EV_THROW	3742	ev_break (EV_P_ int how) EV_NOEXCEPT
3743	{	3743	{
3744	loop_done = how;	3744	loop_done = how;
3745	}	3745	}
3746		3746
3747	void	3747	void
3748	ev_ref (EV_P) EV_THROW	3748	ev_ref (EV_P) EV_NOEXCEPT
3749	{	3749	{
3750	++activecnt;	3750	++activecnt;
3751	}	3751	}
3752		3752
3753	void	3753	void
3754	ev_unref (EV_P) EV_THROW	3754	ev_unref (EV_P) EV_NOEXCEPT
3755	{	3755	{
3756	--activecnt;	3756	--activecnt;
3757	}	3757	}
3758		3758
3759	void	3759	void
3760	ev_now_update (EV_P) EV_THROW	3760	ev_now_update (EV_P) EV_NOEXCEPT
3761	{	3761	{
3762	time_update (EV_A_ 1e100);	3762	time_update (EV_A_ 1e100);
3763	}	3763	}
3764		3764
3765	void	3765	void
3766	ev_suspend (EV_P) EV_THROW	3766	ev_suspend (EV_P) EV_NOEXCEPT
3767	{	3767	{
3768	ev_now_update (EV_A);	3768	ev_now_update (EV_A);
3769	}	3769	}
3770		3770
3771	void	3771	void
3772	ev_resume (EV_P) EV_THROW	3772	ev_resume (EV_P) EV_NOEXCEPT
3773	{	3773	{
3774	ev_tstamp mn_prev = mn_now;	3774	ev_tstamp mn_prev = mn_now;
3775		3775
3776	ev_now_update (EV_A);	3776	ev_now_update (EV_A);
3777	timers_reschedule (EV_A_ mn_now - mn_prev);	3777	timers_reschedule (EV_A_ mn_now - mn_prev);
…		…
3816	w->pending = 0;	3816	w->pending = 0;
3817	}	3817	}
3818	}	3818	}
3819		3819
3820	int	3820	int
3821	ev_clear_pending (EV_P_ void *w) EV_THROW	3821	ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT
3822	{	3822	{
3823	W w_ = (W)w;	3823	W w_ = (W)w;
3824	int pending = w_->pending;	3824	int pending = w_->pending;
3825		3825
3826	if (expect_true (pending))	3826	if (expect_true (pending))
…		…
3860		3860
3861	/*****************************************************************************/	3861	/*****************************************************************************/
3862		3862
3863	noinline	3863	noinline
3864	void	3864	void
3865	ev_io_start (EV_P_ ev_io *w) EV_THROW	3865	ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT
3866	{	3866	{
3867	int fd = w->fd;	3867	int fd = w->fd;
3868		3868
3869	if (expect_false (ev_is_active (w)))	3869	if (expect_false (ev_is_active (w)))
3870	return;	3870	return;
…		…
3887	EV_FREQUENT_CHECK;	3887	EV_FREQUENT_CHECK;
3888	}	3888	}
3889		3889
3890	noinline	3890	noinline
3891	void	3891	void
3892	ev_io_stop (EV_P_ ev_io *w) EV_THROW	3892	ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT
3893	{	3893	{
3894	clear_pending (EV_A_ (W)w);	3894	clear_pending (EV_A_ (W)w);
3895	if (expect_false (!ev_is_active (w)))	3895	if (expect_false (!ev_is_active (w)))
3896	return;	3896	return;
3897		3897
…		…
3907	EV_FREQUENT_CHECK;	3907	EV_FREQUENT_CHECK;
3908	}	3908	}
3909		3909
3910	noinline	3910	noinline
3911	void	3911	void
3912	ev_timer_start (EV_P_ ev_timer *w) EV_THROW	3912	ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT
3913	{	3913	{
3914	if (expect_false (ev_is_active (w)))	3914	if (expect_false (ev_is_active (w)))
3915	return;	3915	return;
3916		3916
3917	ev_at (w) += mn_now;	3917	ev_at (w) += mn_now;
…		…
3932	/assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));/	3932	/assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));/
3933	}	3933	}
3934		3934
3935	noinline	3935	noinline
3936	void	3936	void
3937	ev_timer_stop (EV_P_ ev_timer *w) EV_THROW	3937	ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT
3938	{	3938	{
3939	clear_pending (EV_A_ (W)w);	3939	clear_pending (EV_A_ (W)w);
3940	if (expect_false (!ev_is_active (w)))	3940	if (expect_false (!ev_is_active (w)))
3941	return;	3941	return;
3942		3942
…		…
3963	EV_FREQUENT_CHECK;	3963	EV_FREQUENT_CHECK;
3964	}	3964	}
3965		3965
3966	noinline	3966	noinline
3967	void	3967	void
3968	ev_timer_again (EV_P_ ev_timer *w) EV_THROW	3968	ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT
3969	{	3969	{
3970	EV_FREQUENT_CHECK;	3970	EV_FREQUENT_CHECK;
3971		3971
3972	clear_pending (EV_A_ (W)w);	3972	clear_pending (EV_A_ (W)w);
3973		3973
…		…
3990		3990
3991	EV_FREQUENT_CHECK;	3991	EV_FREQUENT_CHECK;
3992	}	3992	}
3993		3993
3994	ev_tstamp	3994	ev_tstamp
3995	ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW	3995	ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT
3996	{	3996	{
3997	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);	3997	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
3998	}	3998	}
3999		3999
4000	#if EV_PERIODIC_ENABLE	4000	#if EV_PERIODIC_ENABLE
4001	noinline	4001	noinline
4002	void	4002	void
4003	ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW	4003	ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT
4004	{	4004	{
4005	if (expect_false (ev_is_active (w)))	4005	if (expect_false (ev_is_active (w)))
4006	return;	4006	return;
4007		4007
4008	if (w->reschedule_cb)	4008	if (w->reschedule_cb)
…		…
4029	/assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));/	4029	/assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));/
4030	}	4030	}
4031		4031
4032	noinline	4032	noinline
4033	void	4033	void
4034	ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW	4034	ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT
4035	{	4035	{
4036	clear_pending (EV_A_ (W)w);	4036	clear_pending (EV_A_ (W)w);
4037	if (expect_false (!ev_is_active (w)))	4037	if (expect_false (!ev_is_active (w)))
4038	return;	4038	return;
4039		4039
…		…
4058	EV_FREQUENT_CHECK;	4058	EV_FREQUENT_CHECK;
4059	}	4059	}
4060		4060
4061	noinline	4061	noinline
4062	void	4062	void
4063	ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW	4063	ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT
4064	{	4064	{
4065	/* TODO: use adjustheap and recalculation */	4065	/* TODO: use adjustheap and recalculation */
4066	ev_periodic_stop (EV_A_ w);	4066	ev_periodic_stop (EV_A_ w);
4067	ev_periodic_start (EV_A_ w);	4067	ev_periodic_start (EV_A_ w);
4068	}	4068	}
…		…
4074		4074
4075	#if EV_SIGNAL_ENABLE	4075	#if EV_SIGNAL_ENABLE
4076		4076
4077	noinline	4077	noinline
4078	void	4078	void
4079	ev_signal_start (EV_P_ ev_signal *w) EV_THROW	4079	ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT
4080	{	4080	{
4081	if (expect_false (ev_is_active (w)))	4081	if (expect_false (ev_is_active (w)))
4082	return;	4082	return;
4083		4083
4084	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));	4084	assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
…		…
4157	EV_FREQUENT_CHECK;	4157	EV_FREQUENT_CHECK;
4158	}	4158	}
4159		4159
4160	noinline	4160	noinline
4161	void	4161	void
4162	ev_signal_stop (EV_P_ ev_signal *w) EV_THROW	4162	ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT
4163	{	4163	{
4164	clear_pending (EV_A_ (W)w);	4164	clear_pending (EV_A_ (W)w);
4165	if (expect_false (!ev_is_active (w)))	4165	if (expect_false (!ev_is_active (w)))
4166	return;	4166	return;
4167		4167
…		…
4198	#endif	4198	#endif
4199		4199
4200	#if EV_CHILD_ENABLE	4200	#if EV_CHILD_ENABLE
4201		4201
4202	void	4202	void
4203	ev_child_start (EV_P_ ev_child *w) EV_THROW	4203	ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT
4204	{	4204	{
4205	#if EV_MULTIPLICITY	4205	#if EV_MULTIPLICITY
4206	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));	4206	assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
4207	#endif	4207	#endif
4208	if (expect_false (ev_is_active (w)))	4208	if (expect_false (ev_is_active (w)))
…		…
4215		4215
4216	EV_FREQUENT_CHECK;	4216	EV_FREQUENT_CHECK;
4217	}	4217	}
4218		4218
4219	void	4219	void
4220	ev_child_stop (EV_P_ ev_child *w) EV_THROW	4220	ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT
4221	{	4221	{
4222	clear_pending (EV_A_ (W)w);	4222	clear_pending (EV_A_ (W)w);
4223	if (expect_false (!ev_is_active (w)))	4223	if (expect_false (!ev_is_active (w)))
4224	return;	4224	return;
4225		4225
…		…
4490	#else	4490	#else
4491	# define EV_LSTAT(p,b) lstat (p, b)	4491	# define EV_LSTAT(p,b) lstat (p, b)
4492	#endif	4492	#endif
4493		4493
4494	void	4494	void
4495	ev_stat_stat (EV_P_ ev_stat *w) EV_THROW	4495	ev_stat_stat (EV_P_ ev_stat *w) EV_NOEXCEPT
4496	{	4496	{
4497	if (lstat (w->path, &w->attr) < 0)	4497	if (lstat (w->path, &w->attr) < 0)
4498	w->attr.st_nlink = 0;	4498	w->attr.st_nlink = 0;
4499	else if (!w->attr.st_nlink)	4499	else if (!w->attr.st_nlink)
4500	w->attr.st_nlink = 1;	4500	w->attr.st_nlink = 1;
…		…
4540	ev_feed_event (EV_A_ w, EV_STAT);	4540	ev_feed_event (EV_A_ w, EV_STAT);
4541	}	4541	}
4542	}	4542	}
4543		4543
4544	void	4544	void
4545	ev_stat_start (EV_P_ ev_stat *w) EV_THROW	4545	ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT
4546	{	4546	{
4547	if (expect_false (ev_is_active (w)))	4547	if (expect_false (ev_is_active (w)))
4548	return;	4548	return;
4549		4549
4550	ev_stat_stat (EV_A_ w);	4550	ev_stat_stat (EV_A_ w);
…		…
4571		4571
4572	EV_FREQUENT_CHECK;	4572	EV_FREQUENT_CHECK;
4573	}	4573	}
4574		4574
4575	void	4575	void
4576	ev_stat_stop (EV_P_ ev_stat *w) EV_THROW	4576	ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT
4577	{	4577	{
4578	clear_pending (EV_A_ (W)w);	4578	clear_pending (EV_A_ (W)w);
4579	if (expect_false (!ev_is_active (w)))	4579	if (expect_false (!ev_is_active (w)))
4580	return;	4580	return;
4581		4581
…		…
4597	}	4597	}
4598	#endif	4598	#endif
4599		4599
4600	#if EV_IDLE_ENABLE	4600	#if EV_IDLE_ENABLE
4601	void	4601	void
4602	ev_idle_start (EV_P_ ev_idle *w) EV_THROW	4602	ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT
4603	{	4603	{
4604	if (expect_false (ev_is_active (w)))	4604	if (expect_false (ev_is_active (w)))
4605	return;	4605	return;
4606		4606
4607	pri_adjust (EV_A_ (W)w);	4607	pri_adjust (EV_A_ (W)w);
…		…
4620		4620
4621	EV_FREQUENT_CHECK;	4621	EV_FREQUENT_CHECK;
4622	}	4622	}
4623		4623
4624	void	4624	void
4625	ev_idle_stop (EV_P_ ev_idle *w) EV_THROW	4625	ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT
4626	{	4626	{
4627	clear_pending (EV_A_ (W)w);	4627	clear_pending (EV_A_ (W)w);
4628	if (expect_false (!ev_is_active (w)))	4628	if (expect_false (!ev_is_active (w)))
4629	return;	4629	return;
4630		4630
…		…
4644	}	4644	}
4645	#endif	4645	#endif
4646		4646
4647	#if EV_PREPARE_ENABLE	4647	#if EV_PREPARE_ENABLE
4648	void	4648	void
4649	ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW	4649	ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT
4650	{	4650	{
4651	if (expect_false (ev_is_active (w)))	4651	if (expect_false (ev_is_active (w)))
4652	return;	4652	return;
4653		4653
4654	EV_FREQUENT_CHECK;	4654	EV_FREQUENT_CHECK;
…		…
4659		4659
4660	EV_FREQUENT_CHECK;	4660	EV_FREQUENT_CHECK;
4661	}	4661	}
4662		4662
4663	void	4663	void
4664	ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW	4664	ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT
4665	{	4665	{
4666	clear_pending (EV_A_ (W)w);	4666	clear_pending (EV_A_ (W)w);
4667	if (expect_false (!ev_is_active (w)))	4667	if (expect_false (!ev_is_active (w)))
4668	return;	4668	return;
4669		4669
…		…
4682	}	4682	}
4683	#endif	4683	#endif
4684		4684
4685	#if EV_CHECK_ENABLE	4685	#if EV_CHECK_ENABLE
4686	void	4686	void
4687	ev_check_start (EV_P_ ev_check *w) EV_THROW	4687	ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT
4688	{	4688	{
4689	if (expect_false (ev_is_active (w)))	4689	if (expect_false (ev_is_active (w)))
4690	return;	4690	return;
4691		4691
4692	EV_FREQUENT_CHECK;	4692	EV_FREQUENT_CHECK;
…		…
4697		4697
4698	EV_FREQUENT_CHECK;	4698	EV_FREQUENT_CHECK;
4699	}	4699	}
4700		4700
4701	void	4701	void
4702	ev_check_stop (EV_P_ ev_check *w) EV_THROW	4702	ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT
4703	{	4703	{
4704	clear_pending (EV_A_ (W)w);	4704	clear_pending (EV_A_ (W)w);
4705	if (expect_false (!ev_is_active (w)))	4705	if (expect_false (!ev_is_active (w)))
4706	return;	4706	return;
4707		4707
…		…
4721	#endif	4721	#endif
4722		4722
4723	#if EV_EMBED_ENABLE	4723	#if EV_EMBED_ENABLE
4724	noinline	4724	noinline
4725	void	4725	void
4726	ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW	4726	ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT
4727	{	4727	{
4728	ev_run (w->other, EVRUN_NOWAIT);	4728	ev_run (w->other, EVRUN_NOWAIT);
4729	}	4729	}
4730		4730
4731	static void	4731	static void
…		…
4779	ev_idle_stop (EV_A_ idle);	4779	ev_idle_stop (EV_A_ idle);
4780	}	4780	}
4781	#endif	4781	#endif
4782		4782
4783	void	4783	void
4784	ev_embed_start (EV_P_ ev_embed *w) EV_THROW	4784	ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT
4785	{	4785	{
4786	if (expect_false (ev_is_active (w)))	4786	if (expect_false (ev_is_active (w)))
4787	return;	4787	return;
4788		4788
4789	{	4789	{
…		…
4810		4810
4811	EV_FREQUENT_CHECK;	4811	EV_FREQUENT_CHECK;
4812	}	4812	}
4813		4813
4814	void	4814	void
4815	ev_embed_stop (EV_P_ ev_embed *w) EV_THROW	4815	ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT
4816	{	4816	{
4817	clear_pending (EV_A_ (W)w);	4817	clear_pending (EV_A_ (W)w);
4818	if (expect_false (!ev_is_active (w)))	4818	if (expect_false (!ev_is_active (w)))
4819	return;	4819	return;
4820		4820
…		…
4830	}	4830	}
4831	#endif	4831	#endif
4832		4832
4833	#if EV_FORK_ENABLE	4833	#if EV_FORK_ENABLE
4834	void	4834	void
4835	ev_fork_start (EV_P_ ev_fork *w) EV_THROW	4835	ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT
4836	{	4836	{
4837	if (expect_false (ev_is_active (w)))	4837	if (expect_false (ev_is_active (w)))
4838	return;	4838	return;
4839		4839
4840	EV_FREQUENT_CHECK;	4840	EV_FREQUENT_CHECK;
…		…
4845		4845
4846	EV_FREQUENT_CHECK;	4846	EV_FREQUENT_CHECK;
4847	}	4847	}
4848		4848
4849	void	4849	void
4850	ev_fork_stop (EV_P_ ev_fork *w) EV_THROW	4850	ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT
4851	{	4851	{
4852	clear_pending (EV_A_ (W)w);	4852	clear_pending (EV_A_ (W)w);
4853	if (expect_false (!ev_is_active (w)))	4853	if (expect_false (!ev_is_active (w)))
4854	return;	4854	return;
4855		4855
…		…
4868	}	4868	}
4869	#endif	4869	#endif
4870		4870
4871	#if EV_CLEANUP_ENABLE	4871	#if EV_CLEANUP_ENABLE
4872	void	4872	void
4873	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW	4873	ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4874	{	4874	{
4875	if (expect_false (ev_is_active (w)))	4875	if (expect_false (ev_is_active (w)))
4876	return;	4876	return;
4877		4877
4878	EV_FREQUENT_CHECK;	4878	EV_FREQUENT_CHECK;
…		…
4885	ev_unref (EV_A);	4885	ev_unref (EV_A);
4886	EV_FREQUENT_CHECK;	4886	EV_FREQUENT_CHECK;
4887	}	4887	}
4888		4888
4889	void	4889	void
4890	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW	4890	ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4891	{	4891	{
4892	clear_pending (EV_A_ (W)w);	4892	clear_pending (EV_A_ (W)w);
4893	if (expect_false (!ev_is_active (w)))	4893	if (expect_false (!ev_is_active (w)))
4894	return;	4894	return;
4895		4895
…		…
4909	}	4909	}
4910	#endif	4910	#endif
4911		4911
4912	#if EV_ASYNC_ENABLE	4912	#if EV_ASYNC_ENABLE
4913	void	4913	void
4914	ev_async_start (EV_P_ ev_async *w) EV_THROW	4914	ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT
4915	{	4915	{
4916	if (expect_false (ev_is_active (w)))	4916	if (expect_false (ev_is_active (w)))
4917	return;	4917	return;
4918		4918
4919	w->sent = 0;	4919	w->sent = 0;
…		…
4928		4928
4929	EV_FREQUENT_CHECK;	4929	EV_FREQUENT_CHECK;
4930	}	4930	}
4931		4931
4932	void	4932	void
4933	ev_async_stop (EV_P_ ev_async *w) EV_THROW	4933	ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT
4934	{	4934	{
4935	clear_pending (EV_A_ (W)w);	4935	clear_pending (EV_A_ (W)w);
4936	if (expect_false (!ev_is_active (w)))	4936	if (expect_false (!ev_is_active (w)))
4937	return;	4937	return;
4938		4938
…		…
4949		4949
4950	EV_FREQUENT_CHECK;	4950	EV_FREQUENT_CHECK;
4951	}	4951	}
4952		4952
4953	void	4953	void
4954	ev_async_send (EV_P_ ev_async *w) EV_THROW	4954	ev_async_send (EV_P_ ev_async *w) EV_NOEXCEPT
4955	{	4955	{
4956	w->sent = 1;	4956	w->sent = 1;
4957	evpipe_write (EV_A_ &async_pending);	4957	evpipe_write (EV_A_ &async_pending);
4958	}	4958	}
4959	#endif	4959	#endif
…		…
4996		4996
4997	once_cb (EV_A_ once, revents \| ev_clear_pending (EV_A_ &once->io));	4997	once_cb (EV_A_ once, revents \| ev_clear_pending (EV_A_ &once->io));
4998	}	4998	}
4999		4999
5000	void	5000	void
5001	ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (cb)(int revents, void arg), void *arg) EV_THROW	5001	ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (cb)(int revents, void arg), void *arg) EV_NOEXCEPT
5002	{	5002	{
5003	struct ev_once once = (struct ev_once )ev_malloc (sizeof (struct ev_once));	5003	struct ev_once once = (struct ev_once )ev_malloc (sizeof (struct ev_once));
5004		5004
5005	if (expect_false (!once))	5005	if (expect_false (!once))
5006	{	5006	{
…		…
5029	/*****************************************************************************/	5029	/*****************************************************************************/
5030		5030
5031	#if EV_WALK_ENABLE	5031	#if EV_WALK_ENABLE
5032	ecb_cold	5032	ecb_cold
5033	void	5033	void
5034	ev_walk (EV_P_ int types, void (cb)(EV_P_ int type, void w)) EV_THROW	5034	ev_walk (EV_P_ int types, void (cb)(EV_P_ int type, void w)) EV_NOEXCEPT
5035	{	5035	{
5036	int i, j;	5036	int i, j;
5037	ev_watcher_list wl, wn;	5037	ev_watcher_list wl, wn;
5038		5038
5039	if (types & (EV_IO \| EV_EMBED))	5039	if (types & (EV_IO \| EV_EMBED))

Diff Legend

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

Comparing libev/ev.c (file contents): Revision 1.485 by root, Mon Aug 13 10:01:19 2018 UTC vs. Revision 1.486 by root, Thu Oct 25 03:11:04 2018 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.485 by root, Mon Aug 13 10:01:19 2018 UTC vs.
Revision 1.486 by root, Thu Oct 25 03:11:04 2018 UTC