home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS 1992 June / SIMTEL_0692.cdr / msdos / ddjmag / ddj8911.arc / GEHANI.LST < prev    next >
Encoding:
File List  |  1989-10-04  |  4.8 KB  |  232 lines
  1. _CONCURRENT C FOR REAL-TIME PROGRAMMING_
  2. by N.H. Gehani and W.D. Roome
  3.  
  4. [LISTING ONE]
  5.  
  6.  
  7. process spec ttyOutput()
  8. {
  9.     trans void  put(int nc, char *pc);
  10.     trans async ready(), start(), stop();
  11. };
  12.  
  13. process spec ttyInput()
  14. {
  15.     trans void  put(char c);
  16.     trans int   get(int wait);
  17. };
  18.  
  19. process spec ttyReader()
  20. {
  21.     trans async ready();
  22.     trans char  get();
  23. };
  24.  
  25. process spec ttyLine();
  26.  
  27. process ttyInput  ttyIn;
  28. process ttyOutput ttyOut;
  29. process ttyReader ttyRdr;
  30.  
  31.  
  32. [LISTIN╟ TWO]
  33.  
  34. #include "concurrentc.h"
  35. #include "tty.h"
  36.  
  37. void ttyReply(msg, reply)
  38.     char *msg, *reply;
  39. {
  40.     int c;
  41.     char *nasty = "\r\nWAKE UP!\r\n";
  42.  
  43.     while (1) {
  44.         ttyOut.put(strlen(msg), msg);
  45.         c = within 30 ? ttyIn.get(1) : -1;
  46.         if (c != -1)
  47.             break;
  48.         ttyOut.put(strlen(nasty), nasty);
  49.     }
  50.     while (c != '\n') {
  51.         *reply++ = c;
  52.         c = ttyIn.get(1);
  53.     }
  54.     *reply = '\0';
  55. }
  56.  
  57.  
  58. [LISTIN╟ THREE]
  59.  
  60. #include "concurrentc.h"
  61. #include "tty.h"
  62.  
  63. void ttyInit()
  64. {
  65.     ttyOut = create ttyOutput() priority(1);
  66.     c_associate(ttyOut.ready, 1/*DUM*//*PSoutput-ready-interruptPS*/);
  67.     ttyRdr = create ttyReader() priority(2);
  68.     c_associate(ttyRdr.ready, 2/*DUM*//*PSinput-ready-interruptPS*/);
  69.     ttyIn = create ttyInput();
  70.     create ttyLine();
  71. }
  72.  
  73.  
  74. [LISTIN╟ FOUR]
  75.  
  76. #define M_RdrBuff 2048
  77. #define M_OutBuff 2048
  78. #define M_InBuff  1024
  79. #define M_LineLen 1024
  80.  
  81. #define StopChar  0x13  /* ctl-S */
  82. #define StartChar 0x11  /* ctl-Q */
  83. #define EraseChar '\b'  /* backspace */
  84. #define KillChar  0x03  /* ctl-C */
  85.  
  86.  
  87.  
  88. [LISTIN╟ FIVE]
  89.  
  90. #include "concurrentc.h"
  91. #include "tty.h"
  92. #include "defs.h"
  93.  
  94. process body ttyReader()
  95. {
  96.     int  n = 0, in = 0, out = 0;
  97.     char c, buff[M_RdrBuff];
  98.  
  99.     while (1) {
  100.         select {
  101.             accept ready();
  102.             c = uartGetChar();
  103.             if (c == StartChar) {
  104.                 ttyOut.start();
  105.             } else if (c == StopChar) {
  106.                 ttyOut.stop();
  107.             } else if (n < M_RdrBuff) {
  108.                 buff[in] = c;
  109.                 in = (in + 1) % M_RdrBuff;
  110.                 n++;
  111.             }
  112.           or (n > 0):
  113.             accept get()
  114.                 treturn buff[out];
  115.             out = (out + 1) % M_RdrBuff;
  116.             n--;
  117.         }
  118.     }
  119. }
  120.  
  121. [LISTIN╟ SIX]
  122.  
  123. #include "concurrentc.h"
  124. #include "tty.h"
  125. #include "defs.h"
  126.  
  127. process body ttyLine()
  128. {
  129.     int n = 0, putline = 0, i;
  130.     char c, buff[M_LineLen];
  131.  
  132.     while (1) {
  133.         switch (c = ttyRdr.get()) {
  134.             case EraseChar:
  135.                 ttyOut.put(3, "\b \b");
  136.                 if (n > 0)
  137.                     --n;
  138.                 break;
  139.             case KillChar:
  140.                if (n > 0)
  141.                    ttyOut.put(2, "\r\n");
  142.                n = 0;
  143.                break;
  144. è            case '\r':
  145.             case '\n':
  146.                 ttyOut.put(2, "\r\n");
  147.                 buff[n++] = '\n';
  148.                 putline = 1;
  149.                 break;
  150.             default:
  151.                 ttyOut.put(1, &c);
  152.                 buff[n++] = c;
  153.                 if (n >= M_LineLen)
  154.                     putline = 1;
  155.                 break;
  156.         }
  157.         if (putline) {
  158.             for (i = 0; i < n; i++)
  159.                 ttyIn.put(buff[i]);
  160.             putline = n = 0;
  161.         }
  162.     }
  163. }
  164.  
  165.  
  166. [LISTIN╟ SEVEN]
  167. è
  168. #include "concurrentc.h"
  169. #include "tty.h"
  170. #include "defs.h"
  171.  
  172. process body ttyInput()
  173. {
  174.     int n = 0, in = 0, out = 0;
  175.     char buff[M_InBuff];
  176.  
  177.     while (1) {
  178.         select {
  179.           (n < M_InBuff):
  180.             accept put(c)
  181.                 buff[in] = c;
  182.             in = (in + 1) % M_RdrBuff;
  183.             n++;
  184.           or (n > 0):
  185.             accept get(wait)
  186.                 treturn buff[out];
  187.             out = (out + 1) % M_RdrBuff;
  188.             n--;
  189.           or (n == 0):
  190.             accept get(wait) suchthat (!wait)
  191.                 treturn -1;
  192.         }
  193.     }
  194. }
  195.  
  196.  
  197. [LISTIN╟ EIGHT]
  198.  
  199. #include "concurrentc.h"
  200. #include "tty.h"
  201. #include "defs.h"
  202.  
  203. process body ttyOutput()
  204. {
  205.     int n = 0, in = 0, out = 0;
  206.     int running = 1, ttyrdy = 1, i;
  207.     char buff[M_OutBuff];
  208.  
  209.     while (1) {
  210.         select {
  211.             accept start()
  212.                 running = 1;
  213.           or accept stop()
  214.                 running = 0;
  215.           or accept ready()
  216.                 ttyrdy = 1;
  217.           or accept put(nc, pc) suchthat (n+nc <= M_OutBuff) {
  218.                 for (i = 0; i < nc; i++) {
  219.                     buff[in] = pc[i];
  220.                     in = (in + 1) % M_OutBuff;
  221.                 }
  222.                 n += nc;
  223.             }
  224.         }
  225.         if (ttyrdy && running && n > 0) {
  226.             uartPutChar(buff[out]);
  227.             out = (out + 1) % M_OutBuff;
  228.             n--;
  229.             ttyrdy = 0;
  230.         }
  231.     }
  232. }
  233.  
  234.