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

1 files changed, 33 insertions, 35 deletions

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 <signal.h>
 #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;