[bpt/emacs.git] / src / atimer.c

/* Asynchronous timers.
   Copyright (C) 2000 Free Software Foundation, Inc.

This file is part of GNU Emacs.

GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Emacs 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING.  If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */

#include <config.h>
#include <lisp.h>
#include <signal.h>
#include <syssignal.h>
#include <systime.h>
#include <blockinput.h>
#include <atimer.h>
#include <stdio.h>

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif

/* Free-list of atimer structures.  */

static struct atimer *free_atimers;

/* List of currently not running timers due to a call to
   lock_atimer.  */

static struct atimer *stopped_atimers;

/* List of active atimers, sorted by expiration time.  The timer that
   will become ripe next is always at the front of this list.  */

static struct atimer *atimers;

/* Non-zero means alarm_signal_handler has found ripe timers but
   interrupt_input_blocked was non-zero.  In this case, timer
   functions are not called until the next UNBLOCK_INPUT because timer
   functions are expected to call X, and X cannot be assumed to be
   reentrant.  */

int pending_atimers;

/* Block/unblock SIGALRM.  */

#define BLOCK_ATIMERS   sigblock (sigmask (SIGALRM))
#define UNBLOCK_ATIMERS sigunblock (sigmask (SIGALRM))

/* Function prototypes.  */

static void set_alarm P_ ((void));
static void schedule_atimer P_ ((struct atimer *));
static struct atimer *append_atimer_lists P_ ((struct atimer *,
					       struct atimer *));
SIGTYPE alarm_signal_handler ();


/* Start a new atimer of type TYPE.  TIME specifies when the timer is
   ripe.  FN is the function to call when the timer fires.
   CLIENT_DATA is stored in the client_data member of the atimer
   structure returned and so made available to FN when it is called.

   If TYPE is ATIMER_ABSOLUTE, TIME is the absolute time at which the
   timer fires.

   If TYPE is ATIMER_RELATIVE, the timer is ripe TIME s/us in the
   future.

   In both cases, the timer is automatically freed after it has fired.

   If TYPE is ATIMER_CONTINUOUS, the timer fires every TIME s/us.

   Value is a pointer to the atimer started.  It can be used in calls
   to cancel_atimer; don't free it yourself.  */

struct atimer *
start_atimer (type, time, fn, client_data)
     enum atimer_type type;
     EMACS_TIME time;
     atimer_callback fn;
     void *client_data;
{
  struct atimer *t;

  /* Round TIME up to the next full second if we don't have
     itimers.  */
#ifndef HAVE_SETITIMER
  if (EMACS_USECS (time) != 0)
    {
      EMACS_SET_USECS (time, 0);
      EMACS_SET_SECS (time, EMACS_SECS (time) + 1);
    }
#endif /* not HAVE_SETITIMER */

  /* Get an atimer structure from the free-list, or allocate
     a new one.  */
  if (free_atimers)
    {
      t = free_atimers;
      free_atimers = t->next;
    }
  else
    t = (struct atimer *) xmalloc (sizeof *t);

  /* Fill the atimer structure.  */
  bzero (t, sizeof *t);
  t->type = type;
  t->fn = fn;
  t->client_data = client_data;

  BLOCK_ATIMERS;

  /* Compute the timer's expiration time.  */
  switch (type)
    {
    case ATIMER_ABSOLUTE:
      t->expiration = time;
      break;

    case ATIMER_RELATIVE:
      EMACS_GET_TIME (t->expiration);
      EMACS_ADD_TIME (t->expiration, t->expiration, time);
      break;

    case ATIMER_CONTINUOUS:
      EMACS_GET_TIME (t->expiration);
      EMACS_ADD_TIME (t->expiration, t->expiration, time);
      t->interval = time;
      break;
    }

  /* Insert the timer in the list of active atimers.  */
  schedule_atimer (t);
  UNBLOCK_ATIMERS;

  /* Arrange for a SIGALRM at the time the next atimer is ripe.  */
  set_alarm ();

  return t;
}


/* Cancel and free atimer TIMER.  */

void
cancel_atimer (timer)
     struct atimer *timer;
{
  int i;

