The R Project SVN – R – Diff – /trunk/src/gnuwin32/psignal.c

 #include "psignal.h"
 extern int UserBreak;
 /* Define stuff ************************************************************ */
 #ifndef TRUE
-  #define TRUE 1
+# define TRUE 1
 #endif
 #ifndef FALSE
-  #define FALSE 0
+# define FALSE 0
 #endif
 /* Signal groupings ======================================================== */
 #define SIGNAL_DEFAULT_EXIT         case SIGABRT:               \
-                                    case SIGFPE:                \
+				    case SIGFPE:                \
-                                    case SIGILL:                \
+				    case SIGILL:                \
-                                    case SIGINT:                \
+				    case SIGINT:                \
-                                    case SIGSEGV:               \
+				    case SIGSEGV:               \
-                                    case SIGTERM:
+				    case SIGTERM:
 #define IS_SIGNAL(a)        ( ((a) > 0 ) &&  ((a) < NSIG))
 /* Struct stuff **************************************************************/
 struct downhill_Signal_Struct
+{
-	void     (*signal_Handler)(int);
+    void     (*signal_Handler)(int);
-	int      signal_Count;
+    int      signal_Count;
-	int      signal_Extra;
+    int      signal_Extra;
-	sigset_t signal_Mask;
+    sigset_t signal_Mask;
-	int      signal_Flags;
+    int      signal_Flags;
 };
 /* Static stuff **************************************************************/
 static struct downhill_Signal_Struct* downhill_Signal_Info = NULL;
 /* Handle a signal ========================================================= */
 void raise(int signal_Number)
