gxzlib.h

Go to the documentation of this file.

/******************************************************************************
 * GX ZLIB header file - V7.2.12
 *
 * 2005-2015 (c) ARH Inc. (http://www.arh.hu)
 ******************************************************************************/
/******************************************************************************/
#ifndef GXZLIB_INCL
#define GXZLIB_INCL
/******************************************************************************/
#include "gxsd.h"
#if defined(WIN32) && !defined(GX_DOTNET)
#include <windows.h>
#endif
#include <assert.h>
/******************************************************************************/
#ifdef GX_NAMESPACES
namespace gx {
#endif

#ifdef GX_DOTNET
#pragma unmanaged
#endif

/******************************************************************************/
#if !defined(GX_SWIGIF) && !defined(GX_MANUAL) /*(*/
/******************************************************************************/
enum {
    GX_CALL_GZCOMPRESS  = GX_CALL_GROUP_GX_ZLIB,    
    GX_CALL_GZUNCOMPRESS,           
    GX_CALL_CREATEGZ,               
    GX_CALL_OPENGZ,                 
    GX_CALL_CLOSEGZ,                
    GX_CALL_READGZ,                 
    GX_CALL_WRITEGZ,                
    GX_CALL_CREATEZIP,              
    GX_CALL_OPENZIP,                
    GX_CALL_CLOSEZIP,               
    GX_CALL_GETZIPINFO,             
    GX_CALL_GETZIPCOMMENT,          
    GX_CALL_FIRSTFILEINZIP,         
    GX_CALL_NEXTFILEINZIP,          
    GX_CALL_LOCATEFILEINZIP,        
    GX_CALL_FILEINFOINZIP,          
    GX_CALL_OPENFILEINZIP,          
    GX_CALL_READFROMFILEINZIP,      
    GX_CALL_READLEXFIELDZIP,        
    GX_CALL_CREATEFILEINZIP,        
    GX_CALL_WRITETOFILEINZIP,       
    GX_CALL_CLOSEFILEINZIP,         
    GX_CALL_GETINITIALZIPCRC,       
    GX_CALL_CALCULATEZIPCRC,        
    // Unicode extensions
    GX_CALL_CREATEGZW   = GX_CALL_GROUP_GX_ZLIB + 0x100, 
    GX_CALL_OPENGZW,                
    GX_CALL_CREATEZIPW,             
    GX_CALL_OPENZIPW,               
    GX_CALL_CLOSEZIPW,              
    GX_CALL_GETZIPCOMMENTW,         
    GX_CALL_FIRSTFILEINZIPW,        
    GX_CALL_NEXTFILEINZIPW,         
    GX_CALL_LOCATEFILEINZIPW,       
    GX_CALL_FILEINFOINZIPW,         
    GX_CALL_OPENFILEINZIPW,         
    GX_CALL_CREATEFILEINZIPW,       
    GX_CALL_CREATEZIPINMEMORY,      
    GX_CALL_GETZIPINMEMORY,         
    GX_CALL_OPENZIPINMEMORY,        
};
#endif /* GX_SWIGIF GX_MANUAL )*/

#ifdef GX_DOTNET
#pragma managed
#endif

GX_ENUM GX_ZLEVELS {
    GX_Z_NO_COMPRESSION =   0,      
    GX_Z_BEST_SPEED     =   1,      
    GX_Z_BEST_COMPRESSION   =   9,  
    GX_Z_DEFAULT_COMPRESSION = -1   
};

GX_ENUM GX_ZSTRATEGIES {
    GX_Z_FILTERED       = 1,        
    GX_Z_HUFFMAN_ONLY   = 2,        
    GX_Z_RLE            = 3,        
    GX_Z_FIXED          = 4,        
    GX_Z_DEFAULT_STRATEGY = 0       
};

GX_ENUM GX_ZMETHODS {
    GX_Z_DEFLATED   =   8           
};

GX_ENUM GX_CREATEZIPMODES {
    GX_ZIP_CREATE   = 0,    
    GX_ZIP_CREATEAFTER,     
    GX_ZIP_ADDINZIP         
};
/******************************************************************************/
#ifdef GX_DOTNET
    #pragma unmanaged
#endif
/******************************************************************************/
#if !defined(GX_SWIGIF) && !defined(GX_MANUAL)  /*(*/

struct GX_PARM_GZCOMPRESS {
    void *target;           
    int tgtlen;             
    const void *source;     
    int srclen;             
    int level;              
};

struct GX_PARM_GZUNCOMPRESS {
    void *target;           
    int tgtlen;             
    const void *source;     
    int srclen;             
};

struct GX_PARM_CREATEGZ {
    const char *filename;   
    int level;              
    int strategy;           
};

struct GX_PARM_CREATEGZW {
    const wchar_t *filename;
    int level;              
    int strategy;           
};

struct GX_PARM_OPENGZ {
    const char *filename;   
};

struct GX_PARM_OPENGZW {
    const wchar_t *filename;    
};

struct GX_PARM_READGZ {
    void *buffer;           
    int buflen;             
};

struct GX_PARM_WRITEGZ {
    const void *buffer;     
    int buflen;             
};

struct GX_PARM_CREATEZIP {
    const char *filename;   
    int mode;               
};

struct GX_PARM_CREATEZIPW {
    const wchar_t *filename;
    int mode;               
};

struct GX_PARM_OPENZIP {
    const char *filename;   
};

struct GX_PARM_OPENZIPW {
    const wchar_t *filename;    
};

struct GX_PARM_CREATEZIPINMEMORY {
    int mode;                   
};

struct GX_PARM_GETZIPINMEMORY {
    void **pbuffer;             
    int* pbuflen;               
};

struct GX_PARM_OPENZIPINMEMORY {
    void *buffer;               
    int buflen;                 
};

struct GX_PARM_CLOSEZIP {
    const char *comment;    
};

struct GX_PARM_CLOSEZIPW {
    const wchar_t *comment; 
};

struct GX_PARM_GETZIPINFO {
    int nentries;           
    int commentlen;         
};

struct GX_PARM_GETZIPCOMMENT {
    char *target;           
    int tlen;               
};

struct GX_PARM_GETZIPCOMMENTW {
    wchar_t *target;        
    int tlen;               
};

struct GX_ZIPFILEINFO {
    int tm_sec;             
    int tm_min;             
    int tm_hour;            
    int tm_mday;            
    int tm_mon;             
    int tm_year;            
    int dosdate;            
    int internal_fa;        
    int external_fa;        
};

#ifndef __cplusplus

    typedef struct GX_ZIPFILEINFO GX_ZIPFILEINFO;
#endif

struct GX_PARM_CREATEFILEINZIP {
    const char *filename;           
    const GX_ZIPFILEINFO *info;     
    const char *comment;            
    int level;                      
    int strategy;                   
    const char *password;           
    unsigned int crc;               
    const void *exflocal;           
    int exflocal_len;               
    const void *exfglobal;          
    int exfglobal_len;              
};

struct GX_PARM_CREATEFILEINZIPW {
    const wchar_t *filename;        
    const GX_ZIPFILEINFO *info;     
    const wchar_t *comment;         
    int level;                      
    int strategy;                   
    const wchar_t *password;        
    unsigned int crc;               
    const void *exflocal;           
    int exflocal_len;               
    const void *exfglobal;          
    int exfglobal_len;              
};

struct GX_PARM_WRITETOFILEINZIP {
    const void *buffer;             
    int buflen;                     
};

struct GX_ZIPFILEDETINFO {
    // in
    char *filename;         
    int filename_len;       
    void *gextrafield;      
    int gextrafield_len;    
    char *comment;          
    int comment_len;        
    // out
    int version;            
    int version_needed;     
    int flag;               
    int method;             
    int dosdate;            
    unsigned int crc;       
    int compressed_size;    
    int uncompressed_size;  
    int size_filename;      
    int size_file_extra;    
    int size_file_comment;  
    int disk_num_start;     
    int internal_fa;        
    int external_fa;        
    int tm_sec;             
    int tm_min;             
    int tm_hour;            
    int tm_mday;            
    int tm_mon;             
    int tm_year;            
};

#ifndef __cplusplus

