quazip-0.7.2/quazip/qioapi.cpp

/* ioapi.c -- IO base function header for compress/uncompress .zip
   files using zlib + zip or unzip API

   Version 1.01e, February 12th, 2005

   Copyright (C) 1998-2005 Gilles Vollant

   Modified by Sergey A. Tachenov to integrate with Qt.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "zlib.h"
#include "ioapi.h"
#include "quazip_global.h"
#include <QIODevice>
#if (QT_VERSION >= 0x050100)
#define QUAZIP_QSAVEFILE_BUG_WORKAROUND
#endif
#ifdef QUAZIP_QSAVEFILE_BUG_WORKAROUND
#include <QSaveFile>
#endif

/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */

#ifndef SEEK_CUR
#define SEEK_CUR    1
#endif

#ifndef SEEK_END
#define SEEK_END    2
#endif

#ifndef SEEK_SET
#define SEEK_SET    0
#endif

voidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc,voidpf file,int mode)
{
    if (pfilefunc->zfile_func64.zopen64_file != NULL)
        return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,file,mode);
    else
    {
        return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,file,mode);
    }
}

int call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)
{
    if (pfilefunc->zfile_func64.zseek64_file != NULL)
        return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin);
    else
    {
        uLong offsetTruncated = (uLong)offset;
        if (offsetTruncated != offset)
            return -1;
        else
            return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin);
    }
}

ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)
{
    if (pfilefunc->zfile_func64.zseek64_file != NULL)
        return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream);
    else
    {
        uLong tell_uLong = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream);
        if ((tell_uLong) == ((uLong)-1))
            return (ZPOS64_T)-1;
        else
            return tell_uLong;
    }
}

/// @cond internal
struct QIODevice_descriptor {
    // Position only used for writing to sequential devices.
    qint64 pos;
    inline QIODevice_descriptor():
        pos(0)
    {}
};
/// @endcond

voidpf ZCALLBACK qiodevice_open_file_func (
   voidpf opaque,
   voidpf file,
   int mode)
{
    QIODevice_descriptor *d = reinterpret_cast<QIODevice_descriptor*>(opaque);
    QIODevice *iodevice = reinterpret_cast<QIODevice*>(file);
    QIODevice::OpenMode desiredMode;
    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
        desiredMode = QIODevice::ReadOnly;
    else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
        desiredMode = QIODevice::ReadWrite;
    else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
        desiredMode = QIODevice::WriteOnly;
    if (iodevice->isOpen()) {
        if ((iodevice->openMode() & desiredMode) == desiredMode) {
            if (desiredMode != QIODevice::WriteOnly
                    && iodevice->isSequential()) {
                // We can use sequential devices only for writing.
                delete d;
                return NULL;
            } else {
                if ((desiredMode & QIODevice::WriteOnly) != 0) {
                    // open for writing, need to seek existing device
                    if (!iodevice->isSequential()) {
                        iodevice->seek(0);
                    } else {
                        d->pos = iodevice->pos();
                    }
                }
            }
            return iodevice;
        } else {
            delete d;
            return NULL;
        }
    }
    iodevice->open(desiredMode);
    if (iodevice->isOpen()) {
        if (desiredMode != QIODevice::WriteOnly && iodevice->isSequential()) {
            // We can use sequential devices only for writing.
            iodevice->close();
            delete d;
            return NULL;
        } else {
            return iodevice;
        }
    } else {
        delete d;
        return NULL;
    }
}


uLong ZCALLBACK qiodevice_read_file_func (
   voidpf opaque,
   voidpf stream,
   void* buf,
   uLong size)
{
    QIODevice_descriptor *d = reinterpret_cast<QIODevice_descriptor*>(opaque);
    QIODevice *iodevice = reinterpret_cast<QIODevice*>(stream);
    qint64 ret64 = iodevice->read((char*)buf,size);
    uLong ret;
    ret = (uLong) ret64;
    if (ret64 != -1) {
        d->pos += ret64;
    }
    return ret;
}


