PyObject *v3_write(PyObject *_, PyObject *args)
{
Vj1b* dut = ((v3*)_)->dut;
const char *s;
Py_ssize_t n;
if (!PyArg_ParseTuple(args, "s#", &s, &n))
return NULL;
for (Py_ssize_t i = 0; i < n; i++) {
dut->uart0_data = s[i];
dut->uart0_valid = 1;
do {
if (PyErr_CheckSignals())
return NULL;
CYCLE();
} while (dut->uart0_rd == 0);
do {
if (PyErr_CheckSignals())
return NULL;
CYCLE();
} while (dut->uart0_rd == 1);
}
dut->uart0_valid = 0;
Py_RETURN_NONE;
}
static gboolean
pyg_signal_watch_check(GSource *source)
{
PyGILState_STATE state;
GMainLoop *main_loop;
#ifdef HAVE_PYSIGNAL_SETWAKEUPFD
PySignalWatchSource *real_source = (PySignalWatchSource *)source;
GPollFD *poll_fd = &real_source->fd;
unsigned char dummy;
if (poll_fd->revents & G_IO_IN)
read(poll_fd->fd, &dummy, 1);
#endif
state = pyglib_gil_state_ensure();
main_loop = pyg_get_current_main_loop();
if (PyErr_CheckSignals() == -1 && main_loop != NULL) {
PyErr_SetNone(PyExc_KeyboardInterrupt);
g_main_loop_quit(main_loop);
}
pyglib_gil_state_release(state);
return FALSE;
}
int riscos_sleep(double delay)
{
os_t starttime, endtime, time; /* monotonic times (centiseconds) */
int *pollword, ret;
osbool claimed;
/* calculate end time */
starttime = os_read_monotonic_time();
if (starttime + 100.0*delay >INT_MAX)
endtime = INT_MAX;
else
endtime = (os_t)(starttime + 100.0*delay);
/* allocate (in RMA) and set pollword for xupcall_sleep */
pollword = osmodule_alloc(4);
*pollword = 1;
time = starttime;
ret = 0;
while ( time<endtime && time>=starttime ) {
xupcall_sleep (pollword, &claimed);
if (PyErr_CheckSignals()) {
ret = 1;
break;
}
time = os_read_monotonic_time();
}
/* deallocate pollword */
osmodule_free(pollword);
return ret;
}
static PyObject *p_sendfd(PyObject *self, PyObject *args)
{
int sock, fd, ret;
PyObject *data;
if(!PyArg_ParseTuple(args, "iiO", &sock, &fd, &data))
return(NULL);
if(!PyString_Check(data)) {
PyErr_SetString(PyExc_TypeError, "datagram must be a string");
return(NULL);
}
while(1) {
Py_BEGIN_ALLOW_THREADS;
ret = sendfd(sock, fd, PyString_AsString(data), PyString_Size(data));
Py_END_ALLOW_THREADS;
if(ret < 0) {
if(errno == EINTR) {
if(PyErr_CheckSignals())
return(NULL);
continue;
}
PyErr_SetFromErrno(PyExc_OSError);
return(NULL);
}
Py_RETURN_NONE;
}
}
static PyObject *
Simulator_run(Simulator *self, PyObject *args)
{
PyObject *ret = NULL;
int status, not_done;
uint64_t chunk = 8192;
double max_time = DBL_MAX;
if (Simulator_check_sim(self) != 0) {
goto out;
}
if (!PyArg_ParseTuple(args, "|d", &max_time)) {
goto out;
}
not_done = 1;
self->sim->max_time = max_time;
while (not_done) {
status = sim_simulate(self->sim, chunk);
if (status < 0) {
handle_library_error(status);
goto out;
}
not_done = status != 0;
if (PyErr_CheckSignals() < 0) {
goto out;
}
}
/* return True if complete coalescence has occured */
ret = self->sim->time < max_time ? Py_True : Py_False;
Py_INCREF(ret);
out:
return ret;
}
static int
_posixshmem_shm_open_impl(PyObject *module, PyObject *path, int flags,
int mode)
/*[clinic end generated code: output=8d110171a4fa20df input=e83b58fa802fac25]*/
{
int fd;
int async_err = 0;
const char *name = PyUnicode_AsUTF8(path);
if (name == NULL) {
return -1;
}
do {
Py_BEGIN_ALLOW_THREADS
fd = shm_open(name, flags, mode);
Py_END_ALLOW_THREADS
} while (fd < 0 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
if (fd < 0) {
if (!async_err)
PyErr_SetFromErrnoWithFilenameObject(PyExc_OSError, path);
return -1;
}
return fd;
}
static int color_setr(PyColor *self, PyObject *value, void *closure)
{
int v;
if (PyErr_CheckSignals())
return -1;
if (!value)
{
PyErr_SetString(PyExc_TypeError, "Cannot delete red component");
return -1;
}
if (!PyInt_Check(value))
{
PyErr_SetString(PyExc_TypeError, "Red component must be an integer.");
return -1;
}
v = PyInt_AsLong(value);
if ((v < 0) || (v > 255))
{
PyErr_SetString(PyExc_ValueError, "Red component must be between 0 and 255");
return -1;
}
self->color = (self->color & 0xFFFFFF00U) | (u32)v;
return 0;
}
static PyObject *p_recvfd(PyObject *self, PyObject *args)
{
int fd, ret;
char *data;
size_t dlen;
PyObject *ro;
fd = 0;
if(!PyArg_ParseTuple(args, "|i", &fd))
return(NULL);
while(1) {
Py_BEGIN_ALLOW_THREADS;
ret = recvfd(fd, &data, &dlen);
Py_END_ALLOW_THREADS;
if(ret < 0) {
if(errno == 0)
return(Py_BuildValue("OO", Py_None, Py_None));
if(errno == EINTR) {
if(PyErr_CheckSignals())
return(NULL);
continue;
}
PyErr_SetFromErrno(PyExc_OSError);
return(NULL);
}
ro = Py_BuildValue("Ni", PyString_FromStringAndSize(data, dlen), ret);
free(data);
return(ro);
}
}
static int
_Py_open_impl(const char *pathname, int flags, int gil_held)
{
int fd;
int async_err = 0;
#ifndef MS_WINDOWS
int *atomic_flag_works;
#endif
#ifdef MS_WINDOWS
flags |= O_NOINHERIT;
#elif defined(O_CLOEXEC)
atomic_flag_works = &_Py_open_cloexec_works;
flags |= O_CLOEXEC;
#else
atomic_flag_works = NULL;
#endif
if (gil_held) {
do {
Py_BEGIN_ALLOW_THREADS
fd = open(pathname, flags);
Py_END_ALLOW_THREADS
} while (fd < 0
&& errno == EINTR && !(async_err = PyErr_CheckSignals()));
if (async_err)
return -1;
if (fd < 0) {
PyErr_SetFromErrnoWithFilename(PyExc_OSError, pathname);
return -1;
}
}
else {
static PyObject* image_getsizeY(PyImage *self, void *closure)
{
if (PyErr_CheckSignals())
return NULL;
return Py_BuildValue("i", self->pImg->sizeY);
}
static int
tb_printinternal(tracebackobject *tb, PyObject *f, int limit)
{
int err = 0;
int depth = 0;
tracebackobject *tb1 = tb;
while (tb1 != NULL) {
depth++;
tb1 = tb1->tb_next;
}
while (tb != NULL && err == 0) {
if (depth <= limit) {
err = tb_displayline(f,
PyString_AsString(
tb->tb_frame->f_code->co_filename),
tb->tb_lineno,
PyString_AsString(tb->tb_frame->f_code->co_name));
}
depth--;
tb = tb->tb_next;
if (err == 0)
err = PyErr_CheckSignals();
}
return err;
}
static PyObject* pspsnd_setSndFxVolume(PyObject *self,
PyObject *args,
PyObject *kwargs)
{
int volume;
if (!PyArg_ParseTuple(args, "i:setSndFxVolume", &volume))
return NULL;
if (PyErr_CheckSignals())
return NULL;
#ifdef CHECKTYPE
if ((volume < 0) || (volume > 255))
{
PyErr_SetString(PyExc_ValueError, "Bad volume value");
return NULL;
}
#endif
PSPSND::Sound::setVolume((unsigned char)volume);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject* image_getangle(PyImage *self, void *closure)
{
if (PyErr_CheckSignals())
return NULL;
return Py_BuildValue("f", self->pImg->angle);
}
static void
pyuv__check_signals(uv_poll_t *handle, int status, int events)
{
PyGILState_STATE gstate = PyGILState_Ensure();
SignalChecker *self;
ASSERT(handle);
self = PYUV_CONTAINER_OF(handle, SignalChecker, poll_h);
if (status == 0) {
ASSERT(events == UV_READABLE);
}
/* Drain the fd */
if (pyuv__drain_poll_fd(self->fd) != 0) {
uv_poll_stop(handle);
}
/* Check for signals */
PyErr_CheckSignals();
if (PyErr_Occurred()) {
handle_uncaught_exception(HANDLE(self)->loop);
}
Py_DECREF(self);
PyGILState_Release(gstate);
}
static PyObject* color_getg(PyColor *self, void *closure)
{
if (PyErr_CheckSignals())
return NULL;
return Py_BuildValue("i", (self->color >> 8) & 0xFF);
}
static char *
readline_until_enter_or_signal(const char *prompt, int *signal)
{
char * not_done_reading = "";
fd_set selectset;
*signal = 0;
#ifdef HAVE_RL_CATCH_SIGNAL
rl_catch_signals = 0;
#endif
rl_callback_handler_install (prompt, rlhandler);
FD_ZERO(&selectset);
completed_input_string = not_done_reading;
while (completed_input_string == not_done_reading) {
int has_input = 0, err = 0;
while (!has_input)
{ struct timeval timeout = {0, 100000}; /* 0.1 seconds */
/* [Bug #1552726] Only limit the pause if an input hook has been
defined. */
struct timeval *timeoutp = NULL;
if (PyOS_InputHook)
timeoutp = &timeout;
FD_SET(fileno(rl_instream), &selectset);
/* select resets selectset if no input was available */
has_input = select(fileno(rl_instream) + 1, &selectset,
NULL, NULL, timeoutp);
err = errno;
if(PyOS_InputHook) PyOS_InputHook();
}
if (has_input > 0) {
rl_callback_read_char();
}
else if (err == EINTR) {
int s;
#ifdef WITH_THREAD
PyEval_RestoreThread(_PyOS_ReadlineTState);
#endif
s = PyErr_CheckSignals();
#ifdef WITH_THREAD
PyEval_SaveThread();
#endif
if (s < 0) {
rl_free_line_state();
rl_cleanup_after_signal();
rl_callback_handler_remove();
*signal = 1;
completed_input_string = NULL;
}
}
}
return completed_input_string;
}
static CYTHON_INLINE void gevent_check_signals(struct PyGeventLoopObject* loop) {
if (!ev_is_default_loop(loop->_ptr)) {
/* only reporting signals on the default loop */
return;
}
PyErr_CheckSignals();
if (PyErr_Occurred()) gevent_handle_error(loop, Py_None);
}
static int
sem_timedwait_save(sem_t *sem, struct timespec *deadline, PyThreadState *_save)
{
int res;
unsigned long delay, difference;
struct timeval now, tvdeadline, tvdelay;
errno = 0;
tvdeadline.tv_sec = deadline->tv_sec;
tvdeadline.tv_usec = deadline->tv_nsec / 1000;
for (delay = 0 ; ; delay += 1000) {
/* poll */
if (sem_trywait(sem) == 0)
return 0;
else if (errno != EAGAIN)
return MP_STANDARD_ERROR;
/* get current time */
if (gettimeofday(&now, NULL) < 0)
return MP_STANDARD_ERROR;
/* check for timeout */
if (tvdeadline.tv_sec < now.tv_sec ||
(tvdeadline.tv_sec == now.tv_sec &&
tvdeadline.tv_usec <= now.tv_usec)) {
errno = ETIMEDOUT;
return MP_STANDARD_ERROR;
}
/* calculate how much time is left */
difference = (tvdeadline.tv_sec - now.tv_sec) * 1000000 +
(tvdeadline.tv_usec - now.tv_usec);
/* check delay not too long -- maximum is 20 msecs */
if (delay > 20000)
delay = 20000;
if (delay > difference)
delay = difference;
/* sleep */
tvdelay.tv_sec = delay / 1000000;
tvdelay.tv_usec = delay % 1000000;
if (select(0, NULL, NULL, NULL, &tvdelay) < 0)
return MP_STANDARD_ERROR;
/* check for signals */
Py_BLOCK_THREADS
res = PyErr_CheckSignals();
Py_UNBLOCK_THREADS
if (res) {
errno = EINTR;
return MP_EXCEPTION_HAS_BEEN_SET;
}
}
}
PyObject *
py_download_url(G_GNUC_UNUSED PyObject *self, PyObject *args)
{
gboolean ret;
PyObject *py_handle;
LrHandle *handle = NULL;
char *url;
int fd;
GError *tmp_err = NULL;
PyThreadState *state = NULL;
if (!PyArg_ParseTuple(args, "Osi:download_url",
&py_handle, &url, &fd))
return NULL;
Py_XINCREF(py_handle);
if (HandleObject_Check(py_handle)) {
handle = Handle_FromPyObject(py_handle);
} else if (py_handle != Py_None) {
PyErr_SetString(PyExc_TypeError, "Only Handle or None is supported");
return NULL;
}
// XXX: GIL Hack
int hack_rc = gil_logger_hack_begin(&state);
if (hack_rc == GIL_HACK_ERROR)
return NULL;
BeginAllowThreads(&state);
ret = lr_download_url(handle, url, fd, &tmp_err);
EndAllowThreads(&state);
// XXX: GIL Hack
if (!gil_logger_hack_end(hack_rc))
return NULL;
assert((ret && !tmp_err) || (!ret && tmp_err));
if (ret)
Py_RETURN_NONE; // All fine - Return None
// Error occurred
if (PyErr_Occurred()) {
// Python exception occurred (in a python callback probably)
return NULL;
} else if(tmp_err->code == LRE_INTERRUPTED) {
// Interrupted by Ctr+C
g_error_free(tmp_err);
PyErr_SetInterrupt();
PyErr_CheckSignals();
return NULL;
} else {
// Return exception created from GError
RETURN_ERROR(&tmp_err, -1, NULL);
}
}
/* Check whether we received an interrupt before sig_on().
* Return 0 if there was an interrupt, 1 otherwise. */
int _sig_on_interrupt_received()
{
_signals.interrupt_received = 0;
if (PyErr_CheckSignals())
{
_signals.sig_on_count = 0;
return 0;
}
return 1;
}
static PyObject *PySSL_SSLwrite(PySSLObject *self, PyObject *args)
{
char *data;
int len;
int count;
int sockstate;
int err;
if (!PyArg_ParseTuple(args, "s#:write", &data, &count))
return NULL;
sockstate = check_socket_and_wait_for_timeout(self->Socket, 1);
if (sockstate == SOCKET_HAS_TIMED_OUT) {
PyErr_SetString(PySSLErrorObject, "The write operation timed out");
return NULL;
} else if (sockstate == SOCKET_HAS_BEEN_CLOSED) {
PyErr_SetString(PySSLErrorObject, "Underlying socket has been closed.");
return NULL;
} else if (sockstate == SOCKET_TOO_LARGE_FOR_SELECT) {
PyErr_SetString(PySSLErrorObject, "Underlying socket too large for select().");
return NULL;
}
do {
err = 0;
Py_BEGIN_ALLOW_THREADS
len = SSL_write(self->ssl, data, count);
err = SSL_get_error(self->ssl, len);
Py_END_ALLOW_THREADS
if(PyErr_CheckSignals()) {
return NULL;
}
if (err == SSL_ERROR_WANT_READ) {
sockstate = check_socket_and_wait_for_timeout(self->Socket, 0);
} else if (err == SSL_ERROR_WANT_WRITE) {
sockstate = check_socket_and_wait_for_timeout(self->Socket, 1);
} else {
sockstate = SOCKET_OPERATION_OK;
}
if (sockstate == SOCKET_HAS_TIMED_OUT) {
PyErr_SetString(PySSLErrorObject, "The write operation timed out");
return NULL;
} else if (sockstate == SOCKET_HAS_BEEN_CLOSED) {
PyErr_SetString(PySSLErrorObject, "Underlying socket has been closed.");
return NULL;
} else if (sockstate == SOCKET_IS_NONBLOCKING) {
break;
}
} while (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE);
if (len > 0)
return PyInt_FromLong(len);
else
return PySSL_SetError(self, len);
}
/* Implementation of PyObject_Print with recursion checking */
static int
internal_print(PyObject *op, FILE *fp, int flags, int nesting)
{
int ret = 0;
if (nesting > 10) {
PyErr_SetString(PyExc_RuntimeError, "print recursion");
return -1;
}
if (PyErr_CheckSignals())
return -1;
#ifdef USE_STACKCHECK
if (PyOS_CheckStack()) {
PyErr_SetString(PyExc_MemoryError, "stack overflow");
return -1;
}
#endif
clearerr(fp); /* Clear any previous error condition */
if (op == NULL) {
fprintf(fp, "<nil>");
}
else {
if (op->ob_refcnt <= 0)
/* XXX(twouters) cast refcount to long until %zd is
universally available */
fprintf(fp, "<refcnt %ld at %p>",
(long)op->ob_refcnt, op);
else if (op->ob_type->tp_print == NULL) {
PyObject *s;
if (flags & Py_PRINT_RAW)
s = PyObject_Str(op);
else
s = PyObject_Repr(op);
if (s == NULL)
ret = -1;
else {
ret = internal_print(s, fp, Py_PRINT_RAW,
nesting+1);
}
Py_XDECREF(s);
}
else
ret = (*op->ob_type->tp_print)(op, fp, flags);
}
if (ret == 0) {
if (ferror(fp)) {
PyErr_SetFromErrno(PyExc_IOError);
clearerr(fp);
ret = -1;
}
}
return ret;
}
void
EventIterator::wait_internal(int timeout_ms)
{
if (m_done == 0) {return;}
off_t prev_done = m_done;
if (timeout_ms == 0)
{
reset_to(prev_done);
return;
}
int time_remaining = timeout_ms;
int step = m_step;
fflush(m_source);
clearerr(m_source);
int fd = fileno(m_source);
struct stat result;
while ((-1 != fstat(fd, &result)) && (result.st_size == m_done))
{
struct pollfd fd;
fd.fd = watch();
fd.events = POLLIN;
Py_BEGIN_ALLOW_THREADS
if (time_remaining != -1 && time_remaining < 1000) {step = time_remaining;}
if (fd.fd == -1)
{
struct timeval tv;
tv.tv_sec = step / 1000;
tv.tv_usec = 1000*(step % 1000);
select(1,NULL,NULL,NULL,&tv);
}
else
{
::poll(&fd, 1, step);
}
Py_END_ALLOW_THREADS
if (PyErr_CheckSignals() == -1)
{
boost::python::throw_error_already_set();
}
time_remaining -= step;
if (time_remaining <= 0)
{
errno = 0;
break;
}
}
if (errno)
{
THROW_EX(IOError, "Failure when checking file size of event log.");
}
reset_to(prev_done);
}
static int
tb_printinternal(PyTracebackObject *tb, PyObject *f, long limit)
{
int err = 0;
Py_ssize_t depth = 0;
PyObject *last_file = NULL;
int last_line = -1;
PyObject *last_name = NULL;
long cnt = 0;
PyTracebackObject *tb1 = tb;
while (tb1 != NULL) {
depth++;
tb1 = tb1->tb_next;
}
while (tb != NULL && depth > limit) {
depth--;
tb = tb->tb_next;
}
while (tb != NULL && err == 0) {
if (last_file != NULL &&
tb->tb_frame->f_code->co_filename == last_file &&
last_line != -1 && tb->tb_lineno == last_line &&
last_name != NULL && tb->tb_frame->f_code->co_name == last_name)
{
cnt++;
}
else {
if (cnt > 3) {
err = tb_print_line_repeated(f, cnt);
}
last_file = tb->tb_frame->f_code->co_filename;
last_line = tb->tb_lineno;
last_name = tb->tb_frame->f_code->co_name;
cnt = 0;
}
if (err == 0 && cnt < 3) {
err = tb_displayline(f,
tb->tb_frame->f_code->co_filename,
tb->tb_lineno,
tb->tb_frame->f_code->co_name);
if (err == 0) {
err = PyErr_CheckSignals();
}
}
tb = tb->tb_next;
}
if (err == 0 && cnt > 3) {
err = tb_print_line_repeated(f, cnt);
}
return err;
}
static int
conn_poll(ConnectionObject *conn, double timeout, PyThreadState *_save)
{
DWORD bytes, deadline, delay;
int difference, res;
BOOL block = FALSE;
if (!PeekNamedPipe(conn->handle, NULL, 0, NULL, &bytes, NULL))
return MP_STANDARD_ERROR;
if (timeout == 0.0)
return bytes > 0;
if (timeout < 0.0)
block = TRUE;
else
/* XXX does not check for overflow */
deadline = GetTickCount() + (DWORD)(1000 * timeout + 0.5);
Sleep(0);
for (delay = 1 ; ; delay += 1) {
if (!PeekNamedPipe(conn->handle, NULL, 0, NULL, &bytes, NULL))
return MP_STANDARD_ERROR;
else if (bytes > 0)
return TRUE;
if (!block) {
difference = deadline - GetTickCount();
if (difference < 0)
return FALSE;
if ((int)delay > difference)
delay = difference;
}
if (delay > 20)
delay = 20;
Sleep(delay);
/* check for signals */
Py_BLOCK_THREADS
res = PyErr_CheckSignals();
Py_UNBLOCK_THREADS
if (res)
return MP_EXCEPTION_HAS_BEEN_SET;
}
}
static PyObject* color_new(PyTypeObject *type,
PyObject *args,
PyObject *kwargs)
{
PyColor *self;
if (PyErr_CheckSignals())
return NULL;
self = (PyColor*)type->tp_alloc(type, 0);
if (self)
self->color = 0;
return (PyObject*)self;
}
static PyObject *
signal_pause(PyObject *self)
{
Py_BEGIN_ALLOW_THREADS
(void)pause();
Py_END_ALLOW_THREADS
/* make sure that any exceptions that got raised are propagated
* back into Python
*/
if (PyErr_CheckSignals())
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
static PyObject* PyWeave_Sniffer_run(PyWeave_SnifferObject* self)
{
bool capturingFromFile = (Weave::Sniffer::capture_file() != NULL);
for(;;)
{
if(!Weave::Sniffer::next() && capturingFromFile)
break;
if(PyErr_CheckSignals() < 0 || PyErr_Occurred())
return NULL;
}
Py_RETURN_NONE;
}
static int color_init(PyColor *self,
PyObject *args,
PyObject *kwargs)
{
int r, g, b, a = 255;
if (!PyArg_ParseTuple(args, "iii|i:__init__", &r, &g, &b, &a))
return -1;
if (PyErr_CheckSignals())
return -1;
self->color = ((u32)a << 24) | ((u32)b << 16) | ((u32)g << 8) | (u32)r;
return 0;
}
int
PyObject_Print(PyObject *op, FILE *fp, int flags)
{
int ret = 0;
if (PyErr_CheckSignals())
return -1;
#ifdef USE_STACKCHECK
if (PyOS_CheckStack()) {
PyErr_SetString(PyExc_MemoryError, "stack overflow");
return -1;
}
#endif
clearerr(fp); /* Clear any previous error condition */
if (op == NULL) {
fprintf(fp, "<nil>");
}
else {
if (op->ob_refcnt <= 0)
fprintf(fp, "<refcnt %u at %p>",
op->ob_refcnt, op);
else if (op->ob_type->tp_print == NULL) {
PyObject *s;
if (flags & Py_PRINT_RAW)
s = PyObject_Str(op);
else
s = PyObject_Repr(op);
if (s == NULL)
ret = -1;
else {
ret = PyObject_Print(s, fp, Py_PRINT_RAW);
}
Py_XDECREF(s);
}
else
ret = (*op->ob_type->tp_print)(op, fp, flags);
}
if (ret == 0) {
if (ferror(fp)) {
PyErr_SetFromErrno(PyExc_IOError);
clearerr(fp);
ret = -1;
}
}
return ret;
}