[opengtoolkit-cvs] lvzip/c_source iomem.c, NONE, 1.1 iomem.h, NONE, 1.1

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

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

Added Files:
	iomem.c iomem.h 
Log Message:
Addition of memory stream for ZIP file

--- NEW FILE: iomem.c ---
/* iomem.c -- Memory base function header for compress/uncompress .zip
   files using zlib + zip or unzip API

   Copyright (C) 2007 Rolf Kalbermatter
*/

#include "zutil.h"
#include "ioapi.h"
#include "iomem.h"
#include "macbin.h"

voidpf ZCALLBACK mem_open_file_func OF((
   voidpf opaque,
   const char* filename,
   int mode));

uLong ZCALLBACK mem_read_file_func OF((
   voidpf opaque,
   voidpf stream,
   void* buf,
   uLong size));

uLong ZCALLBACK mem_write_file_func OF((
   voidpf opaque,
   voidpf stream,
   const void* buf,
   uLong size));

long ZCALLBACK mem_tell_file_func OF((
   voidpf opaque,
   voidpf stream));

long ZCALLBACK mem_seek_file_func OF((
   voidpf opaque,
   voidpf stream,
   uLong offset,
   int origin));

int ZCALLBACK mem_close_file_func OF((
   voidpf opaque,
   voidpf stream));

int ZCALLBACK mem_error_file_func OF((
   voidpf opaque,
   voidpf stream));

typedef struct
{
    int mode;
    uLong pos;
    int error;
} MEMORY_IO;

voidpf ZCALLBACK mem_open_file_func (opaque, filename, mode)
   voidpf opaque;
   const char* filename;
   int mode;
{
    voidpf ret = NULL;

    if (opaque != NULL)
    {
        MEMORY_IO memio;
        memio.mode = mode;
        memio.pos = 0;
        memio.error = 0;
        ret = malloc(sizeof(MEMORY_IO));
        if (ret)
            *((MEMORY_IO*)ret) = memio;
    }
    return ret;
}


uLong ZCALLBACK mem_read_file_func (opaque, stream, buf, size)
   voidpf opaque;
   voidpf stream;
   void* buf;
   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;
}


uLong ZCALLBACK mem_write_file_func (opaque, stream, buf, size)
   voidpf opaque;
   voidpf stream;
   const void* buf;
   uLong size;
{
    MEMORY_IO* mem = (MEMORY_IO*)stream;
    uLong pos = 0;

    if (stream != NULL && (mem->mode & ZLIB_FILEFUNC_MODE_WRITE))
    {
        pos = mem->pos;
        if ((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);
        mem->pos += size;
        pos = size; 
    }
    return pos;
}

long ZCALLBACK mem_tell_file_func (opaque, stream)
   voidpf opaque;
   voidpf stream;
{
    long ret = -1;

    if (stream != NULL)
    {
        ret = (long)((MEMORY_IO*)stream)->pos;
    }
    return ret;
}

long ZCALLBACK mem_seek_file_func (opaque, stream, offset, origin)
   voidpf opaque;
   voidpf stream;
   uLong offset;
   int origin;
{
    if (stream != NULL)
    {
        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:
                return -1;
        }

        if (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;
                }
            }
            else
                return -1;
        }
        mem->pos = pos;
        return 0;        
    }
    return -1;
}

int ZCALLBACK mem_close_file_func (opaque, stream)
   voidpf opaque;
   voidpf stream;
{
    int ret=-1;

    if (stream != NULL)
    {
        free(stream);
    }
    return ret;
}

int ZCALLBACK mem_error_file_func (opaque, stream)
   voidpf opaque;
   voidpf stream;
{
    int ret=-1;
    if (stream!=NULL)
    {
        ret = ((MEMORY_IO*)stream)->error;
    }
    return ret;
}

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;
    pzlib_filefunc_def->zread_file = mem_read_file_func;
    pzlib_filefunc_def->zwrite_file = mem_write_file_func;
    pzlib_filefunc_def->ztell_file = mem_tell_file_func;
    pzlib_filefunc_def->zseek_file = mem_seek_file_func;
    pzlib_filefunc_def->zclose_file = mem_close_file_func;
    pzlib_filefunc_def->zerror_file = mem_error_file_func;
    pzlib_filefunc_def->opaque = memory;
}

--- NEW FILE: iomem.h ---
/* iowin32.h -- IO base function header for compress/uncompress .zip
   files using zlib + zip or unzip API
   This IO API version uses the Win32 API (for Microsoft Windows)

   Version 1.01e, February 12th, 2005

   Copyright (C) 1998-2005 Gilles Vollant
*/

#include <stdlib.h>


#ifdef __cplusplus
extern "C" {
#endif

void fill_mem_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def, voidpf memory));

#ifdef __cplusplus
}
#endif