uLong ZCALLBACK qiodevice_write_file_func (
   voidpf opaque,
   voidpf stream,
   const void* buf,
   uLong size)
{
    QIODevice_descriptor *d = reinterpret_cast<QIODevice_descriptor*>(opaque);
    QIODevice *iodevice = reinterpret_cast<QIODevice*>(stream);
    uLong ret;
    qint64 ret64 = iodevice->write((char*)buf,size);
    if (ret64 != -1) {
        d->pos += ret64;
    }
    ret = (uLong) ret64;
    return ret;
}

uLong ZCALLBACK qiodevice_tell_file_func (
   voidpf opaque,
   voidpf stream)
{
    QIODevice_descriptor *d = reinterpret_cast<QIODevice_descriptor*>(opaque);
    QIODevice *iodevice = reinterpret_cast<QIODevice*>(stream);
    uLong ret;
    qint64 ret64;
    if (iodevice->isSequential()) {
        ret64 = d->pos;
    } else {
        ret64 = iodevice->pos();
    }
    ret = static_cast<uLong>(ret64);
    return ret;
}

ZPOS64_T ZCALLBACK qiodevice64_tell_file_func (
   voidpf opaque,
   voidpf stream)
{
    QIODevice_descriptor *d = reinterpret_cast<QIODevice_descriptor*>(opaque);
    QIODevice *iodevice = reinterpret_cast<QIODevice*>(stream);
    qint64 ret;
    if (iodevice->isSequential()) {
        ret = d->pos;
    } else {
        ret = iodevice->pos();
    }
    return static_cast<ZPOS64_T>(ret);
}

int ZCALLBACK qiodevice_seek_file_func (
   voidpf /*opaque UNUSED*/,
   voidpf stream,
   uLong offset,
   int origin)
{
    QIODevice *iodevice = reinterpret_cast<QIODevice*>(stream);
    if (iodevice->isSequential()) {
        if (origin == ZLIB_FILEFUNC_SEEK_END
                && offset == 0) {
            // sequential devices are always at end (needed in mdAppend)
            return 0;
        } else {
            qWarning("qiodevice_seek_file_func() called for sequential device");
            return -1;
        }
    }
    uLong qiodevice_seek_result=0;
    int ret;
    switch (origin)
    {
    case ZLIB_FILEFUNC_SEEK_CUR :
        qiodevice_seek_result = ((QIODevice*)stream)->pos() + offset;
        break;
    case ZLIB_FILEFUNC_SEEK_END :
        qiodevice_seek_result = ((QIODevice*)stream)->size() - offset;
        break;
    case ZLIB_FILEFUNC_SEEK_SET :
        qiodevice_seek_result = offset;
        break;
    default:
        return -1;
    }
    ret = !iodevice->seek(qiodevice_seek_result);
    return ret;
}

int ZCALLBACK qiodevice64_seek_file_func (
   voidpf /*opaque UNUSED*/,
   voidpf stream,
   ZPOS64_T offset,
   int origin)
{
    QIODevice *iodevice = reinterpret_cast<QIODevice*>(stream);
    if (iodevice->isSequential()) {
        if (origin == ZLIB_FILEFUNC_SEEK_END
                && offset == 0) {
            // sequential devices are always at end (needed in mdAppend)
            return 0;
        } else {
            qWarning("qiodevice_seek_file_func() called for sequential device");
            return -1;
        }
    }
    qint64 qiodevice_seek_result=0;
    int ret;
    switch (origin)
    {
    case ZLIB_FILEFUNC_SEEK_CUR :
        qiodevice_seek_result = ((QIODevice*)stream)->pos() + offset;
        break;
    case ZLIB_FILEFUNC_SEEK_END :
        qiodevice_seek_result = ((QIODevice*)stream)->size() - offset;
        break;
    case ZLIB_FILEFUNC_SEEK_SET :
        qiodevice_seek_result = offset;
        break;
    default:
        return -1;
    }
    ret = !iodevice->seek(qiodevice_seek_result);
    return ret;
}

