Apply new indentation, brace, and whitespace style

1 files changed, 472 insertions, 472 deletions

diff --git a/signal.cpp b/signal.cpp
index 98883bf4..f713b4e7 100644
--- a/signal.cpp
+++ b/signal.cpp
@@ -36,18 +36,18 @@ The library for various signal related issues
 */
 struct lookup_entry
 {
-	/**
-	   Signal id
-	*/
-	int signal;
-	/**
-	   Signal name
-	*/
-	const wchar_t *name;
-	/**
-	   Signal description
-	*/
-	const wchar_t *desc;	
+    /**
+       Signal id
+    */
+    int signal;
+    /**
+       Signal name
+    */
+    const wchar_t *name;
+    /**
+       Signal description
+    */
+    const wchar_t *desc;
 };
 
 /**
@@ -63,363 +63,363 @@ static int block_count=0;
 static const struct lookup_entry lookup[] =
 {
 #ifdef SIGHUP
-	{
-		SIGHUP, 
-		L"SIGHUP",
-		N_( L"Terminal hung up" )
-	}
-	,
+    {
+        SIGHUP,
+        L"SIGHUP",
+        N_(L"Terminal hung up")
+    }
+    ,
 #endif
 #ifdef SIGINT
-	{
-		SIGINT,
-		L"SIGINT",
-		N_( L"Quit request from job control (^C)" )
-	}
-	,
+    {
+        SIGINT,
+        L"SIGINT",
+        N_(L"Quit request from job control (^C)")
+    }
+    ,
 #endif
 #ifdef SIGQUIT
-	{
-		SIGQUIT,
-		L"SIGQUIT",
-		N_( L"Quit request from job control with core dump (^\\)" )
-	}
-	,
+    {
+        SIGQUIT,
+        L"SIGQUIT",
+        N_(L"Quit request from job control with core dump (^\\)")
+    }
+    ,
 #endif
 #ifdef SIGILL
-	{
-		SIGILL,
-		L"SIGILL",
-		N_( L"Illegal instruction" )
-	}
-	,
+    {
+        SIGILL,
+        L"SIGILL",
+        N_(L"Illegal instruction")
+    }
+    ,
 #endif
 #ifdef SIGTRAP
-	{
-		SIGTRAP, 
-		L"SIGTRAP",
-		N_( L"Trace or breakpoint trap" )
-	}
-	,
+    {
+        SIGTRAP,
+        L"SIGTRAP",
+        N_(L"Trace or breakpoint trap")
+    }
+    ,
 #endif
 #ifdef SIGABRT
-	{
-		SIGABRT,
-		L"SIGABRT",
-		N_( L"Abort" )
-	}
-	,
+    {
+        SIGABRT,
+        L"SIGABRT",
+        N_(L"Abort")
+    }
+    ,
 #endif
 #ifdef SIGBUS
-	{
-		SIGBUS, 
-		L"SIGBUS",
-		N_( L"Misaligned address error" )
-	}
-	,
+    {
+        SIGBUS,
+        L"SIGBUS",
+        N_(L"Misaligned address error")
+    }
+    ,
 #endif
 #ifdef SIGFPE
-	{
-		SIGFPE, 
-		L"SIGFPE",
-		N_( L"Floating point exception" )
-	}
-	,
+    {
+        SIGFPE,
+        L"SIGFPE",
+        N_(L"Floating point exception")
+    }
+    ,
 #endif
 #ifdef SIGKILL
-	{
-		SIGKILL, 
-		L"SIGKILL",
-		N_( L"Forced quit" )
-	}
-	,
+    {
+        SIGKILL,
+        L"SIGKILL",
+        N_(L"Forced quit")
+    }
+    ,
 #endif
 #ifdef SIGUSR1
-	{
-		SIGUSR1,
-		L"SIGUSR1",
-		N_( L"User defined signal 1" )
-	}
-	,
+    {
+        SIGUSR1,
+        L"SIGUSR1",
+        N_(L"User defined signal 1")
+    }
+    ,
 #endif
 #ifdef SIGUSR2
-	{
-		SIGUSR2, L"SIGUSR2",
-		N_( L"User defined signal 2" )
-	}
-	,
+    {
+        SIGUSR2, L"SIGUSR2",
+        N_(L"User defined signal 2")
+    }
+    ,
 #endif
 #ifdef SIGSEGV
-	{
-		SIGSEGV, 
-		L"SIGSEGV",
-		N_( L"Address boundary error" )
-	}
-	,
+    {
+        SIGSEGV,
+        L"SIGSEGV",
+        N_(L"Address boundary error")
+    }
+    ,
 #endif
 #ifdef SIGPIPE
-	{
-		SIGPIPE,
-		L"SIGPIPE",
-		N_( L"Broken pipe" )
-	}
-	,
+    {
+        SIGPIPE,
+        L"SIGPIPE",
+        N_(L"Broken pipe")
+    }
+    ,
 #endif
 #ifdef SIGALRM
-	{
-		SIGALRM, 
-		L"SIGALRM",
-		N_( L"Timer expired" )
-	}
-	,
+    {
+        SIGALRM,
+        L"SIGALRM",
+        N_(L"Timer expired")
+    }
+    ,
 #endif
 #ifdef SIGTERM
-	{
-		SIGTERM,
-		L"SIGTERM",
-		N_( L"Polite quit request" )
-	}
-	,
+    {
+        SIGTERM,
+        L"SIGTERM",
+        N_(L"Polite quit request")
+    }
+    ,
 #endif
 #ifdef SIGCHLD
-	{
-		SIGCHLD,
-		L"SIGCHLD",
-		N_( L"Child process status changed" )
-	}
-	,
+    {
+        SIGCHLD,
+        L"SIGCHLD",
+        N_(L"Child process status changed")
+    }
+    ,
 #endif
 #ifdef SIGCONT
-	{
-		SIGCONT,
-		L"SIGCONT",
-		N_( L"Continue previously stopped process" )
-	}
-	,
+    {
+        SIGCONT,
+        L"SIGCONT",
+        N_(L"Continue previously stopped process")
+    }
+    ,
 #endif
 #ifdef SIGSTOP
-	{
-		SIGSTOP,
-		L"SIGSTOP",
-		N_( L"Forced stop" )
-	}
-	,
+    {
+        SIGSTOP,
+        L"SIGSTOP",
+        N_(L"Forced stop")
+    }
+    ,
 #endif
 #ifdef SIGTSTP
-	{
-		SIGTSTP,
-		L"SIGTSTP",
-		N_( L"Stop request from job control (^Z)" )
-	}
-	,
+    {
+        SIGTSTP,
+        L"SIGTSTP",
+        N_(L"Stop request from job control (^Z)")
+    }
+    ,
 #endif
 #ifdef SIGTTIN
-	{
-		SIGTTIN, 
-		L"SIGTTIN",
-		N_( L"Stop from terminal input" )
-	}
-	,
+    {
+        SIGTTIN,
+        L"SIGTTIN",
+        N_(L"Stop from terminal input")
+    }
+    ,
 #endif
 #ifdef SIGTTOU
-	{
-		SIGTTOU,
-		L"SIGTTOU",
-		N_( L"Stop from terminal output" )
-	}
-	,
+    {
+        SIGTTOU,
+        L"SIGTTOU",
+        N_(L"Stop from terminal output")
+    }
+    ,
 #endif
 #ifdef SIGURG
-	{
-		SIGURG, 
-		L"SIGURG",
-		N_( L"Urgent socket condition" )
-	}
-	,
+    {
+        SIGURG,
+        L"SIGURG",
+        N_(L"Urgent socket condition")
+    }
+    ,
 #endif
 #ifdef SIGXCPU
-	{
-		SIGXCPU,
-		L"SIGXCPU",
-		N_( L"CPU time limit exceeded" )
-	}
-	,
+    {
+        SIGXCPU,
+        L"SIGXCPU",
+        N_(L"CPU time limit exceeded")
+    }
+    ,
 #endif
 #ifdef SIGXFSZ
-	{
-		SIGXFSZ, 
-		L"SIGXFSZ",
-		N_( L"File size limit exceeded" )
-	}
-	,
+    {
+        SIGXFSZ,
+        L"SIGXFSZ",
+        N_(L"File size limit exceeded")
+    }
+    ,
 #endif
 #ifdef SIGVTALRM
-	{
-		SIGVTALRM,
-		L"SIGVTALRM",
-		N_( L"Virtual timer expired" )
-	}
-	,
+    {
+        SIGVTALRM,
+        L"SIGVTALRM",
+        N_(L"Virtual timer expired")
+    }
+    ,
 #endif
 #ifdef SIGPROF
-	{
-		SIGPROF,
-		L"SIGPROF",
-		N_( L"Profiling timer expired" )
-	}
-	,
+    {
+        SIGPROF,
+        L"SIGPROF",
+        N_(L"Profiling timer expired")
+    }
+    ,
 #endif
 #ifdef SIGWINCH
-	{
-		SIGWINCH,
-		L"SIGWINCH",
-		N_( L"Window size change" )
-	}
-	,
+    {
+        SIGWINCH,
+        L"SIGWINCH",
+        N_(L"Window size change")
+    }
+    ,
 #endif
 #ifdef SIGWIND
-	{
-		SIGWIND,
-		L"SIGWIND",
-		N_( L"Window size change" )
-	}
-	,
+    {
+        SIGWIND,
+        L"SIGWIND",
+        N_(L"Window size change")
+    }
+    ,
 #endif
 #ifdef SIGIO
-	{
-		SIGIO,
-		L"SIGIO",
-		N_( L"I/O on asynchronous file descriptor is possible" )
-	}
-	,
+    {
+        SIGIO,
+        L"SIGIO",
+        N_(L"I/O on asynchronous file descriptor is possible")
+    }
+    ,
 #endif
 #ifdef SIGPWR
-	{
-		SIGPWR, 
-		L"SIGPWR",
-		N_( L"Power failure" )
-	}
-	,
+    {
+        SIGPWR,
+        L"SIGPWR",
+        N_(L"Power failure")
+    }
+    ,
 #endif
 #ifdef SIGSYS
-	{
-		SIGSYS, 
-		L"SIGSYS",
-		N_( L"Bad system call" )
-	}
-	,
+    {
+        SIGSYS,
+        L"SIGSYS",
+        N_(L"Bad system call")
+    }
+    ,
 #endif
 #ifdef SIGINFO
-	{
-		SIGINFO,
-		L"SIGINFO",
-		N_( L"Information request" )
-	}
-	,
+    {
+        SIGINFO,
+        L"SIGINFO",
+        N_(L"Information request")
+    }
+    ,
 #endif
 #ifdef SIGSTKFLT
-	{
-		SIGSTKFLT,
-		L"SISTKFLT",
-		N_( L"Stack fault" )
-	}
-	,
+    {
+        SIGSTKFLT,
+        L"SISTKFLT",
+        N_(L"Stack fault")
+    }
+    ,
 #endif
 #ifdef SIGEMT
-	{
-		SIGEMT,
-		L"SIGEMT",
-		N_( L"Emulator trap" )
-	}
-	,
+    {
+        SIGEMT,
+        L"SIGEMT",
+        N_(L"Emulator trap")
+    }
+    ,
 #endif
 #ifdef SIGIOT
-	{
-		SIGIOT,
-		L"SIGIOT",
-		N_( L"Abort (Alias for SIGABRT)" )
-	}
-	,
+    {
+        SIGIOT,
+        L"SIGIOT",
+        N_(L"Abort (Alias for SIGABRT)")
+    }
+    ,
 #endif
 #ifdef SIGUNUSED
-	{
-		SIGUNUSED,
-		L"SIGUNUSED",
-		N_( L"Unused signal" )
-	}
-	,
-#endif
-	{
-		0,
-		0,
-		0
-	}
+    {
+        SIGUNUSED,
+        L"SIGUNUSED",
+        N_(L"Unused signal")
+    }
+    ,
+#endif
+    {
+        0,
+        0,
+        0
+    }
 }
-	;
+;
 
 
 /**
-   Test if \c name is a string describing the signal named \c canonical. 
+   Test if \c name is a string describing the signal named \c canonical.
 */
