comparison src/atimer.c @ 27913:81d5641c8b04

(start_atimer): Don't abort when timers are stopped. (append_atimer_lists): New function. (cancel_atimer, stop_other_atimers, run_all_atimers): Handle arbitrary lists of stopped and running atimers.

27912:ed26ed5b0afc

/* Function prototypes.  */

static void set_alarm P_ ((void));
static void schedule_atimer P_ ((struct atimer *));


/* 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

     atimer_callback fn;
     void *client_data;
{
  struct atimer *t;

  /* May not be called when some timers are stopped.  */
  if (stopped_atimers)
    abort ();

  /* Round TIME up to the next full second if we don't have
     itimers.  */
#ifndef HAVE_SETITIMER
  if (EMACS_USECS (time) != 0)
    {

void
cancel_atimer (timer)
     struct atimer *timer;
{
  struct atimer *t, *prev;
  struct atimer **list;

  BLOCK_ATIMERS;

  /* If we've stopped all other timers except TIMER, we can
     just reset the list of active atimers to null.  */
  if (stopped_atimers && timer == atimers)
    {
      timer->next = free_atimers;
      free_atimers = timer;
      atimers = NULL;
    }
  else
    {
      /* See if TIMER is active or stopped.  */
      list = stopped_atimers ? &stopped_atimers : &atimers;
      for (t = *list, prev = 0; t && t != timer; t = t->next)
	;

      /* If it is, take it off the list of 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)

  UNBLOCK_ATIMERS;
}


/* Stop all timers except timer T.  T null means stop all timers.
   This function may only be called when all timers are running.  Two
   calls of this function in a row will lead to an abort.  You may not
   call cancel_atimer or start_atimer while timers are stopped.  */

void
stop_other_atimers (t)
     struct atimer *t;
{
  BLOCK_ATIMERS;
  
  if (stopped_atimers)
    abort ();

  if (t)
    {
      struct atimer *p, *prev;
      
      /* See if T is active.  */

      else
	/* T is not active.  Let's handle this like T == 0.  */
	t = NULL;
    }
  
  stopped_atimers = atimers;
  atimers = t;
  UNBLOCK_ATIMERS;
}

run_all_atimers ()
{
  if (stopped_atimers)
    {
      struct atimer *t = atimers;
      BLOCK_ATIMERS;
      atimers = stopped_atimers;
      stopped_atimers = NULL;
      if (t)
	schedule_atimer (t);
      UNBLOCK_ATIMERS;
    }
}

27913:81d5641c8b04

/* 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 *));


/* 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

     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)
    {

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 = 0; t && t != timer; 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)

  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.  */

      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_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;
    }
}