int ZCALLBACK qiodevice_close_file_func (
   voidpf opaque,
   voidpf stream)
{
    QIODevice_descriptor *d = reinterpret_cast<QIODevice_descriptor*>(opaque);
    delete d;
    QIODevice *device = reinterpret_cast<QIODevice*>(stream);
#ifdef QUAZIP_QSAVEFILE_BUG_WORKAROUND
    // QSaveFile terribly breaks the is-a idiom:
    // it IS a QIODevice, but it is NOT compatible with it: close() is private
    QSaveFile *file = qobject_cast<QSaveFile*>(device);
    if (file != NULL) {
        // We have to call the ugly commit() instead:
        return file->commit() ? 0 : -1;
    }
#endif
    device->close();
    return 0;
}

int ZCALLBACK qiodevice_fakeclose_file_func (
   voidpf opaque,
   voidpf /*stream*/)
{
    QIODevice_descriptor *d = reinterpret_cast<QIODevice_descriptor*>(opaque);
    delete d;
    return 0;
}

int ZCALLBACK qiodevice_error_file_func (
   voidpf /*opaque UNUSED*/,
   voidpf /*stream UNUSED*/)
{
    // can't check for error due to the QIODevice API limitation
    return 0;
}

void fill_qiodevice_filefunc (
  zlib_filefunc_def* pzlib_filefunc_def)
{
    pzlib_filefunc_def->zopen_file = qiodevice_open_file_func;
    pzlib_filefunc_def->zread_file = qiodevice_read_file_func;
    pzlib_filefunc_def->zwrite_file = qiodevice_write_file_func;
    pzlib_filefunc_def->ztell_file = qiodevice_tell_file_func;
    pzlib_filefunc_def->zseek_file = qiodevice_seek_file_func;
    pzlib_filefunc_def->zclose_file = qiodevice_close_file_func;
    pzlib_filefunc_def->zerror_file = qiodevice_error_file_func;
    pzlib_filefunc_def->opaque = new QIODevice_descriptor;
}

void fill_qiodevice64_filefunc (
  zlib_filefunc64_def* pzlib_filefunc_def)
{
    // Open functions are the same for Qt.
    pzlib_filefunc_def->zopen64_file = qiodevice_open_file_func;
    pzlib_filefunc_def->zread_file = qiodevice_read_file_func;
    pzlib_filefunc_def->zwrite_file = qiodevice_write_file_func;
    pzlib_filefunc_def->ztell64_file = qiodevice64_tell_file_func;
    pzlib_filefunc_def->zseek64_file = qiodevice64_seek_file_func;
    pzlib_filefunc_def->zclose_file = qiodevice_close_file_func;
    pzlib_filefunc_def->zerror_file = qiodevice_error_file_func;
    pzlib_filefunc_def->opaque = new QIODevice_descriptor;
    pzlib_filefunc_def->zfakeclose_file = qiodevice_fakeclose_file_func;
}