    typedef struct GX_ZIPFILEDETINFO GX_ZIPFILEDETINFO;
#endif

struct GX_ZIPFILEDETINFOW {
    // in
    wchar_t *filename;      
    int filename_len;       
    void *gextrafield;      
    int gextrafield_len;    
    wchar_t *comment;       
    int comment_len;        
    // out
    int version;            
    int version_needed;     
    int flag;               
    int method;             
    int dosdate;            
    unsigned int crc;       
    int compressed_size;    
    int uncompressed_size;  
    int size_filename;      
    int size_file_extra;    
    int size_file_comment;  
    int disk_num_start;     
    int internal_fa;        
    int external_fa;        
    int tm_sec;             
    int tm_min;             
    int tm_hour;            
    int tm_mday;            
    int tm_mon;             
    int tm_year;            
};

#ifndef __cplusplus

    typedef struct GX_ZIPFILEDETINFOW GX_ZIPFILEDETINFOW;
#endif

struct GX_PARM_LOCATEFILEINZIP {
    GX_ZIPFILEDETINFO *finfo;   
    const char *filename;       
    int casesensitivity;        
};

struct GX_PARM_LOCATEFILEINZIPW {
    GX_ZIPFILEDETINFOW *finfo;  
    const wchar_t *filename;    
    int casesensitivity;        
};

struct GX_PARM_OPENFILEINZIP {
    int method;                 
    int level;                  
    const char *password;       
};

struct GX_PARM_OPENFILEINZIPW {
    int method;                 
    int level;                  
    const wchar_t *password;    
};

struct GX_PARM_READFROMFILEINZIP {
    void *buffer;               
    int buflen;                 
};

struct GX_PARM_CALCULATEZIPCRC {
    unsigned int crc;           
    const void *buffer;         
    int buflen;                 
};

struct GX_PARM_GETINITIALZIPCRC {
    unsigned int crc;           
};

struct GX_PARM_READLEXFIELDZIP {
    void *buffer;               
    int buflen;                 
};

#endif /* GX_SWIGIF GX_MANUAL )*/

/******************************************************************************/
#if !defined(NO_GX_FUNCTIONS) && !defined(GX_SWIGIF)
/******************************************************************************/

/******************************************************************************/
/******************************************************************************/

/******************************************************************************/
inline int gx_gzcompress(gxHANDLE handle, void *target, int *tgtlen,
                    const void *source, int srclen, int level) {

    struct GX_PARM_GZCOMPRESS gzc;
    int st;

    assert(target && tgtlen && (*tgtlen > 0) && source && (srclen > 0));

    gzc.target = target;
    gzc.tgtlen = *tgtlen;
    gzc.source = source;
    gzc.srclen = srclen;
    gzc.level = level;
    st = gx_call(handle, GX_CALL_GZCOMPRESS, &gzc);
    if(st) *tgtlen = gzc.tgtlen;
    return st;
}
/******************************************************************************/
inline int gx_gzcompressd(void *target, int *tgtlen,
                    const void *source, int srclen, int level) {

    return gx_gzcompress(gx_direct(GX_CALL_GROUP_GX_ZLIB),
                                target, tgtlen, source, srclen, level);
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_gzcompress(void *target, int *tgtlen,
                    const void *source, int srclen, int level) {

    return gx_gzcompressd(target, tgtlen, source, srclen, level);
}
#endif

/******************************************************************************/
inline int gx_gzuncompress(gxHANDLE handle, void *target, int *tgtlen,
                    const void *source, int srclen) {

    struct GX_PARM_GZUNCOMPRESS gzu;
    int st;

    assert(target && tgtlen && (*tgtlen > 0) && source && (srclen > 0));

    gzu.target = target;
    gzu.tgtlen = *tgtlen;
    gzu.source = source;
    gzu.srclen = srclen;
    st = gx_call(handle, GX_CALL_GZUNCOMPRESS, &gzu);
    if(st) *tgtlen = gzu.tgtlen;
    return st;
}
/******************************************************************************/
inline int gx_gzuncompressd(void *target, int *tgtlen,
                    const void *source, int srclen) {

    return gx_gzuncompress(gx_direct(GX_CALL_GROUP_GX_ZLIB),
                                target, tgtlen, source, srclen);
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_gzuncompress(void *target, int *tgtlen,
                    const void *source, int srclen) {
    return gx_gzuncompressd(target, tgtlen, source, srclen);
}
#endif

/******************************************************************************/
inline int gx_creategz(gxHANDLE handle, const wchar_t *filename, int level, int strategy) {
    struct GX_PARM_CREATEGZW cgz;
    assert(filename);
    cgz.filename = filename;
    cgz.level = level;
    cgz.strategy = strategy;
    return gx_call(handle, GX_CALL_CREATEGZW, &cgz);
}

/******************************************************************************/
inline int gx_creategza(gxHANDLE handle, const char *filename, int level, int strategy) {
    struct GX_PARM_CREATEGZ cgz;
    assert(filename);
    cgz.filename = filename;
    cgz.level = level;
    cgz.strategy = strategy;
    return gx_call(handle, GX_CALL_CREATEGZ, &cgz);
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_creategz(gxHANDLE handle, const char *filename, int level, int strategy) {
    return gx_creategza(handle, filename, level, strategy);
}
#endif

/******************************************************************************/
inline int gx_opengz(gxHANDLE handle, const wchar_t *filename) {
    struct GX_PARM_OPENGZW ogz;
    assert(filename);
    ogz.filename = filename;
    return gx_call(handle, GX_CALL_OPENGZW, &ogz);
}

/******************************************************************************/
inline int gx_opengza(gxHANDLE handle, const char *filename) {
    struct GX_PARM_OPENGZ ogz;
    assert(filename);
    ogz.filename = filename;
    return gx_call(handle, GX_CALL_OPENGZ, &ogz);
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_opengz(gxHANDLE handle, const char *filename) {
    return gx_opengza(handle, filename);
}
#endif

/******************************************************************************/
inline int gx_closegz(gxHANDLE handle) {
    return gx_call(handle, GX_CALL_CLOSEGZ, (void *)0);
}

/******************************************************************************/
inline int gx_readgz(gxHANDLE handle, void *buffer, int *buflen) {
    struct GX_PARM_READGZ rgz;
    int st;
    assert(buffer && buflen);
    rgz.buffer = buffer;
    rgz.buflen = *buflen;
    st = gx_call(handle, GX_CALL_READGZ, &rgz);
    if(st) *buflen = rgz.buflen;
    return st;
}

/******************************************************************************/
inline int gx_writegz(gxHANDLE handle, const void *buffer, int buflen) {
    struct GX_PARM_WRITEGZ wgz;
    assert(buffer && buflen);
    wgz.buffer = buffer;
    wgz.buflen = buflen;
    return gx_call(handle, GX_CALL_WRITEGZ, &wgz);
}

/******************************************************************************/
inline int gx_createzip(gxHANDLE handle, const wchar_t *filename, int mode) {
    struct GX_PARM_CREATEZIPW czip;
    assert(filename);
    czip.filename = filename;
    czip.mode = mode;
    return gx_call(handle, GX_CALL_CREATEZIPW, &czip);
}

/******************************************************************************/
inline int gx_createzipa(gxHANDLE handle, const char *filename, int mode) {
    struct GX_PARM_CREATEZIP czip;
    assert(filename);
    czip.filename = filename;
    czip.mode = mode;
    return gx_call(handle, GX_CALL_CREATEZIP, &czip);
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_createzip(gxHANDLE handle, const char *filename, int mode) {
    return gx_createzipa(handle, filename, mode);
}
#endif

/******************************************************************************/
inline int gx_openzip(gxHANDLE handle, const wchar_t *filename) {
    struct GX_PARM_OPENZIPW ozip;
    assert(filename);
    ozip.filename = filename;
    return gx_call(handle, GX_CALL_OPENZIPW, &ozip);
}

/******************************************************************************/
inline int gx_openzipa(gxHANDLE handle, const char *filename) {
    struct GX_PARM_OPENZIP ozip;
    assert(filename);
    ozip.filename = filename;
    return gx_call(handle, GX_CALL_OPENZIP, &ozip);
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_openzip(gxHANDLE handle, const char *filename) {
    return gx_openzipa(handle, filename);
}
#endif

/******************************************************************************/
inline int gx_createzipinmemory(gxHANDLE handle, int mode) {
    struct GX_PARM_CREATEZIPINMEMORY czip;
    czip.mode = mode;
    return gx_call(handle, GX_CALL_CREATEZIPINMEMORY, &czip);
}

/******************************************************************************/
inline int gx_getzipinmemory(gxHANDLE handle, void** pbuffer, int* pbuflen) {
    struct GX_PARM_GETZIPINMEMORY zip;
    assert(pbuffer);
    assert(pbuflen);
    zip.pbuffer = pbuffer;
    zip.pbuflen = pbuflen;
    return gx_call(handle, GX_CALL_GETZIPINMEMORY, &zip);
}

/******************************************************************************/
inline int gx_openzipinmemory(gxHANDLE handle, void* buffer, int buflen) {
    struct GX_PARM_OPENZIPINMEMORY ozip;
    assert(buffer);
    assert(buflen);
    ozip.buffer = buffer;
    ozip.buflen = buflen;
    return gx_call(handle, GX_CALL_OPENZIPINMEMORY, &ozip);
}


/******************************************************************************/
inline int gx_closezip(gxHANDLE handle, const wchar_t *comment) {
    struct GX_PARM_CLOSEZIPW czip;
    czip.comment = comment;
    return gx_call(handle, GX_CALL_CLOSEZIPW, &czip);
}

/******************************************************************************/
inline int gx_closezipa(gxHANDLE handle, const char *comment) {
    struct GX_PARM_CLOSEZIP czip;
    czip.comment = comment;
    return gx_call(handle, GX_CALL_CLOSEZIP, &czip);
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_closezip(gxHANDLE handle, const char *comment = (const char *)0) {
    return gx_closezipa(handle, comment);
}
#endif

/******************************************************************************/
inline int gx_getzipinfo(gxHANDLE handle, struct GX_PARM_GETZIPINFO *info) {
    assert(info);
    return gx_call(handle, GX_CALL_GETZIPINFO, info);
}

/******************************************************************************/
inline int gx_getzipcomment(gxHANDLE handle, wchar_t *target, int *tlen) {
    struct GX_PARM_GETZIPCOMMENTW gzc;
    int st;
    assert(target && tlen && (*tlen > 0));
    gzc.target = target;
    gzc.tlen = *tlen;
    st = gx_call(handle, GX_CALL_GETZIPCOMMENTW, &gzc);
    if(st) *tlen = gzc.tlen;
    return st;
}

/******************************************************************************/
inline int gx_getzipcommenta(gxHANDLE handle, char *target, int *tlen) {
    struct GX_PARM_GETZIPCOMMENT gzc;
    int st;
    assert(target && tlen && (*tlen > 0));
    gzc.target = target;
    gzc.tlen = *tlen;
    st = gx_call(handle, GX_CALL_GETZIPCOMMENT, &gzc);
    if(st) *tlen = gzc.tlen;
    return st;
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_getzipcomment(gxHANDLE handle, char *target, int *tlen) {
    return gx_getzipcommenta(handle, target, tlen);
}
#endif

/******************************************************************************/
inline int gx_createfileinzip(gxHANDLE handle, struct GX_PARM_CREATEFILEINZIPW *cfz) {
    assert(cfz);
    return gx_call(handle, GX_CALL_CREATEFILEINZIPW, cfz);
}

/******************************************************************************/
inline int gx_createfileinzipa(gxHANDLE handle, struct GX_PARM_CREATEFILEINZIP *cfz) {
    assert(cfz);
    return gx_call(handle, GX_CALL_CREATEFILEINZIP, cfz);
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_createfileinzip(gxHANDLE handle, struct GX_PARM_CREATEFILEINZIP *cfz) {
    return gx_createfileinzipa(handle, cfz);
}
#endif

/******************************************************************************/
inline int gx_writetofileinzip(gxHANDLE handle, const void *buffer, int buflen) {
    struct GX_PARM_WRITETOFILEINZIP wfz;
    assert(buffer && (buflen > 0));
    wfz.buffer = buffer;
    wfz.buflen = buflen;
    return gx_call(handle, GX_CALL_WRITETOFILEINZIP, &wfz);
}

/******************************************************************************/
inline int gx_closefileinzip(gxHANDLE handle) {
    return gx_call(handle, GX_CALL_CLOSEFILEINZIP, (void *)0);
}

/******************************************************************************/
inline int gx_firstfileinzip(gxHANDLE handle, GX_ZIPFILEDETINFOW *finfo) {
    assert(finfo);
    return gx_call(handle, GX_CALL_FIRSTFILEINZIPW, finfo);
}

/******************************************************************************/
inline int gx_firstfileinzipa(gxHANDLE handle, GX_ZIPFILEDETINFO *finfo) {
    return gx_call(handle, GX_CALL_FIRSTFILEINZIP, finfo);
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_firstfileinzip(gxHANDLE handle, GX_ZIPFILEDETINFO *finfo) {
    return gx_firstfileinzipa(handle, finfo);
}
#endif

/******************************************************************************/
inline int gx_nextfileinzip(gxHANDLE handle, GX_ZIPFILEDETINFOW *finfo) {
    return gx_call(handle, GX_CALL_NEXTFILEINZIPW, finfo);
}

/******************************************************************************/
inline int gx_nextfileinzipa(gxHANDLE handle, GX_ZIPFILEDETINFO *finfo) {
    return gx_call(handle, GX_CALL_NEXTFILEINZIP, finfo);
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_nextfileinzip(gxHANDLE handle, GX_ZIPFILEDETINFO *finfo) {
    return gx_nextfileinzipa(handle, finfo);
}
#endif

/******************************************************************************/
inline int gx_locatefileinzip(gxHANDLE handle, GX_ZIPFILEDETINFOW *finfo,
                            const wchar_t *filename, int casesensitivity) {
    struct GX_PARM_LOCATEFILEINZIPW lfz;
    assert(filename);
    lfz.finfo = finfo;
    lfz.filename = filename;
    lfz.casesensitivity = casesensitivity;
    return gx_call(handle, GX_CALL_LOCATEFILEINZIPW, &lfz);
}

/******************************************************************************/
inline int gx_locatefileinzipa(gxHANDLE handle, GX_ZIPFILEDETINFO *finfo,
                            const char *filename, int casesensitivity) {
    struct GX_PARM_LOCATEFILEINZIP lfz;
    assert(filename);
    lfz.finfo = finfo;
    lfz.filename = filename;
    lfz.casesensitivity = casesensitivity;
    return gx_call(handle, GX_CALL_LOCATEFILEINZIP, &lfz);
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_locatefileinzip(gxHANDLE handle, GX_ZIPFILEDETINFO *finfo,
                            const char *filename, int casesensitivity) {
    return gx_locatefileinzipa(handle, finfo, filename, casesensitivity);
}
#endif

/******************************************************************************/
inline int gx_fileinfoinzip(gxHANDLE handle, GX_ZIPFILEDETINFOW *finfo) {
    assert(finfo);
    return gx_call(handle, GX_CALL_FILEINFOINZIPW, finfo);
}

/******************************************************************************/
inline int gx_fileinfoinzipa(gxHANDLE handle, GX_ZIPFILEDETINFO *finfo) {
    assert(finfo);
    return gx_call(handle, GX_CALL_FILEINFOINZIP, finfo);
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_fileinfoinzip(gxHANDLE handle, GX_ZIPFILEDETINFO *finfo) {
    return gx_fileinfoinzipa(handle, finfo);
}
#endif

/******************************************************************************/
inline int gx_openfileinzip(gxHANDLE handle, int *method, int *level, const wchar_t *password) {
    struct GX_PARM_OPENFILEINZIPW ofz;
    int st;
    ofz.method = ofz.level = 0;
    ofz.password = password;
    st = gx_call(handle, GX_CALL_OPENFILEINZIPW, &ofz);
    if(st) {
        if(method) *method = ofz.method;
        if(level) *level = ofz.level;
    }
    return st;
}

/******************************************************************************/
inline int gx_openfileinzipa(gxHANDLE handle, int *method, int *level, const char *password) {
    struct GX_PARM_OPENFILEINZIP ofz;
    int st;
    ofz.method = ofz.level = 0;
    ofz.password = password;
    st = gx_call(handle, GX_CALL_OPENFILEINZIP, &ofz);
    if(st) {
        if(method) *method = ofz.method;
        if(level) *level = ofz.level;
    }
    return st;
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_openfileinzip(gxHANDLE handle, int *method, int *level,
                const char *password = (const char *)0) {
    return gx_openfileinzipa(handle, method, level, password);
}
#endif

/******************************************************************************/
inline int gx_readfromfileinzip(gxHANDLE handle, void *target, int *tlen) {
    struct GX_PARM_READFROMFILEINZIP rfz;
    int st;
    assert(target && tlen && (*tlen > 0));
    rfz.buffer = target;
    rfz.buflen = *tlen;
    st = gx_call(handle, GX_CALL_READFROMFILEINZIP, &rfz);
    if(st) *tlen = rfz.buflen;
    return st;
}

/******************************************************************************/
inline int gx_calculatezipcrc(gxHANDLE handle, unsigned int *crc, const void *buffer, int buflen) {
    struct GX_PARM_CALCULATEZIPCRC czc;
    int st;
    assert(crc && buffer && (buflen > 0));
    czc.crc = *crc;
    czc.buffer = buffer;
    czc.buflen = buflen;
    st = gx_call(handle, GX_CALL_CALCULATEZIPCRC, &czc);
    if(st) *crc = czc.crc;
    return st;
}

/******************************************************************************/
inline int gx_calculatezipcrcd(unsigned int *crc, const void *buffer, int buflen) {
    return gx_calculatezipcrc(gx_direct(GX_CALL_GROUP_GX_ZLIB), crc, buffer, buflen);
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_calculatezipcrc(unsigned int *crc, const void *buffer, int buflen) {
    return gx_calculatezipcrcd(crc, buffer, buflen);
}
#endif

/******************************************************************************/
inline int gx_getinitialzipcrc(gxHANDLE handle, unsigned int *crc) {
    struct GX_PARM_GETINITIALZIPCRC gzc;
    int st;
    assert(crc);
    st = gx_call(handle, GX_CALL_GETINITIALZIPCRC, &gzc);
    if(st && crc) *crc = gzc.crc;
    return st;
}

/******************************************************************************/
inline int gx_getinitialzipcrcd(unsigned int *crc) {
    return gx_getinitialzipcrc(gx_direct(GX_CALL_GROUP_GX_ZLIB), crc);
}

#ifdef __cplusplus
/******************************************************************************/
inline int gx_getinitialzipcrc(unsigned int *crc) {
    return gx_getinitialzipcrcd(crc);
}
#endif

/******************************************************************************/
inline int gx_readlexfieldzip(gxHANDLE handle, void *buffer, int *buflen) {
    struct GX_PARM_READLEXFIELDZIP rlfz;
    int st;
    assert(buffer && buflen && (buflen > 0));
    rlfz.buffer = buffer;
    rlfz.buflen = *buflen;
    st = gx_call(handle, GX_CALL_READLEXFIELDZIP, &rlfz);
    if(st) *buflen = rlfz.buflen;
    return st;
};

/******************************************************************************/
/******************************************************************************/

#endif

/******************************************************************************/

#ifdef GX_DOTNET
#pragma managed
#endif

#ifndef NO_GX_CLASSES

/******************************************************************************/
GX_CLASS gxGZip : public gxHandle {
public:
    inline gxGZip() gxFuncThrowsError {
#ifndef GX_DOTNET
        if(!gx_openmodule(this, L"gxzlib", L"default")) gxthrow;
#else
        GX_GETHANDLE(h);
        if(!gx_openmodule(&h, L"gxzlib", L"default")) gxthrow;
        _set_handle(h.handle);
#endif
    }

    inline bool IsValid(void) GX_CONST {
        return gxHandle::IsValid();
    }

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool Compress(void *target, int *tgtlen,
                    const void *source, int srclen, int level) gxFuncThrowsError {
        assert(target && tgtlen && (*tgtlen > 0) && source && (srclen > 0));
        bool st = gx_gzcompress(*this, target, tgtlen,
                    source, srclen, level) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#else

    inline gxOutData Compress(gxInData source, int maxlen, int level) gxFuncThrowsError {
        GX_GETDATA(source);
        GX_GETHANDLE(h);
        int targetlen = maxlen ? maxlen : (GX_DATALEN(source)*2+1024);
        void *target;
        if(!gx_globalalloc(&target, targetlen)) {
            GX_FREEDATA(source);
            gxthrow;
            return GX_PUTDATA_NONE;
        }
        if(!gx_gzcompress(h, target, &targetlen, GX_DATAPTR(source), GX_DATALEN(source), level)) {
            gx_globalfree(target);
            GX_FREEDATA(source);
            gxthrow;
            return GX_PUTDATA_NONE;
        }
        gxOutData ret = GX_PUTDATA(target, targetlen);
        gx_globalfree(target);
        GX_FREEDATA(source);
        return ret;
    }
#endif

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool Uncompress(void *target, int *tgtlen,
                    const void *source, int srclen) gxFuncThrowsError {
        assert(target && tgtlen && (*tgtlen > 0) && source && (srclen > 0));
        bool st = gx_gzuncompress(*this, target, tgtlen, source, srclen) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#else

    inline gxOutData Uncompress(gxInData source, int maxlen) gxFuncThrowsError {
        GX_GETDATA(source);
        GX_GETHANDLE(h);
        int targetlen = maxlen;
        void *target;
        if(!gx_globalalloc(&target, targetlen)) {
            GX_FREEDATA(source);
            gxthrow;
            return GX_PUTDATA_NONE;
        }
        if(!gx_gzuncompress(h, target, &targetlen, GX_DATAPTR(source), GX_DATALEN(source))) {
            gx_globalfree(target);
            GX_FREEDATA(source);
            gxthrow;
            return GX_PUTDATA_NONE;
        }

        gxOutData ret = GX_PUTDATA(target, targetlen);
        gx_globalfree(target);
        GX_FREEDATA(source);
        return ret;
    }
#endif

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool Create(const wchar_t *filename, int level, int strategy) gxFuncThrowsError {
        assert(filename);
        bool st = gx_creategz(*this, filename, level, strategy) ? true : false;
        gxcondthrow(!st);
        return st;
    }

    inline bool Create(const char *filename, int level, int strategy) gxFuncThrowsError {
        assert(filename);
        bool st = gx_creategz(*this, filename, level, strategy) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif

#ifdef GX_UNICODE

    inline bool Create(gxInStr filename, int level, int strategy) gxFuncThrowsError {
        GX_GETSTRING(_filename, filename);
        GX_GETHANDLE(h);
        bool st = gx_creategz(h, _filename, level, strategy) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif
#ifdef GX_ASCII

    inline bool Create(gxInAStr filename, int level, int strategy) gxFuncThrowsError {
        GX_GETASTRING(_filename, filename);
        GX_GETHANDLE(h);
        bool st = gx_creategza(h, _filename, level, strategy) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool Open(const wchar_t *filename) gxFuncThrowsError {
        assert(filename);
        GX_GETHANDLE(h);
        bool st = gx_opengz(h, filename) ? true : false;
        gxcondthrow(!st);
        return st;
    }

    inline bool Open(const char *filename) gxFuncThrowsError {
        assert(filename);
        GX_GETHANDLE(h);
        bool st = gx_opengza(h, filename) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif

#ifdef GX_UNICODE

    inline bool Open(gxInStr filename) gxFuncThrowsError {
        GX_GETSTRING(_filename, filename);
        GX_GETHANDLE(h);
        bool st = gx_opengz(h, _filename) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif
#ifdef GX_ASCII

    inline bool Open(gxInAStr filename) gxFuncThrowsError {
        GX_GETASTRING(_filename, filename);
        GX_GETHANDLE(h);
        bool st = gx_opengza(h, _filename) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif

    inline bool Close(void) gxFuncThrowsError {
        GX_GETHANDLE(h);
        bool st = gx_closegz(h) ? true : false;
        gxcondthrow(!st);
        return st;
    }

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool Read(void *buffer, int *buflen) gxFuncThrowsError {
        assert(buffer && buflen);
        bool st = gx_readgz(*this, buffer, buflen) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#else

    inline gxOutData Read(int len) gxFuncThrowsError {
        int buflen = len;
        void *buffer;
        if(!gx_globalalloc(&buffer, buflen)) {
            gxthrow;
            return GX_PUTDATA_NONE;
        }
        GX_GETHANDLE(h);
        if(!gx_readgz(h, buffer, &buflen)) {
            gx_globalfree(buffer);
            gxthrow;
            return GX_PUTDATA_NONE;
        }
        gxOutData ret = GX_PUTDATA(buffer, buflen);
        gx_globalfree(buffer);
        return ret;
    }
#endif

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool Write(const void *buffer, int buflen) gxFuncThrowsError {
        assert(buffer && buflen);
        GX_GETHANDLE(h);
        bool st = gx_writegz(h, buffer, buflen) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#else

    inline int Write(gxInData buffer) gxFuncThrowsError {
        GX_GETDATA(buffer);
        GX_GETHANDLE(h);
        int l = GX_DATALEN(buffer);
        bool st = gx_writegz(h, GX_DATAPTR(buffer), l) ? true : false;
        GX_FREEDATA(buffer);
        gxcondthrow(!st);
        return st ? l : 0;
    }
#endif
};

/******************************************************************************/
GX_STRUCT gxZipFileInfo {
public:
    int tm_sec;             
    int tm_min;             
    int tm_hour;            
    int tm_mday;            
    int tm_mon;             
    int tm_year;            
    int dosdate;            
    int internal_fa;        
    int external_fa;        
};

GX_STRUCT gxZipFileDetInfo {
public:
    int version;            
    int version_needed;     
    int flag;               
    int method;             
    unsigned int crc;       
    int compressed_size;    
    int uncompressed_size;  
    int size_filename;      
    int size_file_extra;    
    int size_file_comment;  
    int disk_num_start;     
};

/******************************************************************************/
#ifdef GX_DOTNET
    #define CreateFileOld CreateFile
    #undef CreateFile
#endif

GX_CLASS gxZip : public gxHandle {
private:
    int _file_method;   
    int _file_level;    
public:
    inline gxZip() gxFuncThrowsError {
#ifndef GX_DOTNET
        if(!gx_openmodule(this, L"gxzlib", L"default")) gxthrow;
#else
        GX_GETHANDLE(h);
        if(!gx_openmodule(&h, L"gxzlib", L"default")) gxthrow;
        _set_handle(h.handle);
#endif
        _file_method = -1;
        _file_level = -1;
    }

    inline bool IsValid(void) GX_CONST {
        return gxHandle::IsValid();
    }

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool Create(const wchar_t *filename, int mode) gxFuncThrowsError {
        assert(filename);
        GX_GETHANDLE(h);
        bool st = gx_createzip(h, filename, mode) ? true : false;
        gxcondthrow(!st);
        return st;
    }

    inline bool Create(const char *filename, int mode) gxFuncThrowsError {
        assert(filename);
        GX_GETHANDLE(h);
        bool st = gx_createzipa(h, filename, mode) ? true : false;
        gxcondthrow(!st);
        return st;
    }

#endif
#ifdef GX_UNICODE

    inline bool Create(gxInStr filename, int mode) gxFuncThrowsError {
        GX_GETSTRING(_filename, filename);
        GX_GETHANDLE(h);
        bool st = gx_createzip(h, _filename, mode) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif
#ifdef GX_ASCII

    inline bool Create(gxInAStr filename, int mode) gxFuncThrowsError {
        GX_GETASTRING(_filename, filename);
        GX_GETHANDLE(h);
        bool st = gx_createzipa(h, _filename, mode) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool Open(const wchar_t *filename) gxFuncThrowsError {
        assert(filename);
        bool st = gx_openzip(*this, filename) ? true : false;
        gxcondthrow(!st);
        return st;
    }

    inline bool Open(const char *filename) gxFuncThrowsError {
        assert(filename);
        bool st = gx_openzipa(*this, filename) ? true : false;
        gxcondthrow(!st);
        return st;
    }

#endif
#ifdef GX_UNICODE

    inline bool Open(gxInStr filename) gxFuncThrowsError {
        GX_GETHANDLE(h);
        GX_GETSTRING(_filename, filename);
        bool st = gx_openzip(h, _filename) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif
#ifdef GX_ASCII

    inline bool Open(gxInAStr filename) gxFuncThrowsError {
        GX_GETHANDLE(h);
        GX_GETASTRING(_filename, filename);
        bool st = gx_openzipa(h, _filename) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif


#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool CreateZipInMemory(int mode) gxFuncThrowsError {
        GX_GETHANDLE(h);
        bool st = gx_createzipinmemory(h, mode) ? true : false;
        gxcondthrow(!st);
        return st;
    }

    inline bool GetZipInMemory(void** pbuffer, int* pbuflen) gxFuncThrowsError {
        assert(pbuffer);
        assert(pbuflen);
        GX_GETHANDLE(h);
        bool st = gx_getzipinmemory(h, pbuffer, pbuflen) ? true : false;
        gxcondthrow(!st);
        return st;
    }

    inline bool OpenZipInMemory(void* buffer, int buflen) gxFuncThrowsError {
        assert(buffer);
        assert(buflen);
        bool st = gx_openzipinmemory(*this, buffer, buflen) ? true : false;
        gxcondthrow(!st);
        return st;
    }

#endif

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool Close(const wchar_t *comment) gxFuncThrowsError {
        bool st = gx_closezip(*this, comment) ? true : false;
        gxcondthrow(!st);
        return st;
    }

    inline bool Close(const char *comment) gxFuncThrowsError {
        bool st = gx_closezip(*this, comment) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif

#ifdef GX_UNICODE

    inline bool Close(gxInStr comment) gxFuncThrowsError {
        GX_GETHANDLE(h);
        GX_GETSTRING(_comment, comment);
        bool st = gx_closezip(h, _comment) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif
#ifdef GX_ASCII

    inline bool Close(gxInAStr comment) gxFuncThrowsError {
        GX_GETHANDLE(h);
        GX_GETASTRING(_comment, comment);
        bool st = gx_closezipa(h, _comment) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif

    inline bool Close(void) gxFuncThrowsError {
        GX_GETHANDLE(h);
        bool st = gx_closezipa(h, (const char *)0) ? true : false;
        gxcondthrow(!st);
        return st;
    }

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool GetInfo(GX_PARM_GETZIPINFO *info) gxFuncThrowsError {
        assert(info);
        bool st = gx_getzipinfo(*this, info) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif

    inline int GetNEntries(void) gxFuncThrowsError {
        GX_GETHANDLE(h);
        GX_PARM_GETZIPINFO info;
        info.nentries = -1;
        if(!gx_getzipinfo(h, &info)) gxthrow;
        return info.nentries;
    }

    inline int GetCommentLength(void) gxFuncThrowsError {
        GX_GETHANDLE(h);
        GX_PARM_GETZIPINFO info;
        info.commentlen = -1;
        if(!gx_getzipinfo(h, &info)) gxthrow;
        return info.commentlen;
    }

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool GetComment(wchar_t *target, int *tlen) gxFuncThrowsError {
        assert(target && tlen && (*tlen >= 0));
        bool st = gx_getzipcomment(*this, target, tlen) ? true : false;
        gxcondthrow(!st);
        return st;
    }

    inline bool GetComment(char *target, int *tlen) gxFuncThrowsError {
        assert(target && tlen && (*tlen >= 0));
        bool st = gx_getzipcomment(*this, target, tlen) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif

#ifdef GX_UNICODE

    inline gxOutStr GetComment(void) gxFuncThrowsError {
        int buflen = GetCommentLength();
        if(buflen <= 0) return GX_PUTSTRING_NONE;
        wchar_t *buffer;
        if(!gx_globalalloc((void **)(void *)&buffer, sizeof(wchar_t)*(buflen+1))) {
            gxthrow;
            return GX_PUTSTRING_NONE;
        }
        GX_GETHANDLE(h);
        buflen++;
        if(!gx_getzipcomment(h, buffer, &buflen)) {
            gx_globalfree(buffer);
            gxthrow;
            return GX_PUTSTRING_NONE;
        }
        buffer[buflen-1] = 0;
        gxOutStr ret = GX_PUTSTRING(buffer);
        gx_globalfree(buffer);
        return ret;
    }
#endif
#ifdef GX_ASCII

    inline gxOutAStr GetCommentA(void) gxFuncThrowsError {
        int buflen = GetCommentLength();
        if(buflen <= 0) return GX_PUTASTRING_NONE;
        char *buffer;
        if(!gx_globalalloc((void **)(void *)&buffer, buflen+1)) {
            gxthrow;
            return GX_PUTASTRING_NONE;
        }
        GX_GETHANDLE(h);
        if(!gx_getzipcommenta(h, buffer, &buflen)) {
            gx_globalfree(buffer);
            gxthrow;
            return GX_PUTASTRING_NONE;
        }
        buffer[buflen] = 0;
        gxOutAStr ret = GX_PUTASTRING(buffer);
        gx_globalfree(buffer);
        return ret;
    }
#endif

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool CreateFile(GX_PARM_CREATEFILEINZIPW *cfz) gxFuncThrowsError {
        assert(cfz);
        bool st = gx_createfileinzip(*this, cfz) ? true : false;
        gxcondthrow(!st);
        return st;
    }

    inline bool CreateFile(GX_PARM_CREATEFILEINZIP *cfz) gxFuncThrowsError {
        assert(cfz);
        GX_GETHANDLE(h);
        bool st = gx_createfileinzipa(h, cfz) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif

#if defined(GX_DOTNET) || defined(GX_SWIG)

#ifdef GX_UNICODE

    inline bool CreateFile(gxInStr filename, int level, int strategy, gxInStr comment,
        gxZipFileInfo GX_REF_STRUCT(info), gxInStr password, unsigned int crc,
                        gxInData localexf, gxInData globalexf)
    {

        GX_ZIPFILEINFO _info;
        GX_PARM_CREATEFILEINZIPW cfz;
        memset(&cfz, 0, sizeof(cfz));

        _info.tm_sec = info GX_MS tm_sec;
        _info.tm_min = info GX_MS tm_min;
        _info.tm_hour = info GX_MS tm_hour;
        _info.tm_mday = info GX_MS tm_mday;
        _info.tm_mon = info GX_MS tm_mon;
        _info.tm_year = info GX_MS tm_year;
        _info.dosdate = info GX_MS dosdate;
        _info.internal_fa = info GX_MS internal_fa;
        _info.external_fa = info GX_MS external_fa;
        cfz.info = &_info;

        GX_GETSTRING(_filename, filename);
        cfz.filename = _filename;
        cfz.level = level;
        cfz.strategy = strategy;
        GX_GETSTRING(_comment, comment);
        cfz.comment = _comment;
        GX_GETSTRING(_password, password);
        cfz.password = (_password && *_password) ? _password : 0;
        cfz.crc = crc;
        GX_GETDATA(localexf);
        GX_GETDATA(globalexf);
        cfz.exflocal = GX_DATAPTR(localexf);
        cfz.exflocal_len = GX_DATALEN(localexf);
        cfz.exfglobal = GX_DATAPTR(globalexf);
        cfz.exfglobal_len = GX_DATALEN(globalexf);
        GX_GETHANDLE(h);
        bool st = gx_createfileinzip(h, &cfz) ? true : false;
        GX_FREEDATA(localexf);
        GX_FREEDATA(globalexf);
        gxcondthrow(!st);
        return st;
    }
#endif // GX_UNICODE

#ifdef GX_ASCII

    inline bool CreateFile(gxInAStr filename, int level, int strategy,
                        gxInAStr comment, gxZipFileInfo GX_REF_STRUCT(info),
                        gxInAStr password, unsigned int crc,
                        gxInData localexf, gxInData globalexf) {
        GX_ZIPFILEINFO _info;
        GX_PARM_CREATEFILEINZIP cfz;
        memset(&cfz, 0, sizeof(cfz));
        _info.tm_sec = info.tm_sec;
        _info.tm_min = info.tm_min;
        _info.tm_hour = info.tm_hour;
        _info.tm_mday = info.tm_mday;
        _info.tm_mon = info.tm_mon;
        _info.tm_year = info.tm_year;
        _info.dosdate = info.dosdate;
        _info.internal_fa = info.internal_fa;
        _info.external_fa = info.external_fa;
        cfz.info = &_info;
        GX_GETASTRING(_filename, filename);
        cfz.filename = _filename;
        cfz.level = level;
        cfz.strategy = strategy;
        GX_GETASTRING(_comment, comment);
        cfz.comment = _comment;
        GX_GETASTRING(_password, password);
        cfz.password = (_password && *_password) ? _password : 0;
        cfz.crc = crc;
        GX_GETDATA(localexf);
        GX_GETDATA(globalexf);
        cfz.exflocal = GX_DATAPTR(localexf);
        cfz.exflocal_len = GX_DATALEN(localexf);
        cfz.exfglobal = GX_DATAPTR(globalexf);
        cfz.exfglobal_len = GX_DATALEN(globalexf);
        GX_GETHANDLE(h);
        bool st = gx_createfileinzipa(h, &cfz) ? true : false;
        GX_FREEDATA(localexf);
        GX_FREEDATA(globalexf);
        gxcondthrow(!st);
        return st;
    }
#endif // GX_ASCII

#endif // defined(GX_DOTNET) && defined(GX_SWIG)

#ifdef GX_UNICODE

    inline bool CreateFile(gxInStr filename, int level, int strategy,
                        gxInStr comment, gxZipFileInfo GX_REF_STRUCT(info)) {

        GX_ZIPFILEINFO _info;
        GX_PARM_CREATEFILEINZIPW cfz;
        memset(&cfz, 0, sizeof(cfz));

        _info.tm_sec = info GX_MS tm_sec;
        _info.tm_min = info GX_MS tm_min;
        _info.tm_hour = info GX_MS tm_hour;
        _info.tm_mday = info GX_MS tm_mday;
        _info.tm_mon = info GX_MS tm_mon;
        _info.tm_year = info GX_MS tm_year;
        _info.dosdate = info GX_MS dosdate;
        _info.internal_fa = info GX_MS internal_fa;
        _info.external_fa = info GX_MS external_fa;
        cfz.info = &_info;

        GX_GETSTRING(_filename, filename);
        cfz.filename = _filename;
        cfz.level = level;
        cfz.strategy = strategy;
        GX_GETSTRING(_comment, comment);
        cfz.comment = _comment;
        GX_GETHANDLE(h);
        bool st = gx_createfileinzip(h, &cfz) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif // GX_UNICODE

#ifdef GX_ASCII

    inline bool CreateFile(gxInAStr filename, int level, int strategy,
                        gxInAStr comment, gxZipFileInfo GX_REF_STRUCT(info)) {
        GX_ZIPFILEINFO _info;
        GX_PARM_CREATEFILEINZIP cfz;
        memset(&cfz, 0, sizeof(cfz));
        _info.tm_sec = info.tm_sec;
        _info.tm_min = info.tm_min;
        _info.tm_hour = info.tm_hour;
        _info.tm_mday = info.tm_mday;
        _info.tm_mon = info.tm_mon;
        _info.tm_year = info.tm_year;
        _info.dosdate = info.dosdate;
        _info.internal_fa = info.internal_fa;
        _info.external_fa = info.external_fa;
        cfz.info = &_info;
        GX_GETASTRING(_filename, filename);
        cfz.filename = _filename;
        cfz.level = level;
        cfz.strategy = strategy;
        GX_GETASTRING(_comment, comment);
        cfz.comment = _comment;
        GX_GETHANDLE(h);
        bool st = gx_createfileinzipa(h, &cfz) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif // GX_ASCII

#if !defined(GX_DOTNET) && !defined(GX_SWIG)

    inline bool CreateFile(const wchar_t *filename, int level, int strategy,
                        const wchar_t *comment) {

        GX_PARM_CREATEFILEINZIPW cfz;
        memset(&cfz, 0, sizeof(cfz));
        cfz.filename = filename;
        cfz.level = level;
        cfz.strategy = strategy;
        cfz.comment = comment;
        bool st = gx_createfileinzip(*this, &cfz) ? true : false;
        gxcondthrow(!st);
        return st;
    }

    inline bool CreateFile(const char *filename, int level, int strategy,
                        const char *comment) {

        GX_PARM_CREATEFILEINZIP cfz;
        memset(&cfz, 0, sizeof(cfz));
        cfz.filename = filename;
        cfz.level = level;
        cfz.strategy = strategy;
        cfz.comment = comment;
        bool st = gx_createfileinzipa(*this, &cfz) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif


#ifdef GX_UNICODE

    inline bool CreateFile(gxInStr filename, int level, int strategy,
                        gxInStr comment) {

        GX_PARM_CREATEFILEINZIPW cfz;
        memset(&cfz, 0, sizeof(cfz));
        GX_GETSTRING(_filename, filename);
        cfz.filename = _filename;
        cfz.level = level;
        cfz.strategy = strategy;
        GX_GETSTRING(_comment, comment);
        cfz.comment = _comment;
        GX_GETHANDLE(h);
        bool st = gx_createfileinzip(h, &cfz) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif // GX_UNICODE

#ifdef GX_ASCII

    inline bool CreateFile(gxInAStr filename, int level, int strategy,
                        gxInAStr comment) {

        GX_PARM_CREATEFILEINZIP cfz;
        memset(&cfz, 0, sizeof(cfz));
        GX_GETASTRING(_filename, filename);
        cfz.filename = _filename;
        cfz.level = level;
        cfz.strategy = strategy;
        GX_GETASTRING(_comment, comment);
        cfz.comment = _comment;
        GX_GETHANDLE(h);
        bool st = gx_createfileinzipa(h, &cfz) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif // GX_ASCII

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool WriteToFile(const void *buffer, int buflen) gxFuncThrowsError {
        assert(buffer && (buflen >= 0));
        bool st = gx_writetofileinzip(*this, buffer, buflen) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#else

    inline bool WriteToFile(gxInData data) gxFuncThrowsError {
        GX_GETDATA(data);
        GX_GETHANDLE(h);
        bool st = gx_writetofileinzip(h, GX_DATAPTR(data), GX_DATALEN(data)) ?
                        true : false;
        GX_FREEDATA(data);
        gxcondthrow(!st);
        return st;
    }
#endif

    inline bool CloseFile(void) gxFuncThrowsError {
        GX_GETHANDLE(h);
        bool st = gx_closefileinzip(h) ? true : false;
        gxcondthrow(!st);
        return st;
    }

#if !defined(GX_DOTNET) && !defined(GX_SWIG)

    inline bool FirstFile(GX_ZIPFILEDETINFOW *finfo) {
        assert(finfo);
        return gx_firstfileinzip(*this, finfo) ? true : false;
    }

    inline bool FirstFile(GX_ZIPFILEDETINFO *finfo) {
        assert(finfo);
        return gx_firstfileinzip(*this, finfo) ? true : false;
    }
#endif

    inline bool FirstFile(void) {
        GX_GETHANDLE(h);
        return gx_firstfileinzip(h, (GX_ZIPFILEDETINFO *)0) ? true : false;
    }

#if !defined(GX_DOTNET) && !defined(GX_SWIG)

    inline bool NextFile(GX_ZIPFILEDETINFOW *finfo) {
        assert(finfo);
        return gx_nextfileinzip(*this, finfo) ? true : false;
    }

    inline bool NextFile(GX_ZIPFILEDETINFO *finfo) {
        assert(finfo);
        return gx_nextfileinzip(*this, finfo) ? true : false;
    }
#endif

    inline bool NextFile(void) {
        GX_GETHANDLE(h);
        return gx_nextfileinzip(h, (GX_ZIPFILEDETINFO *)0) ? true : false;
    }

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool LocateFile(GX_ZIPFILEDETINFOW *finfo, const wchar_t *filename,
                            int casesensitivity = 0) gxFuncThrowsError {
        assert(finfo);
        assert(filename);
        return gx_locatefileinzip(*this, finfo, filename, casesensitivity) ?
                        true : false;
    }

    inline bool LocateFile(GX_ZIPFILEDETINFO *finfo, const char *filename,
                            int casesensitivity = 0) gxFuncThrowsError {
        assert(finfo);
        assert(filename);
        return gx_locatefileinzipa(*this, finfo, filename, casesensitivity) ?
                        true : false;
    }
#endif

#ifdef GX_UNICODE

    inline bool LocateFile(gxInStr filename, int casesensitivity GX_DEFARG(0)) gxFuncThrowsError {
        GX_GETSTRING(_filename, filename);
        GX_GETHANDLE(h);
        return gx_locatefileinzip(h, (GX_ZIPFILEDETINFOW *)0, _filename,
                        casesensitivity) ? true : false;
    }
#endif
#ifdef GX_ASCII

    inline bool LocateFile(gxInAStr filename, int casesensitivity = 0) gxFuncThrowsError {
        GX_GETASTRING(_filename, filename);
        GX_GETHANDLE(h);
        return gx_locatefileinzipa(h, (GX_ZIPFILEDETINFO *)0, _filename,
                        casesensitivity) ? true : false;
    }
#endif

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool FileInfo(GX_ZIPFILEDETINFO *finfo) gxFuncThrowsError {
        assert(finfo);
        bool st = gx_fileinfoinzip(*this, finfo) ? true : false;
        gxcondthrow(!st);
        return st;
    }

    inline bool FileInfo(GX_ZIPFILEDETINFOW *finfo) gxFuncThrowsError {
        assert(finfo);
        bool st = gx_fileinfoinzip(*this, finfo) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif

    inline gxZipFileInfo GetFileInfo(void) gxFuncThrowsError {
        GX_ZIPFILEDETINFO info;
        memset(&info, 0, sizeof(info));
        gxZipFileInfo ret;
        memset(&ret, 0, sizeof(ret));
        GX_GETHANDLE(h);
        if(gx_fileinfoinzip(h, &info)) {
            ret.tm_sec = info.tm_sec;
            ret.tm_min = info.tm_min;
            ret.tm_hour = info.tm_hour;
            ret.tm_mday = info.tm_mday;
            ret.tm_mon = info.tm_mon;
            ret.tm_year = info.tm_year;
            ret.dosdate = info.dosdate;
            ret.internal_fa = info.internal_fa;
            ret.external_fa = info.external_fa;
        } else {
            gxthrow;
        }
        return ret;
    }

    inline gxZipFileDetInfo GetFileDetInfo(void) gxFuncThrowsError {
        GX_ZIPFILEDETINFO info;
        memset(&info, 0, sizeof(info));
        gxZipFileDetInfo ret;
        memset(&ret, 0, sizeof(ret));
        GX_GETHANDLE(h);
        if(gx_fileinfoinzip(h, &info)) {
            ret.version = info.version;
            ret.version_needed = info.version_needed;
            ret.flag = info.flag;
            ret.method = info.method;
            ret.crc = info.crc;
            ret.compressed_size = info.compressed_size;
            ret.uncompressed_size = info.uncompressed_size;
            ret.size_filename = info.size_filename;
            ret.size_file_extra = info.size_file_extra;
            ret.size_file_comment = info.size_file_comment;
            ret.disk_num_start = info.disk_num_start;
        } else {
            gxthrow;
        }
        return ret;
    }

#ifdef GX_UNICODE

    inline gxOutStr GetFileName(void) {
        GX_ZIPFILEDETINFOW info;
        memset(&info, 0, sizeof(info));
        GX_GETHANDLE(h);
        if(!gx_fileinfoinzip(h, &info)) {
            gxthrow;
            return GX_PUTSTRING_NONE;
        }
        wchar_t *filename;
        if(!gx_globalalloc((void **)(void *)&filename, sizeof(wchar_t)*(info.size_filename+1))) {
            gxthrow;
            return GX_PUTSTRING_NONE;
        }
        info.filename = filename;
        info.filename_len = info.size_filename+1;
        if(!gx_fileinfoinzip(h, &info)) {
            gx_globalfree(filename);
            gxthrow;
            return GX_PUTSTRING_NONE;
        }
        filename[info.size_filename] = 0;
        gxOutStr ret = GX_PUTSTRING(filename);
        gx_globalfree(filename);
        return ret;
    }
#endif
#ifdef GX_ASCII

    inline gxOutAStr GetFileNameA(void) {
        GX_ZIPFILEDETINFO info;
        memset(&info, 0, sizeof(info));
        GX_GETHANDLE(h);
        if(!gx_fileinfoinzipa(h, &info)) {
            gxthrow;
            return GX_PUTASTRING_NONE;
        }
        char *filename;
        if(!gx_globalalloc((void **)(void *)&filename, info.size_filename+1)) {
            gxthrow;
            return GX_PUTASTRING_NONE;
        }
        info.filename = filename;
        info.filename_len = info.size_filename+1;
        if(!gx_fileinfoinzipa(h, &info)) {
            gx_globalfree(filename);
            gxthrow;
            return GX_PUTASTRING_NONE;
        }
        filename[info.size_filename] = 0;
        gxOutAStr ret = GX_PUTASTRING(filename);
        gx_globalfree(filename);
        return ret;
    }
#endif

#ifdef GX_UNICODE

    inline gxOutStr GetFileComment(void) {
        GX_ZIPFILEDETINFOW info;
        memset(&info, 0, sizeof(info));
        GX_GETHANDLE(h);
        if(!gx_fileinfoinzip(h, &info)) {
            gxthrow;
            return GX_PUTSTRING_NONE;
        }
        wchar_t *comment;
        if(!gx_globalalloc((void **)(void *)&comment, sizeof(wchar_t)*(info.size_file_comment+1))) {
            gxthrow;
            return GX_PUTSTRING_NONE;
        }
        info.comment = comment;
        info.comment_len = info.size_file_comment+1;
        if(!gx_fileinfoinzip(h, &info)) {
            gx_globalfree(comment);
            gxthrow;
            return GX_PUTSTRING_NONE;
        }
        comment[info.size_file_comment] = 0;
        gxOutStr ret = GX_PUTSTRING(comment);
        gx_globalfree(comment);
        return ret;
    }
#endif
#ifdef GX_ASCII

    inline gxOutAStr GetFileCommentA(void) {
        GX_ZIPFILEDETINFO info;
        memset(&info, 0, sizeof(info));
        GX_GETHANDLE(h);
        if(!gx_fileinfoinzipa(h, &info)) {
            gxthrow;
            return GX_PUTASTRING_NONE;
        }
        char *comment;
        if(!gx_globalalloc((void **)(void *)&comment, info.size_file_comment+1)) {
            gxthrow;
            return GX_PUTASTRING_NONE;
        }
        info.comment = comment;
        info.comment_len = info.size_file_comment+1;
        if(!gx_fileinfoinzipa(h, &info)) {
            gx_globalfree(comment);
            gxthrow;
            return GX_PUTASTRING_NONE;
        }
        comment[info.size_file_comment] = 0;
        gxOutAStr ret = GX_PUTASTRING(comment);
        gx_globalfree(comment);
        return ret;
    }
#endif

#if defined(GX_DOTNET) || defined(GX_SWIG)

    inline gxOutData GetFileGlobalExtraField(void) {
        GX_ZIPFILEDETINFO info;
        memset(&info, 0, sizeof(info));
        GX_GETHANDLE(h);
        if(!gx_fileinfoinzipa(h, &info)) {
            gxthrow;
            return GX_PUTDATA_NONE;
        }
        void *gextrafield;
        if(!gx_globalalloc(&gextrafield, info.size_file_extra)) {
            gxthrow;
            return GX_PUTDATA_NONE;
        }
        info.gextrafield = gextrafield;
        info.gextrafield_len = info.size_file_extra;
        if(!gx_fileinfoinzipa(h, &info)) {
            gx_globalfree(gextrafield);
            gxthrow;
            return GX_PUTDATA_NONE;
        }
        gxOutData ret = GX_PUTDATA(gextrafield, info.gextrafield_len);
        gx_globalfree(gextrafield);
        return ret;
    }
#endif

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool OpenFile(int *method, int *level, const wchar_t *password) gxFuncThrowsError {
        bool st = gx_openfileinzip(*this, &_file_method, &_file_level, password) ? true : false;
        gxcondthrow(!st);
        if(st) {
            if(method) *method = _file_method;
            if(level) *level = _file_level;
        }
        return st;
    }

    inline bool OpenFile(int *method, int *level = (int *)0, const char *password = (const char *)0) gxFuncThrowsError {
        bool st = gx_openfileinzipa(*this, &_file_method, &_file_level, password) ? true : false;
        gxcondthrow(!st);
        if(st) {
            if(method) *method = _file_method;
            if(level) *level = _file_level;
        }
        return st;
    }
#endif

    inline bool OpenFile(void) gxFuncThrowsError {
        GX_GETHANDLE(h);
        int _fm = _file_method;
        int _fl = _file_level;
        bool st = gx_openfileinzipa(h, &_fm, &_fl, (const char *)0) ? true : false;
        _file_method = _fm;
        _file_level = _fl;
        gxcondthrow(!st);
        return st;
    }

#ifdef GX_UNICODE

    inline bool OpenFile(gxInStr password) gxFuncThrowsError {
        GX_GETSTRING(_password, password);
        GX_GETHANDLE(h);
        int _fm = _file_method;
        int _fl = _file_level;
        bool st = gx_openfileinzip(h, &_fm, &_fl, _password) ? true : false;
        gxcondthrow(!st);
        _file_method = _fm;
        _file_level = _fl;
        return st;
    }
#endif
#ifdef GX_ASCII

    inline bool OpenFile(gxInAStr password) gxFuncThrowsError {
        GX_GETASTRING(_password, password);
        bool st = gx_openfileinzipa(*this, &_file_method, &_file_level, _password) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif

    inline int GetFileMethod(void) gxFuncThrowsError {
        return _file_method;
    }

    inline int GetFileLevel(void) gxFuncThrowsError {
        return _file_level;
    }

#if !defined (GX_SWIG) && !defined(GX_DOTNET)

    inline bool ReadFromFile(void *target, int *tlen) gxFuncThrowsError {
        assert(target && tlen && (*tlen >= 0));
        bool st = gx_readfromfileinzip(*this, target, tlen) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#else

    inline gxOutData ReadFromFile(int len) gxFuncThrowsError {
        void *target;
        if(!gx_globalalloc(&target, len)) {
            gxthrow;
            return GX_PUTDATA_NONE;
        }
        int tlen = len;
        GX_GETHANDLE(h);
        bool st = gx_readfromfileinzip(h, target, &tlen) ? true : false;
        if(!st) {
            gx_globalfree(target);
            gxthrow;
            return GX_PUTDATA_NONE;
        }
        gxOutData ret = GX_PUTDATA(target, tlen);
        gx_globalfree(target);
        return ret;
    }
#endif

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool CalculateCRC(unsigned int *crc, const void *buffer, int buflen) gxFuncThrowsError {
        assert(crc && buffer && (buflen >= 0));
        bool st = gx_calculatezipcrc(*this, crc, buffer, buflen) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#else

    inline unsigned int CalculateCRC(unsigned int initialcrc, gxInData buffer) gxFuncThrowsError {
        unsigned int ret = initialcrc;
        GX_GETHANDLE(h);
        GX_GETDATA(buffer);
        bool st = gx_calculatezipcrc(h, &ret, GX_DATAPTR(buffer), GX_DATALEN(buffer)) ? true : false;
        GX_FREEDATA(buffer);
        gxcondthrow(!st);
        return ret;
    }
#endif

#if !defined(GX_SWIG) && !defined(GX_DOTNET)

    inline bool GetInitialCRC(unsigned int *crc) gxFuncThrowsError {
        assert(crc);
        bool st = gx_getinitialzipcrc(*this, crc) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#endif

    inline unsigned int GetInitialCRC(void) gxFuncThrowsError {
        unsigned int ret = 0;
        GX_GETHANDLE(h);
        if(!gx_getinitialzipcrc(h, &ret)) gxthrow;
        return ret;
    }

#if !defined(GX_DOTNET) && !defined(GX_SWIG)

    inline bool ReadLocalExtraField(void *buffer, int *buflen) gxFuncThrowsError {
        assert(buffer && buflen && (*buflen >= 0));
        bool st = gx_readlexfieldzip(*this, buffer, buflen) ? true : false;
        gxcondthrow(!st);
        return st;
    }
#else

    inline gxOutData ReadLocalExtraField(int maxlen) {
        GX_GETHANDLE(h);
        void *lextrafield;
        if(!gx_globalalloc(&lextrafield, maxlen)) {
            gxthrow;
            return GX_PUTDATA_NONE;
        }
        int lextrafield_len = maxlen;
        if(!gx_readlexfieldzip(h, lextrafield, &lextrafield_len)) {
            gx_globalfree(lextrafield);
            gxthrow;
            return GX_PUTDATA_NONE;
        }
        gxOutData ret = GX_PUTDATA(lextrafield, lextrafield_len);
        gx_globalfree(lextrafield);
        return ret;
    }
#endif

};
#ifdef GX_DOTNET
    #define CreateFile CreateFileOld
    #undef CreateFileOld
#endif
/******************************************************************************/
#endif // NO_GX_CLASSES
/******************************************************************************/
#ifdef GX_NAMESPACES
    }
#endif
/******************************************************************************/
#endif // GXZLIB_INCL
/******************************************************************************/

---

Generated  for GX
(c) ARH Inc.