[opengtoolkit-cvs] lvzip/c_source iomem.c, 1.3, 1.4 macbin.c, 1.29, 1.30 macbin.h, 1.22, 1.23 unzip.c, 1.7, 1.8 zip.c, 1.9, 1.10

[Rolf K. <lab...@us...>]

Update of /cvsroot/opengtoolkit/lvzip/c_source
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv10755/c_source

Modified Files:
	iomem.c macbin.c macbin.h unzip.c zip.c 
Log Message:
Improved memory stream performance on compression and fixed several small bugs for memory streams.

Index: unzip.c
===================================================================
RCS file: /cvsroot/opengtoolkit/lvzip/c_source/unzip.c,v
retrieving revision 1.7
retrieving revision 1.8
diff -C2 -d -r1.7 -r1.8
*** unzip.c	17 Sep 2007 05:07:16 -0000	1.7
--- unzip.c	17 Sep 2007 12:29:41 -0000	1.8
***************
*** 416,422 ****
      int err=UNZ_OK;
  
-     if (unz_copyright[0]!=' ')
-         return NULL;
- 
      if (pzlib_filefunc_def==NULL)
          fill_fopen_filefunc(&us.z_filefunc);
--- 416,419 ----

Index: macbin.c
===================================================================
RCS file: /cvsroot/opengtoolkit/lvzip/c_source/macbin.c,v
retrieving revision 1.29
retrieving revision 1.30
diff -C2 -d -r1.29 -r1.30
*** macbin.c	17 Sep 2007 05:07:16 -0000	1.29
--- macbin.c	17 Sep 2007 12:29:41 -0000	1.30
***************
*** 812,816 ****
  	}
  #elif Win32
- 	DoDebugger();
  	if (err = MakePathDSString(path, &lstr))
  	  return err;
--- 812,815 ----
***************
*** 962,966 ****
        {
  	    fill_mem_filefunc(pzlib_filefunc_def, memory);
- 	    *memory = NULL;
        }
        else
--- 961,964 ----

Index: macbin.h
===================================================================
RCS file: /cvsroot/opengtoolkit/lvzip/c_source/macbin.h,v
retrieving revision 1.22
retrieving revision 1.23
diff -C2 -d -r1.22 -r1.23
*** macbin.h	17 Sep 2007 05:07:16 -0000	1.22
--- macbin.h	17 Sep 2007 12:29:41 -0000	1.23
***************
*** 241,245 ****
--- 241,247 ----
  UPtr DSNewPClr(int32);
  MgErr DSDisposePtr(UPtr);
+ UHandle DSNewHClr(int32 size);
  MgErr DSSetHandleSize(UHandle, int32);
+ int32 DSGetHandleSize(UHandle);
  MgErr DSDisposeHandle(UHandle);
  
***************
*** 247,250 ****
--- 249,253 ----
  
  #define Min(a, b)      ((a) < (b)) ? (a) : (b) 
+ #define Max(a, b)      ((a) > (b)) ? (a) : (b) 
  
  /* Our exported functions */

Index: zip.c
===================================================================
RCS file: /cvsroot/opengtoolkit/lvzip/c_source/zip.c,v
retrieving revision 1.9
retrieving revision 1.10
diff -C2 -d -r1.9 -r1.10
*** zip.c	17 Sep 2007 05:07:16 -0000	1.9
--- zip.c	17 Sep 2007 12:29:41 -0000	1.10
***************
*** 29,34 ****
  #endif
  
- #include "macbin.h"
- 
  #ifndef local
  #  define local static
--- 29,32 ----
***************
*** 726,731 ****
  #endif
  
-     DoDebugger();
- 
      if (file == NULL)
          return ZIP_PARAMERROR;
--- 724,727 ----

Index: iomem.c
===================================================================
RCS file: /cvsroot/opengtoolkit/lvzip/c_source/iomem.c,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** iomem.c	17 Sep 2007 05:07:16 -0000	1.3
--- iomem.c	17 Sep 2007 12:29:41 -0000	1.4
***************
*** 58,77 ****
     int mode;
  {
!     voidpf ret = NULL;
! 
!     if (opaque != NULL)
      {
!         MEMORY_IO memio;
!         memio.mode = mode;
!         if (mode & ZLIB_FILEFUNC_MODE_CREATE)
!             memio.pos = 0;
!         else
!             memio.pos = LStrLen(**(LStrHandle*)opaque);
!         memio.error = 0;
!         ret = malloc(sizeof(MEMORY_IO));
!         if (ret)
!             *((MEMORY_IO*)ret) = memio;
      }
!     return ret;
  }
  
