summaryrefslogtreecommitdiffstats
path: root/src/misc
diff options
context:
space:
mode:
Diffstat (limited to 'src/misc')
-rw-r--r--src/misc/hash/hashGen.h365
-rw-r--r--src/misc/util/module.make2
-rw-r--r--src/misc/util/utilSignal.c520
-rw-r--r--src/misc/util/utilSignal.h71
4 files changed, 957 insertions, 1 deletions
diff --git a/src/misc/hash/hashGen.h b/src/misc/hash/hashGen.h
new file mode 100644
index 00000000..33359e89
--- /dev/null
+++ b/src/misc/hash/hashGen.h
@@ -0,0 +1,365 @@
+/**CFile****************************************************************
+
+ FileName [vecGen.h]
+
+ SystemName [ABC: Logic synthesis and verification system.]
+
+ PackageName [Hash maps.]
+
+ Synopsis [Hash maps.]
+
+ Author [Aaron P. Hurst, Alan Mishchenko]
+
+ Affiliation [UC Berkeley]
+
+ Date [Ver. 1.0. Started - Jan 26, 2011.]
+
+ Revision [$Id: vecGen.h,v 1.00 2005/06/20 00:00:00 ahurst Exp $]
+
+***********************************************************************/
+
+#ifndef __HASH_GEN_H__
+#define __HASH_GEN_H__
+
+
+////////////////////////////////////////////////////////////////////////
+/// INCLUDES ///
+////////////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+#include "extra.h"
+
+ABC_NAMESPACE_HEADER_START
+
+
+////////////////////////////////////////////////////////////////////////
+/// PARAMETERS ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+/// BASIC TYPES ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct Hash_Gen_t_ Hash_Gen_t;
+typedef struct Hash_Gen_Entry_t_ Hash_Gen_Entry_t;
+
+struct Hash_Gen_Entry_t_
+{
+ char * key;
+ void * data;
+ struct Hash_Gen_Entry_t_ * pNext;
+};
+
+struct Hash_Gen_t_
+{
+ int nSize;
+ int nBins;
+ int (* fHash)(void *key, int nBins);
+ int (* fComp)(void *key, void *data);
+ int fFreeKey;
+ Hash_Gen_Entry_t ** pArray;
+};
+
+
+
+////////////////////////////////////////////////////////////////////////
+/// MACRO DEFINITIONS ///
+////////////////////////////////////////////////////////////////////////
+
+#define Hash_GenForEachEntry( pHash, pEntry, bin ) \
+ for(bin=-1, pEntry=NULL; bin < pHash->nBins; (!pEntry)?(pEntry=pHash->pArray[++bin]):(pEntry=pEntry->pNext)) \
+ if (pEntry)
+
+////////////////////////////////////////////////////////////////////////
+/// FUNCTION DEFINITIONS ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+ Synopsis [Default hash function for strings.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static int Hash_DefaultHashFuncStr( void * key, int nBins )
+{
+ char* p = (const char*)key;
+ int h=0;
+
+ for( ; *p ; ++p )
+ h += h*5 + *p;
+
+ return (unsigned)h % nBins;
+}
+
+static int Hash_DefaultCmpFuncStr( void * key1, void * key2 )
+{
+ return strcmp((const char*)key1, (const char*) key2);
+}
+
+/**Function*************************************************************
+
+ Synopsis [Default hash function for (long) integers.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static int Hash_DefaultHashFuncInt( void * key, int nBins )
+{
+ return (long)key % nBins;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Default comparison function for (long) integers.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static int Hash_DefaultCmpFuncInt( void * key1, void* key2 )
+{
+ return (long)key1 - (long)key2;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Allocates a hash map with the given number of bins.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static inline Hash_Gen_t * Hash_GenAlloc(
+ int nBins,
+ int (*Hash_FuncHash)(void *, int),
+ int (*Hash_FuncComp)(void *, void *),
+ int fFreeKey)
+{
+ Hash_Gen_t * p;
+ int i;
+ assert(nBins > 0);
+ p = ABC_CALLOC( Hash_Gen_t, 1 );
+ p->nBins = nBins;
+ p->fHash = Hash_FuncHash? Hash_FuncHash : (int (*)(void *, int))Hash_DefaultHashFuncStr;
+ p->fComp = Hash_FuncComp? Hash_FuncComp : (int (*)(void *, void *))Hash_DefaultCmpFuncStr;
+ p->fFreeKey = fFreeKey;
+ p->nSize = 0;
+ p->pArray = ABC_CALLOC( Hash_Gen_Entry_t *, nBins );
+ return p;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Returns 1 if a key already exists.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static inline int Hash_GenExists( Hash_Gen_t *p, void * key )
+{
+ int bin;
+ Hash_Gen_Entry_t *pEntry;
+
+ // find the bin where this key would live
+ bin = (*(p->fHash))(key, p->nBins);
+
+ // search for key
+ pEntry = p->pArray[bin];
+ while(pEntry) {
+ if ( !p->fComp(pEntry->key,key) ) {
+ return 1;
+ }
+ pEntry = pEntry->pNext;
+ }
+
+ return 0;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Finds or creates an entry with a key and writes value.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static inline void Hash_GenWriteEntry( Hash_Gen_t *p, void * key, void * data )
+{
+ int bin;
+ Hash_Gen_Entry_t *pEntry, **pLast;
+
+ // find the bin where this key would live
+ bin = (*(p->fHash))(key, p->nBins);
+
+ // search for key
+ pLast = &(p->pArray[bin]);
+ pEntry = p->pArray[bin];
+ while(pEntry) {
+ if ( !p->fComp(pEntry->key,key) ) {
+ pEntry->data = data;
+ return;
+ }
+ pLast = &(pEntry->pNext);
+ pEntry = pEntry->pNext;
+ }
+
+ // this key does not currently exist
+ // create a new entry and add to bin
+ p->nSize++;
+ (*pLast) = pEntry = ABC_ALLOC( Hash_Gen_Entry_t, 1 );
+ pEntry->pNext = NULL;
+ pEntry->key = key;
+ pEntry->data = data;
+
+ return;
+}
+
+
+/**Function*************************************************************
+
+ Synopsis [Finds or creates an entry with a key.]
+
+ Description [fCreate specifies whether a new entry should be created.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static inline Hash_Gen_Entry_t * Hash_GenEntry( Hash_Gen_t *p, void * key, int fCreate )
+{
+ int bin;
+ Hash_Gen_Entry_t *pEntry, **pLast;
+
+ // find the bin where this key would live
+ bin = (*(p->fHash))(key, p->nBins);
+
+ // search for key
+ pLast = &(p->pArray[bin]);
+ pEntry = p->pArray[bin];
+ while(pEntry) {
+ if ( !p->fComp(pEntry->key,key) )
+ return pEntry;
+ pLast = &(pEntry->pNext);
+ pEntry = pEntry->pNext;
+ }
+
+ // this key does not currently exist
+ if (fCreate) {
+ // create a new entry and add to bin
+ p->nSize++;
+ (*pLast) = pEntry = ABC_ALLOC( Hash_Gen_Entry_t, 1 );
+ pEntry->pNext = NULL;
+ pEntry->key = key;
+ pEntry->data = NULL;
+ return pEntry;
+ }
+
+ return NULL;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Deletes an entry.]
+
+ Description [Returns data, if there was any.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static inline void* Hash_GenRemove( Hash_Gen_t *p, void * key )
+{
+ int bin;
+ void * data;
+ Hash_Gen_Entry_t *pEntry, **pLast;
+
+ // find the bin where this key would live
+ bin = (*(p->fHash))(key, p->nBins);
+
+ // search for key
+ pLast = &(p->pArray[bin]);
+ pEntry = p->pArray[bin];
+ while(pEntry) {
+ if ( !p->fComp(pEntry->key,key) ) {
+ p->nSize--;
+ data = pEntry->data;
+ *pLast = pEntry->pNext;
+ if (p->fFreeKey)
+ ABC_FREE(pEntry->key);
+ ABC_FREE(pEntry);
+ return data;
+ }
+ pLast = &(pEntry->pNext);
+ pEntry = pEntry->pNext;
+ }
+
+ // could not find key
+ return NULL;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Frees the hash.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static inline void Hash_GenFree( Hash_Gen_t *p )
+{
+ int bin;
+ Hash_Gen_Entry_t *pEntry, *pTemp;
+
+ // free bins
+ for(bin = 0; bin < p->nBins; bin++) {
+ pEntry = p->pArray[bin];
+ while(pEntry) {
+ pTemp = pEntry;
+ if( p->fFreeKey )
+ ABC_FREE(pTemp->key);
+ pEntry = pEntry->pNext;
+ ABC_FREE( pTemp );
+ }
+ }
+
+ // free hash
+ ABC_FREE( p->pArray );
+ ABC_FREE( p );
+}
+
+////////////////////////////////////////////////////////////////////////
+/// END OF FILE ///
+////////////////////////////////////////////////////////////////////////
+
+
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
diff --git a/src/misc/util/module.make b/src/misc/util/module.make
index 54fb8291..c70d582a 100644
--- a/src/misc/util/module.make
+++ b/src/misc/util/module.make
@@ -1 +1 @@
-SRC += src/misc/util/utilFile.c
+SRC += src/misc/util/utilFile.c src/misc/util/utilSignal.c
diff --git a/src/misc/util/utilSignal.c b/src/misc/util/utilSignal.c
new file mode 100644
index 00000000..698ba6d6
--- /dev/null
+++ b/src/misc/util/utilSignal.c
@@ -0,0 +1,520 @@
+/**CFile****************************************************************
+
+ FileName [utilSignal.c]
+
+ SystemName [ABC: Logic synthesis and verification system.]
+
+ PackageName []
+
+ Synopsis []
+
+ Author []
+
+ Affiliation [UC Berkeley]
+
+ Date []
+
+ Revision []
+
+***********************************************************************/
+
+#ifndef _MSC_VER
+
+#include <main.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <hashGen.h>
+#include <errno.h>
+#include <pthread.h>
+
+#include "abc_global.h"
+
+ABC_NAMESPACE_IMPL_START
+
+////////////////////////////////////////////////////////////////////////
+/// DECLARATIONS ///
+////////////////////////////////////////////////////////////////////////
+
+static Hash_Gen_t* watched_pid_hash = NULL;
+static Hash_Gen_t* watched_tmp_files_hash = NULL;
+
+static sigset_t* old_procmask;
+
+////////////////////////////////////////////////////////////////////////
+/// FUNCTION DEFINITIONS ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+ Synopsis []
+
+ Description [Kills all watched child processes and remove all watched termporary files.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+
+void Util_SignalCleanup()
+{
+ int i;
+ Hash_Gen_Entry_t* pEntry;
+
+ // kill all watched child processes
+ Hash_GenForEachEntry(watched_pid_hash, pEntry, i)
+ {
+ pid_t pid = (pid_t)pEntry->key;
+ pid_t ppid = (pid_t)pEntry->data;
+
+ if (getpid() == ppid)
+ {
+ kill(pid, SIGINT);
+ }
+ }
+
+ // remove watched temporary files
+ Hash_GenForEachEntry(watched_tmp_files_hash, pEntry, i)
+ {
+ int fname = (const char*)pEntry->key;
+ pid_t ppid = (pid_t)pEntry->data;
+
+ if( getpid() == ppid )
+ {
+ remove(fname);
+ }
+ }
+}
+
+/**Function*************************************************************
+
+ Synopsis []
+
+ Description [Sets up data structures needed for cleanup in signal handler.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+
+void Util_SignalStartHandler()
+{
+ watched_pid_hash = Hash_GenAlloc(100, Hash_DefaultHashFuncInt, Hash_DefaultCmpFuncInt, 0);
+ watched_tmp_files_hash = Hash_GenAlloc(100, Hash_DefaultHashFuncStr, strcmp, 1);
+}
+
+/**Function*************************************************************
+
+ Synopsis []
+
+ Description [Frees data structures used for clean up in signal handler.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+
+void Util_SignalResetHandler()
+{
+ int i;
+ Hash_Gen_Entry_t* pEntry;
+
+ sigset_t procmask, old_procmask;
+
+ sigemptyset(&procmask);
+ sigaddset(&procmask, SIGINT);
+
+ sigprocmask(SIG_BLOCK, &procmask, &old_procmask);
+
+ Hash_GenFree(watched_pid_hash);
+ watched_pid_hash = Hash_GenAlloc(100, Hash_DefaultHashFuncInt, Hash_DefaultCmpFuncInt, 0);
+
+ Hash_GenFree(watched_tmp_files_hash);
+ watched_tmp_files_hash = Hash_GenAlloc(100, Hash_DefaultHashFuncStr, strcmp, 1);
+
+ sigprocmask(SIG_SETMASK, &old_procmask, NULL);
+}
+
+void Util_SignalStopHandler()
+{
+ int i;
+ Hash_Gen_Entry_t* pEntry;
+
+ Hash_GenFree(watched_pid_hash);
+ watched_pid_hash = NULL;
+
+ Hash_GenFree(watched_tmp_files_hash);
+ watched_tmp_files_hash = NULL;
+}
+
+
+/**Function*************************************************************
+
+ Synopsis []
+
+ Description [Blocks SIGINT. For use when updating watched processes and temporary files to prevent race conditions with the signal handler.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+
+static int nblocks = 0;
+
+void Util_SignalBlockSignals()
+{
+ sigset_t procmask;
+
+ assert(nblocks==0);
+ nblocks ++ ;
+
+ sigemptyset(&procmask);
+ sigaddset(&procmask, SIGINT);
+
+ sigprocmask(SIG_BLOCK, &procmask, &old_procmask);
+}
+
+/**Function*************************************************************
+
+ Synopsis []
+
+ Description [Unblocks SIGINT after a call to Util_SignalBlockSignals.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+
+void Util_SignalUnblockSignals()
+{
+ assert( nblocks==1);
+ nblocks--;
+
+ sigprocmask(SIG_SETMASK, &old_procmask, NULL);
+}
+
+
+static void watch_tmp_file(const char* fname)
+{
+ if( watched_tmp_files_hash != NULL )
+ {
+ Hash_GenWriteEntry(watched_tmp_files_hash, Extra_UtilStrsav(fname), (void*)getpid() );
+ }
+}
+
+static void unwatch_tmp_file(const char* fname)
+{
+ if ( watched_tmp_files_hash )
+ {
+ assert( Hash_GenExists(watched_tmp_files_hash, fname) );
+ Hash_GenRemove(watched_tmp_files_hash, fname);
+ assert( !Hash_GenExists(watched_tmp_files_hash, fname) );
+ }
+}
+
+/**Function*************************************************************
+
+ Synopsis []
+
+ Description [Adds a process id to the list of processes that should be killed in a signal handler.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+
+void Util_SignalAddChildPid(int pid)
+{
+ if ( watched_pid_hash )
+ {
+ Hash_GenWriteEntry(watched_pid_hash, (void*)pid, (void*)getpid());
+ }
+}
+
+/**Function*************************************************************
+
+ Synopsis []
+
+ Description [Removes a process id from the list of processes that should be killed in a signal handler.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+
+void Util_SignalRemoveChildPid(int pid)
+{
+ if ( watched_pid_hash )
+ {
+ Hash_GenRemove(watched_pid_hash, (void*)pid);
+ }
+}
+
+// a dummy signal hanlder to make sure that SIGCHLD and SIGINT will cause sigsuspend() to return
+static int null_sig_handler(int signum)
+{
+ return 0;
+}
+
+
+// enusre that sigsuspend() returns when signal signum occurs -- sigsuspend() does not return if a signal is ignored
+static void replace_sighandler(int signum, struct sigaction* old_sa, int replace_dfl)
+{
+ sigaction(signum, NULL, old_sa);
+
+ if( old_sa->sa_handler == SIG_IGN || old_sa->sa_handler==SIG_DFL && replace_dfl)
+ {
+ struct sigaction sa;
+ memset(&sa, 0, sizeof(sa));
+
+ sa.sa_handler = null_sig_handler;
+
+ sigaction(signum, &sa, &old_sa);
+ }
+}
+
+//
+static int do_waitpid(pid_t pid, sigset_t* old_procmask)
+{
+ int status;
+
+ struct sigaction sigint_sa;
+ struct sigaction sigchld_sa;
+ sigset_t waitmask;
+
+ // ensure SIGINT and SIGCHLD are not blocked during sigsuspend()
+ memcpy(&waitmask, old_procmask, sizeof(sigset_t));
+
+ sigdelset(&waitmask, SIGINT);
+ sigdelset(&waitmask, SIGCHLD);
+
+ // ensure sigsuspend() returns if SIGINT or SIGCHLD occur, and save the current settings for SIGCHLD and SIGINT
+
+ replace_sighandler(SIGINT, &sigint_sa, 0);
+ replace_sighandler(SIGCHLD, &sigchld_sa, 1);
+
+ for(;;)
+ {
+ int rc;
+
+ // wait for a signal -- returns if SIGINT or SIGCHLD (or any other signal that is unblocked and not ignored) occur
+ sigsuspend(&waitmask);
+
+ // check if pid has terminated
+ rc = waitpid(pid, &status, WNOHANG);
+
+ // stop if terminated or some other error occurs
+ if( rc > 0 || rc == -1 && errno!=EINTR )
+ {
+ break;
+ }
+ }
+
+ // process is dead, should no longer be watched
+ Util_SignalRemoveChildPid(pid);
+
+ // restore original behavior of SIGINT and SIGCHLD
+ sigaction(SIGINT, &sigint_sa, NULL);
+ sigaction(SIGCHLD, &sigchld_sa, NULL);
+
+ return status;
+}
+
+static int do_system(const char* cmd, sigset_t* old_procmask)
+{
+ int pid;
+
+ pid = fork();
+
+ if (pid == -1)
+ {
+ // fork failed
+ return -1;
+ }
+ else if( pid == 0)
+ {
+ // child process
+ sigprocmask(SIG_SETMASK, old_procmask, NULL);
+ execl("/bin/sh", "sh", "-c", cmd, NULL);
+ _exit(127);
+ }
+
+ Util_SignalAddChildPid(pid);
+
+ return do_waitpid(pid, old_procmask);
+}
+
+/**Function*************************************************************
+
+ Synopsis []
+
+ Description [Replaces system() with a function that allows SIGINT to interrupt.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+
+int Util_SignalSystem(const char* cmd)
+{
+ int status;
+
+ sigset_t procmask;
+ sigset_t old_procmask;
+
+ // if signal handler is not installed, run the original system()
+ if ( ! watched_pid_hash && ! watched_tmp_files_hash )
+ return system(cmd);
+
+ // block SIGINT and SIGCHLD
+ sigemptyset(&procmask);
+
+ sigaddset(&procmask, SIGINT);
+ sigaddset(&procmask, SIGCHLD);
+
+ sigprocmask(SIG_BLOCK, &procmask, &old_procmask);
+
+ // call the actual function
+ status = do_system(cmd, &old_procmask);
+
+ // restore signal block mask
+ sigprocmask(SIG_SETMASK, &old_procmask, NULL);
+ return status;
+}
+
+/**Function*************************************************************
+
+ Synopsis []
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+
+////////////////////////////////////////////////////////////////////////
+/// END OF FILE ///
+////////////////////////////////////////////////////////////////////////
+
+#else /* #ifndef _MSC_VER */
+
+#include "abc_global.h"
+
+ABC_NAMESPACE_IMPL_START
+
+void Util_SignalCleanup()
+{
+}
+
+void Util_SignalStartHandler()
+{
+}
+
+void Util_SignalResetHandler()
+{
+}
+
+void Util_SignalStopHandler()
+{
+}
+
+void Util_SignalBlockSignals()
+{
+}
+
+void Util_SignalUnblockSignals()
+{
+}
+
+void watch_tmp_file(const char* fname)
+{
+}
+
+void unwatch_tmp_file(const char* fname)
+{
+}
+
+void Util_SignalAddChildPid(int pid)
+{
+}
+
+void Util_SignalRemoveChildPid(int pid)
+{
+}
+
+int Util_SignalSystem(const char* cmd)
+{
+ return system(cmd);
+}
+
+#endif /* #ifdef _MSC_VER */
+
+int tmpFile(const char* prefix, const char* suffix, char** out_name);
+
+/**Function*************************************************************
+
+ Synopsis []
+
+ Description [Create a temporary file and add it to the list of files to be cleaned up in the signal handler.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+
+int Util_SignalTmpFile(const char* prefix, const char* suffix, char** out_name)
+{
+ int fd;
+
+ Util_SignalBlockSignals();
+
+ fd = tmpFile(prefix, suffix, out_name);
+
+ if ( fd != -1 )
+ {
+ watch_tmp_file( *out_name );
+ }
+
+ Util_SignalUnblockSignals();
+
+ return fd;
+}
+
+/**Function*************************************************************
+
+ Synopsis []
+
+ Description [Remove a temporary file (and remove it from the watched files list.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+
+void Util_SignalTmpFileRemove(const char* fname, int fLeave)
+{
+ Util_SignalBlockSignals();
+
+ unwatch_tmp_file(fname);
+
+ if (! fLeave)
+ {
+ remove(fname);
+ }
+
+ Util_SignalUnblockSignals();
+}
+
+ABC_NAMESPACE_IMPL_END
diff --git a/src/misc/util/utilSignal.h b/src/misc/util/utilSignal.h
new file mode 100644
index 00000000..d9802aa0
--- /dev/null
+++ b/src/misc/util/utilSignal.h
@@ -0,0 +1,71 @@
+/**CFile****************************************************************
+
+ FileName [utilSignal.h]
+
+ SystemName [ABC: Logic synthesis and verification system.]
+
+ PackageName []
+
+ Synopsis []
+
+ Author []
+
+ Affiliation [UC Berkeley]
+
+ Date []
+
+ Revision []
+
+***********************************************************************/
+
+#ifndef __UTIL_SIGNAL_H__
+#define __UTIL_SIGNAL_H__
+
+////////////////////////////////////////////////////////////////////////
+/// INCLUDES ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+/// PARAMETERS ///
+////////////////////////////////////////////////////////////////////////
+
+ABC_NAMESPACE_HEADER_START
+
+////////////////////////////////////////////////////////////////////////
+/// BASIC TYPES ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+/// MACRO DEFINITIONS ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+/// FUNCTION DECLARATIONS ///
+////////////////////////////////////////////////////////////////////////
+
+/*=== utilSignal.c ==========================================================*/
+
+void Util_SignalCleanup();
+
+void Util_SignalStartHandler();
+void Util_SignalResetHandler();
+void Util_SignalStopHandler();
+
+void Util_SignalBlockSignals();
+void Util_SignalUnblockSignals();
+
+void Util_SignalAddChildPid(int pid);
+void Util_SignalRemoveChildPid(int pid);
+
+int Util_SignalTmpFile(const char* prefix, const char* suffix, char** out_name);
+void Util_SignalTmpFileRemove(const char* fname, int fLeave);
+
+int Util_SignalSystem(const char* cmd);
+
+ABC_NAMESPACE_HEADER_END
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+/// END OF FILE ///
+////////////////////////////////////////////////////////////////////////
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-29 18:43:01 +0000