signal handler does not raise an exception

Retry:

* signal.sigtimedwait()
* threading.Lock.acquire()
* threading.RLock.acquire()
* time.sleep()

timeout when interrupted by a signal, except if the signal handler raises an
exception. This change is part of the PEP 475.

The asyncore and selectors module doesn't catch the InterruptedError exception
anymore when calling select.select(), since this function should not raise
InterruptedError anymore.

The previous patch only dealt with KeyboardInterrupt when all of the
data had been consumed by the pager.  This deals with the interrupt
when some data is still pending.

Thanks Ben Hoyt for the report.

getentropy() is used (OpenBSD 5.6+).

(OpenBSD 5.6+).

implementation is used.

using the C volatile keyword.

Add _Py_fstat_noraise() function when a Python exception is not welcome.

MemoryError.

MemoryError.

non-integer input.

Use _PyTime_ROUND_FLOOR and _PyTime_ROUND_CEILING instead.

This mimics get_param's error handling for the most part.  It is slightly
better in some regards as get_param can produce some really weird results for
duplicate *0* parts.  It departs from get_param slightly in that if we have a
mix of non-extended and extended pieces for the same parameter name, the new
parser assumes they were all supposed to be extended and concatenates all the
values, whereas get_param always picks the non-extended parameter value.  All
of this error recovery is pretty much arbitrary decisions...

All these functions only accept positive timeouts, so this change has no effect
in practice.

Add also more tests for ROUNd_FLOOR.

calls fstat() once. Before fstat() was called twice, which was not necessary.

check that microseconds and nanoseconds fits into the specified range.

Add _PyTime_AsTimeval_noraise() function. Call it when it's not possible (or
not useful) to raise a Python exception on overflow.

Don't call _Py_open() from _close_open_fds_safe() because it is call just after
fork(). It's not good to play with locks (the GIL) between fork() and exec().

Use instead _Py_open_noraise() which doesn't touch to the GIL.

datetime.time: round towards minus infinity ("floor") instead of rounding
towards zero ("down").