added pumping events when waiting for screen redraw
[rocksndiamonds.git] / src / libgame / zip / iowin32.c
1 /* iowin32.c -- IO base function header for compress/uncompress .zip
2    Version 1.2.0, September 16th, 2017
3    part of the MiniZip project
4
5    Copyright (C) 2012-2017 Nathan Moinvaziri
6      https://github.com/nmoinvaz/minizip
7    Copyright (C) 2009-2010 Mathias Svensson
8      Modifications for Zip64 support
9      http://result42.com
10    Copyright (C) 1998-2010 Gilles Vollant
11      http://www.winimage.com/zLibDll/minizip.html
12
13    This program is distributed under the terms of the same license as zlib.
14    See the accompanying LICENSE file for the full text of the license.
15 */
16
17 #ifdef _WIN32
18
19 #include <stdlib.h>
20 #include <tchar.h>
21
22 #include "zlib.h"
23 #include "ioapi.h"
24 #include "iowin32.h"
25
26 #ifndef INVALID_HANDLE_VALUE
27 #  define INVALID_HANDLE_VALUE (0xFFFFFFFF)
28 #endif
29
30 #ifndef INVALID_SET_FILE_POINTER
31 #  define INVALID_SET_FILE_POINTER ((DWORD)-1)
32 #endif
33
34 #if defined(WINAPI_FAMILY_PARTITION) && (!(defined(IOWIN32_USING_WINRT_API)))
35 #  if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
36 #    define IOWIN32_USING_WINRT_API 1
37 #  endif
38 #endif
39
40 voidpf   ZCALLBACK win32_open_file_func     (voidpf opaque, const char *filename, int mode);
41 uint32_t ZCALLBACK win32_read_file_func     (voidpf opaque, voidpf stream, void* buf, uint32_t size);
42 uint32_t ZCALLBACK win32_write_file_func    (voidpf opaque, voidpf stream, const void *buf, uint32_t size);
43 uint64_t ZCALLBACK win32_tell64_file_func   (voidpf opaque, voidpf stream);
44 long     ZCALLBACK win32_seek64_file_func   (voidpf opaque, voidpf stream, uint64_t offset, int origin);
45 int      ZCALLBACK win32_close_file_func    (voidpf opaque, voidpf stream);
46 int      ZCALLBACK win32_error_file_func    (voidpf opaque, voidpf stream);
47
48 typedef struct
49 {
50     HANDLE hf;
51     int error;
52     void *filename;
53     int filenameLength;
54 } WIN32FILE_IOWIN;
55
56
57 static void win32_translate_open_mode(int mode,
58                                       DWORD* lpdwDesiredAccess,
59                                       DWORD* lpdwCreationDisposition,
60                                       DWORD* lpdwShareMode,
61                                       DWORD* lpdwFlagsAndAttributes)
62 {
63     *lpdwDesiredAccess = 0;
64     *lpdwShareMode = 0;
65     *lpdwCreationDisposition = 0;
66     *lpdwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
67
68     if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ)
69     {
70         *lpdwDesiredAccess = GENERIC_READ;
71         *lpdwCreationDisposition = OPEN_EXISTING;
72         *lpdwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
73     }
74     else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
75     {
76         *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
77         *lpdwCreationDisposition = OPEN_EXISTING;
78     }
79     else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
80     {
81         *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
82         *lpdwCreationDisposition = CREATE_ALWAYS;
83     }
84 }
85
86 static voidpf win32_build_iowin(HANDLE hFile)
87 {
88     WIN32FILE_IOWIN *iowin = NULL;
89
90     if ((hFile != NULL) && (hFile != INVALID_HANDLE_VALUE))
91     {
92         iowin = (WIN32FILE_IOWIN *)malloc(sizeof(WIN32FILE_IOWIN));
93         if (iowin == NULL)
94         {
95             CloseHandle(hFile);
96             return NULL;
97         }
98         memset(iowin, 0, sizeof(WIN32FILE_IOWIN));
99         iowin->hf = hFile;
100     }
101     return (voidpf)iowin;
102 }
103
104 static voidpf ZCALLBACK win32_open64_file_func(voidpf opaque, const void *filename, int mode)
105 {
106     DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes;
107     HANDLE hFile = NULL;
108     WIN32FILE_IOWIN *iowin = NULL;
109
110     win32_translate_open_mode(mode, &dwDesiredAccess, &dwCreationDisposition, &dwShareMode, &dwFlagsAndAttributes);
111
112     if ((filename != NULL) && (dwDesiredAccess != 0))
113     {
114 #ifdef IOWIN32_USING_WINRT_API
115 #ifdef UNICODE
116         hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
117 #else
118         WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
119         MultiByteToWideChar(CP_ACP, 0, (const char*)filename, -1, filenameW, FILENAME_MAX + 0x200);
120         hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
121 #endif
122 #else
123         hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
124 #endif
125     }
126
127     iowin = win32_build_iowin(hFile);
128     if (iowin == NULL)
129         return NULL;
130     iowin->filenameLength = _tcslen(filename) + 1;
131     iowin->filename = (void*)malloc(iowin->filenameLength * sizeof(TCHAR));
132     _tcsncpy(iowin->filename, filename, iowin->filenameLength);
133     return iowin;
134 }
135
136 static voidpf ZCALLBACK win32_open64_file_funcA(voidpf opaque, const void *filename, int mode)
137 {
138     DWORD dwDesiredAccess, dwCreationDisposition, dwShareMode, dwFlagsAndAttributes ;
139     HANDLE hFile = NULL;
140     WIN32FILE_IOWIN *iowin = NULL;
141
142     win32_translate_open_mode(mode, &dwDesiredAccess, &dwCreationDisposition, &dwShareMode, &dwFlagsAndAttributes);
143
144     if ((filename != NULL) && (dwDesiredAccess != 0))
145     {
146 #ifdef IOWIN32_USING_WINRT_API
147         WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
148         MultiByteToWideChar(CP_ACP, 0, (const char*)filename, -1, filenameW, FILENAME_MAX + 0x200);
149         hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
150 #else
151         hFile = CreateFileA((LPCSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
152 #endif
153     }
154
155     iowin = win32_build_iowin(hFile);
156     if (iowin == NULL)
157         return NULL;
158     iowin->filenameLength = strlen(filename) + 1;
159     iowin->filename = (void*)malloc(iowin->filenameLength * sizeof(char));
160     strncpy(iowin->filename, filename, iowin->filenameLength);
161     return iowin;
162 }
163
164 static voidpf ZCALLBACK win32_open64_file_funcW(voidpf opaque, const void *filename, int mode)
165 {
166     DWORD dwDesiredAccess, dwCreationDisposition, dwShareMode, dwFlagsAndAttributes;
167     HANDLE hFile = NULL;
168     WIN32FILE_IOWIN *iowin = NULL;
169
170     win32_translate_open_mode(mode, &dwDesiredAccess, &dwCreationDisposition, &dwShareMode, &dwFlagsAndAttributes);
171
172     if ((filename != NULL) && (dwDesiredAccess != 0))
173     {
174 #ifdef IOWIN32_USING_WINRT_API
175         hFile = CreateFile2((LPCWSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
176 #else
177         hFile = CreateFileW((LPCWSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
178 #endif
179     }
180
181     iowin = win32_build_iowin(hFile);
182     if (iowin == NULL)
183         return NULL;
184     if (iowin->filename == NULL)
185     {
186         iowin->filenameLength = wcslen(filename) + 1;
187         iowin->filename = (void*)malloc(iowin->filenameLength * sizeof(WCHAR));
188         wcsncpy(iowin->filename, filename, iowin->filenameLength);
189     }
190     return iowin;
191 }
192
193 voidpf ZCALLBACK win32_open_file_func(voidpf opaque, const char *filename, int mode)
194 {
195     DWORD dwDesiredAccess, dwCreationDisposition, dwShareMode, dwFlagsAndAttributes ;
196     HANDLE hFile = NULL;
197     WIN32FILE_IOWIN *iowin = NULL;
198
199     win32_translate_open_mode(mode, &dwDesiredAccess, &dwCreationDisposition, &dwShareMode, &dwFlagsAndAttributes);
200
201     if ((filename != NULL) && (dwDesiredAccess != 0))
202     {
203 #ifdef IOWIN32_USING_WINRT_API
204 #ifdef UNICODE
205         hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
206 #else
207         WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
208         MultiByteToWideChar(CP_ACP, 0, (const char*)filename, -1, filenameW, FILENAME_MAX + 0x200);
209         hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
210 #endif
211 #else
212         hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
213 #endif
214     }
215
216     iowin = win32_build_iowin(hFile);
217     if (iowin == NULL)
218         return NULL;
219     iowin->filenameLength = _tcslen((TCHAR*)filename) + 1;
220     iowin->filename = (void*)malloc(iowin->filenameLength * sizeof(TCHAR));
221     _tcsncpy(iowin->filename, (TCHAR*)filename, iowin->filenameLength);
222     return iowin;
223 }
224
225 static voidpf ZCALLBACK win32_opendisk64_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode)
226 {
227     WIN32FILE_IOWIN *iowin = NULL;
228     TCHAR *diskFilename = NULL;
229     voidpf ret = NULL;
230     int i = 0;
231
232     if (stream == NULL)
233         return NULL;
234     iowin = (WIN32FILE_IOWIN*)stream;
235     diskFilename = (TCHAR*)malloc(iowin->filenameLength * sizeof(TCHAR));
236     _tcsncpy(diskFilename, iowin->filename, iowin->filenameLength);
237     for (i = iowin->filenameLength - 1; i >= 0; i -= 1)
238     {
239         if (diskFilename[i] != _T('.'))
240             continue;
241         _sntprintf(&diskFilename[i], iowin->filenameLength - i, _T(".z%02d"), number_disk + 1);
242         break;
243     }
244     if (i >= 0)
245         ret = win32_open64_file_func(opaque, (char*)diskFilename, mode);
246     free(diskFilename);
247     return ret;
248 }
249
250 static voidpf ZCALLBACK win32_opendisk64_file_funcW(voidpf opaque, voidpf stream, uint32_t number_disk, int mode)
251 {
252     WIN32FILE_IOWIN *iowin = NULL;
253     WCHAR *diskFilename = NULL;
254     voidpf ret = NULL;
255     int i = 0;
256
257     if (stream == NULL)
258         return NULL;
259     iowin = (WIN32FILE_IOWIN*)stream;
260     diskFilename = (WCHAR*)malloc((iowin->filenameLength + 10) * sizeof(WCHAR));
261     wcsncpy(diskFilename, iowin->filename, iowin->filenameLength);
262     for (i = iowin->filenameLength - 1; i >= 0; i -= 1)
263     {
264         if (diskFilename[i] != L'.')
265             continue;
266         _snwprintf(&diskFilename[i], (iowin->filenameLength + 10) - i, L".z%02d", number_disk + 1);
267         break;
268     }
269     if (i >= 0)
270         ret = win32_open64_file_funcW(opaque, diskFilename, mode);
271     free(diskFilename);
272     return ret;
273 }
274
275 static voidpf ZCALLBACK win32_opendisk64_file_funcA(voidpf opaque, voidpf stream, uint32_t number_disk, int mode)
276 {
277     WIN32FILE_IOWIN *iowin = NULL;
278     char *diskFilename = NULL;
279     voidpf ret = NULL;
280     int i = 0;
281
282     if (stream == NULL)
283         return NULL;
284     iowin = (WIN32FILE_IOWIN*)stream;
285     diskFilename = (char*)malloc(iowin->filenameLength * sizeof(char));
286     strncpy(diskFilename, iowin->filename, iowin->filenameLength);
287     for (i = iowin->filenameLength - 1; i >= 0; i -= 1)
288     {
289         if (diskFilename[i] != '.')
290             continue;
291         _snprintf(&diskFilename[i], iowin->filenameLength - i, ".z%02d", number_disk + 1);
292         break;
293     }
294     if (i >= 0)
295         ret = win32_open64_file_funcA(opaque, diskFilename, mode);
296     free(diskFilename);
297     return ret;
298 }
299
300 static voidpf ZCALLBACK win32_opendisk_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode)
301 {
302     WIN32FILE_IOWIN *iowin = NULL;
303     TCHAR *diskFilename = NULL;
304     voidpf ret = NULL;
305     int i = 0;
306
307     if (stream == NULL)
308         return NULL;
309     iowin = (WIN32FILE_IOWIN*)stream;
310     diskFilename = (TCHAR*)malloc(iowin->filenameLength * sizeof(TCHAR));
311     _tcsncpy(diskFilename, iowin->filename, iowin->filenameLength);
312     for (i = iowin->filenameLength - 1; i >= 0; i -= 1)
313     {
314         if (diskFilename[i] != _T('.'))
315             continue;
316         _sntprintf(&diskFilename[i], iowin->filenameLength - i, _T(".z%02d"), number_disk + 1);
317         break;
318     }
319     if (i >= 0)
320         ret = win32_open_file_func(opaque, (char*)diskFilename, mode);
321     free(diskFilename);
322     return ret;
323 }
324
325 uint32_t ZCALLBACK win32_read_file_func(voidpf opaque, voidpf stream, void* buf, uint32_t size)
326 {
327     DWORD ret = 0;
328     HANDLE hFile = NULL;
329     if (stream != NULL)
330         hFile = ((WIN32FILE_IOWIN*)stream)->hf;
331
332     if (hFile != NULL)
333     {
334         if (!ReadFile(hFile, buf, size, &ret, NULL))
335         {
336             DWORD dwErr = GetLastError();
337             if (dwErr == ERROR_HANDLE_EOF)
338                 dwErr = 0;
339             ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr;
340         }
341     }
342
343     return (uint32_t)ret;
344 }
345
346 uint32_t ZCALLBACK win32_write_file_func(voidpf opaque, voidpf stream, const void *buf, uint32_t size)
347 {
348     DWORD ret = 0;
349     HANDLE hFile = NULL;
350     if (stream != NULL)
351         hFile = ((WIN32FILE_IOWIN*)stream)->hf;
352
353     if (hFile != NULL)
354     {
355         if (!WriteFile(hFile, buf, size, &ret, NULL))
356         {
357             DWORD dwErr = GetLastError();
358             if (dwErr == ERROR_HANDLE_EOF)
359                 dwErr = 0;
360             ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr;
361         }
362     }
363
364     return (uint32_t)ret;
365 }
366
367 static BOOL win32_setfilepointer_internal(HANDLE hFile, LARGE_INTEGER pos, LARGE_INTEGER *newPos, DWORD dwMoveMethod)
368 {
369 #ifdef IOWIN32_USING_WINRT_API
370     return SetFilePointerEx(hFile, pos, newPos, dwMoveMethod);
371 #else
372     LONG lHigh = pos.HighPart;
373     BOOL ret = TRUE;
374     DWORD dwNewPos = SetFilePointer(hFile, pos.LowPart, &lHigh, dwMoveMethod);
375     if ((dwNewPos == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR))
376         ret = FALSE;
377     if ((newPos != NULL) && (ret))
378     {
379         newPos->LowPart = dwNewPos;
380         newPos->HighPart = lHigh;
381     }
382     return ret;
383 #endif
384 }
385
386 static long ZCALLBACK win32_tell_file_func(voidpf opaque, voidpf stream)
387 {
388     long ret = -1;
389     HANDLE hFile = NULL;
390     if (stream != NULL)
391         hFile = ((WIN32FILE_IOWIN*)stream)->hf;
392     if (hFile != NULL)
393     {
394         LARGE_INTEGER pos;
395         pos.QuadPart = 0;
396         if (!win32_setfilepointer_internal(hFile, pos, &pos, FILE_CURRENT))
397         {
398             DWORD dwErr = GetLastError();
399             ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr;
400             ret = -1;
401         }
402         else
403             ret = (long)pos.LowPart;
404     }
405     return ret;
406 }
407
408 uint64_t ZCALLBACK win32_tell64_file_func(voidpf opaque, voidpf stream)
409 {
410     uint64_t ret = (uint64_t)-1;
411     HANDLE hFile = NULL;
412     if (stream != NULL)
413         hFile = ((WIN32FILE_IOWIN*)stream)->hf;
414
415     if (hFile)
416     {
417         LARGE_INTEGER pos;
418         pos.QuadPart = 0;
419         if (!win32_setfilepointer_internal(hFile, pos, &pos, FILE_CURRENT))
420         {
421             DWORD dwErr = GetLastError();
422             ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr;
423             ret = (uint64_t)-1;
424         }
425         else
426             ret = pos.QuadPart;
427     }
428     return ret;
429 }
430
431 static long ZCALLBACK win32_seek_file_func(voidpf opaque, voidpf stream, uint32_t offset, int origin)
432 {
433     DWORD dwMoveMethod = 0xFFFFFFFF;
434     HANDLE hFile = NULL;
435     long ret = -1;
436
437     if (stream != NULL)
438         hFile = ((WIN32FILE_IOWIN*)stream)->hf;
439
440     switch (origin)
441     {
442         case ZLIB_FILEFUNC_SEEK_CUR:
443             dwMoveMethod = FILE_CURRENT;
444             break;
445         case ZLIB_FILEFUNC_SEEK_END:
446             dwMoveMethod = FILE_END;
447             break;
448         case ZLIB_FILEFUNC_SEEK_SET:
449             dwMoveMethod = FILE_BEGIN;
450             break;
451         default:
452             return -1;
453     }
454
455     if (hFile != NULL)
456     {
457         LARGE_INTEGER pos;
458         pos.QuadPart = offset;
459         if (!win32_setfilepointer_internal(hFile, pos, NULL, dwMoveMethod))
460         {
461             DWORD dwErr = GetLastError();
462             ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr;
463             ret = -1;
464         }
465         else
466             ret = 0;
467     }
468     return ret;
469 }
470
471 long ZCALLBACK win32_seek64_file_func(voidpf opaque, voidpf stream, uint64_t offset, int origin)
472 {
473     DWORD dwMoveMethod = 0xFFFFFFFF;
474     HANDLE hFile = NULL;
475     long ret = -1;
476
477     if (stream != NULL)
478         hFile = ((WIN32FILE_IOWIN*)stream)->hf;
479
480     switch (origin)
481     {
482         case ZLIB_FILEFUNC_SEEK_CUR:
483             dwMoveMethod = FILE_CURRENT;
484             break;
485         case ZLIB_FILEFUNC_SEEK_END:
486             dwMoveMethod = FILE_END;
487             break;
488         case ZLIB_FILEFUNC_SEEK_SET:
489             dwMoveMethod = FILE_BEGIN;
490             break;
491         default:
492             return -1;
493     }
494
495     if (hFile)
496     {
497         LARGE_INTEGER pos;
498         pos.QuadPart = offset;
499         if (!win32_setfilepointer_internal(hFile, pos, NULL, dwMoveMethod))
500         {
501             DWORD dwErr = GetLastError();
502             ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr;
503             ret = -1;
504         }
505         else
506             ret = 0;
507     }
508     return ret;
509 }
510
511 int ZCALLBACK win32_close_file_func(voidpf opaque, voidpf stream)
512 {
513     WIN32FILE_IOWIN* iowin = NULL;
514     int ret = -1;
515
516     if (stream == NULL)
517         return ret;
518     iowin = ((WIN32FILE_IOWIN*)stream);
519     if (iowin->filename != NULL)
520         free(iowin->filename);
521     if (iowin->hf != NULL)
522     {
523         CloseHandle(iowin->hf);
524         ret=0;
525     }
526     free(stream);
527     return ret;
528 }
529
530 int ZCALLBACK win32_error_file_func(voidpf opaque, voidpf stream)
531 {
532     int ret = -1;
533     if (stream == NULL)
534         return ret;
535     ret = ((WIN32FILE_IOWIN*)stream)->error;
536     return ret;
537 }
538
539 void fill_win32_filefunc(zlib_filefunc_def *pzlib_filefunc_def)
540 {
541     pzlib_filefunc_def->zopen_file = win32_open_file_func;
542     pzlib_filefunc_def->zopendisk_file = win32_opendisk_file_func;
543     pzlib_filefunc_def->zread_file = win32_read_file_func;
544     pzlib_filefunc_def->zwrite_file = win32_write_file_func;
545     pzlib_filefunc_def->ztell_file = win32_tell_file_func;
546     pzlib_filefunc_def->zseek_file = win32_seek_file_func;
547     pzlib_filefunc_def->zclose_file = win32_close_file_func;
548     pzlib_filefunc_def->zerror_file = win32_error_file_func;
549     pzlib_filefunc_def->opaque = NULL;
550 }
551
552 void fill_win32_filefunc64(zlib_filefunc64_def *pzlib_filefunc_def)
553 {
554     pzlib_filefunc_def->zopen64_file = win32_open64_file_func;
555     pzlib_filefunc_def->zopendisk64_file = win32_opendisk64_file_func;
556     pzlib_filefunc_def->zread_file = win32_read_file_func;
557     pzlib_filefunc_def->zwrite_file = win32_write_file_func;
558     pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
559     pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
560     pzlib_filefunc_def->zclose_file = win32_close_file_func;
561     pzlib_filefunc_def->zerror_file = win32_error_file_func;
562     pzlib_filefunc_def->opaque = NULL;
563 }
564
565 void fill_win32_filefunc64A(zlib_filefunc64_def *pzlib_filefunc_def)
566 {
567     pzlib_filefunc_def->zopen64_file = win32_open64_file_funcA;
568     pzlib_filefunc_def->zopendisk64_file = win32_opendisk64_file_funcA;
569     pzlib_filefunc_def->zread_file = win32_read_file_func;
570     pzlib_filefunc_def->zwrite_file = win32_write_file_func;
571     pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
572     pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
573     pzlib_filefunc_def->zclose_file = win32_close_file_func;
574     pzlib_filefunc_def->zerror_file = win32_error_file_func;
575     pzlib_filefunc_def->opaque = NULL;
576 }
577
578 void fill_win32_filefunc64W(zlib_filefunc64_def *pzlib_filefunc_def)
579 {
580     pzlib_filefunc_def->zopen64_file = win32_open64_file_funcW;
581     pzlib_filefunc_def->zopendisk64_file = win32_opendisk64_file_funcW;
582     pzlib_filefunc_def->zread_file = win32_read_file_func;
583     pzlib_filefunc_def->zwrite_file = win32_write_file_func;
584     pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
585     pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
586     pzlib_filefunc_def->zclose_file = win32_close_file_func;
587     pzlib_filefunc_def->zerror_file = win32_error_file_func;
588     pzlib_filefunc_def->opaque = NULL;
589 }
590
591 #endif // _WIN32