home *** CD-ROM | disk | FTP | other *** search
/ BCI NET / BCI NET Dec 94.iso / archives / telecomm / terms / term-4.1-source.lha / Extras / Source / term-Source.lha / termResponse.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-04  |  3.1 KB  |  175 lines
  1. /*
  2. **    termResponse.c
  3. **
  4. **    Signal event handling routines
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12.     /* Yet another function pointer. */
  13.  
  14. typedef BYTE (* RESPONSE)(VOID);
  15.  
  16.     /* Signal response table entry. */
  17.  
  18. struct SignalResponseInfo
  19. {
  20.     RESPONSE    Routine;
  21.     ULONG        Mask;
  22. };
  23.  
  24.     /* Signal response table. */
  25.  
  26. STATIC struct SignalResponseInfo    ResponseTable[7];
  27. STATIC WORD                ResponseCount;
  28. STATIC ULONG                ResponseMask;
  29.  
  30. #ifdef DATAFEED
  31. BPTR DataFeed;
  32. #endif    /* DATAFEED */
  33.  
  34.     /* AddResponse(RESPONSE Routine,ULONG Mask):
  35.      *
  36.      *    Register a signal response routine.
  37.      */
  38.  
  39. STATIC VOID __regargs
  40. AddResponse(RESPONSE Routine,ULONG Mask)
  41. {
  42.     ResponseTable[ResponseCount] . Routine    = Routine;
  43.     ResponseTable[ResponseCount] . Mask    = Mask;
  44.  
  45.     ResponseMask |= Mask;
  46.  
  47.     ResponseCount++;
  48. }
  49.  
  50.     /* HandleResponse():
  51.      *
  52.      *    Register routines and corresponding signals,
  53.      *    wait for events and process them.
  54.      */
  55.  
  56. VOID
  57. HandleResponse()
  58. {
  59.     register ULONG    SignalSet;
  60.     register BYTE    Running,
  61.             SerialRunning;
  62.     register WORD    i;
  63.  
  64.     ResponseMask    = XEM_Signal;
  65.     ResponseCount    = 0;
  66.  
  67.     AddResponse((RESPONSE)HandleSerialCheck,SIG_CHECK);
  68.  
  69.     if(WorkbenchPort)
  70.         AddResponse((RESPONSE)HandleWorkbenchWindow,SIG_WORKBENCH);
  71.  
  72.     if(ReadPort && Status != STATUS_HOLDING && ProcessIO)
  73.     {
  74.         AddResponse(HandleSerial,SIG_SERIAL);
  75.  
  76.         SerialRunning = TRUE;
  77.     }
  78.     else
  79.         SerialRunning = FALSE;
  80.  
  81.     if(OwnDevUnitBase && !Config -> SerialConfig -> Shared && OwnDevBit != -1)
  82.         AddResponse(HandleOwnDevUnit,1L << OwnDevBit);
  83.  
  84.     AddResponse(HandleWindow,SIG_WINDOW);
  85.  
  86.     if(TermRexxPort)
  87.         AddResponse(HandleRexx,SIG_REXX);
  88.  
  89.     AddResponse(HandleQueueMsg,SIG_QUEUE);
  90.  
  91. #ifdef DATAFEED
  92.         /* Wait for events. */
  93.  
  94.     if(HostReadBuffer || DataHold)
  95.     {
  96.         if(ReadPort && Status != STATUS_HOLDING)
  97.             SignalSet = CheckSignal(ResponseMask) | SIG_SERIAL;
  98.         else
  99.             SignalSet = CheckSignal(ResponseMask);
  100.     }
  101.     else
  102.     {
  103.         if(DataFeed)
  104.             SignalSet = CheckSignal(ResponseMask);
  105.         else
  106.             SignalSet = Wait(ResponseMask);
  107.     }
  108. #else
  109.         /* Wait for events. */
  110.  
  111.     if(HostReadBuffer || DataHold)
  112.     {
  113.         if(ReadPort && Status != STATUS_HOLDING)
  114.             SignalSet = CheckSignal(ResponseMask) | SIG_SERIAL;
  115.         else
  116.             SignalSet = CheckSignal(ResponseMask);
  117.     }
  118.     else
  119.         SignalSet = Wait(ResponseMask);
  120. #endif    /* DATAFEED */
  121.  
  122.     if(SignalSet & XEM_Signal)
  123.         HandleExternalEmulation();
  124.  
  125.     FOREVER
  126.     {
  127. #ifdef DATAFEED
  128.         if(DataFeed)
  129.         {
  130.             UBYTE    LocalBuffer[256];
  131.             LONG    Len;
  132.  
  133.             if((Len = Read(DataFeed,LocalBuffer,256)) > 0)
  134.             {
  135.                 if(Marking)
  136.                     DropMarker();
  137.  
  138.                 ConProcess(LocalBuffer,Len);
  139.             }
  140.             else
  141.             {
  142.                 Close(DataFeed);
  143.  
  144.                 DataFeed = NULL;
  145.             }
  146.         }
  147. #endif    /* DATAFEED */
  148.  
  149.         for(i = 0, Running = FALSE ; !MainTerminated && i < ResponseCount ; i++)
  150.         {
  151.             if(SignalSet & ResponseTable[i] . Mask)
  152.             {
  153.                 if((*ResponseTable[i] . Routine)())
  154.                     Running = TRUE;
  155.                 else
  156.                     SignalSet &= ~ResponseTable[i] . Mask;
  157.             }
  158.         }
  159.  
  160.         if(!SerialRunning && ReadPort && Status != STATUS_HOLDING && ProcessIO)
  161.         {
  162.             AddResponse(HandleSerial,SIG_SERIAL);
  163.  
  164.             SerialRunning = TRUE;
  165.  
  166.             SignalSet |= SIG_SERIAL;
  167.         }
  168.  
  169.         if(Running && !MainTerminated)
  170.             SignalSet |= SetSignal(0,ResponseMask) & ResponseMask;
  171.         else
  172.             break;
  173.     }
  174. }
  175.