#pragma implementation "Signal.h"
#include <Signal.h>
#include <sys/time.h>

#ifndef MAXSIG
#ifdef NSIG
#define MAXSIG NSIG
#elif defined(_NSIG)
#define MAXSIG _NSIG
#elif defined(SIGMAX)
#define MAXSIG (SIGMAX + 1)
#endif
#endif

static volatile int flag[MAXSIG];
static Event *u_sig[MAXSIG];

int Signal::check() {
  while (flag[0]) {
    flag[0] = 0;
    for (int i = 1; i < MAXSIG; ++i) {
      if (flag[i]) {
	flag[i] = 0;
	flag[0] = -1;	// check array again next time round
	signal(i,handler);
	if (u_sig[i] == 0 || u_sig[i]->handler()) {
	  return -i-1;// return signal to caller
	}
      }
    }
  }
  return -1;
}

timeval Signal::timeout;

void Signal::handler(int s) {
  // this causes infinite recursion for
  // some signals - e.g. SIGCLD
/* signal(s,handler); */	
  // We reenable the signal in check() instead.  This widens the window in
  // which a second signal will abort us, but we couldn't *guarrantee* to
  // reenable it in time anyway.
  flag[s] = -1;
  flag[0] = -1;
  timeout.tv_sec = 0;
}

Signal::Signal(int s,Event *e) {
  prev = u_sig[sig = s];
  u_sig[sig] = e;
  save = signal(sig,handler);
  if (save == SIG_IGN)
    signal(sig,save);
}

Signal::~Signal() {
  signal(sig,save);
  u_sig[sig] = prev;
}