--- 58,72 ----
     int mode;
  {
!     MEMORY_IO *memio = malloc(sizeof(MEMORY_IO));
!     if (memio)
      {
!         memio->pos = 0;
!         memio->mode = mode;
!         memio->error = 0;
! 
! //        if (opaque && !(mode & ZLIB_FILEFUNC_MODE_CREATE))
! //            memio->pos = LStrLen(*(LStrHandle)opaque);
      }
!     return memio;
  }
  
***************
*** 83,100 ****
     uLong size;
  {
!     uLong ret = 0;
! 
!     if (stream != NULL)
      {
          MEMORY_IO* mem = (MEMORY_IO*)stream;
-         uLong pos = mem->pos;
-         ret = LStrLen(**(LStrHandle*)opaque) - pos;   
-         if (size < ret)
-             ret = size;
  
!         zmemcpy(buf, LStrBuf(**(LStrHandle*)opaque) + pos, ret);
!         mem->pos += ret; 
      }
!     return ret;
  }
  
--- 78,124 ----
     uLong size;
  {
!     if (stream && opaque)
      {
          MEMORY_IO* mem = (MEMORY_IO*)stream;
  
!         if (mem->pos + size > (uLong)LStrLen(*(LStrHandle)opaque))
!             size = LStrLen(*(LStrHandle)opaque) - mem->pos;
! 
!         zmemcpy(buf, LStrBuf(*(LStrHandle)opaque) + mem->pos, size);
!         mem->pos += size;
!         return size;
      }
!     return 0;
! }
! 
! static MgErr ResizeStringHandle(LStrHandle handle, int32 offset, const void *buf, int32 size, int32 mode)
! {
!     if (!handle)
!         return mgArgErr;
! 
!     if (DSGetHandleSize((UHandle)handle) < (offset + size + (int32)sizeof(int32)))
!     {
!         MgErr err = fEOF;
! 
!         if (!(mode & ZLIB_FILEFUNC_MODE_WRITE))
!             return err;
! 
!         if (err = NumericArrayResize(uB, 1, &(UHandle)handle, Max(10000, (offset + size) << 1)))
!             return err;
!     }
! 
!     if (mode & ZLIB_FILEFUNC_MODE_WRITE)
!     {
!         if (buf)
!             zmemcpy(LStrBuf(*handle) + offset, buf, size);
! 
!         /* only grow the memory stream */
!         if (offset + size > LStrLen(*handle))
!             LStrLen(*handle) = offset + size;
!     }
!     else if (offset + size > LStrLen(*handle))
!         return fEOF;
! 
!     return noErr;
  }
  
***************
*** 107,133 ****
  {
      MEMORY_IO* mem = (MEMORY_IO*)stream;
-     uLong pos = 0;
  
!     DoDebugger();
!     if (stream != NULL && (mem->mode & ZLIB_FILEFUNC_MODE_WRITE))
      {
!         pos = mem->pos;
!         if ((*(LStrHandle*)opaque) ||
!             ((uLong)LStrLen(**(LStrHandle*)opaque) < (pos + size)))
          {
!             int err;
! 
!             if (err = NumericArrayResize(uB, 1, (UHandle*)opaque, pos + size))
!             {
!                 mem->error = err;
!                 return 0;
!             }
          }
-         zmemcpy(LStrBuf(**(LStrHandle*)opaque) + pos, buf, size);
-         LStrLen(**(LStrHandle*)opaque) = size;
          mem->pos += size;
!         pos = size; 
      }
!     return pos;
  }
  
--- 131,147 ----
  {
      MEMORY_IO* mem = (MEMORY_IO*)stream;
  
!     if (mem != NULL && (mem->mode & ZLIB_FILEFUNC_MODE_WRITE))
      {
!         MgErr err = ResizeStringHandle((LStrHandle)opaque, mem->pos, buf, size, mem->mode); 
!         if (err)
          {
!             mem->error = err;
!             return 0;
          }
          mem->pos += size;
!         return size; 
      }
!     return 0;
  }
  
***************
*** 136,146 ****
     voidpf stream;
  {
-     long ret = -1;
- 
      if (stream != NULL)
      {
!         ret = (long)((MEMORY_IO*)stream)->pos;
      }
!     return ret;
  }
  
