home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / adaptor.zip / adapt.zip / adaptor / dalib / pvm3 / buffer.c < prev    next >
C/C++ Source or Header  |  1993-04-07  |  8KB  |  192 lines
  1. /**************************************************************************
  2. *                                                                         *
  3. *  Author      : Dr. Thomas Brandes, GMD, I1.HR                           *
  4. *  Copyright   : GMD St. Augustin, Germany                                *
  5. *  Date        : Aug 92                                                   *
  6. *  Last Update : Aug 92                                                   *
  7. *                                                                         *
  8. *  This Module is part of the DALIB                                       *
  9. *                                                                         *
  10. *  Module      : buffer.c                                                 *
  11. *                                                                         *
  12. *  Function    : Combining of messages in a buffer (send + recv)          *
  13. *                                                                         *
  14. *  is used for combining non-continguous sections to one message          *
  15. *  (only for internal use in the library)                                 *
  16. *                                                                         *
  17. *  Export :                                                               *
  18. *                                                                         *
  19. *   Filling and sending the buffer                                        *
  20. *                                                                         *
  21. *     dalib_create_buffer (size, 0);                                      *
  22. *     dalib_fill_buffer (ptr1, size1);                                    *
  23. *                ...                                                      *
  24. *     dalib_fill_buffer (ptrn, sizen);                                    *
  25. *     dalib_send_buffer (to);                                             *
  26. *     dalib_destroy_buffer ();                                            *
  27. *                                                                         *
  28. *   Receiving and getting from the buffer                                 *
  29. *                                                                         *
  30. *     dalib_create_buffer (size, 1);                                      *
  31. *     dalib_recv_buffer (from);                                           *
  32. *     dalib_get_buffer (ptr1, size1);                                     *
  33. *                ...                                                      *
  34. *     dalib_get_buffer (ptrn, sizen);                                     *
  35. *     dalib_destroy_buffer ();                                            *
  36. *                                                                         *
  37. **************************************************************************/
  38.  
  39.      /*********************************************************
  40.      *                                                        *
  41.      *  Global data for the buffer                            *
  42.      *                                                        *
  43.      *                                                        *
  44.      *   ------    <- dalib_buffer_size                       *
  45.      *   |    |                                               *
  46.      *   |    |    <- dalib_buffer_pos                        *
  47.      *   |    |                                               *
  48.      *   |    |                                               *
  49.      *   |    |                                               *
  50.      *   |    |                                               *
  51.      *   ------                                               *
  52.      *                                                        *
  53.      *********************************************************/
  54.  
  55. #include <stdio.h>
  56.  
  57. unsigned char *dalib_buffer;
  58. int dalib_buffer_size;
  59. int dalib_buffer_pos;
  60. int dalib_buffer_kind;  /* 0 for send, 1 for recv */
  61.  
  62.      /*********************************************************
  63.      *                                                        *
  64.      *  Creating and Destroying of the Buffer                 *
  65.      *                                                        *
  66.      *********************************************************/
  67.  
  68. void dalib_create_buffer (size, kind)
  69. int size;
  70. int kind;
  71.  
  72. { /* create a buffer with size bytes */
  73.  
  74.   dalib_buffer = (unsigned char*) (malloc (size));
  75.   if (dalib_buffer == NULL)
  76.      { printf ("Creation of a buffer with %d Bytes failed\n", size);
  77.        exit (-1);
  78.      }
  79. #ifdef MEIKO_CS2
  80.   ew_touchBuf(dalib_buffer, size);
  81. #endif
  82.  
  83.   dalib_buffer_size = size;
  84.   dalib_buffer_pos  = 0;
  85.   if (kind == 0)
  86.     dalib_buffer_kind = 0;  /* buffer is for fill and send */
  87.    else
  88.     dalib_buffer_kind = 1;  /* buffer is for recv and get */
  89. }
  90.  
  91. void dalib_destroy_buffer ()
  92.  
  93. { /* destroy the buffer */
  94.   free (dalib_buffer);
  95.   dalib_buffer_size = 0;
  96. }
  97.  
  98.      /*********************************************************
  99.      *                                                        *
  100.      *  Fill the Buffer  / Read from Buffer                   *
  101.      *                                                        *
  102.      *********************************************************/
  103.  
  104. void dalib_fill_buffer (ptr, size)
  105.  
  106. unsigned char *ptr;
  107. int size;
  108.  
  109. {
  110.   /* make sure that filling is allowed */
  111.   if (dalib_buffer_kind != 0)
  112.    { printf ("Internal Error: No Buffer filling\n");
  113.      exit(-1);
  114.    }
  115.  
  116.   /* make sure that new message is not to large */
  117.   if (dalib_buffer_pos + size > dalib_buffer_size)
  118.    { printf ("Internal Error: Message to big for buffer filling\n");
  119.      exit(-1);
  120.    }
  121.  
  122.   dalib_memcpy (dalib_buffer+dalib_buffer_pos, ptr, size);
  123.   dalib_buffer_pos += size;
  124. }
  125.  
  126. void dalib_get_buffer (ptr, size)
  127.  
  128. unsigned char *ptr;
  129. int size;
  130.  
  131. {
  132.   /* make sure that receiving is allowed */
  133.   if (dalib_buffer_kind != 1)
  134.    { printf ("Internal Error: No Buffer receiving \n");
  135.      exit(-1);
  136.    }
  137.  
  138.    dalib_memcpy (ptr, dalib_buffer+dalib_buffer_pos, size);
  139.    dalib_buffer_pos += size;
  140. }
  141.  
  142.      /*********************************************************
  143.      *                                                        *
  144.      *  Sending / Receiving of the buffer                     *
  145.      *                                                        *
  146.      *********************************************************/
  147.  
  148. void dalib_send_buffer (to)
  149. int to;
  150.  
  151. { /* the whole buffer is send to process 'to' */
  152.   int from;
  153.  
  154.   /* make sure that sending is allowed */
  155.   if (dalib_buffer_kind != 0)
  156.    { printf ("Internal Error: No Buffer sending \n");
  157.      exit(-1);
  158.    }
  159.  
  160.   /* make sure that the buffer is full */
  161.   if (dalib_buffer_pos != dalib_buffer_size)
  162.    { printf ("Internal Error: Buffer not full for sending \n");
  163.      exit(-1);
  164.    }
  165.  
  166.   from = dalib_pid_();
  167.   asend (from, to, dalib_buffer, dalib_buffer_size);
  168. }
  169.  
  170. void dalib_recv_buffer (from)
  171. int from;
  172.  
  173. { /* the whole buffer is received from process 'from' */
  174.   int to;
  175.  
  176.   /* make sure that receiving is allowed */
  177.   if (dalib_buffer_kind != 1)
  178.    { printf ("Internal Error: No Buffer receiving \n");
  179.      exit(-1);
  180.    }
  181.  
  182.   /* make sure that the buffer was empty */
  183.   if (dalib_buffer_pos != 0)
  184.    { printf ("Internal Error: Buffer not empty for receiving\n");
  185.      exit(-1);
  186.    }
  187.  
  188.   to = dalib_pid_();
  189.   areceive (to, from, dalib_buffer, dalib_buffer_size);
  190. }
  191.  
  192.