  BLOCK_ATIMERS;

  for (i = 0; i < 2; ++i)
    {
      struct atimer *t, *prev;
      struct atimer **list = i ? &stopped_atimers : &atimers;

      /* See if TIMER is active or stopped.  */
      for (t = *list, prev = NULL; t && t != timer; prev = t, t = t->next)
	;

      /* If it is, take it off the its list, and put in on the
	 free-list.  We don't bother to arrange for setting a
	 different alarm time, since a too early one doesn't hurt.  */
      if (t)
	{
	  if (prev)
	    prev->next = t->next;
	  else
	    *list = t->next;

	  t->next = free_atimers;
	  free_atimers = t;
	  break;
	}
    }

  UNBLOCK_ATIMERS;
}


/* Append two lists of atimers LIST1 and LIST2 and return the
   result list.  */

static struct atimer *
append_atimer_lists (list1, list2)
     struct atimer *list1, *list2;
{
  if (list1 == NULL)
    return list2;
  else if (list2 == NULL)
    return list1;
  else
    {
      struct atimer *p;

      for (p = list1; p->next; p = p->next)
	;
      p->next = list2;
      return list1;
    }
}


/* Stop all timers except timer T.  T null means stop all timers.  */

void
stop_other_atimers (t)
     struct atimer *t;
{
  BLOCK_ATIMERS;

  if (t)
    {
      struct atimer *p, *prev;

      /* See if T is active.  */
      for (p = atimers, prev = 0; p && p != t; p = p->next)
	;

      if (p == t)
	{
	  if (prev)
	    prev->next = t->next;
	  else
	    atimers = t->next;
	  t->next = NULL;
	}
      else
	/* T is not active.  Let's handle this like T == 0.  */
	t = NULL;
    }

  stopped_atimers = append_atimer_lists (atimers, stopped_atimers);
  atimers = t;
  UNBLOCK_ATIMERS;
}


/* Run all timers again, if some have been stopped with a call to
   stop_other_atimers.  */

void
run_all_atimers ()
{
  if (stopped_atimers)
    {
      struct atimer *t = atimers;
      struct atimer *next;

      BLOCK_ATIMERS;
      atimers = stopped_atimers;
      stopped_atimers = NULL;

      while (t)
	{
	  next = t->next;
	  schedule_atimer (t);
	  t = next;
	}

      UNBLOCK_ATIMERS;
    }
}


/* A version of run_all_timers suitable for a record_unwind_protect.  */

Lisp_Object
unwind_stop_other_atimers (dummy)
     Lisp_Object dummy;
{
  run_all_atimers ();
  return Qnil;
}


/* Arrange for a SIGALRM to arrive when the next timer is ripe.  */

static void
set_alarm ()
{
#if defined (USG) && !defined (POSIX_SIGNALS)
  /* USG systems forget handlers when they are used;
     must reestablish each time.  */
  signal (SIGALRM, alarm_signal_handler);
#endif /* USG */

  if (atimers)
    {
      EMACS_TIME now, time;
#ifdef HAVE_SETITIMER
      struct itimerval it;
#endif

      /* Determine s/us till the next timer is ripe.  */
      EMACS_GET_TIME (now);
      EMACS_SUB_TIME (time, atimers->expiration, now);

#ifdef HAVE_SETITIMER
      /* Don't set the interval to 0; this disables the timer.  */
      if (EMACS_TIME_LE (atimers->expiration, now))
	{
	  EMACS_SET_SECS (time, 0);
	  EMACS_SET_USECS (time, 1000);
	}

      bzero (&it, sizeof it);
      it.it_value = time;
      setitimer (ITIMER_REAL, &it, 0);
#else /* not HAVE_SETITIMER */
      alarm (max (EMACS_SECS (time), 1));
#endif /* not HAVE_SETITIMER */
    }
}


/* Insert timer T into the list of active atimers `atimers', keeping
   the list sorted by expiration time.  T must not be in this list
   already.  */

static void
schedule_atimer (t)
     struct atimer *t;
{
  struct atimer *a = atimers, *prev = NULL;