-static int match_signal_name( const wchar_t *canonical, 
-							  const wchar_t *name )
+static int match_signal_name(const wchar_t *canonical,
+                             const wchar_t *name)
 {
-	if( wcsncasecmp( name, L"sig", 3 )==0)
-		name +=3;
+    if (wcsncasecmp(name, L"sig", 3)==0)
+        name +=3;
 
-	return wcscasecmp( canonical+3,name ) == 0;	
+    return wcscasecmp(canonical+3,name) == 0;
 }
 
 
-int wcs2sig( const wchar_t *str )
+int wcs2sig(const wchar_t *str)
 {
-	int i;
-	wchar_t *end=0;
-	
-	for( i=0; lookup[i].desc ; i++ )
-	{
-		if( match_signal_name( lookup[i].name, str) )
-		{
-			return lookup[i].signal;
-		}
-	}
-	errno=0;
-	int res = fish_wcstoi( str, &end, 10 );
-	if( !errno && res>=0 && !*end )
-		return res;
-
-	return -1;	
+    int i;
+    wchar_t *end=0;
+
+    for (i=0; lookup[i].desc ; i++)
+    {
+        if (match_signal_name(lookup[i].name, str))
+        {
+            return lookup[i].signal;
+        }
+    }
+    errno=0;
+    int res = fish_wcstoi(str, &end, 10);
+    if (!errno && res>=0 && !*end)
+        return res;
+
+    return -1;
 }
 
 
