From 325530e630c68c7c10a2f4339f5b43434fcd0329 Mon Sep 17 00:00:00 2001 From: sc Date: Tue, 28 Nov 2000 14:19:35 +0000 Subject: Incorporation into IvyLeague Ccu -> Ivl ccu -> ivl Smart pointers disappear (too dangerous) Imakefile disappears (Makefile now) An empty cplus_bugs.h has been created locally --- utils/Signal.cc | 68 ++++++++++++++++++++++++++++----------------------------- 1 file changed, 33 insertions(+), 35 deletions(-) (limited to 'utils/Signal.cc') diff --git a/utils/Signal.cc b/utils/Signal.cc index d03ff65..c15167e 100644 --- a/utils/Signal.cc +++ b/utils/Signal.cc @@ -78,10 +78,9 @@ extern "C" { #include #endif - -/*?class CcuBaseSignalHandler -The class \typ{CcuBaseSignalHandler} is provided as a base class for signal handlers. -It comes with a derived class \typ{CcuSignalHandler} that can be used as is, without +/*?class IvlBaseSignalHandler +The class \typ{IvlBaseSignalHandler} is provided as a base class for signal handlers. +It comes with a derived class \typ{IvlSignalHandler} that can be used as is, without any derivation. A signal handler is created for a specific signal, identified by a numeric value. The following constants are defined: \var{AllSigs, SigHup, SigInt, SigQuit, SigIll, SigTrap, @@ -91,7 +90,7 @@ and \var{SigLost}. The value \var{AllSigs} is not meaningful to signal handlers. When a signal is received by the program and a signal handler was created for that signal, its method \fun{Handle} is called. This method should be redefined in derived -classes of \var{CcuBaseSignalHandler}. +classes of \var{IvlBaseSignalHandler}. Several signal handlers can be created for the same signal. However, only one is active at a time. A stack of signal handlers is maintained for every signal, so that @@ -136,22 +135,22 @@ const int SigUrg = SIGURG; const int SigLost = SIGLOST; #endif -CcuList* CcuBaseSignalHandler::HandlerStacks = 0; +IvlList* IvlBaseSignalHandler::HandlerStacks = 0; /*?hidden?*/ void -CcuBaseSignalHandler :: ClassInit () +IvlBaseSignalHandler :: ClassInit () { - HandlerStacks = new CcuList [NumSigs]; + HandlerStacks = new IvlList [NumSigs]; } /*? Create a signal handler for the signal \var{sig}. ?*/ -CcuBaseSignalHandler :: CcuBaseSignalHandler (int sig) +IvlBaseSignalHandler :: IvlBaseSignalHandler (int sig) : Signal (sig) { - CcuSignalBlocker b (sig); + IvlSignalBlocker b (sig); if (!HandlerStacks) ClassInit (); HandlerStacks [Signal-1].Prepend (this); @@ -159,16 +158,16 @@ CcuBaseSignalHandler :: CcuBaseSignalHandler (int sig) } /*?nodoc?*/ -CcuBaseSignalHandler :: ~CcuBaseSignalHandler () +IvlBaseSignalHandler :: ~IvlBaseSignalHandler () { - CcuSignalBlocker b (Signal); - CcuList& stack = HandlerStacks [Signal-1]; + IvlSignalBlocker b (Signal); + IvlList& stack = HandlerStacks [Signal-1]; if (stack.First () == this) { stack.RemoveFirst (); if (stack.IsEmpty ()) InstallNone (Signal); else - ((CcuBaseSignalHandler*) stack.First ())->Install (); + ((IvlBaseSignalHandler*) stack.First ())->Install (); } else stack.Remove (this, 1); } @@ -178,14 +177,14 @@ CcuBaseSignalHandler :: ~CcuBaseSignalHandler () Get the signal that is handled by this signal handler. ?*/ int -CcuBaseSignalHandler :: GetSignal () +IvlBaseSignalHandler :: GetSignal () { } #endif /* DOC */ /*?hidden?*/ void -CcuBaseSignalHandler :: Install () +IvlBaseSignalHandler :: Install () { struct sigaction act; #ifdef __sgi @@ -200,7 +199,7 @@ CcuBaseSignalHandler :: Install () /*?hidden?*/ void -CcuBaseSignalHandler :: InstallNone (int sig) +IvlBaseSignalHandler :: InstallNone (int sig) { struct sigaction act; act.sa_handler = SIG_DFL; @@ -211,9 +210,9 @@ CcuBaseSignalHandler :: InstallNone (int sig) /*?hidden?*/ void -CcuBaseSignalHandler :: DoHandle (int sig) +IvlBaseSignalHandler :: DoHandle (int sig) { - CcuBaseSignalHandler* s = (CcuBaseSignalHandler*) HandlerStacks [sig-1].First (); + IvlBaseSignalHandler* s = (IvlBaseSignalHandler*) HandlerStacks [sig-1].First (); if (s) s->Handle (); } @@ -223,14 +222,14 @@ This virtual function should be redefined in derived classes. It is called when this handler is the currently active one and a signal is received. ?*/ void -CcuBaseSignalHandler :: Handle () +IvlBaseSignalHandler :: Handle () { } -/*?class CcuSignalHandler -The class \typ{CcuSignalHandler} is a derived class of \typ{CcuBaseSignalHandler} that +/*?class IvlSignalHandler +The class \typ{IvlSignalHandler} is a derived class of \typ{IvlBaseSignalHandler} that can be used without deriving a new class. -Each \typ{CcuSignalHandler} holds a pointer to a function which is called when a +Each \typ{IvlSignalHandler} holds a pointer to a function which is called when a signal is received. This function, which is passed to the constructor, must take an \typ{int} argument and return \typ{void}. ?*/ @@ -239,27 +238,27 @@ take an \typ{int} argument and return \typ{void}. Create a signal handler for signal \var{sig}. The function \var{handler} will be called when a signal is received. ?*/ -CcuSignalHandler :: CcuSignalHandler (int sig, void (*handler) (int)) -: CcuBaseSignalHandler (sig), +IvlSignalHandler :: IvlSignalHandler (int sig, void (*handler) (int)) +: IvlBaseSignalHandler (sig), Handler (handler) { } /*?nodoc?*/ -CcuSignalHandler :: ~CcuSignalHandler () +IvlSignalHandler :: ~IvlSignalHandler () { } /*?hidden?*/ void -CcuSignalHandler :: Handle () +IvlSignalHandler :: Handle () { (*Handler) (Signal); } -/*?class CcuSignalBlocker -The class \typ{CcuSignalBlocker} provides protection against signals. -When a \typ{CcuSignalBlocker} is created for a signal type, the program will +/*?class IvlSignalBlocker +The class \typ{IvlSignalBlocker} provides protection against signals. +When a \typ{IvlSignalBlocker} is created for a signal type, the program will be protected against such signals during the lifetime of the signal blocker. Signal blockers are often used as follows: \begin{ccode} @@ -267,7 +266,7 @@ Signal blockers are often used as follows: sensitive_function () { // protect this function against alarms - CcuSignalBlocker b (SigAlrm); + IvlSignalBlocker b (SigAlrm); ... } \end{ccode} @@ -280,14 +279,13 @@ However, the special value \var{AllSigs} allows the creation of signal blockers that protect against all kinds of signals. ?*/ -int CcuSignalBlocker::BlockCounts [NumSigs]; - +int IvlSignalBlocker::BlockCounts [NumSigs]; /*? Create a signal blocker for the signal \var{sig}. If \var{sig} is \var{AllSigs}, all signals will be blocked. ?*/ -CcuSignalBlocker :: CcuSignalBlocker (int sig) +IvlSignalBlocker :: IvlSignalBlocker (int sig) : Signal (sig) { int all = sig < 1 || sig > NumSigs; @@ -311,7 +309,7 @@ CcuSignalBlocker :: CcuSignalBlocker (int sig) } /*?nodoc?*/ -CcuSignalBlocker :: ~CcuSignalBlocker () +IvlSignalBlocker :: ~IvlSignalBlocker () { int all = Signal < 1 || Signal > NumSigs; int change = 0; -- cgit v1.1