  /* Look for the first atimer that is ripe after T.  */
  while (a && EMACS_TIME_GT (t->expiration, a->expiration))
    prev = a, a = a->next;

  /* Insert T in front of the atimer found, if any.  */
  if (prev)
    prev->next = t;
  else
    atimers = t;

  t->next = a;
}


/* Signal handler for SIGALRM.  SIGNO is the signal number, i.e.
   SIGALRM.  */

SIGTYPE
alarm_signal_handler (signo)
     int signo;
{
  EMACS_TIME now;

  EMACS_GET_TIME (now);
  pending_atimers = 0;

  while (atimers
	 && (pending_atimers = interrupt_input_blocked) == 0
	 && EMACS_TIME_LE (atimers->expiration, now))
    {
      struct atimer *t;

      t = atimers;
      atimers = atimers->next;
      t->fn (t);

      if (t->type == ATIMER_CONTINUOUS)
	{
	  EMACS_ADD_TIME (t->expiration, now, t->interval);
	  schedule_atimer (t);
	}
      else
	{
	  t->next = free_atimers;
	  free_atimers = t;
	}

      EMACS_GET_TIME (now);
    }

  set_alarm ();
}


/* Call alarm_signal_handler for pending timers.  */

void
do_pending_atimers ()
{
  if (pending_atimers)
    {
      BLOCK_ATIMERS;
      alarm_signal_handler (SIGALRM);
      UNBLOCK_ATIMERS;
    }
}


/* Turn alarms on/off.  This seems to be temporarily necessary on
   some systems like HPUX (see process.c).  */

void
turn_on_atimers (on)
     int on;
{
  if (on)
    {
      signal (SIGALRM, alarm_signal_handler);
      set_alarm ();
    }
  else
    alarm (0);
}


void
init_atimer ()
{
  free_atimers = atimers = NULL;
  pending_atimers = 0;
  signal (SIGALRM, alarm_signal_handler);
}

/* arch-tag: e6308261-eec6-404b-89fb-6e5909518d70
   (do not change this comment) */
Commit	Line	Data
e12489f9 GM	1	/* Asynchronous timers.
	2	Copyright (C) 2000 Free Software Foundation, Inc.
	3
	4	This file is part of GNU Emacs.
	5
	6	GNU Emacs is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2, or (at your option)
	9	any later version.
	10
	11	GNU Emacs is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GNU Emacs; see the file COPYING. If not, write to
	18	the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	19	Boston, MA 02111-1307, USA. */
	20
	21	#include <config.h>
	22	#include <lisp.h>
	23	#include <signal.h>
	24	#include <syssignal.h>
	25	#include <systime.h>
	26	#include <blockinput.h>
	27	#include <atimer.h>
	28	#include <stdio.h>
	29
	30	#ifdef HAVE_UNISTD_H
	31	#include <unistd.h>
	32	#endif
	33
	34	#ifdef HAVE_SYS_TIME_H
	35	#include <sys/time.h>
	36	#endif
	37
e12489f9 GM	38	/* Free-list of atimer structures. */
	39
	40	static struct atimer *free_atimers;
	41
9c2e3e8d GM	42	/* List of currently not running timers due to a call to
	43	lock_atimer. */
	44
	45	static struct atimer *stopped_atimers;
	46
e12489f9 GM	47	/* List of active atimers, sorted by expiration time. The timer that
	48	will become ripe next is always at the front of this list. */
	49
	50	static struct atimer *atimers;
	51
	52	/* Non-zero means alarm_signal_handler has found ripe timers but
	53	interrupt_input_blocked was non-zero. In this case, timer
	54	functions are not called until the next UNBLOCK_INPUT because timer
	55	functions are expected to call X, and X cannot be assumed to be
	56	reentrant. */
	57
	58	int pending_atimers;
	59
5f351ff1	60	/* Block/unblock SIGALRM. */
e12489f9 GM	61
	62	#define BLOCK_ATIMERS sigblock (sigmask (SIGALRM))
	63	#define UNBLOCK_ATIMERS sigunblock (sigmask (SIGALRM))
	64
	65	/* Function prototypes. */
	66
	67	static void set_alarm P_ ((void));
	68	static void schedule_atimer P_ ((struct atimer *));