-const wchar_t *sig2wcs( int sig )
+const wchar_t *sig2wcs(int sig)
 {
-	int i;
+    int i;
 
-	for( i=0; lookup[i].desc ; i++ )
-	{
-		if( lookup[i].signal == sig )
-		{
-			return lookup[i].name;
-		}
-	}
+    for (i=0; lookup[i].desc ; i++)
+    {
+        if (lookup[i].signal == sig)
+        {
+            return lookup[i].name;
+        }
+    }
 
-	return _(L"Unknown");
+    return _(L"Unknown");
 }
 
-const wchar_t *signal_get_desc( int sig )
+const wchar_t *signal_get_desc(int sig)
 {
-	int i;
+    int i;
 
-	for( i=0; lookup[i].desc ; i++ )
-	{
-		if( lookup[i].signal == sig )
-		{
-			return _(lookup[i].desc);
-		}
-	}
+    for (i=0; lookup[i].desc ; i++)
+    {
+        if (lookup[i].signal == sig)
+        {
+            return _(lookup[i].desc);
+        }
+    }
 
-	return _(L"Unknown");
+    return _(L"Unknown");
 }
 
 /**
@@ -429,37 +429,37 @@ static void default_handler(int signal, siginfo_t *info, void *context)
 {
     if (event_is_signal_observed(signal))
     {
-		event_fire_signal(signal);
-	}
+        event_fire_signal(signal);
+    }
 }
 
 /**
    Respond to a winch signal by checking the terminal size
 */
