ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.c
(Generate patch)

Comparing libev/ev.c (file contents):
Revision 1.483 by root, Tue Jul 31 04:45:58 2018 UTC vs.
Revision 1.487 by root, Mon Oct 29 00:00:21 2018 UTC

1/* 1/*
2 * libev event processing core, watcher management 2 * libev event processing core, watcher management
3 * 3 *
4 * Copyright (c) 2007,2008,2009,2010,2011,2012,2013 Marc Alexander Lehmann <libev@schmorp.de> 4 * Copyright (c) 2007-2018 Marc Alexander Lehmann <libev@schmorp.de>
5 * All rights reserved. 5 * All rights reserved.
6 * 6 *
7 * Redistribution and use in source and binary forms, with or without modifica- 7 * Redistribution and use in source and binary forms, with or without modifica-
8 * tion, are permitted provided that the following conditions are met: 8 * tion, are permitted provided that the following conditions are met:
9 * 9 *
… …
1677{ 1677{
1678 write (STDERR_FILENO, msg, strlen (msg)); 1678 write (STDERR_FILENO, msg, strlen (msg));
1679} 1679}
1680#endif 1680#endif
1681 1681
1682static void (*syserr_cb)(const char *msg) EV_THROW; 1682static void (*syserr_cb)(const char *msg) EV_NOEXCEPT;
1683 1683
1684ecb_cold 1684ecb_cold
1685void 1685void
1686ev_set_syserr_cb (void (*cb)(const char *msg) EV_THROW) EV_THROW 1686ev_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
1691noinline ecb_cold 1691noinline ecb_cold
… …
1710 abort (); 1710 abort ();
1711 } 1711 }
1712} 1712}
1713 1713
1714static void * 1714static void *
1715ev_realloc_emul (void *ptr, long size) EV_THROW 1715ev_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
1731static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul; 1731static void *(*alloc)(void *ptr, long size) EV_NOEXCEPT = ev_realloc_emul;
1732 1732
1733ecb_cold 1733ecb_cold
1734void 1734void
1735ev_set_allocator (void *(*cb)(void *ptr, long size) EV_THROW) EV_THROW 1735ev_set_allocator (void *(*cb)(void *ptr, long size) EV_NOEXCEPT) EV_NOEXCEPT
1736{ 1736{
1737 alloc = cb; 1737 alloc = cb;
1738} 1738}
1739 1739
1740inline_speed void * 1740inline_speed void *
… …
1857 1857
1858/*****************************************************************************/ 1858/*****************************************************************************/
1859 1859
1860#ifndef EV_HAVE_EV_TIME 1860#ifndef EV_HAVE_EV_TIME
1861ev_tstamp 1861ev_tstamp
1862ev_time (void) EV_THROW 1862ev_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
1895ev_tstamp 1895ev_tstamp
1896ev_now (EV_P) EV_THROW 1896ev_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
1902void 1902void
1903ev_sleep (ev_tstamp delay) EV_THROW 1903ev_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
1997noinline 1997noinline
1998void 1998void
1999ev_feed_event (EV_P_ void *w, int revents) EV_THROW 1999ev_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
2069void 2069void
2070ev_feed_fd_event (EV_P_ int fd, int revents) EV_THROW 2070ev_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
… …
2475#endif 2475#endif
2476 { 2476 {
2477#ifdef _WIN32 2477#ifdef _WIN32
2478 WSABUF buf; 2478 WSABUF buf;
2479 DWORD sent; 2479 DWORD sent;
2480 buf.buf = &buf; 2480 buf.buf = (char *)&buf;
2481 buf.len = 1; 2481 buf.len = 1;
2482 WSASend (EV_FD_TO_WIN32_HANDLE (evpipe [1]), &buf, 1, &sent, 0, 0, 0); 2482 WSASend (EV_FD_TO_WIN32_HANDLE (evpipe [1]), &buf, 1, &sent, 0, 0, 0);
2483#else 2483#else
2484 write (evpipe [1], &(evpipe [1]), 1); 2484 write (evpipe [1], &(evpipe [1]), 1);
2485#endif 2485#endif
… …
2557} 2557}
2558 2558
2559/*****************************************************************************/ 2559/*****************************************************************************/
2560 2560
2561void 2561void
2562ev_feed_signal (int signum) EV_THROW 2562ev_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
2587noinline 2587noinline
2588void 2588void
2589ev_feed_signal_event (EV_P_ int signum) EV_THROW 2589ev_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
2715ecb_cold int 2715ecb_cold int
2716ev_version_major (void) EV_THROW 2716ev_version_major (void) EV_NOEXCEPT
2717{ 2717{
2718 return EV_VERSION_MAJOR; 2718 return EV_VERSION_MAJOR;
2719} 2719}
2720 2720
2721ecb_cold int 2721ecb_cold int
2722ev_version_minor (void) EV_THROW 2722ev_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
2739ecb_cold 2739ecb_cold
2740unsigned int 2740unsigned int
2741ev_supported_backends (void) EV_THROW 2741ev_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
2754ecb_cold 2754ecb_cold
2755unsigned int 2755unsigned int
2756ev_recommended_backends (void) EV_THROW 2756ev_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
2777ecb_cold 2777ecb_cold
2778unsigned int 2778unsigned int
2779ev_embeddable_backends (void) EV_THROW 2779ev_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
2790unsigned int 2790unsigned int
2791ev_backend (EV_P) EV_THROW 2791ev_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
2797unsigned int 2797unsigned int
2798ev_iteration (EV_P) EV_THROW 2798ev_iteration (EV_P) EV_NOEXCEPT
2799{ 2799{
2800 return loop_count; 2800 return loop_count;
2801} 2801}
2802 2802
2803unsigned int 2803unsigned int
2804ev_depth (EV_P) EV_THROW 2804ev_depth (EV_P) EV_NOEXCEPT
2805{ 2805{
2806 return loop_depth; 2806 return loop_depth;
2807} 2807}
2808 2808
2809void 2809void
2810ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_THROW 2810ev_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
2815void 2815void
2816ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_THROW 2816ev_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
2821void 2821void
2822ev_set_userdata (EV_P_ void *data) EV_THROW 2822ev_set_userdata (EV_P_ void *data) EV_NOEXCEPT
2823{ 2823{
2824 userdata = data; 2824 userdata = data;
2825} 2825}
2826 2826
2827void * 2827void *
2828ev_userdata (EV_P) EV_THROW 2828ev_userdata (EV_P) EV_NOEXCEPT
2829{ 2829{
2830 return userdata; 2830 return userdata;
2831} 2831}
2832 2832
2833void 2833void
2834ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_THROW 2834ev_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
2839void 2839void
2840ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV_P) EV_THROW) EV_THROW 2840ev_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 */
2848noinline ecb_cold 2848noinline ecb_cold
2849static void 2849static void
2850loop_init (EV_P_ unsigned int flags) EV_THROW 2850loop_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
3099ecb_cold 3099ecb_cold
3100struct ev_loop * 3100struct ev_loop *
3101ev_loop_new (unsigned int flags) EV_THROW 3101ev_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
3157void ecb_cold 3157void ecb_cold
3158ev_verify (EV_P) EV_THROW 3158ev_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
… …
3244ecb_cold 3244ecb_cold
3245struct ev_loop * 3245struct ev_loop *
3246#else 3246#else
3247int 3247int
3248#endif 3248#endif
3249ev_default_loop (unsigned int flags) EV_THROW 3249ev_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
3277void 3277void
3278ev_loop_fork (EV_P) EV_THROW 3278ev_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
3291unsigned int 3291unsigned int
3292ev_pending_count (EV_P) EV_THROW 3292ev_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--; )
… …
3304void 3304void
3305ev_invoke_pending (EV_P) 3305ev_invoke_pending (EV_P)
3306{ 3306{
3307 pendingpri = NUMPRI; 3307 pendingpri = NUMPRI;
3308 3308
3309 while (pendingpri) /* pendingpri possibly gets modified in the inner loop */ 3309 do
3310 { 3310 {
3311 --pendingpri; 3311 --pendingpri;
3312 3312
3313 /* pendingpri possibly gets modified in the inner loop */
3313 while (pendingcnt [pendingpri]) 3314 while (pendingcnt [pendingpri])
3314 { 3315 {
3315 ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri]; 3316 ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri];
3316 3317
3317 p->w->pending = 0; 3318 p->w->pending = 0;
3318 EV_CB_INVOKE (p->w, p->events); 3319 EV_CB_INVOKE (p->w, p->events);
3319 EV_FREQUENT_CHECK; 3320 EV_FREQUENT_CHECK;
3320 } 3321 }
3321 } 3322 }
3323 while (pendingpri);
3322} 3324}
3323 3325
3324#if EV_IDLE_ENABLE 3326#if EV_IDLE_ENABLE
3325/* make idle watchers pending. this handles the "call-idle */ 3327/* make idle watchers pending. this handles the "call-idle */
3326/* only when higher priorities are idle" logic */ 3328/* only when higher priorities are idle" logic */
… …
3735 3737
3736 return activecnt; 3738 return activecnt;
3737} 3739}
3738 3740
3739void 3741void
3740ev_break (EV_P_ int how) EV_THROW 3742ev_break (EV_P_ int how) EV_NOEXCEPT
3741{ 3743{
3742 loop_done = how; 3744 loop_done = how;
3743} 3745}
3744 3746
3745void 3747void
3746ev_ref (EV_P) EV_THROW 3748ev_ref (EV_P) EV_NOEXCEPT
3747{ 3749{
3748 ++activecnt; 3750 ++activecnt;
3749} 3751}
3750 3752
3751void 3753void
3752ev_unref (EV_P) EV_THROW 3754ev_unref (EV_P) EV_NOEXCEPT
3753{ 3755{
3754 --activecnt; 3756 --activecnt;
3755} 3757}
3756 3758
3757void 3759void
3758ev_now_update (EV_P) EV_THROW 3760ev_now_update (EV_P) EV_NOEXCEPT
3759{ 3761{
3760 time_update (EV_A_ 1e100); 3762 time_update (EV_A_ 1e100);
3761} 3763}
3762 3764
3763void 3765void
3764ev_suspend (EV_P) EV_THROW 3766ev_suspend (EV_P) EV_NOEXCEPT
3765{ 3767{
3766 ev_now_update (EV_A); 3768 ev_now_update (EV_A);
3767} 3769}
3768 3770
3769void 3771void
3770ev_resume (EV_P) EV_THROW 3772ev_resume (EV_P) EV_NOEXCEPT
3771{ 3773{
3772 ev_tstamp mn_prev = mn_now; 3774 ev_tstamp mn_prev = mn_now;
3773 3775
3774 ev_now_update (EV_A); 3776 ev_now_update (EV_A);
3775 timers_reschedule (EV_A_ mn_now - mn_prev); 3777 timers_reschedule (EV_A_ mn_now - mn_prev);
… …
3814 w->pending = 0; 3816 w->pending = 0;
3815 } 3817 }
3816} 3818}
3817 3819
3818int 3820int
3819ev_clear_pending (EV_P_ void *w) EV_THROW 3821ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT
3820{ 3822{
3821 W w_ = (W)w; 3823 W w_ = (W)w;
3822 int pending = w_->pending; 3824 int pending = w_->pending;
3823 3825
3824 if (expect_true (pending)) 3826 if (expect_true (pending))
… …
3858 3860
3859/*****************************************************************************/ 3861/*****************************************************************************/
3860 3862
3861noinline 3863noinline
3862void 3864void
3863ev_io_start (EV_P_ ev_io *w) EV_THROW 3865ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT
3864{ 3866{
3865 int fd = w->fd; 3867 int fd = w->fd;
3866 3868
3867 if (expect_false (ev_is_active (w))) 3869 if (expect_false (ev_is_active (w)))
3868 return; 3870 return;
… …
3885 EV_FREQUENT_CHECK; 3887 EV_FREQUENT_CHECK;
3886} 3888}
3887 3889
3888noinline 3890noinline
3889void 3891void
3890ev_io_stop (EV_P_ ev_io *w) EV_THROW 3892ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT
3891{ 3893{
3892 clear_pending (EV_A_ (W)w); 3894 clear_pending (EV_A_ (W)w);
3893 if (expect_false (!ev_is_active (w))) 3895 if (expect_false (!ev_is_active (w)))
3894 return; 3896 return;
3895 3897
… …
3905 EV_FREQUENT_CHECK; 3907 EV_FREQUENT_CHECK;
3906} 3908}
3907 3909
3908noinline 3910noinline
3909void 3911void
3910ev_timer_start (EV_P_ ev_timer *w) EV_THROW 3912ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT
3911{ 3913{
3912 if (expect_false (ev_is_active (w))) 3914 if (expect_false (ev_is_active (w)))
3913 return; 3915 return;
3914 3916
3915 ev_at (w) += mn_now; 3917 ev_at (w) += mn_now;
… …
3930 /*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));*/
3931} 3933}
3932 3934
3933noinline 3935noinline
3934void 3936void
3935ev_timer_stop (EV_P_ ev_timer *w) EV_THROW 3937ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT
3936{ 3938{
3937 clear_pending (EV_A_ (W)w); 3939 clear_pending (EV_A_ (W)w);
3938 if (expect_false (!ev_is_active (w))) 3940 if (expect_false (!ev_is_active (w)))
3939 return; 3941 return;
3940 3942
… …
3961 EV_FREQUENT_CHECK; 3963 EV_FREQUENT_CHECK;
3962} 3964}
3963 3965
3964noinline 3966noinline
3965void 3967void
3966ev_timer_again (EV_P_ ev_timer *w) EV_THROW 3968ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT
3967{ 3969{
3968 EV_FREQUENT_CHECK; 3970 EV_FREQUENT_CHECK;
3969 3971
3970 clear_pending (EV_A_ (W)w); 3972 clear_pending (EV_A_ (W)w);
3971 3973
… …
3988 3990
3989 EV_FREQUENT_CHECK; 3991 EV_FREQUENT_CHECK;
3990} 3992}
3991 3993
3992ev_tstamp 3994ev_tstamp
3993ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW 3995ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT
3994{ 3996{
3995 return ev_at (w) - (ev_is_active (w) ? mn_now : 0.); 3997 return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
3996} 3998}
3997 3999
3998#if EV_PERIODIC_ENABLE 4000#if EV_PERIODIC_ENABLE
3999noinline 4001noinline
4000void 4002void
4001ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW 4003ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT
4002{ 4004{
4003 if (expect_false (ev_is_active (w))) 4005 if (expect_false (ev_is_active (w)))
4004 return; 4006 return;
4005 4007
4006 if (w->reschedule_cb) 4008 if (w->reschedule_cb)
… …
4027 /*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));*/
4028} 4030}
4029 4031
4030noinline 4032noinline
4031void 4033void
4032ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW 4034ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT
4033{ 4035{
4034 clear_pending (EV_A_ (W)w); 4036 clear_pending (EV_A_ (W)w);
4035 if (expect_false (!ev_is_active (w))) 4037 if (expect_false (!ev_is_active (w)))
4036 return; 4038 return;
4037 4039
… …
4056 EV_FREQUENT_CHECK; 4058 EV_FREQUENT_CHECK;
4057} 4059}
4058 4060
4059noinline 4061noinline
4060void 4062void
4061ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW 4063ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT
4062{ 4064{
4063 /* TODO: use adjustheap and recalculation */ 4065 /* TODO: use adjustheap and recalculation */
4064 ev_periodic_stop (EV_A_ w); 4066 ev_periodic_stop (EV_A_ w);
4065 ev_periodic_start (EV_A_ w); 4067 ev_periodic_start (EV_A_ w);
4066} 4068}
… …
4072 4074
4073#if EV_SIGNAL_ENABLE 4075#if EV_SIGNAL_ENABLE
4074 4076
4075noinline 4077noinline
4076void 4078void
4077ev_signal_start (EV_P_ ev_signal *w) EV_THROW 4079ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT
4078{ 4080{
4079 if (expect_false (ev_is_active (w))) 4081 if (expect_false (ev_is_active (w)))
4080 return; 4082 return;
4081 4083
4082 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));
… …
4155 EV_FREQUENT_CHECK; 4157 EV_FREQUENT_CHECK;
4156} 4158}
4157 4159
4158noinline 4160noinline
4159void 4161void
4160ev_signal_stop (EV_P_ ev_signal *w) EV_THROW 4162ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT
4161{ 4163{
4162 clear_pending (EV_A_ (W)w); 4164 clear_pending (EV_A_ (W)w);
4163 if (expect_false (!ev_is_active (w))) 4165 if (expect_false (!ev_is_active (w)))
4164 return; 4166 return;
4165 4167
… …
4196#endif 4198#endif
4197 4199
4198#if EV_CHILD_ENABLE 4200#if EV_CHILD_ENABLE
4199 4201
4200void 4202void
4201ev_child_start (EV_P_ ev_child *w) EV_THROW 4203ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT
4202{ 4204{
4203#if EV_MULTIPLICITY 4205#if EV_MULTIPLICITY
4204 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));
4205#endif 4207#endif
4206 if (expect_false (ev_is_active (w))) 4208 if (expect_false (ev_is_active (w)))
… …
4213 4215
4214 EV_FREQUENT_CHECK; 4216 EV_FREQUENT_CHECK;
4215} 4217}
4216 4218
4217void 4219void
4218ev_child_stop (EV_P_ ev_child *w) EV_THROW 4220ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT
4219{ 4221{
4220 clear_pending (EV_A_ (W)w); 4222 clear_pending (EV_A_ (W)w);
4221 if (expect_false (!ev_is_active (w))) 4223 if (expect_false (!ev_is_active (w)))
4222 return; 4224 return;
4223 4225
… …
4488#else 4490#else
4489# define EV_LSTAT(p,b) lstat (p, b) 4491# define EV_LSTAT(p,b) lstat (p, b)
4490#endif 4492#endif
4491 4493
4492void 4494void
4493ev_stat_stat (EV_P_ ev_stat *w) EV_THROW 4495ev_stat_stat (EV_P_ ev_stat *w) EV_NOEXCEPT
4494{ 4496{
4495 if (lstat (w->path, &w->attr) < 0) 4497 if (lstat (w->path, &w->attr) < 0)
4496 w->attr.st_nlink = 0; 4498 w->attr.st_nlink = 0;
4497 else if (!w->attr.st_nlink) 4499 else if (!w->attr.st_nlink)
4498 w->attr.st_nlink = 1; 4500 w->attr.st_nlink = 1;
… …
4538 ev_feed_event (EV_A_ w, EV_STAT); 4540 ev_feed_event (EV_A_ w, EV_STAT);
4539 } 4541 }
4540} 4542}
4541 4543
4542void 4544void
4543ev_stat_start (EV_P_ ev_stat *w) EV_THROW 4545ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT
4544{ 4546{
4545 if (expect_false (ev_is_active (w))) 4547 if (expect_false (ev_is_active (w)))
4546 return; 4548 return;
4547 4549
4548 ev_stat_stat (EV_A_ w); 4550 ev_stat_stat (EV_A_ w);
… …
4569 4571
4570 EV_FREQUENT_CHECK; 4572 EV_FREQUENT_CHECK;
4571} 4573}
4572 4574
4573void 4575void
4574ev_stat_stop (EV_P_ ev_stat *w) EV_THROW 4576ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT
4575{ 4577{
4576 clear_pending (EV_A_ (W)w); 4578 clear_pending (EV_A_ (W)w);
4577 if (expect_false (!ev_is_active (w))) 4579 if (expect_false (!ev_is_active (w)))
4578 return; 4580 return;
4579 4581
… …
4595} 4597}
4596#endif 4598#endif
4597 4599
4598#if EV_IDLE_ENABLE 4600#if EV_IDLE_ENABLE
4599void 4601void
4600ev_idle_start (EV_P_ ev_idle *w) EV_THROW 4602ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT
4601{ 4603{
4602 if (expect_false (ev_is_active (w))) 4604 if (expect_false (ev_is_active (w)))
4603 return; 4605 return;
4604 4606
4605 pri_adjust (EV_A_ (W)w); 4607 pri_adjust (EV_A_ (W)w);
… …
4618 4620
4619 EV_FREQUENT_CHECK; 4621 EV_FREQUENT_CHECK;
4620} 4622}
4621 4623
4622void 4624void
4623ev_idle_stop (EV_P_ ev_idle *w) EV_THROW 4625ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT
4624{ 4626{
4625 clear_pending (EV_A_ (W)w); 4627 clear_pending (EV_A_ (W)w);
4626 if (expect_false (!ev_is_active (w))) 4628 if (expect_false (!ev_is_active (w)))
4627 return; 4629 return;
4628 4630
… …
4642} 4644}
4643#endif 4645#endif
4644 4646
4645#if EV_PREPARE_ENABLE 4647#if EV_PREPARE_ENABLE
4646void 4648void
4647ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW 4649ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT
4648{ 4650{
4649 if (expect_false (ev_is_active (w))) 4651 if (expect_false (ev_is_active (w)))
4650 return; 4652 return;
4651 4653
4652 EV_FREQUENT_CHECK; 4654 EV_FREQUENT_CHECK;
… …
4657 4659
4658 EV_FREQUENT_CHECK; 4660 EV_FREQUENT_CHECK;
4659} 4661}
4660 4662
4661void 4663void
4662ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW 4664ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT
4663{ 4665{
4664 clear_pending (EV_A_ (W)w); 4666 clear_pending (EV_A_ (W)w);
4665 if (expect_false (!ev_is_active (w))) 4667 if (expect_false (!ev_is_active (w)))
4666 return; 4668 return;
4667 4669
… …
4680} 4682}
4681#endif 4683#endif
4682 4684
4683#if EV_CHECK_ENABLE 4685#if EV_CHECK_ENABLE
4684void 4686void
4685ev_check_start (EV_P_ ev_check *w) EV_THROW 4687ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT
4686{ 4688{
4687 if (expect_false (ev_is_active (w))) 4689 if (expect_false (ev_is_active (w)))
4688 return; 4690 return;
4689 4691
4690 EV_FREQUENT_CHECK; 4692 EV_FREQUENT_CHECK;
… …
4695 4697
4696 EV_FREQUENT_CHECK; 4698 EV_FREQUENT_CHECK;
4697} 4699}
4698 4700
4699void 4701void
4700ev_check_stop (EV_P_ ev_check *w) EV_THROW 4702ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT
4701{ 4703{
4702 clear_pending (EV_A_ (W)w); 4704 clear_pending (EV_A_ (W)w);
4703 if (expect_false (!ev_is_active (w))) 4705 if (expect_false (!ev_is_active (w)))
4704 return; 4706 return;
4705 4707
… …
4719#endif 4721#endif
4720 4722
4721#if EV_EMBED_ENABLE 4723#if EV_EMBED_ENABLE
4722noinline 4724noinline
4723void 4725void
4724ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW 4726ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT
4725{ 4727{
4726 ev_run (w->other, EVRUN_NOWAIT); 4728 ev_run (w->other, EVRUN_NOWAIT);
4727} 4729}
4728 4730
4729static void 4731static void
… …
4777 ev_idle_stop (EV_A_ idle); 4779 ev_idle_stop (EV_A_ idle);
4778} 4780}
4779#endif 4781#endif
4780 4782
4781void 4783void
4782ev_embed_start (EV_P_ ev_embed *w) EV_THROW 4784ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT
4783{ 4785{
4784 if (expect_false (ev_is_active (w))) 4786 if (expect_false (ev_is_active (w)))
4785 return; 4787 return;
4786 4788
4787 { 4789 {
… …
4808 4810
4809 EV_FREQUENT_CHECK; 4811 EV_FREQUENT_CHECK;
4810} 4812}
4811 4813
4812void 4814void
4813ev_embed_stop (EV_P_ ev_embed *w) EV_THROW 4815ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT
4814{ 4816{
4815 clear_pending (EV_A_ (W)w); 4817 clear_pending (EV_A_ (W)w);
4816 if (expect_false (!ev_is_active (w))) 4818 if (expect_false (!ev_is_active (w)))
4817 return; 4819 return;
4818 4820
… …
4828} 4830}
4829#endif 4831#endif
4830 4832
4831#if EV_FORK_ENABLE 4833#if EV_FORK_ENABLE
4832void 4834void
4833ev_fork_start (EV_P_ ev_fork *w) EV_THROW 4835ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT
4834{ 4836{
4835 if (expect_false (ev_is_active (w))) 4837 if (expect_false (ev_is_active (w)))
4836 return; 4838 return;
4837 4839
4838 EV_FREQUENT_CHECK; 4840 EV_FREQUENT_CHECK;
… …
4843 4845
4844 EV_FREQUENT_CHECK; 4846 EV_FREQUENT_CHECK;
4845} 4847}
4846 4848
4847void 4849void
4848ev_fork_stop (EV_P_ ev_fork *w) EV_THROW 4850ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT
4849{ 4851{
4850 clear_pending (EV_A_ (W)w); 4852 clear_pending (EV_A_ (W)w);
4851 if (expect_false (!ev_is_active (w))) 4853 if (expect_false (!ev_is_active (w)))
4852 return; 4854 return;
4853 4855
… …
4866} 4868}
4867#endif 4869#endif
4868 4870
4869#if EV_CLEANUP_ENABLE 4871#if EV_CLEANUP_ENABLE
4870void 4872void
4871ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW 4873ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4872{ 4874{
4873 if (expect_false (ev_is_active (w))) 4875 if (expect_false (ev_is_active (w)))
4874 return; 4876 return;
4875 4877
4876 EV_FREQUENT_CHECK; 4878 EV_FREQUENT_CHECK;
… …
4883 ev_unref (EV_A); 4885 ev_unref (EV_A);
4884 EV_FREQUENT_CHECK; 4886 EV_FREQUENT_CHECK;
4885} 4887}
4886 4888
4887void 4889void
4888ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW 4890ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT
4889{ 4891{
4890 clear_pending (EV_A_ (W)w); 4892 clear_pending (EV_A_ (W)w);
4891 if (expect_false (!ev_is_active (w))) 4893 if (expect_false (!ev_is_active (w)))
4892 return; 4894 return;
4893 4895
… …
4907} 4909}
4908#endif 4910#endif
4909 4911
4910#if EV_ASYNC_ENABLE 4912#if EV_ASYNC_ENABLE
4911void 4913void
4912ev_async_start (EV_P_ ev_async *w) EV_THROW 4914ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT
4913{ 4915{
4914 if (expect_false (ev_is_active (w))) 4916 if (expect_false (ev_is_active (w)))
4915 return; 4917 return;
4916 4918
4917 w->sent = 0; 4919 w->sent = 0;
… …
4926 4928
4927 EV_FREQUENT_CHECK; 4929 EV_FREQUENT_CHECK;
4928} 4930}
4929 4931
4930void 4932void
4931ev_async_stop (EV_P_ ev_async *w) EV_THROW 4933ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT
4932{ 4934{
4933 clear_pending (EV_A_ (W)w); 4935 clear_pending (EV_A_ (W)w);
4934 if (expect_false (!ev_is_active (w))) 4936 if (expect_false (!ev_is_active (w)))
4935 return; 4937 return;
4936 4938
… …
4947 4949
4948 EV_FREQUENT_CHECK; 4950 EV_FREQUENT_CHECK;
4949} 4951}
4950 4952
4951void 4953void
4952ev_async_send (EV_P_ ev_async *w) EV_THROW 4954ev_async_send (EV_P_ ev_async *w) EV_NOEXCEPT
4953{ 4955{
4954 w->sent = 1; 4956 w->sent = 1;
4955 evpipe_write (EV_A_ &async_pending); 4957 evpipe_write (EV_A_ &async_pending);
4956} 4958}
4957#endif 4959#endif
… …
4994 4996
4995 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));
4996} 4998}
4997 4999
4998void 5000void
4999ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_THROW 5001ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_NOEXCEPT
5000{ 5002{
5001 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));
5002 5004
5003 if (expect_false (!once)) 5005 if (expect_false (!once))
5004 { 5006 {
… …
5027/*****************************************************************************/ 5029/*****************************************************************************/
5028 5030
5029#if EV_WALK_ENABLE 5031#if EV_WALK_ENABLE
5030ecb_cold 5032ecb_cold
5031void 5033void
5032ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW 5034ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_NOEXCEPT
5033{ 5035{
5034 int i, j; 5036 int i, j;
5035 ev_watcher_list *wl, *wn; 5037 ev_watcher_list *wl, *wn;
5036 5038
5037 if (types & (EV_IO | EV_EMBED)) 5039 if (types & (EV_IO | EV_EMBED))

Diff Legend

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