50b1039f GM	69	static struct atimer append_atimer_lists P_ ((struct atimer ,
50b1039f GM	70	struct atimer *));
a3aca278	71	SIGTYPE alarm_signal_handler ();
e12489f9 GM	72
	73
	74	/* Start a new atimer of type TYPE. TIME specifies when the timer is
	75	ripe. FN is the function to call when the timer fires.
	76	CLIENT_DATA is stored in the client_data member of the atimer
	77	structure returned and so made available to FN when it is called.
	78
	79	If TYPE is ATIMER_ABSOLUTE, TIME is the absolute time at which the
	80	timer fires.
	81
	82	If TYPE is ATIMER_RELATIVE, the timer is ripe TIME s/us in the
	83	future.
	84
	85	In both cases, the timer is automatically freed after it has fired.
	86
	87	If TYPE is ATIMER_CONTINUOUS, the timer fires every TIME s/us.
	88
	89	Value is a pointer to the atimer started. It can be used in calls
	90	to cancel_atimer; don't free it yourself. */
	91
	92	struct atimer *
	93	start_atimer (type, time, fn, client_data)
	94	enum atimer_type type;
	95	EMACS_TIME time;
	96	atimer_callback fn;
	97	void *client_data;
	98	{
	99	struct atimer *t;
	100
	101	/* Round TIME up to the next full second if we don't have
	102	itimers. */
	103	#ifndef HAVE_SETITIMER
	104	if (EMACS_USECS (time) != 0)
	105	{
4ce94f99 EZ	106	EMACS_SET_USECS (time, 0);
4ce94f99 EZ	107	EMACS_SET_SECS (time, EMACS_SECS (time) + 1);
e12489f9 GM	108	}
	109	#endif /* not HAVE_SETITIMER */
	110
	111	/* Get an atimer structure from the free-list, or allocate
	112	a new one. */
	113	if (free_atimers)
	114	{
	115	t = free_atimers;
	116	free_atimers = t->next;
	117	}
	118	else
	119	t = (struct atimer ) xmalloc (sizeof t);
	120
	121	/* Fill the atimer structure. */
	122	bzero (t, sizeof *t);
	123	t->type = type;
	124	t->fn = fn;
	125	t->client_data = client_data;
	126
	127	BLOCK_ATIMERS;
	128
	129	/* Compute the timer's expiration time. */
	130	switch (type)
	131	{
	132	case ATIMER_ABSOLUTE:
	133	t->expiration = time;
	134	break;
177c0ea7	135
e12489f9 GM	136	case ATIMER_RELATIVE:
	137	EMACS_GET_TIME (t->expiration);
	138	EMACS_ADD_TIME (t->expiration, t->expiration, time);
	139	break;
177c0ea7	140
e12489f9 GM	141	case ATIMER_CONTINUOUS:
	142	EMACS_GET_TIME (t->expiration);
	143	EMACS_ADD_TIME (t->expiration, t->expiration, time);
	144	t->interval = time;
	145	break;
	146	}
	147
	148	/* Insert the timer in the list of active atimers. */
	149	schedule_atimer (t);
	150	UNBLOCK_ATIMERS;
	151
	152	/* Arrange for a SIGALRM at the time the next atimer is ripe. */
	153	set_alarm ();
177c0ea7	154
e12489f9 GM	155	return t;
	156	}
	157
	158
	159	/* Cancel and free atimer TIMER. */
	160
	161	void
	162	cancel_atimer (timer)
	163	struct atimer *timer;
	164	{
50b1039f	165	int i;
177c0ea7	166
e12489f9 GM	167	BLOCK_ATIMERS;
e12489f9 GM	168
50b1039f	169	for (i = 0; i < 2; ++i)
94870977	170	{
50b1039f GM	171	struct atimer t, prev;
50b1039f GM	172	struct atimer **list = i ? &stopped_atimers : &atimers;
177c0ea7	173
94870977	174	/* See if TIMER is active or stopped. */
4ab1d4be	175	for (t = *list, prev = NULL; t && t != timer; prev = t, t = t->next)
94870977 GM	176	;
94870977 GM	177
50b1039f	178	/* If it is, take it off the its list, and put in on the
94870977 GM	179	free-list. We don't bother to arrange for setting a
	180	different alarm time, since a too early one doesn't hurt. */
	181	if (t)
	182	{
	183	if (prev)
	184	prev->next = t->next;
	185	else
	186	*list = t->next;
177c0ea7	187
94870977 GM	188	t->next = free_atimers;
94870977 GM	189	free_atimers = t;
4ab1d4be	190	break;
94870977	191	}
e12489f9 GM	192	}
	193
	194	UNBLOCK_ATIMERS;
	195	}
	196
	197