void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32)
{
    p_filefunc64_32->zfile_func64.zopen64_file = NULL;
    p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file;
    p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
    p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file;
    p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file;
    p_filefunc64_32->zfile_func64.ztell64_file = NULL;
    p_filefunc64_32->zfile_func64.zseek64_file = NULL;
    p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file;
    p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
    p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque;
    p_filefunc64_32->zfile_func64.zfakeclose_file = NULL;
    p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file;
    p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file;
}
Revision:	1096
Committed:	Sat Dec 30 14:40:33 2017 UTC (7 years, 10 months ago) by s10k
Content type:	text/x-c++src
File size:	11526 byte(s)
Log Message:	Added zlib, quazip, basicxmlsyntaxhighlighter, conditionalsemaphore and linenumberdisplay libraries. zlib and quazip are pre-compiled, but you can compile them yourself, just delete the dll files (or equivalent binary files to your OS)
#	Content
1	/* ioapi.c -- IO base function header for compress/uncompress .zip
2	files using zlib + zip or unzip API
3
4	Version 1.01e, February 12th, 2005
5
6	Copyright (C) 1998-2005 Gilles Vollant
7
8	Modified by Sergey A. Tachenov to integrate with Qt.
9	*/
10
11	#include <stdio.h>
12	#include <stdlib.h>
13	#include <string.h>
14
15	#include "zlib.h"
16	#include "ioapi.h"
17	#include "quazip_global.h"
18	#include <QIODevice>
19	#if (QT_VERSION >= 0x050100)
20	#define QUAZIP_QSAVEFILE_BUG_WORKAROUND
21	#endif
22	#ifdef QUAZIP_QSAVEFILE_BUG_WORKAROUND
23	#include <QSaveFile>
24	#endif
25
26	/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
27
28	#ifndef SEEK_CUR
29	#define SEEK_CUR 1
30	#endif
31
32	#ifndef SEEK_END
33	#define SEEK_END 2
34	#endif
35
36	#ifndef SEEK_SET
37	#define SEEK_SET 0
38	#endif
39
40	voidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc,voidpf file,int mode)
41	{
42	if (pfilefunc->zfile_func64.zopen64_file != NULL)
43	return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,file,mode);
44	else
45	{
46	return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,file,mode);
47	}
48	}
49
50	int call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)
51	{
52	if (pfilefunc->zfile_func64.zseek64_file != NULL)
53	return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin);
54	else
55	{
56	uLong offsetTruncated = (uLong)offset;
57	if (offsetTruncated != offset)
58	return -1;
59	else
60	return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin);
61	}
62	}
63
64	ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)
65	{
66	if (pfilefunc->zfile_func64.zseek64_file != NULL)
67	return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream);
68	else
69	{
70	uLong tell_uLong = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream);
71	if ((tell_uLong) == ((uLong)-1))
72	return (ZPOS64_T)-1;
73	else
74	return tell_uLong;
75	}
76	}
77
78	/// @cond internal
79	struct QIODevice_descriptor {
80	// Position only used for writing to sequential devices.
81	qint64 pos;
82	inline QIODevice_descriptor():
83	pos(0)
84	{}
85	};
86	/// @endcond
87
88	voidpf ZCALLBACK qiodevice_open_file_func (
89	voidpf opaque,
90	voidpf file,
91	int mode)
92	{
93	QIODevice_descriptor d = reinterpret_cast<QIODevice_descriptor>(opaque);
94	QIODevice iodevice = reinterpret_cast<QIODevice>(file);
95	QIODevice::OpenMode desiredMode;
96	if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
97	desiredMode = QIODevice::ReadOnly;
98	else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
99	desiredMode = QIODevice::ReadWrite;
100	else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
101	desiredMode = QIODevice::WriteOnly;
102	if (iodevice->isOpen()) {
103	if ((iodevice->openMode() & desiredMode) == desiredMode) {
104	if (desiredMode != QIODevice::WriteOnly
105	&& iodevice->isSequential()) {
106	// We can use sequential devices only for writing.
107	delete d;
108	return NULL;
109	} else {
110	if ((desiredMode & QIODevice::WriteOnly) != 0) {
111	// open for writing, need to seek existing device
112	if (!iodevice->isSequential()) {
113	iodevice->seek(0);
114	} else {
115	d->pos = iodevice->pos();
116	}
117	}
118	}
119	return iodevice;
120	} else {
121	delete d;
122	return NULL;
123	}
124	}
125	iodevice->open(desiredMode);
126	if (iodevice->isOpen()) {
127	if (desiredMode != QIODevice::WriteOnly && iodevice->isSequential()) {
128	// We can use sequential devices only for writing.
129	iodevice->close();
130	delete d;
131	return NULL;
132	} else {
133	return iodevice;
134	}
135	} else {
136	delete d;
137	return NULL;
138	}
139	}
140
141
142	uLong ZCALLBACK qiodevice_read_file_func (
143	voidpf opaque,
144	voidpf stream,
145	void* buf,
146	uLong size)
147	{
148	QIODevice_descriptor d = reinterpret_cast<QIODevice_descriptor>(opaque);
149	QIODevice iodevice = reinterpret_cast<QIODevice>(stream);
150	qint64 ret64 = iodevice->read((char*)buf,size);
151	uLong ret;
152	ret = (uLong) ret64;
153	if (ret64 != -1) {
154	d->pos += ret64;
155	}
156	return ret;
157	}
158
159
160	uLong ZCALLBACK qiodevice_write_file_func (
161	voidpf opaque,
162	voidpf stream,
163	const void* buf,
164	uLong size)
165	{
166	QIODevice_descriptor d = reinterpret_cast<QIODevice_descriptor>(opaque);
167	QIODevice iodevice = reinterpret_cast<QIODevice>(stream);
168	uLong ret;
169	qint64 ret64 = iodevice->write((char*)buf,size);
170	if (ret64 != -1) {
171	d->pos += ret64;
172	}
173	ret = (uLong) ret64;
174	return ret;
175	}
176
177	uLong ZCALLBACK qiodevice_tell_file_func (
178	voidpf opaque,
179	voidpf stream)
180	{
181	QIODevice_descriptor d = reinterpret_cast<QIODevice_descriptor>(opaque);
182	QIODevice iodevice = reinterpret_cast<QIODevice>(stream);
183	uLong ret;
184	qint64 ret64;
185	if (iodevice->isSequential()) {
186	ret64 = d->pos;
187	} else {
188	ret64 = iodevice->pos();
189	}
190	ret = static_cast<uLong>(ret64);
191	return ret;
192	}
193
194	ZPOS64_T ZCALLBACK qiodevice64_tell_file_func (
195	voidpf opaque,
196	voidpf stream)
197	{
198	QIODevice_descriptor d = reinterpret_cast<QIODevice_descriptor>(opaque);
199	QIODevice iodevice = reinterpret_cast<QIODevice>(stream);
200	qint64 ret;
201	if (iodevice->isSequential()) {
202	ret = d->pos;
203	} else {
204	ret = iodevice->pos();
205	}
206	return static_cast<ZPOS64_T>(ret);
207	}
208
209	int ZCALLBACK qiodevice_seek_file_func (
210	voidpf /opaque UNUSED/,
211	voidpf stream,
212	uLong offset,
213	int origin)
214	{
215	QIODevice iodevice = reinterpret_cast<QIODevice>(stream);
216	if (iodevice->isSequential()) {
217	if (origin == ZLIB_FILEFUNC_SEEK_END
218	&& offset == 0) {
219	// sequential devices are always at end (needed in mdAppend)
220	return 0;
221	} else {
222	qWarning("qiodevice_seek_file_func() called for sequential device");
223	return -1;
224	}
225	}
226	uLong qiodevice_seek_result=0;
227	int ret;
228	switch (origin)
229	{
230	case ZLIB_FILEFUNC_SEEK_CUR :
231	qiodevice_seek_result = ((QIODevice*)stream)->pos() + offset;
232	break;
233	case ZLIB_FILEFUNC_SEEK_END :
234	qiodevice_seek_result = ((QIODevice*)stream)->size() - offset;
235	break;
236	case ZLIB_FILEFUNC_SEEK_SET :
237	qiodevice_seek_result = offset;
238	break;
239	default:
240	return -1;
241	}
242	ret = !iodevice->seek(qiodevice_seek_result);
243	return ret;
244	}
245
246	int ZCALLBACK qiodevice64_seek_file_func (
247	voidpf /opaque UNUSED/,
248	voidpf stream,
249	ZPOS64_T offset,
250	int origin)
251	{
252	QIODevice iodevice = reinterpret_cast<QIODevice>(stream);
253	if (iodevice->isSequential()) {
254	if (origin == ZLIB_FILEFUNC_SEEK_END
255	&& offset == 0) {
256	// sequential devices are always at end (needed in mdAppend)
257	return 0;
258	} else {
259	qWarning("qiodevice_seek_file_func() called for sequential device");
260	return -1;
261	}
262	}
263	qint64 qiodevice_seek_result=0;
264	int ret;
265	switch (origin)
266	{
267	case ZLIB_FILEFUNC_SEEK_CUR :
268	qiodevice_seek_result = ((QIODevice*)stream)->pos() + offset;
269	break;
270	case ZLIB_FILEFUNC_SEEK_END :
271	qiodevice_seek_result = ((QIODevice*)stream)->size() - offset;
272	break;
273	case ZLIB_FILEFUNC_SEEK_SET :
274	qiodevice_seek_result = offset;
275	break;
276	default:
277	return -1;
278	}
279	ret = !iodevice->seek(qiodevice_seek_result);
280	return ret;
281	}
282
283	int ZCALLBACK qiodevice_close_file_func (
284	voidpf opaque,
285	voidpf stream)
286	{
287	QIODevice_descriptor d = reinterpret_cast<QIODevice_descriptor>(opaque);
288	delete d;
289	QIODevice device = reinterpret_cast<QIODevice>(stream);
290	#ifdef QUAZIP_QSAVEFILE_BUG_WORKAROUND
291	// QSaveFile terribly breaks the is-a idiom:
292	// it IS a QIODevice, but it is NOT compatible with it: close() is private
293	QSaveFile file = qobject_cast<QSaveFile>(device);
294	if (file != NULL) {
295	// We have to call the ugly commit() instead:
296	return file->commit() ? 0 : -1;
297	}
298	#endif
299	device->close();
300	return 0;
301	}
302
303	int ZCALLBACK qiodevice_fakeclose_file_func (
304	voidpf opaque,
305	voidpf /stream/)
306	{
307	QIODevice_descriptor d = reinterpret_cast<QIODevice_descriptor>(opaque);
308	delete d;
309	return 0;
310	}
311
312	int ZCALLBACK qiodevice_error_file_func (
313	voidpf /opaque UNUSED/,
314	voidpf /stream UNUSED/)
315	{
316	// can't check for error due to the QIODevice API limitation
317	return 0;
318	}
319
320	void fill_qiodevice_filefunc (
321	zlib_filefunc_def* pzlib_filefunc_def)
322	{
323	pzlib_filefunc_def->zopen_file = qiodevice_open_file_func;
324	pzlib_filefunc_def->zread_file = qiodevice_read_file_func;
325	pzlib_filefunc_def->zwrite_file = qiodevice_write_file_func;
326	pzlib_filefunc_def->ztell_file = qiodevice_tell_file_func;
327	pzlib_filefunc_def->zseek_file = qiodevice_seek_file_func;
328	pzlib_filefunc_def->zclose_file = qiodevice_close_file_func;
329	pzlib_filefunc_def->zerror_file = qiodevice_error_file_func;
330	pzlib_filefunc_def->opaque = new QIODevice_descriptor;
331	}
332
333	void fill_qiodevice64_filefunc (
334	zlib_filefunc64_def* pzlib_filefunc_def)
335	{
336	// Open functions are the same for Qt.
337	pzlib_filefunc_def->zopen64_file = qiodevice_open_file_func;
338	pzlib_filefunc_def->zread_file = qiodevice_read_file_func;
339	pzlib_filefunc_def->zwrite_file = qiodevice_write_file_func;
340	pzlib_filefunc_def->ztell64_file = qiodevice64_tell_file_func;
341	pzlib_filefunc_def->zseek64_file = qiodevice64_seek_file_func;
342	pzlib_filefunc_def->zclose_file = qiodevice_close_file_func;
343	pzlib_filefunc_def->zerror_file = qiodevice_error_file_func;
344	pzlib_filefunc_def->opaque = new QIODevice_descriptor;
345	pzlib_filefunc_def->zfakeclose_file = qiodevice_fakeclose_file_func;
346	}
347
348	void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32)
349	{
350	p_filefunc64_32->zfile_func64.zopen64_file = NULL;
351	p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file;
352	p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
353	p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file;
354	p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file;
355	p_filefunc64_32->zfile_func64.ztell64_file = NULL;
356	p_filefunc64_32->zfile_func64.zseek64_file = NULL;
357	p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file;
358	p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
359	p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque;
360	p_filefunc64_32->zfile_func64.zfakeclose_file = NULL;
361	p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file;
362	p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file;
363	}