home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / POLYEDIT.LZH / MODEL / BUFFER.C < prev    next >
C/C++ Source or Header  |  1995-03-21  |  4KB  |  198 lines
  1. /*
  2.  *        データバッファ管理
  3.  *
  4.  *        Copyright    T.Kobayashi        1994.6.18
  5.  */
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include <assert.h>
  10.  
  11. #include "lib.h"
  12. #include "alloc.h"
  13. #include "buffer.h"
  14.  
  15. #define    FLAG_USE    0x1234
  16. #define    FLAG_NOUSE    0x4321
  17.  
  18. static    char    *BufTop, *BufEnd, *BufNext ;
  19.  
  20. /*    データバッファの初期化    */
  21. void    BufferInit( size )
  22. int        size ;
  23. {
  24.     BufTop = BufNext = MemoryAlloc( size );
  25.     BufEnd = BufTop + size ;
  26. }
  27.  
  28. /*    データバッファの解放    */
  29. void    BufferExit()
  30. {
  31.     MemoryFree( BufTop );
  32. }
  33.  
  34. /*    データバッファの確保    */
  35. void    *BufferAppend( size )
  36. int        size ;
  37. {
  38.     DataBuffer    *ret ;
  39.  
  40.     assert( size > sizeof( DataBuffer ) );
  41.     assert( ( size & 3 ) == 0 );
  42.  
  43.     if ( BufNext + size < BufEnd )
  44.     {
  45.         ret = (DataBuffer*)BufNext ;
  46.         ret->flag = FLAG_USE ;
  47.         ret->size = size ;
  48.         BufNext += size ;
  49.         return (void*)ret ;
  50.     }
  51.     else
  52.     {
  53.         MessageError( "データバッファがオーバフローしました(BufferAppend)" );
  54.         return NULL ;
  55.     }
  56. }
  57.  
  58. /*    バッファの削除    */
  59. void    BufferDelete( buf )
  60. void    *buf ;
  61. {
  62.     assert( ((DataBuffer*)buf)->flag == FLAG_USE );
  63.     assert( BufTop <= (char*)buf && (char*)buf < BufNext );
  64.  
  65.     ((DataBuffer*)buf)->flag = FLAG_NOUSE ;
  66. }
  67.  
  68. /*    バッファ削除後の修正（ゴミ集め）    */
  69. void    BufferDeleteCorrect()
  70. {
  71.     int            size ;
  72.     DataBuffer    *src, *dst ;
  73.     
  74.     src = (DataBuffer*)BufTop ;
  75.     dst = (DataBuffer*)BufTop ;
  76.  
  77.     while( (char*)src < BufNext )
  78.     {
  79.         assert( dst <= src );
  80.         size = src->size ;
  81.         if ( src->flag == FLAG_USE )
  82.         {
  83.             if ( dst < src )
  84.                 memmove( dst, src, size );
  85.             dst = (DataBuffer*)( (char*)dst + size );
  86.         }
  87.         else
  88.         {
  89.             assert( src->flag == FLAG_NOUSE );
  90.         }
  91.         src = (DataBuffer*)( (char*)src + size );
  92.     }
  93.     BufNext = (char*)dst ;
  94. }
  95.  
  96. /*    バッファの挿入    */
  97. void    *BufferInsert( dbuf, size )
  98. void    *dbuf ;
  99. int        size ;
  100. {
  101.     DataBuffer    *buf = dbuf ;
  102.  
  103.     assert( buf->flag == FLAG_USE );
  104.     assert( BufTop <= (char*)buf && (char*)buf < BufNext );
  105.  
  106.     if ( BufNext + size < BufEnd )
  107.     {
  108.         memmove( (char*)buf + size, (char*)buf, BufNext - (char*)buf );
  109.         buf->flag = FLAG_USE ;
  110.         buf->size = size ;
  111.         BufNext += size ;
  112.         return (void*)buf ;
  113.     }
  114.     else
  115.     {
  116.         MessageError( "データバッファがオーバフローしました(BufferInsert)" );
  117.         return NULL ;
  118.     }
  119. }
  120.  
  121. /*    バッファのコピー    */
  122. void    BufferCopy( dst, src, size )
  123. void    *dst ;
  124. void    *src ;
  125. int        size ;
  126. {
  127.     memcpy( (char*)dst + sizeof( short )*2, (char*)src + sizeof( short )*2,
  128.             size - sizeof( short )*2 );
  129. }
  130.  
  131. /*    バッファのサイズ変更    */
  132. void    *BufferResize( dbuf, size )
  133. void    *dbuf ;
  134. int        size ;
  135. {
  136.     int        dsize ;
  137.     DataBuffer    *buf = dbuf ;
  138.     
  139.     assert( buf->flag == FLAG_USE );
  140.     assert( BufTop <= (char*)buf && (char*)buf < BufNext );
  141.  
  142.     dsize = size - buf->size ;
  143.     if ( dsize <= 0 )
  144.         return (void*)buf ;
  145.  
  146.     if ( BufNext + dsize < BufEnd )
  147.     {
  148.         memmove( (char*)buf + dsize, (char*)buf, BufNext - (char*)buf );
  149.         buf->size = size ;
  150.         BufNext += dsize ;
  151.         return (void*)buf ;
  152.     }
  153.     else
  154.     {
  155.         MessageError( "データバッファがオーバフローしました(BufferInsert)" );
  156.         return NULL ;
  157.     }
  158. }
  159.  
  160. /*    先頭のバッファ    */
  161. void    *BufferTop()
  162. {
  163.     if ( BufTop == BufNext )
  164.         return NULL ;
  165.     else
  166.         return (void*)BufTop ;
  167. }
  168.  
  169. /*    次のバッファ    */
  170. void    *BufferNext( dbuf )
  171. void    *dbuf ;
  172. {
  173.     DataBuffer    *ret ;
  174.     DataBuffer    *buf = dbuf ;
  175.  
  176.     assert( buf->flag == FLAG_USE );
  177.     assert( BufTop <= (char*)buf && (char*)buf < BufNext );
  178.  
  179.     ret = (DataBuffer*)( (char*)buf + buf->size );
  180.     if ( (char*)ret < BufNext )
  181.         return (void*)ret ;
  182.     else
  183.         return NULL ;
  184. }
  185.  
  186. /*    バッファのチェック    */
  187. void    BufferCheck()
  188. {
  189.     DataBuffer    *buf ;
  190.     
  191.     buf = (DataBuffer*)BufTop ;
  192.     while( (char*)buf < BufNext )
  193.     {
  194.         assert( buf->flag == FLAG_USE );
  195.         buf = (DataBuffer*)( (char*)buf + buf->size );
  196.     }
  197. }
  198.