-/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001, 2002, 2004 Free Software Foundation, Inc.
+/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001, 2002, 2004, 2006,
+ * 2007, 2008, 2009, 2011, 2013, 2014 Free Software Foundation, Inc.
*
* This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 3 of
+ * the License, or (at your option) any later version.
*
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301 USA
*/
\f
-#if HAVE_CONFIG_H
+#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
+#include <fcntl.h> /* for mingw */
#include <signal.h>
+#include <stdio.h>
#include <errno.h>
+#ifdef HAVE_PROCESS_H
+#include <process.h> /* for mingw */
+#endif
+
+#include <unistd.h>
+
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+
+#include <full-write.h>
+
#include "libguile/_scm.h"
#include "libguile/async.h"
#include "libguile/eval.h"
#include "libguile/root.h"
#include "libguile/vectors.h"
+#include "libguile/threads.h"
#include "libguile/validate.h"
#include "libguile/scmsigs.h"
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-
-#ifdef __MINGW32__
-#include <windows.h>
-#define alarm(sec) (0)
-/* This weird comma expression is because Sleep is void under Windows. */
-#define sleep(sec) (Sleep ((sec) * 1000), 0)
-#define usleep(usec) (Sleep ((usec) / 1000), 0)
-#define kill(pid, sig) raise (sig)
-#endif
\f
\f
/* take_signal is installed as the C signal handler whenever a Scheme
- handler is set. when a signal arrives, take_signal will queue the
- Scheme handler procedure for its thread. */
+ handler is set. When a signal arrives, take_signal will write a
+ byte into the 'signal pipe'. The 'signal delivery thread' will
+ read this pipe and queue the appropriate asyncs.
+
+ When Guile is built without threads, the signal handler will
+ install the async directly.
+*/
/* Scheme vectors with information about a signal. signal_handlers
- contains the handler procedure or #f, signal_handler_cells contains
- pre-queued cells for the handler (since we can't do fancy things
- during signal delivery), signal_cell_handlers contains the SCM
- value to be stuffed into the pre-queued cell upon delivery, and
+ contains the handler procedure or #f, signal_handler_asyncs
+ contains the thunk to be marked as an async when the signal arrives
+ (or the cell with the thunk in a singlethreaded Guile), and
signal_handler_threads points to the thread that a signal should be
delivered to.
*/
static SCM *signal_handlers;
-static SCM signal_handler_cells;
-static SCM signal_cell_handlers;
+static SCM signal_handler_asyncs;
static SCM signal_handler_threads;
+/* The signal delivery thread. */
+scm_i_thread *scm_i_signal_delivery_thread = NULL;
+
+/* The mutex held when launching the signal delivery thread. */
+static scm_i_pthread_mutex_t signal_delivery_thread_mutex =
+ SCM_I_PTHREAD_MUTEX_INITIALIZER;
+
+
/* saves the original C handlers, when a new handler is installed.
set to SIG_ERR if the original handler is installed. */
#ifdef HAVE_SIGACTION
static SIGRETTYPE (*orig_handlers[NSIG])(int);
#endif
+static SCM
+close_1 (SCM proc, SCM arg)
+{
+ return scm_primitive_eval_x (scm_list_3 (scm_sym_lambda, SCM_EOL,
+ scm_list_2 (proc, arg)));
+}
+
+#if SCM_USE_PTHREAD_THREADS
+/* On mingw there's no notion of inter-process signals, only a raise()
+ within the process itself which apparently invokes the registered handler
+ immediately. Not sure how well the following code will cope in this
+ case. It builds but it may not offer quite the same scheme-level
+ semantics as on a proper system. If you're relying on much in the way of
+ signal handling on mingw you probably lose anyway. */
+
+static int signal_pipe[2];
static SIGRETTYPE
take_signal (int signum)
{
- if (signum >= 0 && signum < NSIG)
- {
- SCM cell = SCM_VECTOR_REF(signal_handler_cells, signum);
- SCM handler = SCM_VECTOR_REF(signal_cell_handlers, signum);
- SCM thread = SCM_VECTOR_REF(signal_handler_threads, signum);
- scm_root_state *root = scm_i_thread_root (thread);
- if (SCM_CONSP (cell))
- {
- SCM_SETCAR (cell, handler);
- root->pending_asyncs = 1;
- }
- }
-
+ char sigbyte = signum;
+ full_write (signal_pipe[1], &sigbyte, 1);
+
#ifndef HAVE_SIGACTION
signal (signum, take_signal);
#endif
}
-SCM
-scm_sigaction (SCM signum, SCM handler, SCM flags)
+struct signal_pipe_data
{
- return scm_sigaction_for_thread (signum, handler, flags, SCM_UNDEFINED);
-}
+ char sigbyte;
+ ssize_t n;
+ int err;
+};
+
+static void*
+read_signal_pipe_data (void * data)
+{
+ struct signal_pipe_data *sdata = data;
+
+ sdata->n = read (signal_pipe[0], &sdata->sigbyte, 1);
+ sdata->err = errno;
+ return NULL;
+}
+
static SCM
-close_1 (SCM proc, SCM arg)
+signal_delivery_thread (void *data)
{
- return scm_primitive_eval_x (scm_list_3 (scm_sym_lambda, SCM_EOL,
- scm_list_2 (proc, arg)));
+ int sig;
+#if HAVE_PTHREAD_SIGMASK /* not on mingw, see notes above */
+ sigset_t all_sigs;
+ sigfillset (&all_sigs);
+ scm_i_pthread_sigmask (SIG_SETMASK, &all_sigs, NULL);
+#endif
+
+ while (1)
+ {
+ struct signal_pipe_data sigdata;
+
+ scm_without_guile (read_signal_pipe_data, &sigdata);
+
+ sig = sigdata.sigbyte;
+ if (sigdata.n == 1 && sig >= 0 && sig < NSIG)
+ {
+ SCM h, t;
+
+ h = SCM_SIMPLE_VECTOR_REF (signal_handler_asyncs, sig);
+ t = SCM_SIMPLE_VECTOR_REF (signal_handler_threads, sig);
+ if (scm_is_true (h))
+ scm_system_async_mark_for_thread (h, t);
+ }
+ else if (sigdata.n == 0)
+ break; /* the signal pipe was closed. */
+ else if (sigdata.n < 0 && sigdata.err != EINTR)
+ perror ("error in signal delivery thread");
+ }
+
+ return SCM_UNSPECIFIED; /* not reached unless all other threads exited */
}
-/* Make sure that signal SIGNUM can be delivered to THREAD, using
- HANDLER. THREAD and HANDLER must either both be non-#f (which
- means install the handler), or both #f (which means deinstall an
- existing handler).
-*/
+static void
+start_signal_delivery_thread (void)
+{
+ SCM signal_thread;
-struct install_handler_data {
- int signum;
- SCM thread;
- SCM handler;
-};
+ scm_i_pthread_mutex_lock (&signal_delivery_thread_mutex);
-static SCM
-scm_delq_spine_x (SCM cell, SCM list)
+ if (pipe2 (signal_pipe, O_CLOEXEC) != 0)
+ scm_syserror (NULL);
+ signal_thread = scm_spawn_thread (signal_delivery_thread, NULL,
+ scm_handle_by_message,
+ "signal delivery thread");
+ scm_i_signal_delivery_thread = SCM_I_THREAD_DATA (signal_thread);
+
+ scm_i_pthread_mutex_unlock (&signal_delivery_thread_mutex);
+}
+
+void
+scm_i_ensure_signal_delivery_thread ()
{
- SCM s = list, prev = SCM_BOOL_F;
-
- while (!SCM_EQ_P (cell, s))
- {
- if (SCM_NULLP (s))
- return list;
- prev = s;
- s = SCM_CDR (s);
- }
- if (SCM_FALSEP (prev))
- return SCM_CDR (cell);
- else
- {
- SCM_SETCDR (prev, SCM_CDR (cell));
- return list;
- }
+ static scm_i_pthread_once_t once = SCM_I_PTHREAD_ONCE_INIT;
+ scm_i_pthread_once (&once, start_signal_delivery_thread);
}
-static void *
-really_install_handler (void *data)
+#else /* !SCM_USE_PTHREAD_THREADS */
+
+static SIGRETTYPE
+take_signal (int signum)
{
- struct install_handler_data *args = data;
- int signum = args->signum;
- SCM thread = args->thread;
- SCM handler = args->handler;
- SCM cell;
- SCM old_thread;
-
- /* The following modifications are done while signals can be
- delivered. That is not a real problem since the signal handler
- will only touch the car of the handler cell and set the
- pending_asyncs trigger of a thread. While the data structures
- are in flux, the signal handler might store the wrong handler in
- the cell, or set pending_asyncs of the wrong thread. We fix this
- at the end by making sure that the cell has the right handler in
- it, if any, and that pending_asyncs is set for the new thread.
- */
+ SCM cell = SCM_SIMPLE_VECTOR_REF (signal_handler_asyncs, signum);
+ scm_i_thread *t = SCM_I_CURRENT_THREAD;
- /* Make sure we have a cell. */
- cell = SCM_VECTOR_REF (signal_handler_cells, signum);
- if (SCM_FALSEP (cell))
+ if (scm_is_false (SCM_CDR (cell)))
{
- cell = scm_cons (SCM_BOOL_F, SCM_EOL);
- SCM_VECTOR_SET (signal_handler_cells, signum, cell);
+ SCM_SETCDR (cell, t->active_asyncs);
+ t->active_asyncs = cell;
+ t->pending_asyncs = 1;
}
- /* Make sure it is queued for the right thread. */
- old_thread = SCM_VECTOR_REF (signal_handler_threads, signum);
- if (!SCM_EQ_P (thread, old_thread))
- {
- scm_root_state *r;
- if (!SCM_FALSEP (old_thread))
- {
- r = scm_i_thread_root (old_thread);
- r->signal_asyncs = scm_delq_spine_x (cell, r->signal_asyncs);
- }
- if (!SCM_FALSEP (thread))
- {
- r = scm_i_thread_root (thread);
- SCM_SETCDR (cell, r->signal_asyncs);
- r->signal_asyncs = cell;
- /* Set pending_asyncs just in case. A signal that is
- delivered while we modify the data structures here might set
- pending_asyncs of old_thread. */
- r->pending_asyncs = 1;
- }
- SCM_VECTOR_SET (signal_handler_threads, signum, thread);
- }
+#ifndef HAVE_SIGACTION
+ signal (signum, take_signal);
+#endif
+}
+
+void
+scm_i_ensure_signal_delivery_thread ()
+{
+ return;
+}
- /* Set the new handler. */
- if (SCM_FALSEP (handler))
+#endif /* !SCM_USE_PTHREAD_THREADS */
+
+static void
+install_handler (int signum, SCM thread, SCM handler)
+{
+ if (scm_is_false (handler))
{
- SCM_VECTOR_SET (*signal_handlers, signum, SCM_BOOL_F);
- SCM_VECTOR_SET (signal_cell_handlers, signum, SCM_BOOL_F);
+ SCM_SIMPLE_VECTOR_SET (*signal_handlers, signum, SCM_BOOL_F);
+ SCM_SIMPLE_VECTOR_SET (signal_handler_asyncs, signum, SCM_BOOL_F);
}
else
{
- SCM_VECTOR_SET (*signal_handlers, signum, handler);
- SCM_VECTOR_SET (signal_cell_handlers, signum,
- close_1 (handler, scm_int2num (signum)));
+ SCM async = close_1 (handler, scm_from_int (signum));
+#if !SCM_USE_PTHREAD_THREADS
+ async = scm_cons (async, SCM_BOOL_F);
+#endif
+ SCM_SIMPLE_VECTOR_SET (*signal_handlers, signum, handler);
+ SCM_SIMPLE_VECTOR_SET (signal_handler_asyncs, signum, async);
}
- /* Now fix up the cell. It might contain the old handler but since
- it is now queued for the new thread, we must make sure that the
- new handler is run. Any signal that is delivered during the
- following code will install the new handler, so we have no
- problem.
- */
- if (!SCM_FALSEP (SCM_CAR (cell)))
- SCM_SETCAR (cell, SCM_VECTOR_REF (signal_cell_handlers, signum));
-
- /* Phfew. That should be it. */
- return NULL;
+ SCM_SIMPLE_VECTOR_SET (signal_handler_threads, signum, thread);
}
-static void
-install_handler (int signum, SCM thread, SCM handler)
+SCM
+scm_sigaction (SCM signum, SCM handler, SCM flags)
{
- /* We block asyncs while installing the handler. It would be safe
- to leave them on, but we might run the wrong handler should a
- signal be delivered.
- */
-
- struct install_handler_data args;
- args.signum = signum;
- args.thread = thread;
- args.handler = handler;
- scm_c_call_with_blocked_asyncs (really_install_handler, &args);
+ return scm_sigaction_for_thread (signum, handler, flags, SCM_UNDEFINED);
}
/* user interface for installation of signal handlers. */
"a scheme procedure has been specified, that procedure will run\n"
"in the given @var{thread}. When no thread has been given, the\n"
"thread that made this call to @code{sigaction} is used.\n"
- "Flags can "
- "optionally be specified for the new handler (@code{SA_RESTART} will\n"
- "always be added if it's available and the system is using restartable\n"
- "system calls.) The return value is a pair with information about the\n"
+ "Flags can optionally be specified for the new handler.\n"
+ "The return value is a pair with information about the\n"
"old handler as described above.\n\n"
"This interface does not provide access to the \"signal blocking\"\n"
"facility. Maybe this is not needed, since the thread support may\n"
SCM old_handler;
- SCM_VALIDATE_INUM_COPY (1, signum, csig);
- if (csig < 0 || csig >= NSIG)
- SCM_OUT_OF_RANGE (1, signum);
+ csig = scm_to_signed_integer (signum, 0, NSIG-1);
+
#if defined(HAVE_SIGACTION)
-#if defined(SA_RESTART) && defined(HAVE_RESTARTABLE_SYSCALLS)
- /* don't allow SA_RESTART to be omitted if HAVE_RESTARTABLE_SYSCALLS
- is defined, since libguile would be likely to produce spurious
- EINTR errors. */
- action.sa_flags = SA_RESTART;
-#else
action.sa_flags = 0;
-#endif
if (!SCM_UNBNDP (flags))
- {
- SCM_VALIDATE_INUM (3, flags);
- action.sa_flags |= SCM_INUM (flags);
- }
+ action.sa_flags |= scm_to_int (flags);
sigemptyset (&action.sa_mask);
#endif
SCM_MISC_ERROR ("thread has already exited", SCM_EOL);
}
- SCM_DEFER_INTS;
- old_handler = SCM_VECTOR_REF(*signal_handlers, csig);
+ scm_i_ensure_signal_delivery_thread ();
+
+ SCM_CRITICAL_SECTION_START;
+ old_handler = SCM_SIMPLE_VECTOR_REF (*signal_handlers, csig);
if (SCM_UNBNDP (handler))
query_only = 1;
- else if (SCM_EQ_P (scm_integer_p (handler), SCM_BOOL_T))
+ else if (scm_is_integer (handler))
{
- if (SCM_NUM2LONG (2, handler) == (long) SIG_DFL
- || SCM_NUM2LONG (2, handler) == (long) SIG_IGN)
+ long handler_int = scm_to_long (handler);
+
+ if (handler_int == (long) SIG_DFL || handler_int == (long) SIG_IGN)
{
#ifdef HAVE_SIGACTION
- action.sa_handler = (SIGRETTYPE (*) (int)) SCM_INUM (handler);
+ action.sa_handler = (SIGRETTYPE (*) (int)) handler_int;
#else
- chandler = (SIGRETTYPE (*) (int)) SCM_INUM (handler);
+ chandler = (SIGRETTYPE (*) (int)) handler_int;
#endif
install_handler (csig, SCM_BOOL_F, SCM_BOOL_F);
}
else
- SCM_OUT_OF_RANGE (2, handler);
+ {
+ SCM_CRITICAL_SECTION_END;
+ SCM_OUT_OF_RANGE (2, handler);
+ }
}
- else if (SCM_FALSEP (handler))
+ else if (scm_is_false (handler))
{
/* restore the default handler. */
#ifdef HAVE_SIGACTION
orig_handlers[csig] = old_action;
}
if (old_action.sa_handler == SIG_DFL || old_action.sa_handler == SIG_IGN)
- old_handler = scm_long2num ((long) old_action.sa_handler);
- SCM_ALLOW_INTS;
- return scm_cons (old_handler, SCM_MAKINUM (old_action.sa_flags));
+ old_handler = scm_from_long ((long) old_action.sa_handler);
+ SCM_CRITICAL_SECTION_END;
+ return scm_cons (old_handler, scm_from_int (old_action.sa_flags));
#else
if (query_only)
{
orig_handlers[csig] = old_chandler;
}
if (old_chandler == SIG_DFL || old_chandler == SIG_IGN)
- old_handler = scm_long2num ((long) old_chandler);
- SCM_ALLOW_INTS;
- return scm_cons (old_handler, SCM_MAKINUM (0));
+ old_handler = scm_from_long ((long) old_chandler);
+ SCM_CRITICAL_SECTION_END;
+ return scm_cons (old_handler, scm_from_int (0));
#endif
}
#undef FUNC_NAME
if (sigaction (i, &orig_handlers[i], NULL) == -1)
SCM_SYSERROR;
orig_handlers[i].sa_handler = SIG_ERR;
- SCM_VECTOR_SET (*signal_handlers, i, SCM_BOOL_F);
+ SCM_SIMPLE_VECTOR_SET (*signal_handlers, i, SCM_BOOL_F);
}
#else
if (orig_handlers[i] != SIG_ERR)
if (signal (i, orig_handlers[i]) == SIG_ERR)
SCM_SYSERROR;
orig_handlers[i] = SIG_ERR;
- SCM_VECTOR_SET (*signal_handlers, i, SCM_BOOL_F);
+ SCM_SIMPLE_VECTOR_SET (*signal_handlers, i, SCM_BOOL_F);
}
#endif
}
}
#undef FUNC_NAME
+#if HAVE_DECL_ALARM
SCM_DEFINE (scm_alarm, "alarm", 1, 0, 0,
(SCM i),
"Set a timer to raise a @code{SIGALRM} signal after the specified\n"
"no previous alarm, the return value is zero.")
#define FUNC_NAME s_scm_alarm
{
- unsigned int j;
- SCM_VALIDATE_INUM (1, i);
- j = alarm (SCM_INUM (i));
- return SCM_MAKINUM (j);
+ return scm_from_uint (alarm (scm_to_uint (i)));
}
#undef FUNC_NAME
+#endif /* HAVE_ALARM */
#ifdef HAVE_SETITIMER
SCM_DEFINE (scm_setitimer, "setitimer", 5, 0, 0,
if(rv != 0)
SCM_SYSERROR;
- return scm_list_2(scm_cons(scm_long2num(old_timer.it_interval.tv_sec),
- scm_long2num(old_timer.it_interval.tv_usec)),
- scm_cons(scm_long2num(old_timer.it_value.tv_sec),
- scm_long2num(old_timer.it_value.tv_usec)));
+ return scm_list_2 (scm_cons (scm_from_long (old_timer.it_interval.tv_sec),
+ scm_from_long (old_timer.it_interval.tv_usec)),
+ scm_cons (scm_from_long (old_timer.it_value.tv_sec),
+ scm_from_long (old_timer.it_value.tv_usec)));
}
#undef FUNC_NAME
#endif /* HAVE_SETITIMER */
if(rv != 0)
SCM_SYSERROR;
- return scm_list_2(scm_cons(scm_long2num(old_timer.it_interval.tv_sec),
- scm_long2num(old_timer.it_interval.tv_usec)),
- scm_cons(scm_long2num(old_timer.it_value.tv_sec),
- scm_long2num(old_timer.it_value.tv_usec)));
+ return scm_list_2 (scm_cons (scm_from_long (old_timer.it_interval.tv_sec),
+ scm_from_long (old_timer.it_interval.tv_usec)),
+ scm_cons (scm_from_long (old_timer.it_value.tv_sec),
+ scm_from_long (old_timer.it_value.tv_usec)));
}
#undef FUNC_NAME
#endif /* HAVE_GETITIMER */
(SCM i),
"Wait for the given number of seconds (an integer) or until a signal\n"
"arrives. The return value is zero if the time elapses or the number\n"
- "of seconds remaining otherwise.")
+ "of seconds remaining otherwise.\n"
+ "\n"
+ "See also @code{usleep}.")
#define FUNC_NAME s_scm_sleep
{
- unsigned long j;
- SCM_VALIDATE_INUM_MIN (1, i,0);
- j = scm_thread_sleep (SCM_INUM(i));
- return scm_ulong2num (j);
+ return scm_from_uint (scm_std_sleep (scm_to_uint (i)));
}
#undef FUNC_NAME
SCM_DEFINE (scm_usleep, "usleep", 1, 0, 0,
(SCM i),
- "Sleep for I microseconds. @code{usleep} is not available on\n"
- "all platforms.")
+ "Wait the given period @var{usecs} microseconds (an integer).\n"
+ "If a signal arrives the wait stops and the return value is the\n"
+ "time remaining, in microseconds. If the period elapses with no\n"
+ "signal the return is zero.\n"
+ "\n"
+ "On most systems the process scheduler is not microsecond accurate and\n"
+ "the actual period slept by @code{usleep} may be rounded to a system\n"
+ "clock tick boundary. Traditionally such ticks were 10 milliseconds\n"
+ "apart, and that interval is often still used.\n"
+ "\n"
+ "See also @code{sleep}.")
#define FUNC_NAME s_scm_usleep
{
- unsigned long j;
- SCM_VALIDATE_INUM_MIN (1, i,0);
- j = scm_thread_usleep (SCM_INUM (i));
- return scm_ulong2num (j);
+ return scm_from_ulong (scm_std_usleep (scm_to_ulong (i)));
}
#undef FUNC_NAME
"@var{sig} is as described for the kill procedure.")
#define FUNC_NAME s_scm_raise
{
- SCM_VALIDATE_INUM (1, sig);
- SCM_DEFER_INTS;
- if (kill (getpid (), (int) SCM_INUM (sig)) != 0)
+ if (raise (scm_to_int (sig)) != 0)
SCM_SYSERROR;
- SCM_ALLOW_INTS;
return SCM_UNSPECIFIED;
}
#undef FUNC_NAME
\f
+void
+scm_i_close_signal_pipe()
+{
+ /* SIGNAL_DELIVERY_THREAD_MUTEX is only locked while the signal delivery
+ thread is being launched. The thread that calls this function is
+ already holding the thread admin mutex, so if the delivery thread hasn't
+ been launched at this point, it never will be before shutdown. */
+ scm_i_pthread_mutex_lock (&signal_delivery_thread_mutex);
+
+#if SCM_USE_PTHREAD_THREADS
+ if (scm_i_signal_delivery_thread != NULL)
+ close (signal_pipe[1]);
+#endif
+
+ scm_i_pthread_mutex_unlock (&signal_delivery_thread_mutex);
+}
+
void
scm_init_scmsigs ()
{
signal_handlers =
SCM_VARIABLE_LOC (scm_c_define ("signal-handlers",
scm_c_make_vector (NSIG, SCM_BOOL_F)));
- signal_handler_cells =
- scm_permanent_object (scm_c_make_vector (NSIG, SCM_BOOL_F));
- signal_cell_handlers =
- scm_permanent_object (scm_c_make_vector (NSIG, SCM_BOOL_F));
- signal_handler_threads =
- scm_permanent_object (scm_c_make_vector (NSIG, SCM_BOOL_F));
+ signal_handler_asyncs = scm_c_make_vector (NSIG, SCM_BOOL_F);
+ signal_handler_threads = scm_c_make_vector (NSIG, SCM_BOOL_F);
for (i = 0; i < NSIG; i++)
{
#else
orig_handlers[i] = SIG_ERR;
#endif
-
-#ifdef HAVE_RESTARTABLE_SYSCALLS
- /* If HAVE_RESTARTABLE_SYSCALLS is defined, it's important that
- signals really are restartable. don't rely on the same
- run-time that configure got: reset the default for every signal.
- */
-#ifdef HAVE_SIGINTERRUPT
- siginterrupt (i, 0);
-#elif defined(SA_RESTART)
- {
- struct sigaction action;
-
- sigaction (i, NULL, &action);
- if (!(action.sa_flags & SA_RESTART))
- {
- action.sa_flags |= SA_RESTART;
- sigaction (i, &action, NULL);
- }
- }
-#endif
- /* if neither siginterrupt nor SA_RESTART are available we may
- as well assume that signals are always restartable. */
-#endif
}
- scm_c_define ("NSIG", scm_long2num (NSIG));
- scm_c_define ("SIG_IGN", scm_long2num ((long) SIG_IGN));
- scm_c_define ("SIG_DFL", scm_long2num ((long) SIG_DFL));
+ scm_c_define ("NSIG", scm_from_long (NSIG));
+ scm_c_define ("SIG_IGN", scm_from_long ((long) SIG_IGN));
+ scm_c_define ("SIG_DFL", scm_from_long ((long) SIG_DFL));
#ifdef SA_NOCLDSTOP
- scm_c_define ("SA_NOCLDSTOP", scm_long2num (SA_NOCLDSTOP));
+ scm_c_define ("SA_NOCLDSTOP", scm_from_long (SA_NOCLDSTOP));
#endif
#ifdef SA_RESTART
- scm_c_define ("SA_RESTART", scm_long2num (SA_RESTART));
+ scm_c_define ("SA_RESTART", scm_from_long (SA_RESTART));
#endif
#if defined(HAVE_SETITIMER) || defined(HAVE_GETITIMER)
/* Stuff needed by setitimer and getitimer. */
- scm_c_define ("ITIMER_REAL", SCM_MAKINUM (ITIMER_REAL));
- scm_c_define ("ITIMER_VIRTUAL", SCM_MAKINUM (ITIMER_VIRTUAL));
- scm_c_define ("ITIMER_PROF", SCM_MAKINUM (ITIMER_PROF));
+ scm_c_define ("ITIMER_REAL", scm_from_int (ITIMER_REAL));
+ scm_c_define ("ITIMER_VIRTUAL", scm_from_int (ITIMER_VIRTUAL));
+ scm_c_define ("ITIMER_PROF", scm_from_int (ITIMER_PROF));
#endif /* defined(HAVE_SETITIMER) || defined(HAVE_GETITIMER) */
#include "libguile/scmsigs.x"
HCoop / bpt / guile.git / blobdiff