… | |
… | |
567 | |
567 | |
568 | static int ev_default_loop_ptr; |
568 | static int ev_default_loop_ptr; |
569 | |
569 | |
570 | #endif |
570 | #endif |
571 | |
571 | |
|
|
572 | #if EV_MINIMAL < 2 |
|
|
573 | # define EV_SUSPEND_CB if (expect_false (suspend_cb)) suspend_cb (EV_A) |
|
|
574 | # define EV_RESUME_CB if (expect_false (resume_cb )) resume_cb (EV_A) |
|
|
575 | # define EV_INVOKE_PENDING invoke_cb (EV_A) |
|
|
576 | #else |
|
|
577 | # define EV_SUSPEND_CB (void)0 |
|
|
578 | # define EV_RESUME_CB (void)0 |
|
|
579 | # define EV_INVOKE_PENDING ev_invoke_pending (EV_A) |
|
|
580 | #endif |
|
|
581 | |
572 | /*****************************************************************************/ |
582 | /*****************************************************************************/ |
573 | |
583 | |
574 | #ifndef EV_HAVE_EV_TIME |
584 | #ifndef EV_HAVE_EV_TIME |
575 | ev_tstamp |
585 | ev_tstamp |
576 | ev_time (void) |
586 | ev_time (void) |
… | |
… | |
1357 | ev_backend (EV_P) |
1367 | ev_backend (EV_P) |
1358 | { |
1368 | { |
1359 | return backend; |
1369 | return backend; |
1360 | } |
1370 | } |
1361 | |
1371 | |
|
|
1372 | #if EV_MINIMAL < 2 |
1362 | unsigned int |
1373 | unsigned int |
1363 | ev_loop_count (EV_P) |
1374 | ev_loop_count (EV_P) |
1364 | { |
1375 | { |
1365 | return loop_count; |
1376 | return loop_count; |
1366 | } |
1377 | } |
… | |
… | |
1380 | void |
1391 | void |
1381 | ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) |
1392 | ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) |
1382 | { |
1393 | { |
1383 | timeout_blocktime = interval; |
1394 | timeout_blocktime = interval; |
1384 | } |
1395 | } |
|
|
1396 | |
|
|
1397 | void |
|
|
1398 | ev_set_userdata (EV_P_ void *data) |
|
|
1399 | { |
|
|
1400 | userdata = data; |
|
|
1401 | } |
|
|
1402 | |
|
|
1403 | void * |
|
|
1404 | ev_userdata (EV_P) |
|
|
1405 | { |
|
|
1406 | return userdata; |
|
|
1407 | } |
|
|
1408 | |
|
|
1409 | void ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) |
|
|
1410 | { |
|
|
1411 | invoke_cb = invoke_pending_cb; |
|
|
1412 | } |
|
|
1413 | |
|
|
1414 | void ev_set_blocking_cb (EV_P_ void (*suspend_cb_)(EV_P), void (*resume_cb_)(EV_P)) |
|
|
1415 | { |
|
|
1416 | suspend_cb = suspend_cb_; |
|
|
1417 | resume_cb = resume_cb_; |
|
|
1418 | } |
|
|
1419 | #endif |
1385 | |
1420 | |
1386 | /* initialise a loop structure, must be zero-initialised */ |
1421 | /* initialise a loop structure, must be zero-initialised */ |
1387 | static void noinline |
1422 | static void noinline |
1388 | loop_init (EV_P_ unsigned int flags) |
1423 | loop_init (EV_P_ unsigned int flags) |
1389 | { |
1424 | { |
… | |
… | |
1411 | |
1446 | |
1412 | ev_rt_now = ev_time (); |
1447 | ev_rt_now = ev_time (); |
1413 | mn_now = get_clock (); |
1448 | mn_now = get_clock (); |
1414 | now_floor = mn_now; |
1449 | now_floor = mn_now; |
1415 | rtmn_diff = ev_rt_now - mn_now; |
1450 | rtmn_diff = ev_rt_now - mn_now; |
|
|
1451 | #if EV_MINIMAL < 2 |
1416 | invoke_cb = ev_invoke_pending; |
1452 | invoke_cb = ev_invoke_pending; |
|
|
1453 | #endif |
1417 | |
1454 | |
1418 | io_blocktime = 0.; |
1455 | io_blocktime = 0.; |
1419 | timeout_blocktime = 0.; |
1456 | timeout_blocktime = 0.; |
1420 | backend = 0; |
1457 | backend = 0; |
1421 | backend_fd = -1; |
1458 | backend_fd = -1; |
… | |
… | |
1615 | void |
1652 | void |
1616 | ev_loop_fork (EV_P) |
1653 | ev_loop_fork (EV_P) |
1617 | { |
1654 | { |
1618 | postfork = 1; /* must be in line with ev_default_fork */ |
1655 | postfork = 1; /* must be in line with ev_default_fork */ |
1619 | } |
1656 | } |
|
|
1657 | #endif /* multiplicity */ |
1620 | |
1658 | |
1621 | #if EV_VERIFY |
1659 | #if EV_VERIFY |
1622 | static void noinline |
1660 | static void noinline |
1623 | verify_watcher (EV_P_ W w) |
1661 | verify_watcher (EV_P_ W w) |
1624 | { |
1662 | { |
… | |
… | |
1652 | verify_watcher (EV_A_ ws [cnt]); |
1690 | verify_watcher (EV_A_ ws [cnt]); |
1653 | } |
1691 | } |
1654 | } |
1692 | } |
1655 | #endif |
1693 | #endif |
1656 | |
1694 | |
|
|
1695 | #if EV_MINIMAL < 2 |
1657 | void |
1696 | void |
1658 | ev_loop_verify (EV_P) |
1697 | ev_loop_verify (EV_P) |
1659 | { |
1698 | { |
1660 | #if EV_VERIFY |
1699 | #if EV_VERIFY |
1661 | int i; |
1700 | int i; |
… | |
… | |
1714 | for (w = (ev_child *)childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next) |
1753 | for (w = (ev_child *)childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next) |
1715 | for (signum = signalmax; signum--; ) if (signals [signum].gotsig) |
1754 | for (signum = signalmax; signum--; ) if (signals [signum].gotsig) |
1716 | # endif |
1755 | # endif |
1717 | #endif |
1756 | #endif |
1718 | } |
1757 | } |
1719 | |
1758 | #endif |
1720 | #endif /* multiplicity */ |
|
|
1721 | |
1759 | |
1722 | #if EV_MULTIPLICITY |
1760 | #if EV_MULTIPLICITY |
1723 | struct ev_loop * |
1761 | struct ev_loop * |
1724 | ev_default_loop_init (unsigned int flags) |
1762 | ev_default_loop_init (unsigned int flags) |
1725 | #else |
1763 | #else |
… | |
… | |
1786 | ev_invoke (EV_P_ void *w, int revents) |
1824 | ev_invoke (EV_P_ void *w, int revents) |
1787 | { |
1825 | { |
1788 | EV_CB_INVOKE ((W)w, revents); |
1826 | EV_CB_INVOKE ((W)w, revents); |
1789 | } |
1827 | } |
1790 | |
1828 | |
1791 | void |
1829 | void noinline |
1792 | ev_invoke_pending (EV_P) |
1830 | ev_invoke_pending (EV_P) |
1793 | { |
1831 | { |
1794 | int pri; |
1832 | int pri; |
1795 | |
1833 | |
1796 | for (pri = NUMPRI; pri--; ) |
1834 | for (pri = NUMPRI; pri--; ) |
… | |
… | |
2035 | } |
2073 | } |
2036 | |
2074 | |
2037 | void |
2075 | void |
2038 | ev_loop (EV_P_ int flags) |
2076 | ev_loop (EV_P_ int flags) |
2039 | { |
2077 | { |
|
|
2078 | #if EV_MINIMAL < 2 |
2040 | ++loop_depth; |
2079 | ++loop_depth; |
|
|
2080 | #endif |
2041 | |
2081 | |
2042 | loop_done = EVUNLOOP_CANCEL; |
2082 | loop_done = EVUNLOOP_CANCEL; |
2043 | |
2083 | |
2044 | invoke_cb (EV_A); /* in case we recurse, ensure ordering stays nice and clean */ |
2084 | EV_INVOKE_PENDING; /* in case we recurse, ensure ordering stays nice and clean */ |
2045 | |
2085 | |
2046 | do |
2086 | do |
2047 | { |
2087 | { |
2048 | #if EV_VERIFY >= 2 |
2088 | #if EV_VERIFY >= 2 |
2049 | ev_loop_verify (EV_A); |
2089 | ev_loop_verify (EV_A); |
… | |
… | |
2062 | /* we might have forked, so queue fork handlers */ |
2102 | /* we might have forked, so queue fork handlers */ |
2063 | if (expect_false (postfork)) |
2103 | if (expect_false (postfork)) |
2064 | if (forkcnt) |
2104 | if (forkcnt) |
2065 | { |
2105 | { |
2066 | queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK); |
2106 | queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK); |
2067 | invoke_cb (EV_A); |
2107 | EV_INVOKE_PENDING; |
2068 | } |
2108 | } |
2069 | #endif |
2109 | #endif |
2070 | |
2110 | |
2071 | /* queue prepare watchers (and execute them) */ |
2111 | /* queue prepare watchers (and execute them) */ |
2072 | if (expect_false (preparecnt)) |
2112 | if (expect_false (preparecnt)) |
2073 | { |
2113 | { |
2074 | queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE); |
2114 | queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE); |
2075 | invoke_cb (EV_A); |
2115 | EV_INVOKE_PENDING; |
2076 | } |
2116 | } |
2077 | |
2117 | |
2078 | /* we might have forked, so reify kernel state if necessary */ |
2118 | /* we might have forked, so reify kernel state if necessary */ |
2079 | if (expect_false (postfork)) |
2119 | if (expect_false (postfork)) |
2080 | loop_fork (EV_A); |
2120 | loop_fork (EV_A); |
… | |
… | |
2129 | waittime -= sleeptime; |
2169 | waittime -= sleeptime; |
2130 | } |
2170 | } |
2131 | } |
2171 | } |
2132 | } |
2172 | } |
2133 | |
2173 | |
|
|
2174 | #if EV_MINIMAL < 2 |
2134 | ++loop_count; |
2175 | ++loop_count; |
|
|
2176 | #endif |
2135 | backend_poll (EV_A_ waittime); |
2177 | backend_poll (EV_A_ waittime); |
2136 | |
2178 | |
2137 | /* update ev_rt_now, do magic */ |
2179 | /* update ev_rt_now, do magic */ |
2138 | time_update (EV_A_ waittime + sleeptime); |
2180 | time_update (EV_A_ waittime + sleeptime); |
2139 | } |
2181 | } |
… | |
… | |
2151 | |
2193 | |
2152 | /* queue check watchers, to be executed first */ |
2194 | /* queue check watchers, to be executed first */ |
2153 | if (expect_false (checkcnt)) |
2195 | if (expect_false (checkcnt)) |
2154 | queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK); |
2196 | queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK); |
2155 | |
2197 | |
2156 | invoke_cb (EV_A); |
2198 | EV_INVOKE_PENDING; |
2157 | } |
2199 | } |
2158 | while (expect_true ( |
2200 | while (expect_true ( |
2159 | activecnt |
2201 | activecnt |
2160 | && !loop_done |
2202 | && !loop_done |
2161 | && !(flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK)) |
2203 | && !(flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK)) |
2162 | )); |
2204 | )); |
2163 | |
2205 | |
2164 | if (loop_done == EVUNLOOP_ONE) |
2206 | if (loop_done == EVUNLOOP_ONE) |
2165 | loop_done = EVUNLOOP_CANCEL; |
2207 | loop_done = EVUNLOOP_CANCEL; |
2166 | |
2208 | |
|
|
2209 | #if EV_MINIMAL < 2 |
2167 | --loop_depth; |
2210 | --loop_depth; |
|
|
2211 | #endif |
2168 | } |
2212 | } |
2169 | |
2213 | |
2170 | void |
2214 | void |
2171 | ev_unloop (EV_P_ int how) |
2215 | ev_unloop (EV_P_ int how) |
2172 | { |
2216 | { |