void
scm_init_finalizer_thread (void)
{
#if SCM_USE_PTHREAD_THREADS
if (automatic_finalization_p)
{
if (pipe2 (finalization_pipe, O_CLOEXEC) != 0)
scm_syserror (NULL);
GC_set_finalizer_notifier (spawn_finalizer_thread);
}
#endif
}
/* Write data to the channel. Throw `guile-ssh-error' on a libssh
error, or signal a system error if amount of data written is
smaller than size SZ. */
static void
ptob_write (SCM channel, const void *data, size_t sz)
#define FUNC_NAME "ptob_write"
{
struct channel_data *channel_data = _scm_to_channel_data (channel);
int res = ssh_channel_write (channel_data->ssh_channel, data, sz);
if (res == SSH_ERROR)
{
ssh_session session = ssh_channel_get_session (channel_data->ssh_channel);
guile_ssh_session_error1 (FUNC_NAME, session, channel);
}
if (res < sz)
scm_syserror (FUNC_NAME);
}
static void scm_resolv_error (const char *subr, SCM bad_value)
{
#ifdef NETDB_INTERNAL
if (h_errno == NETDB_INTERNAL)
{
/* errno supposedly contains a useful value. */
scm_syserror (subr);
}
else
#endif
{
SCM key;
const char *errmsg;
switch (h_errno)
{
case HOST_NOT_FOUND:
key = scm_host_not_found_key;
errmsg = "Unknown host";
break;
case TRY_AGAIN:
key = scm_try_again_key;
errmsg = "Host name lookup failure";
break;
case NO_RECOVERY:
key = scm_no_recovery_key;
errmsg = "Unknown server error";
break;
case NO_DATA:
key = scm_no_data_key;
errmsg = "No address associated with name";
break;
default:
scm_misc_error (subr, "Unknown resolver error", SCM_EOL);
errmsg = NULL;
}
#ifdef HAVE_HSTRERROR
errmsg = (const char *) hstrerror (h_errno);
#endif
scm_error (key, subr, errmsg, SCM_BOOL_F, SCM_EOL);
}
}
/* Create a new plotter whose output and error are Guile ports */
SCM
gupl_newpl (SCM type, SCM outp, SCM errp, SCM param)
{
char *c_type;
FILE *c_outp, *c_errp;
plPlotter *ret;
plPlotterParams *c_param;
SCM_ASSERT (scm_is_string (type), type, SCM_ARG1, "newpl");
SCM_ASSERT (scm_is_true (scm_output_port_p (outp)), outp, SCM_ARG2,
"newpl");
SCM_ASSERT (scm_is_true (scm_output_port_p (errp)), errp, SCM_ARG3, "newpl");
SCM_ASSERT (_scm_is_plparams (param), param, SCM_ARG4, "newpl");
/* Convert the output port to a special stream */
c_outp = fopencookie (SCM2PTR (outp), "wb", port_funcs);
/* Don't buffer port here, since the underlying Guile port also has
port buffering. Double buffering causes problems. */
setvbuf (c_outp, NULL, _IONBF, 0);
if (c_outp == NULL)
scm_syserror ("newpl");
/* Convert the err port to a special stream */
c_errp = fopencookie (SCM2PTR (errp), "wb", port_funcs);
if (c_errp == NULL)
scm_out_of_range ("newpl", errp);
setvbuf (c_errp, NULL, _IONBF, 0);
c_type = scm_to_locale_string (type);
c_param = _scm_to_plparams (param);
ret = pl_newpl_r (c_type, NULL, c_outp, c_errp, c_param);
free (c_type);
if (ret == NULL)
return SCM_BOOL_F;
return _scm_from_plotter (ret);
}
int
scm_set_automatic_finalization_enabled (int enabled_p)
{
int was_enabled_p = automatic_finalization_p;
if (enabled_p == was_enabled_p)
return was_enabled_p;
if (!scm_initialized_p)
{
automatic_finalization_p = enabled_p;
return was_enabled_p;
}
if (enabled_p)
{
#if SCM_USE_PTHREAD_THREADS
if (pipe2 (finalization_pipe, O_CLOEXEC) != 0)
scm_syserror (NULL);
GC_set_finalizer_notifier (spawn_finalizer_thread);
#else
GC_set_finalizer_notifier (queue_finalizer_async);
#endif
}
else
{
GC_set_finalizer_notifier (0);
#if SCM_USE_PTHREAD_THREADS
stop_finalization_thread ();
close (finalization_pipe[0]);
close (finalization_pipe[1]);
finalization_pipe[0] = -1;
finalization_pipe[1] = -1;
#endif
}
automatic_finalization_p = enabled_p;
return was_enabled_p;
}
static int
ioscm_fill_input (SCM port)
{
/* Borrowed from libguile/fports.c. */
long count;
scm_t_port *pt = SCM_PTAB_ENTRY (port);
/* If we're called on stdout,stderr, punt. */
if (! scm_is_eq (port, input_port_scm))
return (scm_t_wchar) EOF; /* Set errno and return -1? */
gdb_flush (gdb_stdout);
gdb_flush (gdb_stderr);
count = ui_file_read (gdb_stdin, (char *) pt->read_buf, pt->read_buf_size);
if (count == -1)
scm_syserror (FUNC_NAME);
if (count == 0)
return (scm_t_wchar) EOF;
pt->read_pos = pt->read_buf;
pt->read_end = pt->read_buf + count;
return *pt->read_buf;
}
static int
ioscm_input_waiting (SCM port)
{
int fdes = 0;
if (! scm_is_eq (port, input_port_scm))
return 0;
#ifdef HAVE_POLL
{
/* This is copied from libguile/fports.c. */
struct pollfd pollfd = { fdes, POLLIN, 0 };
static int use_poll = -1;
if (use_poll < 0)
{
/* This is copied from event-loop.c: poll cannot be used for stdin on
m68k-motorola-sysv. */
struct pollfd test_pollfd = { fdes, POLLIN, 0 };
if (poll (&test_pollfd, 1, 0) == 1 && (test_pollfd.revents & POLLNVAL))
use_poll = 0;
else
use_poll = 1;
}
if (use_poll)
{
/* Guile doesn't export SIGINT hooks like Python does.
For now pass EINTR to scm_syserror, that's what fports.c does. */
if (poll (&pollfd, 1, 0) < 0)
scm_syserror (FUNC_NAME);
return pollfd.revents & POLLIN ? 1 : 0;
}
}
/* Fall through. */
#endif
{
struct timeval timeout;
fd_set input_fds;
int num_fds = fdes + 1;
int num_found;
memset (&timeout, 0, sizeof (timeout));
FD_ZERO (&input_fds);
FD_SET (fdes, &input_fds);
num_found = interruptible_select (num_fds,
&input_fds, NULL, NULL,
&timeout);
if (num_found < 0)
{
/* Guile doesn't export SIGINT hooks like Python does.
For now pass EINTR to scm_syserror, that's what fports.c does. */
scm_syserror (FUNC_NAME);
}
return num_found > 0 && FD_ISSET (fdes, &input_fds);
}
}