--- 150,158 ----
     voidpf stream;
  {
      if (stream != NULL)
      {
!         return (long)((MEMORY_IO*)stream)->pos;
      }
!     return -1;
  }
  
***************
*** 154,169 ****
      {
          MEMORY_IO* mem = (MEMORY_IO*)stream;
!         uLong pos;
  
          switch (origin)
          {
              case ZLIB_FILEFUNC_SEEK_CUR :
!                 pos = mem->pos + offset;
                  break;
              case ZLIB_FILEFUNC_SEEK_END :
!                 pos = LStrLen(**(LStrHandle*)opaque) + offset;
!                 break;
              case ZLIB_FILEFUNC_SEEK_SET :
!                 pos = offset;
                  break;
              default:
--- 166,183 ----
      {
          MEMORY_IO* mem = (MEMORY_IO*)stream;
!         uLong size = 0;
!         MgErr err;
  
          switch (origin)
          {
              case ZLIB_FILEFUNC_SEEK_CUR :
!                 size = mem->pos + offset;
                  break;
              case ZLIB_FILEFUNC_SEEK_END :
!                 if (opaque)
!                     size = LStrLen(*(LStrHandle)opaque);
!                 /* fall through */
              case ZLIB_FILEFUNC_SEEK_SET :
!                 size += offset;
                  break;
              default:
***************
*** 171,191 ****
          }
  
!         if (!(*(LStrHandle*)opaque) || (pos > LStrLen(**(LStrHandle*)opaque)))
          {
!             if (mem->mode & ZLIB_FILEFUNC_MODE_WRITE)
!             {
!                 MgErr err;
!                 if (err = NumericArrayResize(uB, 1, (UHandle*)opaque, pos))
!                 {
!                     mem->error = err;
!                     return -1;
!                 }
!                 LStrLen(**(LStrHandle*)opaque) = pos;
!            }
!             else
!                 return -1;
          }
!         mem->pos = pos;
!         return 0;        
      }
      return -1;
--- 185,194 ----
          }
  
!         if (!(err = ResizeStringHandle((LStrHandle)opaque, 0, NULL, size, mem->mode)))
          {
!             mem->pos = size;
!             return 0;
          }
!         mem->error = err;
      }
      return -1;
***************
*** 198,211 ****
  {
      int ret = -1;
  
      if (output)
      {
!         UHandle *p = (UHandle*)output;
!         if (*p)
!             DSDisposeHandle(*p);
!         *p = *(UHandle*)opaque;
      }
!     else
!         DSDisposeHandle(*(UHandle*)opaque);
  
      if (stream != NULL)
--- 201,222 ----
  {
      int ret = -1;
+     UHandle s = (UHandle)opaque;    
  
      if (output)
      {
!         UHandle *o = (UHandle*)output;
!         if (*o)
!             DSDisposeHandle(*o);
!         if (s)
!         {
!             /* Make sure the handle is not ridiculously oversized */
!             int32 size = LStrLen(*(LStrHandle)s) + (int32)sizeof(int32);
!             if (DSGetHandleSize(s) > size)
!                 DSSetHandleSize(s, size);
!         }
!         *o = s;
      }
!     else if (s)
!         DSDisposeHandle(s);
  
      if (stream != NULL)
***************
*** 231,235 ****
  void fill_mem_filefunc (pzlib_filefunc_def, memory)
    zlib_filefunc_def* pzlib_filefunc_def;
!   voidpf memory;
  {
      pzlib_filefunc_def->zopen_file = mem_open_file_func;
--- 242,246 ----
  void fill_mem_filefunc (pzlib_filefunc_def, memory)
    zlib_filefunc_def* pzlib_filefunc_def;
!   UHandle *memory;
  {
      pzlib_filefunc_def->zopen_file = mem_open_file_func;
***************
*** 240,243 ****
      pzlib_filefunc_def->zclose_file = mem_close_file_func;
      pzlib_filefunc_def->zerror_file = mem_error_file_func;
!     pzlib_filefunc_def->opaque = memory;
  }
--- 251,262 ----
      pzlib_filefunc_def->zclose_file = mem_close_file_func;
      pzlib_filefunc_def->zerror_file = mem_error_file_func;
!     if (*memory)
!     {
!         pzlib_filefunc_def->opaque = *memory;
!         *memory = DSNewHClr(sizeof(int32));
!     }
!     else
!     {
!         pzlib_filefunc_def->opaque = DSNewHClr(sizeof(int32));
!     }
  }