-static void handle_winch( int sig, siginfo_t *info, void *context )
+static void handle_winch(int sig, siginfo_t *info, void *context)
 {
-	common_handle_winch( sig );	
-	default_handler( sig, 0, 0 );	
+    common_handle_winch(sig);
+    default_handler(sig, 0, 0);
 }
 
 /**
    Respond to a hup signal by exiting, unless it is caught by a
    shellscript function, in which case we do nothing.
 */
-static void handle_hup( int sig, siginfo_t *info, void *context )
+static void handle_hup(int sig, siginfo_t *info, void *context)
 {
-	if (event_is_signal_observed(SIGHUP))
-	{
-		default_handler(sig, 0, 0);
-	}
-	else
-	{
-		reader_exit(1, 1);
-	}	
+    if (event_is_signal_observed(SIGHUP))
+    {
+        default_handler(sig, 0, 0);
+    }
+    else
+    {
+        reader_exit(1, 1);
+    }
 }
 
 /** Handle sigterm. The only thing we do is restore the front process ID, then die. */
-static void handle_term( int sig, siginfo_t *info, void *context )
+static void handle_term(int sig, siginfo_t *info, void *context)
 {
     restore_term_foreground_process_group();
     signal(SIGTERM, SIG_DFL);
@@ -470,34 +470,34 @@ static void handle_term( int sig, siginfo_t *info, void *context )
    Interactive mode ^C handler. Respond to int signal by setting
    interrupted-flag and stopping all loops and conditionals.
 */
-static void handle_int( int sig, siginfo_t *info, void *context )
+static void handle_int(int sig, siginfo_t *info, void *context)
 {
-	reader_handle_int( sig );
-	default_handler( sig, info, context);	
+    reader_handle_int(sig);
+    default_handler(sig, info, context);
 }
 
 /**
    sigchld handler. Does notification and calls the handler in proc.c
 */
-static void handle_chld( int sig, siginfo_t *info, void *context )
+static void handle_chld(int sig, siginfo_t *info, void *context)
 {
-	job_handle_signal( sig, info, context );
-	default_handler( sig, info, context);	
+    job_handle_signal(sig, info, context);
+    default_handler(sig, info, context);
 }
 
 void signal_reset_handlers()
 {
-	int i;
-	
-	struct sigaction act;
-	sigemptyset( & act.sa_mask );
-	act.sa_flags=0;
-	act.sa_handler=SIG_DFL;
-	
-	for( i=0; lookup[i].desc ; i++ )
-	{
-		sigaction( lookup[i].signal, &act, 0);
-	}	
+    int i;
+
+    struct sigaction act;
+    sigemptyset(& act.sa_mask);
+    act.sa_flags=0;
+    act.sa_handler=SIG_DFL;
+
+    for (i=0; lookup[i].desc ; i++)
+    {
+        sigaction(lookup[i].signal, &act, 0);
+    }
 }
 
 
@@ -506,196 +506,196 @@ void signal_reset_handlers()
 */
 void signal_set_handlers()
 {
-	struct sigaction act;
-
-	if( get_is_interactive() == -1 )
-		return;
-	
-	sigemptyset( & act.sa_mask );
-	act.sa_flags=SA_SIGINFO;
-	act.sa_sigaction = &default_handler;
-	
-	/*
-	  First reset everything to a use default_handler, a function
-	  whose sole action is to fire of an event
-	*/
-	sigaction( SIGINT, &act, 0);
-	sigaction( SIGQUIT, &act, 0);
-	sigaction( SIGTSTP, &act, 0);
-	sigaction( SIGTTIN, &act, 0);
-	sigaction( SIGTTOU, &act, 0);
-	sigaction( SIGCHLD, &act, 0);
-	
-	/*
-	  Ignore sigpipe, it is generated if fishd dies, but we can
-	  recover.
-	*/
-	sigaction( SIGPIPE, &act, 0);
-
-	if( get_is_interactive() )
-	{
-		/*
-		   Interactive mode. Ignore interactive signals.  We are a
-		   shell, we know whats best for the user. ;-)
-		*/
-		
-		act.sa_handler=SIG_IGN;
-		
-		sigaction( SIGINT, &act, 0);
-		sigaction( SIGQUIT, &act, 0);
-		sigaction( SIGTSTP, &act, 0);
-		sigaction( SIGTTIN, &act, 0);
-		sigaction( SIGTTOU, &act, 0);
-
-		act.sa_sigaction = &handle_int;
-		act.sa_flags = SA_SIGINFO;
-		if( sigaction( SIGINT, &act, 0) )
-		{
-			wperror( L"sigaction" );
-			FATAL_EXIT();
-		}
-
-		act.sa_sigaction = &handle_chld;
-		act.sa_flags = SA_SIGINFO;
-		if( sigaction( SIGCHLD, &act, 0) )
-		{
-			wperror( L"sigaction" );
-			FATAL_EXIT();
-		}
-		
+    struct sigaction act;
+
+    if (get_is_interactive() == -1)
+        return;
+
+    sigemptyset(& act.sa_mask);
+    act.sa_flags=SA_SIGINFO;
+    act.sa_sigaction = &default_handler;
+
+    /*
+      First reset everything to a use default_handler, a function
+      whose sole action is to fire of an event
+    */
+    sigaction(SIGINT, &act, 0);
+    sigaction(SIGQUIT, &act, 0);
+    sigaction(SIGTSTP, &act, 0);
+    sigaction(SIGTTIN, &act, 0);
+    sigaction(SIGTTOU, &act, 0);
+    sigaction(SIGCHLD, &act, 0);
+
+    /*
+      Ignore sigpipe, it is generated if fishd dies, but we can
+      recover.
+    */
+    sigaction(SIGPIPE, &act, 0);
+
+    if (get_is_interactive())
+    {
+        /*
+           Interactive mode. Ignore interactive signals.  We are a
+           shell, we know whats best for the user. ;-)
+        */
+
+        act.sa_handler=SIG_IGN;
+
+        sigaction(SIGINT, &act, 0);
+        sigaction(SIGQUIT, &act, 0);
+        sigaction(SIGTSTP, &act, 0);
+        sigaction(SIGTTIN, &act, 0);
+        sigaction(SIGTTOU, &act, 0);
+
+        act.sa_sigaction = &handle_int;
+        act.sa_flags = SA_SIGINFO;
+        if (sigaction(SIGINT, &act, 0))
+        {
+            wperror(L"sigaction");
+            FATAL_EXIT();
+        }
+
+        act.sa_sigaction = &handle_chld;
+        act.sa_flags = SA_SIGINFO;
+        if (sigaction(SIGCHLD, &act, 0))
+        {
+            wperror(L"sigaction");
+            FATAL_EXIT();
+        }
+
 #ifdef SIGWINCH
-		act.sa_flags = SA_SIGINFO;
-		act.sa_sigaction= &handle_winch;
-		if( sigaction( SIGWINCH, &act, 0 ) )
-		{
-			wperror( L"sigaction" );
-			FATAL_EXIT();
-		}
-#endif
-
-		act.sa_flags = SA_SIGINFO;
-		act.sa_sigaction= &handle_hup;
-		if( sigaction( SIGHUP, &act, 0 ) )
-		{
-			wperror( L"sigaction" );
-			FATAL_EXIT();
-		}
-        
-		// SIGTERM restores the terminal controlling process before dying
-		act.sa_flags = SA_SIGINFO;
-		act.sa_sigaction= &handle_term;
-		if( sigaction( SIGTERM, &act, 0 ) )
-		{
-			wperror( L"sigaction" );
-			FATAL_EXIT();
-		}
-
-	}
-	else
-	{
-		/*
-		  Non-interactive. Ignore interrupt, check exit status of
-		  processes to determine result instead.
-		*/
-		act.sa_handler=SIG_IGN;
-
-		sigaction( SIGINT, &act, 0);
-		sigaction( SIGQUIT, &act, 0);
-
-		act.sa_handler=SIG_DFL;
-
-		act.sa_sigaction = &handle_chld;
-		act.sa_flags = SA_SIGINFO;
-		if( sigaction( SIGCHLD, &act, 0) )
-		{
-			wperror( L"sigaction" );
-			exit_without_destructors(1);
-		}
-	}
-	
+        act.sa_flags = SA_SIGINFO;
+        act.sa_sigaction= &handle_winch;
+        if (sigaction(SIGWINCH, &act, 0))
+        {
+            wperror(L"sigaction");
+            FATAL_EXIT();
+        }
+#endif
+
+        act.sa_flags = SA_SIGINFO;
+        act.sa_sigaction= &handle_hup;
+        if (sigaction(SIGHUP, &act, 0))
+        {
+            wperror(L"sigaction");
+            FATAL_EXIT();
+        }
+
+        // SIGTERM restores the terminal controlling process before dying
+        act.sa_flags = SA_SIGINFO;
+        act.sa_sigaction= &handle_term;
+        if (sigaction(SIGTERM, &act, 0))
+        {
+            wperror(L"sigaction");
+            FATAL_EXIT();
+        }
+
+    }
+    else
+    {
+        /*
+          Non-interactive. Ignore interrupt, check exit status of
+          processes to determine result instead.
+        */
+        act.sa_handler=SIG_IGN;
+
+        sigaction(SIGINT, &act, 0);
+        sigaction(SIGQUIT, &act, 0);
+
+        act.sa_handler=SIG_DFL;
+
+        act.sa_sigaction = &handle_chld;
+        act.sa_flags = SA_SIGINFO;
+        if (sigaction(SIGCHLD, &act, 0))
+        {
+            wperror(L"sigaction");
+            exit_without_destructors(1);
+        }
+    }
+
 }
 
-void signal_handle( int sig, int do_handle )
+void signal_handle(int sig, int do_handle)
 {
-	struct sigaction act;
-	
-	/*
-	  These should always be handled
-	*/
-	if( (sig == SIGINT) ||
-		(sig == SIGQUIT) ||
-		(sig == SIGTSTP) ||
-		(sig == SIGTTIN) ||
-		(sig == SIGTTOU) ||
-		(sig == SIGCHLD) )
-		return;
-	
-	sigemptyset( &act.sa_mask );
-	if( do_handle )
-	{
-		act.sa_flags = SA_SIGINFO;
-		act.sa_sigaction = &default_handler;
-	}
-	else
-	{
-		act.sa_flags = 0;
-		act.sa_handler = SIG_DFL;
-	}
-	
-	sigaction( sig, &act, 0);
+    struct sigaction act;
+
+    /*
+      These should always be handled
+    */
+    if ((sig == SIGINT) ||
+            (sig == SIGQUIT) ||
+            (sig == SIGTSTP) ||
+            (sig == SIGTTIN) ||
+            (sig == SIGTTOU) ||
+            (sig == SIGCHLD))
+        return;
+
+    sigemptyset(&act.sa_mask);
+    if (do_handle)
+    {
+        act.sa_flags = SA_SIGINFO;
+        act.sa_sigaction = &default_handler;
+    }
+    else
+    {
+        act.sa_flags = 0;
+        act.sa_handler = SIG_DFL;
+    }
+
+    sigaction(sig, &act, 0);
 }
 
 void get_signals_with_handlers(sigset_t *set)
 {
     sigemptyset(set);
-	for( int i=0; lookup[i].desc ; i++ )
-	{
+    for (int i=0; lookup[i].desc ; i++)
+    {
         struct sigaction act = {};
-		sigaction(lookup[i].signal, NULL, &act);
+        sigaction(lookup[i].signal, NULL, &act);
         if (act.sa_handler != SIG_DFL)
             sigaddset(set, lookup[i].signal);
-	}
+    }
 }
 
 void signal_block()
 {
     ASSERT_IS_MAIN_THREAD();
-	sigset_t chldset; 
-	
-	if( !block_count )
-	{
-		sigfillset( &chldset );
-		VOMIT_ON_FAILURE(pthread_sigmask(SIG_BLOCK, &chldset, NULL));
-	}
-	
-	block_count++;
+    sigset_t chldset;
+
+    if (!block_count)
+    {
+        sigfillset(&chldset);
+        VOMIT_ON_FAILURE(pthread_sigmask(SIG_BLOCK, &chldset, NULL));
+    }
+
+    block_count++;
 //	debug( 0, L"signal block level increased to %d", block_count );
 }
 
 void signal_unblock()
 {
     ASSERT_IS_MAIN_THREAD();
-	sigset_t chldset; 
-
-	block_count--;
-
-	if( block_count < 0 )
-	{
-		debug( 0, _( L"Signal block mismatch" ) );
-		bugreport();
-		FATAL_EXIT();
-	}
-	
-	if( !block_count )
-	{
-		sigfillset( &chldset );
-		VOMIT_ON_FAILURE(pthread_sigmask(SIG_UNBLOCK, &chldset, 0));
-	}
+    sigset_t chldset;
+
+    block_count--;
+
+    if (block_count < 0)
+    {
+        debug(0, _(L"Signal block mismatch"));
+        bugreport();
+        FATAL_EXIT();
+    }
+
+    if (!block_count)
+    {
+        sigfillset(&chldset);
+        VOMIT_ON_FAILURE(pthread_sigmask(SIG_UNBLOCK, &chldset, 0));
+    }
 //	debug( 0, L"signal block level decreased to %d", block_count );
 }
 
 int signal_is_blocked()
 {
-	return !!block_count;
+    return !!block_count;
 }