home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / multitsk / cpptask / tskbuf.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-21  |  3.5 KB  |  200 lines
  1. /*
  2.    CPPTask - A Multitasking Kernel For C++
  3.  
  4.    Version 1.0 08-12-91
  5.  
  6.    Ported by Rich Smith from:
  7.  
  8.    Public Domain Software written by
  9.       Thomas Wagner
  10.       Patschkauer Weg 31
  11.       D-1000 Berlin 33
  12.       West Germany
  13.  
  14.    NOTE: None of the Buffer routines my be used from inside an interrupt
  15.          handler. The routines are relatively slow, since they use
  16.          the normal word pipe and resource calls. Optimization would be 
  17.          possible by using block moves and internally handling resources.
  18.  
  19.    TSKBUF.CPP - Buffered Message handling routines.
  20.  
  21.    Subroutines:
  22.         buffer::buffer
  23.         buffer::~buffer
  24.         buffer::read_buffer
  25.         buffer::c_read_buffer
  26.         buffer::write_buffer
  27.         buffer::c_write_buffer
  28.         buffer::check_buffer
  29.  
  30. */
  31.  
  32. #include <stdio.h>
  33.  
  34. #include "task.hpp"
  35. #include "tsklocal.hpp"
  36.  
  37.  
  38. /*
  39.    buffer
  40. */
  41. buffer::buffer (farptr pbuf, word bufsize)
  42. :pip(pbuf, bufsize), buf_write(), buf_read()
  43. {
  44.    flags = 0;
  45.    msgcnt = 0;
  46. }
  47.  
  48.  
  49. /*
  50.    ~buffer
  51. */
  52. buffer::~buffer ()
  53. {
  54.    msgcnt = 0;
  55. }
  56.  
  57.  
  58. /*
  59.    read_buffer
  60. */
  61. int far buffer::read_buffer (farptr msg, int size, dword timeout)
  62. {
  63.    int i, len, l1, l2;
  64.    word w;
  65.  
  66.    if ((i = buf_read.request_resource (timeout)) < 0)
  67.       return i;
  68.  
  69.    if ((len = pip.read_wpipe (timeout)) < 0)
  70.       {
  71.       buf_read.release_resource ();
  72.       return len;
  73.       }
  74.  
  75.    l1 = (len < size) ? len : size;
  76.  
  77.    for (i = 0; i < l1; i++)
  78.       {
  79.       if (!(i & 1))
  80.          w = pip.read_wpipe (0L);
  81.       else
  82.          w = w >> 8;
  83.       ((byteptr)msg) [i] = (byte)w;
  84.       }
  85.  
  86.    l2 = (len + 1) >> 1;
  87.    for (i = (l1 + 1) >> 1; i < l2; i++)
  88.       pip.read_wpipe (0L);
  89.    if (l1 < size)
  90.       ((byteptr)msg) [l1] = 0;
  91.  
  92.    msgcnt--;
  93.  
  94.    buf_read.release_resource ();
  95.    return len;
  96. }
  97.  
  98.  
  99. /*
  100.    c_read_buffer
  101. */
  102. int far buffer::c_read_buffer (farptr msg, int size)
  103. {
  104.    int res;
  105.    CRITICAL;
  106.  
  107.    res = -1;
  108.    C_ENTER;
  109.  
  110.    if (pip.get_filled() && buf_read.get_state())
  111.       {
  112.       buf_read.request_resource (0L);
  113.       C_LEAVE;
  114.       res = read_buffer (msg, size, 0L);
  115.       }
  116.    else
  117.       C_LEAVE;
  118.  
  119.    return res;
  120. }
  121.  
  122.  
  123. /*
  124.    tsk_wrbuf
  125. */
  126. int buffer::tsk_wrbuf (word w, dword timeout)
  127. {
  128.    int i;
  129.  
  130.    if ((i = pip.write_wpipe (w, timeout)) < 0)
  131.       buf_write.release_resource ();
  132.    return i;
  133. }
  134.  
  135.  
  136. /*
  137.    write_buffer
  138. */
  139. int far buffer::write_buffer (farptr msg, int size, dword timeout)
  140. {
  141.    int i, res, l2;
  142.  
  143.    if (size < 0 || (word)((size + 3) >> 1) > pip.get_bufsize())
  144.       return -3;
  145.  
  146.    if ((i = buf_write.request_resource (timeout)) < 0)
  147.       return i;
  148.  
  149.    if ((i = tsk_wrbuf ((word)size, timeout)) < 0)
  150.       return i;
  151.  
  152.    l2 = (size + 1) >> 1;
  153.  
  154.    for (i = 0; i < l2; i++)
  155.       if ((res = tsk_wrbuf (((wordptr)msg) [i], timeout)) < 0)
  156.          return res;
  157.  
  158.    msgcnt++;
  159.  
  160.    buf_write.release_resource ();
  161.    return size;
  162. }
  163.  
  164.  
  165. /*
  166.    c_write_buffer
  167. */
  168. int far buffer::c_write_buffer (farptr msg, int size)
  169. {
  170.    int res;
  171.    CRITICAL;
  172.  
  173.    if (size < 0 || (word)((size + 3) >> 1) > pip.get_bufsize())
  174.       return -3;
  175.  
  176.    C_ENTER;
  177.    res = -1;
  178.  
  179.    if (pip.wpipe_free () >= ((size + 3) >> 1) && buf_write.get_state())
  180.       {
  181.       buf_write.request_resource (0L);
  182.       C_LEAVE;
  183.       res = write_buffer (msg, size, 0L);
  184.       }
  185.    else
  186.       C_LEAVE;
  187.  
  188.    return res;
  189. }
  190.  
  191.  
  192. /*
  193.    check_buffer
  194. */
  195. word far buffer::check_buffer (void)
  196. {
  197.    return msgcnt;
  198. }
  199.  
  200.