+{
-        if (!IS_SIGNAL(signal_Number)) {
+    if (!IS_SIGNAL(signal_Number)) {
-			errno = EINVAL;
+	errno = EINVAL;
-			return;
+	return;
-        }
+    }
-	/* Check to see if we're masking this signal */
+    /* Check to see if we're masking this signal */
-	if (sigismember(&downhill_Sigset_Mask,signal_Number))
+    if (sigismember(&downhill_Sigset_Mask,signal_Number))
-	{
+    {
-		downhill_Signal_Info[signal_Number].signal_Count++;
+	downhill_Signal_Info[signal_Number].signal_Count++;
+    }
+    else
+    {
+	/* Do a signal's action */
+	if (downhill_Signal_Info[signal_Number].signal_Handler ==
+	    SIG_DFL)
+	{
+	    switch (signal_Number)
+	    {
+		SIGNAL_DEFAULT_EXIT
+		    exit(3);
+	    default:
+		break;
+	    }
 	}
+	else if (
+	    (downhill_Signal_Info[signal_Number].signal_Handler ==
+	     SIG_IGN)
+	    )
+	{/* IGNORE */}
 	else
-        {
-	        /* Do a signal's action */
-		if (downhill_Signal_Info[signal_Number].signal_Handler ==
-		 SIG_DFL)
-		{
+	{
-			switch (signal_Number)
-			{
-				SIGNAL_DEFAULT_EXIT
-					exit(3);
-				default:
-                                        break;
-			}
-		}
-		else if (
-                 (downhill_Signal_Info[signal_Number].signal_Handler ==
-                  SIG_IGN)
-                )
-		  {/* IGNORE */}
-		else
-		{
-			void (*signal_HandlerOld)(int);
+	    void (*signal_HandlerOld)(int);
-			/* Do we reset the handler? */
+	    /* Do we reset the handler? */
-			signal_HandlerOld =
+	    signal_HandlerOld =
-			 downhill_Signal_Info[signal_Number].signal_Handler;
+		downhill_Signal_Info[signal_Number].signal_Handler;
-			if (downhill_Signal_Info[signal_Number].signal_Flags&
+	    if (downhill_Signal_Info[signal_Number].signal_Flags&
-			 SA_RESETHAND)
+		SA_RESETHAND)
-			{
+	    {
-				downhill_Signal_Info[signal_Number].
+		downhill_Signal_Info[signal_Number].
-				 signal_Handler = SIG_DFL;
+		    signal_Handler = SIG_DFL;
-			}
+	    }
-			/* Do the action */
+	    /* Do the action */
-			if ((signal_Number == SIGCHLD) &&
+	    if ((signal_Number == SIGCHLD) &&
-			 (downhill_Signal_Info[signal_Number].signal_Flags&
+		(downhill_Signal_Info[signal_Number].signal_Flags&
-			 SA_NOCLDSTOP))
+		 SA_NOCLDSTOP))
-			{
+	    {
-				/* Ignore SIGCHLD */
+		/* Ignore SIGCHLD */
-			}
+	    }
-			else
+	    else
-			{
+	    {
-				sigset_t sigset_MaskOriginal =
+		sigset_t sigset_MaskOriginal =
-				          downhill_Sigset_Mask;
+		    downhill_Sigset_Mask;
-				sigset_t sigset_MaskNew = downhill_Signal_Info[
+		sigset_t sigset_MaskNew = downhill_Signal_Info[
-				          signal_Number].signal_Mask;
+		    signal_Number].signal_Mask;
-				/* Set the new signal mask */
+		/* Set the new signal mask */
-				sigaddset(&sigset_MaskNew,signal_Number);
+		sigaddset(&sigset_MaskNew,signal_Number);
-				sigprocmask(SIG_BLOCK,&sigset_MaskNew,NULL);
+		sigprocmask(SIG_BLOCK,&sigset_MaskNew,NULL);
-				/* Execute the handler */
+		/* Execute the handler */
-				signal_HandlerOld(signal_Number);
+		signal_HandlerOld(signal_Number);
-				/* Restore the signal mask */
+		/* Restore the signal mask */
-				sigprocmask(SIG_SETMASK,&sigset_MaskOriginal,
+		sigprocmask(SIG_SETMASK,&sigset_MaskOriginal,
-				 NULL);
+			    NULL);
-			}
+	    }
-		}
-                PulseEvent(IGotASignal);
+	}
+	PulseEvent(IGotASignal);
+    }
+}
 /* Init the signal re-direction ============================================ */
 /* Hardware interrupt handler.  */
 static BOOL CALLBACK hwIntrHandler (DWORD type)
+{
-  int ret;
+    int ret;
-  switch (type) {
+    switch (type) {
-  case CTRL_C_EVENT :
+    case CTRL_C_EVENT :
-  case CTRL_BREAK_EVENT :
+    case CTRL_BREAK_EVENT :
-    /*
+	/*
-	Why SIGBREAK? SIGINT is used internally by R and the signal
+	  Why SIGBREAK? SIGINT is used internally by R and the signal
-	handler for SIGINT ends with a 'longjmp'. But, under Windows,
+	  handler for SIGINT ends with a 'longjmp'. But, under Windows,
-	hardware interrupt handler runs in a different thread. So,
+	  hardware interrupt handler runs in a different thread. So,
-	longjmp fails (tipically it will crash R). So, we raise a SIGBREAK
+	  longjmp fails (tipically it will crash R). So, we raise a SIGBREAK
-	to record that the user want to stop. This is then
+	  to record that the user want to stop. This is then
-	processed at due time. Drawback of this approach: if R is lost
+	  processed at due time. Drawback of this approach: if R is lost
-	inside a C or Fortran routine we don't break it. I (g.m.) have
+	  inside a C or Fortran routine we don't break it. I (g.m.) have
-	tried to raise a signal in the appropriate thread using
+	  tried to raise a signal in the appropriate thread using
-	SuspendThread/GetThreadContext/setting Eip to the signal handler/
+	  SuspendThread/GetThreadContext/setting Eip to the signal handler/
-	SetThreadContext/ResumeThread but I had success only under NT.
+	  SetThreadContext/ResumeThread but I had success only under NT.
-    */
+	*/
-    raise(SIGBREAK);
+	raise(SIGBREAK);
-    /* Seems that SIGBREAK is not working under 1,4,0, so do it via
+	/* Seems that SIGBREAK is not working under 1,4,0, so do it via
-       a semaphore, as RGui does */
+	   a semaphore, as RGui does */
-    UserBreak = 1;
+	UserBreak = 1;
-    ret = TRUE;
+	ret = TRUE;
-    break;
+	break;
-  default:
+    default:
-    ret = FALSE;
+	ret = FALSE;
-  }
+    }
-  return ret ;
+    return ret ;
+}
 static int downhill_Signal_Init(void)
+{
-	/* Skip this if we've already done it */
+    /* Skip this if we've already done it */
-	if (downhill_Signal_Info == NULL)
+    if (downhill_Signal_Info == NULL)
+    {
+	if (!(downhill_Signal_Info =
+	      calloc(sizeof(struct downhill_Signal_Struct),NSIG)) ||
+	    !(IGotASignal=CreateEvent(NULL,FALSE,FALSE,NULL)) ||
+	    !SetConsoleCtrlHandler (hwIntrHandler, TRUE))
+	{
-		if (!(downhill_Signal_Info =
-		      calloc(sizeof(struct downhill_Signal_Struct),NSIG)) ||
-		    !(IGotASignal=CreateEvent(NULL,FALSE,FALSE,NULL)) ||
-                    !SetConsoleCtrlHandler (hwIntrHandler, TRUE))
-		{
-                  if (downhill_Signal_Info) free(downhill_Signal_Info);
+	    if (downhill_Signal_Info) free(downhill_Signal_Info);
-                  if (IGotASignal) CloseHandle(IGotASignal);
+	    if (IGotASignal) CloseHandle(IGotASignal);
-		  errno = ENOMEM;
+	    errno = ENOMEM;
-		  return FALSE;
+	    return FALSE;
-		}
+	}
+    }
-	return TRUE;
+    return TRUE;
+}
 /* Set a signal action ===================================================== */
 int sigaction(int signal_Number,struct sigaction* sigaction_Info,
      struct sigaction* sigaction_InfoOld)
+{
-	/* Make sure we're init'd */
+    /* Make sure we're init'd */
-	if (!downhill_Signal_Init())
+    if (!downhill_Signal_Init())
-	{
+    {
-		return -1;
+	return -1;
-	}
+    }
-	/* Set the signal */
+    /* Set the signal */
-        if (IS_SIGNAL(signal_Number)) {
+    if (IS_SIGNAL(signal_Number)) {
-			if (sigaction_InfoOld != NULL)
+	if (sigaction_InfoOld != NULL)
-			{
+	{
-				sigaction_InfoOld->sa_handler =
+	    sigaction_InfoOld->sa_handler =
-				 downhill_Signal_Info[signal_Number].
+		downhill_Signal_Info[signal_Number].
-				 signal_Handler;
+		signal_Handler;
-				sigaction_InfoOld->sa_mask =
+	    sigaction_InfoOld->sa_mask =
-				 downhill_Signal_Info[signal_Number].
+		downhill_Signal_Info[signal_Number].
-				 signal_Mask;
+		signal_Mask;
-				sigaction_InfoOld->sa_flags =
+	    sigaction_InfoOld->sa_flags =
-				 downhill_Signal_Info[signal_Number].
+		downhill_Signal_Info[signal_Number].
-				 signal_Flags;
+		signal_Flags;
-			}
+	}
-			if (sigaction_Info != NULL)
+	if (sigaction_Info != NULL)
-			{
+	{
-				downhill_Signal_Info[signal_Number].
+	    downhill_Signal_Info[signal_Number].
-				 signal_Handler = sigaction_Info->sa_handler;
+		signal_Handler = sigaction_Info->sa_handler;
-				downhill_Signal_Info[signal_Number].
+	    downhill_Signal_Info[signal_Number].
-				 signal_Count = 0;
+		signal_Count = 0;
-				downhill_Signal_Info[signal_Number].
+	    downhill_Signal_Info[signal_Number].
-				 signal_Extra = 0;
+		signal_Extra = 0;
-				downhill_Signal_Info[signal_Number].
+	    downhill_Signal_Info[signal_Number].
-				 signal_Mask = sigaction_Info->sa_mask;
+		signal_Mask = sigaction_Info->sa_mask;
-				downhill_Signal_Info[signal_Number].
+	    downhill_Signal_Info[signal_Number].
-				 signal_Flags = sigaction_Info->sa_flags;
+		signal_Flags = sigaction_Info->sa_flags;
-			}
-        }
-        else  {
-			errno = EINVAL;
-			return -1;
+	}
+    }
+    else  {
+	errno = EINVAL;
+	return -1;
+    }
-	return 0;
+    return 0;
+}
 /* Set the action of a signal ============================================== */
 sighandler_t signal(int signal_Number, sighandler_t signal_Handler)
+{
-	sighandler_t signal_HandlerOld;
+    sighandler_t signal_HandlerOld;
-	/* Make sure we're init'd */
+    /* Make sure we're init'd */
-	if (!IS_SIGNAL(signal_Number) || !downhill_Signal_Init() )
+    if (!IS_SIGNAL(signal_Number) || !downhill_Signal_Init() )
-	{
+    {
-		return SIG_ERR;
+	return SIG_ERR;
-	}
+    }
-	signal_HandlerOld =
+    signal_HandlerOld =
-		downhill_Signal_Info[signal_Number].signal_Handler;
+	downhill_Signal_Info[signal_Number].signal_Handler;
-	downhill_Signal_Info[signal_Number].signal_Handler =
+    downhill_Signal_Info[signal_Number].signal_Handler =
-		signal_Handler;
+	signal_Handler;
-	downhill_Signal_Info[signal_Number].signal_Count = 0;
+    downhill_Signal_Info[signal_Number].signal_Count = 0;
-	downhill_Signal_Info[signal_Number].signal_Extra = 0;
+    downhill_Signal_Info[signal_Number].signal_Extra = 0;
-	downhill_Signal_Info[signal_Number].signal_Mask = 0;
+    downhill_Signal_Info[signal_Number].signal_Mask = 0;
-	downhill_Signal_Info[signal_Number].signal_Flags = 0;
+    downhill_Signal_Info[signal_Number].signal_Flags = 0;
-	return signal_HandlerOld;
+    return signal_HandlerOld;
+}
 /* Add a signal to a set =================================================== */
 int sigaddset(sigset_t* sigset_Info,int signal_Number)
+{
     if (IS_SIGNAL(signal_Number)) {
-	    (*sigset_Info) |= (1 << (signal_Number - 1));
+	(*sigset_Info) |= (1 << (signal_Number - 1));
-            return 0;
+	return 0;
+    }
     else {
-	     errno = EINVAL;
+	errno = EINVAL;
-	     return -1;
+	return -1;
+    }
     return 0;
+}
 /* Remove a signal from a set ============================================== */
 int sigdelset(sigset_t* sigset_Info,int signal_Number)
+{
     if (IS_SIGNAL(signal_Number)) {
-	    *sigset_Info &= ~(1<< (signal_Number - 1));
+	*sigset_Info &= ~(1<< (signal_Number - 1));
-            return 0;
+	return 0;
+    }
     else {
-	     errno = EINVAL;
+	errno = EINVAL;
-	     return -1;
+	return -1;
+    }
     return 0;
+}
 /* Empty a set ============================================================= */
 int sigemptyset(sigset_t* sigset_Info)
+{
-	*sigset_Info = 0;
+    *sigset_Info = 0;
-	return 0;
+    return 0;
+}
 /* Fill a set ============================================================== */
 int sigfillset(sigset_t* sigset_Info)
+{
-	*sigset_Info = (sigset_t)-1;
+    *sigset_Info = (sigset_t)-1;
-	return 0;
+    return 0;
+}
 /* Checks if a signal is in a set ========================================== */
 int sigismember(sigset_t* sigset_Info,int signal_Number)
+{
-      if (IS_SIGNAL(signal_Number)) {
+    if (IS_SIGNAL(signal_Number)) {
-			if ( *sigset_Info & (1 << (signal_Number-1)))
+	if ( *sigset_Info & (1 << (signal_Number-1)))
-				return 1;
+	    return 1;
-                        else
+	else
-                                return 0;
+	    return 0;
-      }
+    }
-      errno = EINVAL;
+    errno = EINVAL;
-      return -1;
+    return -1;
+}
 /* Returns the signals pending ============================================= */
 int sigpending(sigset_t* sigset_Info)
+{
-	int signal_Index;
+    int signal_Index;
-	/* Make sure we're init'd */
+    /* Make sure we're init'd */
-	if (!downhill_Signal_Init())
+    if (!downhill_Signal_Init())
-	{
+    {
-		return -1;
+	return -1;
-	}
+    }
-	/* Check all the pending signals */
+    /* Check all the pending signals */
-        sigemptyset(sigset_Info);
+    sigemptyset(sigset_Info);
-	for (signal_Index = 1;signal_Index < NSIG;signal_Index++)
+    for (signal_Index = 1;signal_Index < NSIG;signal_Index++)
+    {
+	if (downhill_Signal_Info[signal_Index].signal_Count > 0)
+	{
-		if (downhill_Signal_Info[signal_Index].signal_Count > 0)
-		{
-			sigaddset(sigset_Info,signal_Index);
+	    sigaddset(sigset_Info,signal_Index);
-		}
+	}
+    }
-	return 0;
+    return 0;
+}
 /* Change the blocked signals ============================================== */
 int sigprocmask(int mask_Function,sigset_t* sigset_Info,
      sigset_t* sigset_InfoOld)
+{
-	int      signal_Index;
+    int      signal_Index;
-	sigset_t sigset_MaskOld = downhill_Sigset_Mask;
+    sigset_t sigset_MaskOld = downhill_Sigset_Mask;
-	/* Make sure we're init'd */
+    /* Make sure we're init'd */
-	if (!downhill_Signal_Init())
+    if (!downhill_Signal_Init())
-	{
+    {
-		return -1;
+	return -1;
-	}
+    }
-	/* Return the current value */
+    /* Return the current value */
-	if (sigset_InfoOld != NULL)
+    if (sigset_InfoOld != NULL)
-	{
+    {
-		*sigset_InfoOld = sigset_MaskOld;
+	*sigset_InfoOld = sigset_MaskOld;
-	}
+    }
-	/* Set the new mask */
+    /* Set the new mask */
-        if (sigset_Info) {
+    if (sigset_Info) {
-	   switch (mask_Function)
+	switch (mask_Function)
-	   {
+	{
-		case SIG_BLOCK:
+	case SIG_BLOCK:
-			downhill_Sigset_Mask |= (*sigset_Info);
+	    downhill_Sigset_Mask |= (*sigset_Info);
-			break;
+	    break;
-		case SIG_UNBLOCK:
+	case SIG_UNBLOCK:
-			downhill_Sigset_Mask &= ~(*sigset_Info);
+	    downhill_Sigset_Mask &= ~(*sigset_Info);
-			break;
+	    break;
-		case SIG_SETMASK:
+	case SIG_SETMASK:
-			downhill_Sigset_Mask = *sigset_Info;
+	    downhill_Sigset_Mask = *sigset_Info;
-			break;
+	    break;
-		default:
+	default:
-			errno = EINVAL;
+	    errno = EINVAL;
-			return -1;
+	    return -1;
-          }
+	}
+    }
-	/* And release any signals that were pending */
+    /* And release any signals that were pending */
-	for (signal_Index = 1;signal_Index < NSIG;signal_Index++)
+    for (signal_Index = 1;signal_Index < NSIG;signal_Index++)
+    {
+	if ((!sigismember(&downhill_Sigset_Mask,signal_Index)) &&
+	    (sigismember(&sigset_MaskOld,signal_Index)) &&
+	    (downhill_Signal_Info[signal_Index].signal_Count > 0))
+	{
-		if ((!sigismember(&downhill_Sigset_Mask,signal_Index)) &&
-		 (sigismember(&sigset_MaskOld,signal_Index)) &&
-		 (downhill_Signal_Info[signal_Index].signal_Count > 0))
+	    downhill_Signal_Info[signal_Index].signal_Count = 0;
-		{
-	            downhill_Signal_Info[signal_Index].signal_Count = 0;
-		    raise(signal_Index);
+	    raise(signal_Index);
-		}
+	}
+    }
-	return 0;
+    return 0;
+}
 /* Set signal mask ========================================================= */
 int sigsetmask(int signal_MaskNew)
+{
-	int signal_MaskOld = downhill_Sigset_Mask;
+    int signal_MaskOld = downhill_Sigset_Mask;
-	if (sigprocmask(SIG_SETMASK, &signal_MaskNew, NULL) == -1)
+    if (sigprocmask(SIG_SETMASK, &signal_MaskNew, NULL) == -1)
-		return (int)-1;
+	return (int)-1;
-	return signal_MaskOld;
+    return signal_MaskOld;
+}
 /* Add signals to mask ===================================================== */
 int sigblock(int signal_MaskNew)
+{
-	/* Block a specific group of signals */
+    /* Block a specific group of signals */
-	return sigsetmask(downhill_Sigset_Mask|signal_MaskNew);
+    return sigsetmask(downhill_Sigset_Mask|signal_MaskNew);
+}
 /* Hold a signal =========================================================== */
 int sighold(int signal_Number)
+{
-	/* Block a specific signal */
+    /* Block a specific signal */
-	if (sigblock(sigmask(signal_Number)) == -1)
+    if (sigblock(sigmask(signal_Number)) == -1)
-	{
+    {
-		return -1;
+	return -1;
-	}
+    }
-	return 0;
+    return 0;
+}
 /* Release a signal ======================================================== */
 int sigrelse(int signal_Number)
+{
-	/* Release a specific signal */
+    /* Release a specific signal */
-	if (sigsetmask(downhill_Sigset_Mask&(~sigmask(signal_Number))) == -1)
+    if (sigsetmask(downhill_Sigset_Mask&(~sigmask(signal_Number))) == -1)
-	{
+    {
-		return -1;
+	return -1;
-	}
+    }
-	return 0;
+    return 0;
+}
 /* Pause until a signal ==================================================== */
 int pause(void)
+{
-	/* Wait for a signal */
+    /* Wait for a signal */
-        WaitForSingleObject(IGotASignal,INFINITE);
+    WaitForSingleObject(IGotASignal,INFINITE);
-	/* And return if we were interrupted */
+    /* And return if we were interrupted */
-	errno = EINTR;
+    errno = EINTR;
-	return -1;
+    return -1;
+}
 /* Suspend the process until a signal ====================================== */
 int sigsuspend(sigset_t* sigset_Info)
+{
-	sigset_t sigset_MaskOriginal = downhill_Sigset_Mask;
+    sigset_t sigset_MaskOriginal = downhill_Sigset_Mask;
-	/* Set the new mask */
+    /* Set the new mask */
-	sigprocmask(SIG_SETMASK,sigset_Info,NULL);
+    sigprocmask(SIG_SETMASK,sigset_Info,NULL);
-	/* Wait for the signal */
+    /* Wait for the signal */
-	pause();
+    pause();
-	/* Reset the old mask */
+    /* Reset the old mask */
-	sigprocmask(SIG_SETMASK,&sigset_MaskOriginal,NULL);
+    sigprocmask(SIG_SETMASK,&sigset_MaskOriginal,NULL);
-	return -1;
+    return -1;
+}

The R Project SVN R

(root)/trunk/src/gnuwin32/psignal.c – Rev 42642 → 45070