50b1039f GM	198	/* Append two lists of atimers LIST1 and LIST2 and return the
	199	result list. */
	200
	201	static struct atimer *
	202	append_atimer_lists (list1, list2)
	203	struct atimer list1, list2;
	204	{
	205	if (list1 == NULL)
	206	return list2;
	207	else if (list2 == NULL)
	208	return list1;
	209	else
	210	{
	211	struct atimer *p;
177c0ea7	212
50b1039f GM	213	for (p = list1; p->next; p = p->next)
	214	;
	215	p->next = list2;
	216	return list1;
	217	}
	218	}
	219
	220
	221	/* Stop all timers except timer T. T null means stop all timers. */
9c2e3e8d GM	222
	223	void
	224	stop_other_atimers (t)
	225	struct atimer *t;
	226	{
	227	BLOCK_ATIMERS;
177c0ea7	228
9c2e3e8d GM	229	if (t)
9c2e3e8d GM	230	{
2503c8b1	231	struct atimer p, prev;
177c0ea7	232
2503c8b1 GM	233	/* See if T is active. */
	234	for (p = atimers, prev = 0; p && p != t; p = p->next)
	235	;
	236
	237	if (p == t)
	238	{
	239	if (prev)
	240	prev->next = t->next;
	241	else
	242	atimers = t->next;
	243	t->next = NULL;
	244	}
	245	else
	246	/* T is not active. Let's handle this like T == 0. */
	247	t = NULL;
9c2e3e8d	248	}
177c0ea7	249
50b1039f	250	stopped_atimers = append_atimer_lists (atimers, stopped_atimers);
9c2e3e8d GM	251	atimers = t;
	252	UNBLOCK_ATIMERS;
	253	}
	254
	255
	256	/* Run all timers again, if some have been stopped with a call to
	257	stop_other_atimers. */
	258
	259	void
	260	run_all_atimers ()
	261	{
	262	if (stopped_atimers)
	263	{
	264	struct atimer *t = atimers;
50b1039f	265	struct atimer *next;
177c0ea7	266
9c2e3e8d GM	267	BLOCK_ATIMERS;
	268	atimers = stopped_atimers;
	269	stopped_atimers = NULL;
177c0ea7	270
50b1039f GM	271	while (t)
	272	{
	273	next = t->next;
	274	schedule_atimer (t);
	275	t = next;
	276	}
177c0ea7	277
9c2e3e8d GM	278	UNBLOCK_ATIMERS;
	279	}
	280	}
	281
	282
	283	/* A version of run_all_timers suitable for a record_unwind_protect. */
	284
	285	Lisp_Object
	286	unwind_stop_other_atimers (dummy)
	287	Lisp_Object dummy;
	288	{
	289	run_all_atimers ();
	290	return Qnil;
	291	}
	292
	293
