home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / OTL-MC7.DMS / in.adf / classsource.lha / ClassSource / Exec / Signals / Signals.c
Encoding:
C/C++ Source or Header  |  1995-02-12  |  2.4 KB  |  136 lines
  1.  
  2. #include <classes/Exec/Signals.h>
  3.  
  4. #include <pragma/exec_lib.h>
  5.  
  6. SignalC::SignalC(LONG signalNum)
  7.     : ShareC()
  8. {
  9.     sigNum = AllocSignal(signalNum);
  10.     if (sigNum == -1)
  11.         throw SignalX(signalNum);
  12. }
  13.  
  14. SignalC::~SignalC()
  15. {
  16.     if (only())
  17.         if (sigNum != -1)
  18.             FreeSignal(sigNum);
  19. }
  20.  
  21. SignalC &SignalC::operator = (const SignalC &s)
  22. {
  23.     if (this != &s)
  24.     {
  25.         if (only())
  26.             if (sigNum != -1)
  27.                 FreeSignal(sigNum);
  28.         ShareC::operator=(s);
  29.         sigNum = s.sigNum;
  30.     };
  31.     return *this;
  32. }
  33.  
  34. // ****************************************************************
  35.  
  36. SignalHandlerC::SignalHandlerC(LONG signalNum)
  37.     : NodeC()
  38. {
  39.     if (signalNum == -1)
  40.         mask = 0
  41.     else
  42.         mask = 1L << signalNum;
  43. }
  44.  
  45. SignalHandlerC::SignalHandlerC(SignalC &signal)
  46.     : NodeC()
  47. {
  48.     mask = 1L << signal.number();
  49. }
  50.  
  51. SignalHandlerC::SignalHandlerC(const SignalHandlerC &s)
  52. {
  53.     mask = s.mask;
  54. }
  55.  
  56. SignalHandlerC::~SignalHandlerC()
  57. {
  58. }
  59.  
  60. SignalHandlerC &SignalHandlerC::operator = (const SignalHandlerC &s)
  61. {
  62.     if (this != &s)
  63.     {
  64.         mask = s.mask;
  65.     }
  66.     return *this;
  67. }
  68.  
  69. // *****************************************************************
  70.  
  71. SignalsC::SignalsC()
  72.     : ListC()
  73. {
  74.     mask = 0;
  75. }
  76.  
  77. SignalsC::~SignalsC()
  78. {
  79. }
  80.  
  81. VOID SignalsC::add(SignalHandlerC &handler)
  82. {
  83.     addTail(handler);
  84. }
  85.  
  86. ULONG SignalsC::wait()
  87. {
  88.     buildMask();
  89.     // Wenn keine Signale erwartet werden, wird nicht gewartet, logisch.
  90.     // Wenn die Maske == ~0 ist, wird auch nicht gewartet. Da einige Signale
  91.     // dem Benutzer nicht zur Verfügung stehen, also auch nicht in der Maske
  92.     // auftauchen können, steht damit eine Art "Notausgang" vor dem Wait()
  93.     // zur Verfügung. Dieses Feature ist jedoch nicht dokumentiert und im
  94.     // wesentlichen für so abstruses Signalhandling wie von MUI gedacht, wo
  95.     // die eigentliche Arbeit in der signals() Methode des SignalHandlerCs
  96.     // steckt (und damit auch der Abbruch der Wait() Schleife).
  97.     if ((mask) && (mask != ~0))
  98.         return Wait(mask);
  99.     return 0;
  100. }
  101.  
  102. BOOL SignalsC::handle(ULONG signals)
  103. {
  104.     ListCursorC lc(*this);
  105.     BOOL r = FALSE;
  106.     BOOL b;
  107.     while (!lc.isDone()) {
  108.         if (((SignalHandlerC *) lc.item())->forMe(signals))
  109.         {
  110.             b = ((SignalHandlerC *) lc.item())->handle(signals);
  111.             r = r || b;
  112.         };
  113.         lc.next();
  114.     };
  115.     return r;
  116. }
  117.  
  118. VOID SignalsC::loop()
  119. {
  120.     ULONG signals;
  121.     for (;;) {
  122.         signals = wait();
  123.         if (handle(signals))
  124.             return;
  125.     };
  126. }
  127.  
  128. VOID SignalsC::buildMask()
  129. {
  130.     ListCursorC lc(*this);
  131.     while (!lc.isDone()) {
  132.         mask |= ((SignalHandlerC *) lc.item())->signals();
  133.         lc.next();
  134.     };
  135. }
  136.