e12489f9 GM	294	/* Arrange for a SIGALRM to arrive when the next timer is ripe. */
	295
	296	static void
	297	set_alarm ()
	298	{
e12489f9 GM	299	#if defined (USG) && !defined (POSIX_SIGNALS)
	300	/* USG systems forget handlers when they are used;
	301	must reestablish each time. */
	302	signal (SIGALRM, alarm_signal_handler);
	303	#endif /* USG */
177c0ea7	304
e12489f9 GM	305	if (atimers)
	306	{
	307	EMACS_TIME now, time;
	308	#ifdef HAVE_SETITIMER
	309	struct itimerval it;
	310	#endif
	311
	312	/* Determine s/us till the next timer is ripe. */
	313	EMACS_GET_TIME (now);
	314	EMACS_SUB_TIME (time, atimers->expiration, now);
	315
	316	#ifdef HAVE_SETITIMER
	317	/* Don't set the interval to 0; this disables the timer. */
	318	if (EMACS_TIME_LE (atimers->expiration, now))
	319	{
	320	EMACS_SET_SECS (time, 0);
	321	EMACS_SET_USECS (time, 1000);
	322	}
177c0ea7	323
e12489f9 GM	324	bzero (&it, sizeof it);
	325	it.it_value = time;
	326	setitimer (ITIMER_REAL, &it, 0);
	327	#else /* not HAVE_SETITIMER */
	328	alarm (max (EMACS_SECS (time), 1));
	329	#endif /* not HAVE_SETITIMER */
	330	}
	331	}
	332
	333
	334	/* Insert timer T into the list of active atimers `atimers', keeping
	335	the list sorted by expiration time. T must not be in this list
	336	already. */
	337
	338	static void
	339	schedule_atimer (t)
	340	struct atimer *t;
	341	{
	342	struct atimer a = atimers, prev = NULL;
	343
	344	/* Look for the first atimer that is ripe after T. */
	345	while (a && EMACS_TIME_GT (t->expiration, a->expiration))
	346	prev = a, a = a->next;
	347
	348	/* Insert T in front of the atimer found, if any. */
	349	if (prev)
	350	prev->next = t;
	351	else
	352	atimers = t;
177c0ea7	353
e12489f9 GM	354	t->next = a;
	355	}
	356
	357
	358	/* Signal handler for SIGALRM. SIGNO is the signal number, i.e.
	359	SIGALRM. */
	360
	361	SIGTYPE
	362	alarm_signal_handler (signo)
	363	int signo;
	364	{
	365	EMACS_TIME now;
177c0ea7	366
e12489f9 GM	367	EMACS_GET_TIME (now);
e12489f9 GM	368	pending_atimers = 0;
177c0ea7	369
e12489f9 GM	370	while (atimers
	371	&& (pending_atimers = interrupt_input_blocked) == 0
	372	&& EMACS_TIME_LE (atimers->expiration, now))
	373	{
	374	struct atimer *t;
177c0ea7	375
e12489f9 GM	376	t = atimers;
	377	atimers = atimers->next;
	378	t->fn (t);
177c0ea7	379
e12489f9 GM	380	if (t->type == ATIMER_CONTINUOUS)
	381	{
	382	EMACS_ADD_TIME (t->expiration, now, t->interval);
	383	schedule_atimer (t);
	384	}
	385	else
	386	{
	387	t->next = free_atimers;
	388	free_atimers = t;
	389	}
177c0ea7	390
e12489f9 GM	391	EMACS_GET_TIME (now);
e12489f9 GM	392	}
177c0ea7	393
e12489f9 GM	394	set_alarm ();
	395	}
	396
	397
	398	/* Call alarm_signal_handler for pending timers. */
	399
	400	void
	401	do_pending_atimers ()
	402	{
	403	if (pending_atimers)
	404	{
	405	BLOCK_ATIMERS;
	406	alarm_signal_handler (SIGALRM);
	407	UNBLOCK_ATIMERS;
	408	}
	409	}
	410
	411
	412	/* Turn alarms on/off. This seems to be temporarily necessary on
	413	some systems like HPUX (see process.c). */
	414
	415	void
	416	turn_on_atimers (on)
	417	int on;
	418	{
	419	if (on)
	420	{
	421	signal (SIGALRM, alarm_signal_handler);
	422	set_alarm ();
	423	}
	424	else
	425	alarm (0);
	426	}
	427
	428
	429	void
	430	init_atimer ()
	431	{
	432	free_atimers = atimers = NULL;
	433	pending_atimers = 0;
	434	signal (SIGALRM, alarm_signal_handler);
	435	}
ab5796a9 MB	436
	437	/* arch-tag: e6308261-eec6-404b-89fb-6e5909518d70
	438	(do not change this comment) */