zlib 1.0.7
This commit is contained in:
Mark Adler
21
contrib/README.contrib
Normal file
21
contrib/README.contrib
Normal file
@@ -0,0 +1,21 @@
|
||||
All files under this contrib directory are UNSUPPORTED. There were
|
||||
provided by users of zlib and were not tested by the authors of zlib.
|
||||
Use at your own risk. Please contact the authors of the contributions
|
||||
for help about these, not the zlib authors. Thanks.
|
||||
|
||||
|
||||
asm386/ by Gilles Vollant <info@winimage.com>
|
||||
386 asm code replacing longest_match(). This code may be slower
|
||||
than the C code if you have a good compiler.
|
||||
|
||||
iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
|
||||
A C++ I/O streams interface to the zlib gz* functions
|
||||
|
||||
iostream2/ by Tyge L<>vset <Tyge.Lovset@cmr.no>
|
||||
Another C++ I/O streams interface
|
||||
|
||||
untgz/ by "Pedro A. Aranda Guti\irrez" <paag@tid.es>
|
||||
A very simple tar.gz file extractor using zlib
|
||||
|
||||
visual-basic.txt by Carlos Rios <c_rios@sonda.cl>
|
||||
How to use compress(), uncompress() and the gz* functions from VB.
|
||||
464
contrib/asm386/gvmat32.asm
Normal file
464
contrib/asm386/gvmat32.asm
Normal file
@@ -0,0 +1,464 @@
|
||||
;
|
||||
; gvmat32.asm -- Asm portion of the optimized longest_match for 32 bits x86
|
||||
; Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant.
|
||||
; File written by Gilles Vollant, by modifiying the longest_match
|
||||
; from Jean-loup Gailly in deflate.c
|
||||
; It need wmask == 0x7fff
|
||||
; (assembly code is faster with a fixed wmask)
|
||||
;
|
||||
; For Visual C++ 4.2 and ML 6.11c (version in directory \MASM611C of Win95 DDK)
|
||||
; I compile with : "ml /coff /Zi /c gvmat32.asm"
|
||||
;
|
||||
; uInt longest_match_gvasm(IPos cur_match,int* match_start_ptr,uInt scan_end,
|
||||
; uInt scan_start,ush* prev,uch* window,int best_len,
|
||||
; IPos limit,uInt chain_length,uch* scanrp,
|
||||
; uInt nice_match);
|
||||
|
||||
;uInt longest_match(s, cur_match)
|
||||
; deflate_state *s;
|
||||
; IPos cur_match; /* current match */
|
||||
|
||||
NbStack equ 76
|
||||
cur_match equ dword ptr[esp+NbStack-0]
|
||||
str_s equ dword ptr[esp+NbStack-4]
|
||||
; 5 dword on top (ret,ebp,esi,edi,ebx)
|
||||
adrret equ dword ptr[esp+NbStack-8]
|
||||
pushebp equ dword ptr[esp+NbStack-12]
|
||||
pushedi equ dword ptr[esp+NbStack-16]
|
||||
pushesi equ dword ptr[esp+NbStack-20]
|
||||
pushebx equ dword ptr[esp+NbStack-24]
|
||||
|
||||
chain_length equ dword ptr [esp+NbStack-28]
|
||||
limit equ dword ptr [esp+NbStack-32]
|
||||
best_len equ dword ptr [esp+NbStack-36]
|
||||
window equ dword ptr [esp+NbStack-40]
|
||||
prev equ dword ptr [esp+NbStack-44]
|
||||
scan_start equ word ptr [esp+NbStack-48]
|
||||
scan_end equ word ptr [esp+NbStack-52]
|
||||
match_start_ptr equ dword ptr [esp+NbStack-56]
|
||||
nice_match equ dword ptr [esp+NbStack-60]
|
||||
scanrp equ dword ptr [esp+NbStack-64]
|
||||
|
||||
windowlen equ dword ptr [esp+NbStack-68]
|
||||
match_start equ dword ptr [esp+NbStack-72]
|
||||
strend equ dword ptr [esp+NbStack-76]
|
||||
NbStackAdd equ (76-24)
|
||||
|
||||
.386p
|
||||
|
||||
name gvmatch
|
||||
.MODEL FLAT
|
||||
|
||||
|
||||
@lmtype TYPEDEF PROTO C :PTR , :SDWORD
|
||||
longest_match_c PROTO @lmtype
|
||||
|
||||
dep_max_chain_length equ 70h
|
||||
dep_window equ 2ch
|
||||
dep_strstart equ 60h
|
||||
dep_prev_length equ 6ch
|
||||
dep_nice_match equ 84h
|
||||
dep_w_size equ 20h
|
||||
dep_prev equ 34h
|
||||
dep_w_mask equ 28h
|
||||
dep_good_match equ 80h
|
||||
dep_match_start equ 64h
|
||||
dep_lookahead equ 68h
|
||||
|
||||
|
||||
_TEXT segment
|
||||
public _longest_match_asm7fff
|
||||
|
||||
MAX_MATCH equ 258
|
||||
MIN_MATCH equ 3
|
||||
MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1)
|
||||
|
||||
; initialize or check the variables used in match.asm.
|
||||
|
||||
|
||||
; -----------------------------------------------------------------------
|
||||
; Set match_start to the longest match starting at the given string and
|
||||
; return its length. Matches shorter or equal to prev_length are discarded,
|
||||
; in which case the result is equal to prev_length and match_start is
|
||||
; garbage.
|
||||
; IN assertions: cur_match is the head of the hash chain for the current
|
||||
; string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
|
||||
|
||||
; int longest_match(cur_match)
|
||||
|
||||
_longest_match_asm7fff proc near
|
||||
|
||||
|
||||
|
||||
; return address
|
||||
|
||||
mov eax,[esp+4]
|
||||
mov bx,[eax+dep_w_mask]
|
||||
cmp bx,7fffh
|
||||
jnz longest_match_c
|
||||
|
||||
push ebp
|
||||
push edi
|
||||
push esi
|
||||
push ebx
|
||||
|
||||
sub esp,NbStackAdd
|
||||
|
||||
;//mov ebp,str_s
|
||||
mov ebp,eax
|
||||
|
||||
mov eax,[ebp+dep_max_chain_length]
|
||||
mov ebx,[ebp+dep_prev_length]
|
||||
cmp [ebp+dep_good_match],ebx ; if prev_length>=good_match chain_length >>= 2
|
||||
ja noshr
|
||||
shr eax,2
|
||||
noshr:
|
||||
mov edi,[ebp+dep_nice_match]
|
||||
mov chain_length,eax
|
||||
mov edx,[ebp+dep_lookahead]
|
||||
cmp edx,edi
|
||||
;if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
|
||||
jae nolookaheadnicematch
|
||||
mov edi,edx
|
||||
nolookaheadnicematch:
|
||||
mov best_len,ebx
|
||||
|
||||
|
||||
mov esi,[ebp+dep_window]
|
||||
mov ecx,[ebp+dep_strstart]
|
||||
mov window,esi
|
||||
|
||||
mov nice_match,edi
|
||||
add esi,ecx
|
||||
mov scanrp,esi
|
||||
mov ax,word ptr [esi]
|
||||
mov bx,word ptr [esi+ebx-1]
|
||||
add esi,MAX_MATCH-1
|
||||
mov scan_start,ax
|
||||
mov strend,esi
|
||||
mov scan_end,bx
|
||||
|
||||
; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
|
||||
; s->strstart - (IPos)MAX_DIST(s) : NIL;
|
||||
|
||||
mov esi,[ebp+dep_w_size]
|
||||
sub esi,MIN_LOOKAHEAD
|
||||
; here esi = MAX_DIST(s)
|
||||
sub ecx,esi
|
||||
ja nodist
|
||||
xor ecx,ecx
|
||||
nodist:
|
||||
mov limit,ecx
|
||||
|
||||
|
||||
|
||||
|
||||
mov eax,[ebp+dep_prev]
|
||||
mov prev,eax
|
||||
|
||||
mov ebx,dword ptr [ebp+dep_match_start]
|
||||
mov bp,scan_start
|
||||
mov edx,cur_match
|
||||
mov match_start,ebx
|
||||
|
||||
mov bx,scan_end
|
||||
mov eax,window
|
||||
mov edi,eax
|
||||
add edi,best_len
|
||||
mov esi,prev
|
||||
dec edi
|
||||
mov windowlen,edi
|
||||
|
||||
jmp beginloop2
|
||||
align 4
|
||||
|
||||
; here, in the loop
|
||||
;;;; eax = chain_length
|
||||
; edx = dx = cur_match
|
||||
; ecx = limit
|
||||
; bx = scan_end
|
||||
; bp = scan_start
|
||||
; edi = windowlen (window + best_len)
|
||||
; esi = prev
|
||||
|
||||
|
||||
;// here; eax <=16
|
||||
normalbeg0add16:
|
||||
add chain_length,16
|
||||
jz exitloop
|
||||
normalbeg0:
|
||||
cmp word ptr[edi+edx-0],bx
|
||||
je normalbeg2
|
||||
and edx,7fffh
|
||||
mov dx,word ptr[esi+edx*2]
|
||||
cmp ecx,edx
|
||||
jnb exitloop
|
||||
dec chain_length
|
||||
jnz normalbeg0
|
||||
;jnbexitloopshort1:
|
||||
jmp exitloop
|
||||
|
||||
contloop3:
|
||||
mov edi,windowlen
|
||||
|
||||
; cur_match = prev[cur_match & wmask]
|
||||
and edx,7fffh
|
||||
mov dx,word ptr[esi+edx*2]
|
||||
; if cur_match > limit, go to exitloop
|
||||
cmp ecx,edx
|
||||
jnbexitloopshort1:
|
||||
jnb exitloop
|
||||
; if --chain_length != 0, go to exitloop
|
||||
|
||||
beginloop2:
|
||||
sub chain_length,16+1
|
||||
jna normalbeg0add16
|
||||
|
||||
do16:
|
||||
cmp word ptr[edi+edx],bx
|
||||
je normalbeg2dc0
|
||||
|
||||
maccn MACRO lab
|
||||
and edx,7fffh
|
||||
mov dx,word ptr[esi+edx*2]
|
||||
cmp ecx,edx
|
||||
jnb exitloop
|
||||
cmp word ptr[edi+edx-0],bx
|
||||
je lab
|
||||
ENDM
|
||||
|
||||
rcontloop0:
|
||||
maccn normalbeg2dc1
|
||||
|
||||
rcontloop1:
|
||||
maccn normalbeg2dc2
|
||||
|
||||
rcontloop2:
|
||||
maccn normalbeg2dc3
|
||||
|
||||
rcontloop3:
|
||||
maccn normalbeg2dc4
|
||||
|
||||
rcontloop4:
|
||||
maccn normalbeg2dc5
|
||||
|
||||
rcontloop5:
|
||||
maccn normalbeg2dc6
|
||||
|
||||
rcontloop6:
|
||||
maccn normalbeg2dc7
|
||||
|
||||
rcontloop7:
|
||||
maccn normalbeg2dc8
|
||||
|
||||
rcontloop8:
|
||||
maccn normalbeg2dc9
|
||||
|
||||
rcontloop9:
|
||||
maccn normalbeg2dc10
|
||||
|
||||
rcontloop10:
|
||||
maccn normalbeg2dc11
|
||||
|
||||
rcontloop11:
|
||||
maccn short normalbeg2dc12
|
||||
|
||||
rcontloop12:
|
||||
maccn short normalbeg2dc13
|
||||
|
||||
rcontloop13:
|
||||
maccn short normalbeg2dc14
|
||||
|
||||
rcontloop14:
|
||||
maccn short normalbeg2dc15
|
||||
|
||||
rcontloop15:
|
||||
and edx,7fffh
|
||||
mov dx,word ptr[esi+edx*2]
|
||||
cmp ecx,edx
|
||||
jnb short exitloopshort
|
||||
|
||||
sub chain_length,16
|
||||
ja do16
|
||||
jmp normalbeg0add16
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
exitloopshort:
|
||||
jmp exitloop
|
||||
|
||||
normbeg MACRO rcontlab,valsub
|
||||
cmp bp,word ptr[eax+edx]
|
||||
jne rcontlab
|
||||
add chain_length,16-valsub
|
||||
jmp iseq
|
||||
ENDM
|
||||
|
||||
normalbeg2dc12:
|
||||
normbeg rcontloop12,12
|
||||
|
||||
normalbeg2dc13:
|
||||
normbeg rcontloop13,13
|
||||
|
||||
normalbeg2dc14:
|
||||
normbeg rcontloop14,14
|
||||
|
||||
normalbeg2dc15:
|
||||
normbeg rcontloop15,15
|
||||
|
||||
normalbeg2dc11:
|
||||
normbeg rcontloop11,11
|
||||
|
||||
normalbeg2dc10:
|
||||
normbeg rcontloop10,10
|
||||
|
||||
|
||||
normalbeg2dc9:
|
||||
normbeg rcontloop9,9
|
||||
|
||||
normalbeg2dc8:
|
||||
normbeg rcontloop8,8
|
||||
|
||||
normalbeg2dc7:
|
||||
normbeg rcontloop7,7
|
||||
|
||||
normalbeg2dc5:
|
||||
normbeg rcontloop5,5
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
normalbeg2dc6:
|
||||
normbeg rcontloop6,6
|
||||
|
||||
normalbeg2dc4:
|
||||
normbeg rcontloop4,4
|
||||
|
||||
normalbeg2dc3:
|
||||
normbeg rcontloop3,3
|
||||
|
||||
normalbeg2dc2:
|
||||
normbeg rcontloop2,2
|
||||
|
||||
normalbeg2dc1:
|
||||
normbeg rcontloop1,1
|
||||
|
||||
normalbeg2dc0:
|
||||
normbeg rcontloop0,0
|
||||
|
||||
|
||||
; we go in normalbeg2 because *(ushf*)(match+best_len-1) == scan_end
|
||||
|
||||
normalbeg2:
|
||||
|
||||
; 10 nop here take 10% time
|
||||
mov edi,window
|
||||
;mov chain_length,eax ; now, we need eax...
|
||||
|
||||
cmp bp,word ptr[edi+edx]
|
||||
jne contloop3 ; if *(ushf*)match != scan_start, continue
|
||||
|
||||
iseq:
|
||||
|
||||
mov edi,eax
|
||||
mov esi,scanrp ; esi = scan
|
||||
add edi,edx ; edi = window + cur_match = match
|
||||
|
||||
|
||||
mov eax,[esi+3] ; compare manually dword at match+3
|
||||
xor eax,[edi+3] ; and scan +3
|
||||
|
||||
jz begincompare ; if equal, go to long compare
|
||||
|
||||
; we will determine the unmatch byte and calculate len (in esi)
|
||||
or al,al
|
||||
je eq1rr
|
||||
mov esi,3
|
||||
jmp trfinval
|
||||
eq1rr:
|
||||
or ax,ax
|
||||
je eq1
|
||||
|
||||
mov esi,4
|
||||
jmp trfinval
|
||||
eq1:
|
||||
shl eax,8
|
||||
jz eq11
|
||||
mov esi,5
|
||||
jmp trfinval
|
||||
eq11:
|
||||
mov esi,6
|
||||
jmp trfinval
|
||||
|
||||
begincompare:
|
||||
; here we now scan and match begin same
|
||||
add edi,6
|
||||
add esi,6
|
||||
mov ecx,(MAX_MATCH-(2+4))/4 ;//; scan for at most MAX_MATCH bytes
|
||||
repe cmpsd ;//; loop until mismatch
|
||||
|
||||
je trfin ; go to trfin if not unmatch
|
||||
; we determine the unmatch byte
|
||||
sub esi,4
|
||||
mov eax,[edi-4]
|
||||
xor eax,[esi]
|
||||
or al,al
|
||||
|
||||
jnz trfin
|
||||
inc esi
|
||||
|
||||
or ax,ax
|
||||
jnz trfin
|
||||
inc esi
|
||||
|
||||
shl eax,8
|
||||
jnz trfin
|
||||
inc esi
|
||||
|
||||
trfin:
|
||||
sub esi,scanrp ; esi = len
|
||||
trfinval:
|
||||
cmp esi,best_len ; if len <= best_len, go contloop2
|
||||
jbe contloop2
|
||||
|
||||
mov best_len,esi ; len become best_len
|
||||
|
||||
mov match_start,edx
|
||||
cmp esi,nice_match ;//; if esi >= nice_match, exit
|
||||
mov ecx,scanrp
|
||||
jae exitloop
|
||||
add esi,window
|
||||
add ecx,best_len
|
||||
dec esi
|
||||
mov windowlen,esi
|
||||
mov bx,[ecx-1]
|
||||
|
||||
|
||||
; now we restore eax, ecx and esi, for the big loop :
|
||||
contloop2:
|
||||
mov esi,prev
|
||||
mov ecx,limit
|
||||
;mov eax,chain_length
|
||||
mov eax,window
|
||||
jmp contloop3
|
||||
|
||||
exitloop:
|
||||
mov ebx,match_start
|
||||
mov ebp,str_s
|
||||
mov dword ptr [ebp+dep_match_start],ebx
|
||||
mov eax,best_len
|
||||
add esp,NbStackAdd
|
||||
|
||||
|
||||
pop ebx
|
||||
pop esi
|
||||
pop edi
|
||||
pop ebp
|
||||
ret
|
||||
|
||||
_longest_match_asm7fff endp
|
||||
|
||||
_TEXT ends
|
||||
end
|
||||
|
||||
229
contrib/asm386/gvmat32c.c
Normal file
229
contrib/asm386/gvmat32c.c
Normal file
@@ -0,0 +1,229 @@
|
||||
/* gvmat32.c -- C portion of the optimized longest_match for 32 bits x86
|
||||
* Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant.
|
||||
* File written by Gilles Vollant, by modifiying the longest_match
|
||||
* from Jean-loup Gailly in deflate.c
|
||||
* it prepare all parameters and call the assembly longest_match_gvasm
|
||||
* longest_match execute standard C code is wmask != 0x7fff
|
||||
* (assembly code is faster with a fixed wmask)
|
||||
*
|
||||
*/
|
||||
//#pragma optimize("agt",on)
|
||||
|
||||
#include "deflate.h"
|
||||
|
||||
#undef FAR
|
||||
#include <windows.h>
|
||||
|
||||
#ifdef ASMV
|
||||
|
||||
#define NIL 0
|
||||
|
||||
static unsigned int tot=0;
|
||||
static unsigned int totl0=0;
|
||||
static unsigned int totl0p0=0;
|
||||
static unsigned int ba0=0;
|
||||
static unsigned int ba1=0;
|
||||
static unsigned int cpta=0;
|
||||
static unsigned int cptb=0;
|
||||
|
||||
#define UNALIGNED_OK
|
||||
#define gvshow(a,b,c,d)
|
||||
/*
|
||||
void gvshow(int chain_length,int len,int limit,ushf* prev)
|
||||
{
|
||||
static int ival=0;
|
||||
char sz[80];
|
||||
unsigned long i;
|
||||
int prev0=*prev;
|
||||
ival++;
|
||||
//wsprintf(sz,"call %u, len=%u, chain_length=%u\n",ival,len,chain_length);
|
||||
//OutputDebugString(sz);
|
||||
tot++;
|
||||
if (limit==NIL)
|
||||
totl0++;
|
||||
if ((limit==NIL) && (prev0==0))
|
||||
totl0p0++;
|
||||
for (i=limit+1;i<32768;i++)
|
||||
{
|
||||
ush va=*(prev+i);
|
||||
if (ba0>4000000000)
|
||||
{
|
||||
ba0+=10;
|
||||
}
|
||||
ba0++;
|
||||
if ((va>limit) || (va==0))
|
||||
continue;
|
||||
ba1++;
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
/* if your C compiler don't add underline before function name,
|
||||
define ADD_UNDERLINE_ASMFUNC */
|
||||
#ifdef ADD_UNDERLINE_ASMFUNC
|
||||
#define longest_match_asm7fff _longest_match_asm7fff
|
||||
#endif
|
||||
void match_init()
|
||||
{
|
||||
}
|
||||
|
||||
uInt longest_match_c(
|
||||
deflate_state *s,
|
||||
IPos cur_match); /* current match */
|
||||
|
||||
|
||||
uInt longest_match_asm7fff(
|
||||
deflate_state *s,
|
||||
IPos cur_match); /* current match */
|
||||
|
||||
uInt longest_match(
|
||||
deflate_state *s,
|
||||
IPos cur_match) /* current match */
|
||||
{
|
||||
if (s->w_mask == 0x7fff)
|
||||
return longest_match_asm7fff(s,cur_match);
|
||||
return longest_match_c(s,cur_match);
|
||||
}
|
||||
|
||||
|
||||
|
||||
uInt longest_match_c(s, cur_match)
|
||||
deflate_state *s;
|
||||
IPos cur_match; /* current match */
|
||||
{
|
||||
unsigned chain_length = s->max_chain_length;/* max hash chain length */
|
||||
register Bytef *scan = s->window + s->strstart; /* current string */
|
||||
register Bytef *match; /* matched string */
|
||||
register int len; /* length of current match */
|
||||
int best_len = s->prev_length; /* best match length so far */
|
||||
int nice_match = s->nice_match; /* stop if match long enough */
|
||||
IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
|
||||
s->strstart - (IPos)MAX_DIST(s) : NIL;
|
||||
/* Stop when cur_match becomes <= limit. To simplify the code,
|
||||
* we prevent matches with the string of window index 0.
|
||||
*/
|
||||
Posf *prev = s->prev;
|
||||
uInt wmask = s->w_mask;
|
||||
|
||||
#ifdef UNALIGNED_OK
|
||||
/* Compare two bytes at a time. Note: this is not always beneficial.
|
||||
* Try with and without -DUNALIGNED_OK to check.
|
||||
*/
|
||||
register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
|
||||
register ush scan_start = *(ushf*)scan;
|
||||
register ush scan_end = *(ushf*)(scan+best_len-1);
|
||||
#else
|
||||
register Bytef *strend = s->window + s->strstart + MAX_MATCH;
|
||||
register Byte scan_end1 = scan[best_len-1];
|
||||
register Byte scan_end = scan[best_len];
|
||||
#endif
|
||||
|
||||
/* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
|
||||
* It is easy to get rid of this optimization if necessary.
|
||||
*/
|
||||
Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
|
||||
|
||||
/* Do not waste too much time if we already have a good match: */
|
||||
if (s->prev_length >= s->good_match) {
|
||||
chain_length >>= 2;
|
||||
}
|
||||
/* Do not look for matches beyond the end of the input. This is necessary
|
||||
* to make deflate deterministic.
|
||||
*/
|
||||
if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
|
||||
|
||||
Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
|
||||
|
||||
do {
|
||||
Assert(cur_match < s->strstart, "no future");
|
||||
match = s->window + cur_match;
|
||||
|
||||
/* Skip to next match if the match length cannot increase
|
||||
* or if the match length is less than 2:
|
||||
*/
|
||||
#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
|
||||
/* This code assumes sizeof(unsigned short) == 2. Do not use
|
||||
* UNALIGNED_OK if your compiler uses a different size.
|
||||
*/
|
||||
if (*(ushf*)(match+best_len-1) != scan_end ||
|
||||
*(ushf*)match != scan_start) continue;
|
||||
|
||||
/* It is not necessary to compare scan[2] and match[2] since they are
|
||||
* always equal when the other bytes match, given that the hash keys
|
||||
* are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
|
||||
* strstart+3, +5, ... up to strstart+257. We check for insufficient
|
||||
* lookahead only every 4th comparison; the 128th check will be made
|
||||
* at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
|
||||
* necessary to put more guard bytes at the end of the window, or
|
||||
* to check more often for insufficient lookahead.
|
||||
*/
|
||||
Assert(scan[2] == match[2], "scan[2]?");
|
||||
scan++, match++;
|
||||
do {
|
||||
} while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
|
||||
*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
|
||||
*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
|
||||
*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
|
||||
scan < strend);
|
||||
/* The funny "do {}" generates better code on most compilers */
|
||||
|
||||
/* Here, scan <= window+strstart+257 */
|
||||
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
|
||||
if (*scan == *match) scan++;
|
||||
|
||||
len = (MAX_MATCH - 1) - (int)(strend-scan);
|
||||
scan = strend - (MAX_MATCH-1);
|
||||
|
||||
#else /* UNALIGNED_OK */
|
||||
|
||||
if (match[best_len] != scan_end ||
|
||||
match[best_len-1] != scan_end1 ||
|
||||
*match != *scan ||
|
||||
*++match != scan[1]) continue;
|
||||
|
||||
/* The check at best_len-1 can be removed because it will be made
|
||||
* again later. (This heuristic is not always a win.)
|
||||
* It is not necessary to compare scan[2] and match[2] since they
|
||||
* are always equal when the other bytes match, given that
|
||||
* the hash keys are equal and that HASH_BITS >= 8.
|
||||
*/
|
||||
scan += 2, match++;
|
||||
Assert(*scan == *match, "match[2]?");
|
||||
|
||||
/* We check for insufficient lookahead only every 8th comparison;
|
||||
* the 256th check will be made at strstart+258.
|
||||
*/
|
||||
do {
|
||||
} while (*++scan == *++match && *++scan == *++match &&
|
||||
*++scan == *++match && *++scan == *++match &&
|
||||
*++scan == *++match && *++scan == *++match &&
|
||||
*++scan == *++match && *++scan == *++match &&
|
||||
scan < strend);
|
||||
|
||||
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
|
||||
|
||||
len = MAX_MATCH - (int)(strend - scan);
|
||||
scan = strend - MAX_MATCH;
|
||||
|
||||
#endif /* UNALIGNED_OK */
|
||||
|
||||
if (len > best_len) {
|
||||
s->match_start = cur_match;
|
||||
best_len = len;
|
||||
if (len >= nice_match) break;
|
||||
#ifdef UNALIGNED_OK
|
||||
scan_end = *(ushf*)(scan+best_len-1);
|
||||
#else
|
||||
scan_end1 = scan[best_len-1];
|
||||
scan_end = scan[best_len];
|
||||
#endif
|
||||
}
|
||||
} while ((cur_match = prev[cur_match & wmask]) > limit
|
||||
&& --chain_length != 0);
|
||||
|
||||
if ((uInt)best_len <= s->lookahead) return best_len;
|
||||
return s->lookahead;
|
||||
}
|
||||
|
||||
#endif /* ASMV */
|
||||
1
contrib/asm386/mkgvmt32.bat
Normal file
1
contrib/asm386/mkgvmt32.bat
Normal file
@@ -0,0 +1 @@
|
||||
c:\masm611\bin\ml /coff /Zi /c /Flgvmat32.lst gvmat32.asm
|
||||
781
contrib/asm386/zlibvc.mak
Normal file
781
contrib/asm386/zlibvc.mak
Normal file
@@ -0,0 +1,781 @@
|
||||
# Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
|
||||
# ** DO NOT EDIT **
|
||||
|
||||
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
|
||||
|
||||
!IF "$(CFG)" == ""
|
||||
CFG=zlibvc - Win32 Debug
|
||||
!MESSAGE No configuration specified. Defaulting to zlibvc - Win32 Debug.
|
||||
!ENDIF
|
||||
|
||||
!IF "$(CFG)" != "zlibvc - Win32 Release" && "$(CFG)" != "zlibvc - Win32 Debug"
|
||||
!MESSAGE Invalid configuration "$(CFG)" specified.
|
||||
!MESSAGE You can specify a configuration when running NMAKE on this makefile
|
||||
!MESSAGE by defining the macro CFG on the command line. For example:
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "zlibvc.mak" CFG="zlibvc - Win32 Debug"
|
||||
!MESSAGE
|
||||
!MESSAGE Possible choices for configuration are:
|
||||
!MESSAGE
|
||||
!MESSAGE "zlibvc - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
|
||||
!MESSAGE "zlibvc - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
|
||||
!MESSAGE
|
||||
!ERROR An invalid configuration is specified.
|
||||
!ENDIF
|
||||
|
||||
!IF "$(OS)" == "Windows_NT"
|
||||
NULL=
|
||||
!ELSE
|
||||
NULL=nul
|
||||
!ENDIF
|
||||
################################################################################
|
||||
# Begin Project
|
||||
# PROP Target_Last_Scanned "zlibvc - Win32 Debug"
|
||||
CPP=cl.exe
|
||||
RSC=rc.exe
|
||||
MTL=mktyplib.exe
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 0
|
||||
# PROP BASE Output_Dir "Release"
|
||||
# PROP BASE Intermediate_Dir "Release"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 0
|
||||
# PROP Output_Dir "Release"
|
||||
# PROP Intermediate_Dir "Release"
|
||||
# PROP Target_Dir ""
|
||||
OUTDIR=.\Release
|
||||
INTDIR=.\Release
|
||||
|
||||
ALL : "$(OUTDIR)\zlib.dll" "$(OUTDIR)\zlibvc.bsc"
|
||||
|
||||
CLEAN :
|
||||
-@erase "$(INTDIR)\adler32.obj"
|
||||
-@erase "$(INTDIR)\adler32.sbr"
|
||||
-@erase "$(INTDIR)\compress.obj"
|
||||
-@erase "$(INTDIR)\compress.sbr"
|
||||
-@erase "$(INTDIR)\crc32.obj"
|
||||
-@erase "$(INTDIR)\crc32.sbr"
|
||||
-@erase "$(INTDIR)\deflate.obj"
|
||||
-@erase "$(INTDIR)\deflate.sbr"
|
||||
-@erase "$(INTDIR)\gvmat32c.obj"
|
||||
-@erase "$(INTDIR)\gvmat32c.sbr"
|
||||
-@erase "$(INTDIR)\gzio.obj"
|
||||
-@erase "$(INTDIR)\gzio.sbr"
|
||||
-@erase "$(INTDIR)\infblock.obj"
|
||||
-@erase "$(INTDIR)\infblock.sbr"
|
||||
-@erase "$(INTDIR)\infcodes.obj"
|
||||
-@erase "$(INTDIR)\infcodes.sbr"
|
||||
-@erase "$(INTDIR)\inffast.obj"
|
||||
-@erase "$(INTDIR)\inffast.sbr"
|
||||
-@erase "$(INTDIR)\inflate.obj"
|
||||
-@erase "$(INTDIR)\inflate.sbr"
|
||||
-@erase "$(INTDIR)\inftrees.obj"
|
||||
-@erase "$(INTDIR)\inftrees.sbr"
|
||||
-@erase "$(INTDIR)\infutil.obj"
|
||||
-@erase "$(INTDIR)\infutil.sbr"
|
||||
-@erase "$(INTDIR)\trees.obj"
|
||||
-@erase "$(INTDIR)\trees.sbr"
|
||||
-@erase "$(INTDIR)\uncompr.obj"
|
||||
-@erase "$(INTDIR)\uncompr.sbr"
|
||||
-@erase "$(INTDIR)\zlib.res"
|
||||
-@erase "$(INTDIR)\zutil.obj"
|
||||
-@erase "$(INTDIR)\zutil.sbr"
|
||||
-@erase "$(OUTDIR)\zlib.dll"
|
||||
-@erase "$(OUTDIR)\zlib.exp"
|
||||
-@erase "$(OUTDIR)\zlib.lib"
|
||||
-@erase "$(OUTDIR)\zlib.map"
|
||||
-@erase "$(OUTDIR)\zlibvc.bsc"
|
||||
|
||||
"$(OUTDIR)" :
|
||||
if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
|
||||
|
||||
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
|
||||
# ADD CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D fdopen=_fdopen /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "ASMV" /FR /YX /c
|
||||
CPP_PROJ=/nologo /MT /W3 /GX /O2 /D "NDEBUG" /D fdopen=_fdopen /D "WIN32" /D\
|
||||
"_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "ASMV"\
|
||||
/FR"$(INTDIR)/" /Fp"$(INTDIR)/zlibvc.pch" /YX /Fo"$(INTDIR)/" /c
|
||||
CPP_OBJS=.\Release/
|
||||
CPP_SBRS=.\Release/
|
||||
# ADD BASE MTL /nologo /D "NDEBUG" /win32
|
||||
# ADD MTL /nologo /D "NDEBUG" /win32
|
||||
MTL_PROJ=/nologo /D "NDEBUG" /win32
|
||||
# ADD BASE RSC /l 0x40c /d "NDEBUG"
|
||||
# ADD RSC /l 0x40c /d "NDEBUG"
|
||||
RSC_PROJ=/l 0x40c /fo"$(INTDIR)/zlib.res" /d "NDEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
BSC32_FLAGS=/nologo /o"$(OUTDIR)/zlibvc.bsc"
|
||||
BSC32_SBRS= \
|
||||
"$(INTDIR)\adler32.sbr" \
|
||||
"$(INTDIR)\compress.sbr" \
|
||||
"$(INTDIR)\crc32.sbr" \
|
||||
"$(INTDIR)\deflate.sbr" \
|
||||
"$(INTDIR)\gvmat32c.sbr" \
|
||||
"$(INTDIR)\gzio.sbr" \
|
||||
"$(INTDIR)\infblock.sbr" \
|
||||
"$(INTDIR)\infcodes.sbr" \
|
||||
"$(INTDIR)\inffast.sbr" \
|
||||
"$(INTDIR)\inflate.sbr" \
|
||||
"$(INTDIR)\inftrees.sbr" \
|
||||
"$(INTDIR)\infutil.sbr" \
|
||||
"$(INTDIR)\trees.sbr" \
|
||||
"$(INTDIR)\uncompr.sbr" \
|
||||
"$(INTDIR)\zutil.sbr"
|
||||
|
||||
"$(OUTDIR)\zlibvc.bsc" : "$(OUTDIR)" $(BSC32_SBRS)
|
||||
$(BSC32) @<<
|
||||
$(BSC32_FLAGS) $(BSC32_SBRS)
|
||||
<<
|
||||
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386
|
||||
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo /subsystem:windows /dll /map /machine:I386 /nodefaultlib /out:"Release/zlib.dll"
|
||||
LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
|
||||
advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo\
|
||||
/subsystem:windows /dll /incremental:no /pdb:"$(OUTDIR)/zlib.pdb"\
|
||||
/map:"$(INTDIR)/zlib.map" /machine:I386 /nodefaultlib /def:".\zlib.def"\
|
||||
/out:"$(OUTDIR)/zlib.dll" /implib:"$(OUTDIR)/zlib.lib"
|
||||
DEF_FILE= \
|
||||
".\zlib.def"
|
||||
LINK32_OBJS= \
|
||||
"$(INTDIR)\adler32.obj" \
|
||||
"$(INTDIR)\compress.obj" \
|
||||
"$(INTDIR)\crc32.obj" \
|
||||
"$(INTDIR)\deflate.obj" \
|
||||
"$(INTDIR)\gvmat32c.obj" \
|
||||
"$(INTDIR)\gzio.obj" \
|
||||
"$(INTDIR)\infblock.obj" \
|
||||
"$(INTDIR)\infcodes.obj" \
|
||||
"$(INTDIR)\inffast.obj" \
|
||||
"$(INTDIR)\inflate.obj" \
|
||||
"$(INTDIR)\inftrees.obj" \
|
||||
"$(INTDIR)\infutil.obj" \
|
||||
"$(INTDIR)\trees.obj" \
|
||||
"$(INTDIR)\uncompr.obj" \
|
||||
"$(INTDIR)\zlib.res" \
|
||||
"$(INTDIR)\zutil.obj" \
|
||||
".\GVMAT32.obj"
|
||||
|
||||
"$(OUTDIR)\zlib.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
|
||||
$(LINK32) @<<
|
||||
$(LINK32_FLAGS) $(LINK32_OBJS)
|
||||
<<
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 1
|
||||
# PROP BASE Output_Dir "Debug"
|
||||
# PROP BASE Intermediate_Dir "Debug"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 1
|
||||
# PROP Output_Dir "Debug"
|
||||
# PROP Intermediate_Dir "Debug"
|
||||
# PROP Target_Dir ""
|
||||
OUTDIR=.\Debug
|
||||
INTDIR=.\Debug
|
||||
|
||||
ALL : "$(OUTDIR)\zlib.dll"
|
||||
|
||||
CLEAN :
|
||||
-@erase "$(INTDIR)\adler32.obj"
|
||||
-@erase "$(INTDIR)\compress.obj"
|
||||
-@erase "$(INTDIR)\crc32.obj"
|
||||
-@erase "$(INTDIR)\deflate.obj"
|
||||
-@erase "$(INTDIR)\gvmat32c.obj"
|
||||
-@erase "$(INTDIR)\gzio.obj"
|
||||
-@erase "$(INTDIR)\infblock.obj"
|
||||
-@erase "$(INTDIR)\infcodes.obj"
|
||||
-@erase "$(INTDIR)\inffast.obj"
|
||||
-@erase "$(INTDIR)\inflate.obj"
|
||||
-@erase "$(INTDIR)\inftrees.obj"
|
||||
-@erase "$(INTDIR)\infutil.obj"
|
||||
-@erase "$(INTDIR)\trees.obj"
|
||||
-@erase "$(INTDIR)\uncompr.obj"
|
||||
-@erase "$(INTDIR)\vc40.idb"
|
||||
-@erase "$(INTDIR)\vc40.pdb"
|
||||
-@erase "$(INTDIR)\zlib.res"
|
||||
-@erase "$(INTDIR)\zutil.obj"
|
||||
-@erase "$(OUTDIR)\zlib.dll"
|
||||
-@erase "$(OUTDIR)\zlib.exp"
|
||||
-@erase "$(OUTDIR)\zlib.ilk"
|
||||
-@erase "$(OUTDIR)\zlib.lib"
|
||||
-@erase "$(OUTDIR)\zlib.pdb"
|
||||
|
||||
"$(OUTDIR)" :
|
||||
if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
|
||||
|
||||
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
|
||||
# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /YX /c
|
||||
CPP_PROJ=/nologo /MTd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS"\
|
||||
/D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL"\
|
||||
/Fp"$(INTDIR)/zlibvc.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c
|
||||
CPP_OBJS=.\Debug/
|
||||
CPP_SBRS=.\.
|
||||
# ADD BASE MTL /nologo /D "_DEBUG" /win32
|
||||
# ADD MTL /nologo /D "_DEBUG" /win32
|
||||
MTL_PROJ=/nologo /D "_DEBUG" /win32
|
||||
# ADD BASE RSC /l 0x40c /d "_DEBUG"
|
||||
# ADD RSC /l 0x40c /d "_DEBUG"
|
||||
RSC_PROJ=/l 0x40c /fo"$(INTDIR)/zlib.res" /d "_DEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
BSC32_FLAGS=/nologo /o"$(OUTDIR)/zlibvc.bsc"
|
||||
BSC32_SBRS= \
|
||||
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386
|
||||
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /subsystem:windows /dll /debug /machine:I386 /out:"Debug/zlib.dll"
|
||||
LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
|
||||
advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo\
|
||||
/subsystem:windows /dll /incremental:yes /pdb:"$(OUTDIR)/zlib.pdb" /debug\
|
||||
/machine:I386 /def:".\zlib.def" /out:"$(OUTDIR)/zlib.dll"\
|
||||
/implib:"$(OUTDIR)/zlib.lib"
|
||||
DEF_FILE= \
|
||||
".\zlib.def"
|
||||
LINK32_OBJS= \
|
||||
"$(INTDIR)\adler32.obj" \
|
||||
"$(INTDIR)\compress.obj" \
|
||||
"$(INTDIR)\crc32.obj" \
|
||||
"$(INTDIR)\deflate.obj" \
|
||||
"$(INTDIR)\gvmat32c.obj" \
|
||||
"$(INTDIR)\gzio.obj" \
|
||||
"$(INTDIR)\infblock.obj" \
|
||||
"$(INTDIR)\infcodes.obj" \
|
||||
"$(INTDIR)\inffast.obj" \
|
||||
"$(INTDIR)\inflate.obj" \
|
||||
"$(INTDIR)\inftrees.obj" \
|
||||
"$(INTDIR)\infutil.obj" \
|
||||
"$(INTDIR)\trees.obj" \
|
||||
"$(INTDIR)\uncompr.obj" \
|
||||
"$(INTDIR)\zlib.res" \
|
||||
"$(INTDIR)\zutil.obj" \
|
||||
".\GVMAT32.obj"
|
||||
|
||||
"$(OUTDIR)\zlib.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
|
||||
$(LINK32) @<<
|
||||
$(LINK32_FLAGS) $(LINK32_OBJS)
|
||||
<<
|
||||
|
||||
!ENDIF
|
||||
|
||||
.c{$(CPP_OBJS)}.obj:
|
||||
$(CPP) $(CPP_PROJ) $<
|
||||
|
||||
.cpp{$(CPP_OBJS)}.obj:
|
||||
$(CPP) $(CPP_PROJ) $<
|
||||
|
||||
.cxx{$(CPP_OBJS)}.obj:
|
||||
$(CPP) $(CPP_PROJ) $<
|
||||
|
||||
.c{$(CPP_SBRS)}.sbr:
|
||||
$(CPP) $(CPP_PROJ) $<
|
||||
|
||||
.cpp{$(CPP_SBRS)}.sbr:
|
||||
$(CPP) $(CPP_PROJ) $<
|
||||
|
||||
.cxx{$(CPP_SBRS)}.sbr:
|
||||
$(CPP) $(CPP_PROJ) $<
|
||||
|
||||
################################################################################
|
||||
# Begin Target
|
||||
|
||||
# Name "zlibvc - Win32 Release"
|
||||
# Name "zlibvc - Win32 Debug"
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
!ENDIF
|
||||
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\adler32.c
|
||||
DEP_CPP_ADLER=\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
|
||||
"$(INTDIR)\adler32.obj" : $(SOURCE) $(DEP_CPP_ADLER) "$(INTDIR)"
|
||||
|
||||
"$(INTDIR)\adler32.sbr" : $(SOURCE) $(DEP_CPP_ADLER) "$(INTDIR)"
|
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
|
||||
"$(INTDIR)\adler32.obj" : $(SOURCE) $(DEP_CPP_ADLER) "$(INTDIR)"
|
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\compress.c
|
||||
DEP_CPP_COMPR=\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
|
||||
"$(INTDIR)\compress.obj" : $(SOURCE) $(DEP_CPP_COMPR) "$(INTDIR)"
|
||||
|
||||
"$(INTDIR)\compress.sbr" : $(SOURCE) $(DEP_CPP_COMPR) "$(INTDIR)"
|
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
|
||||
"$(INTDIR)\compress.obj" : $(SOURCE) $(DEP_CPP_COMPR) "$(INTDIR)"
|
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\crc32.c
|
||||
DEP_CPP_CRC32=\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
|
||||
"$(INTDIR)\crc32.obj" : $(SOURCE) $(DEP_CPP_CRC32) "$(INTDIR)"
|
||||
|
||||
"$(INTDIR)\crc32.sbr" : $(SOURCE) $(DEP_CPP_CRC32) "$(INTDIR)"
|
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
|
||||
"$(INTDIR)\crc32.obj" : $(SOURCE) $(DEP_CPP_CRC32) "$(INTDIR)"
|
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\deflate.c
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
DEP_CPP_DEFLA=\
|
||||
".\deflate.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
"$(INTDIR)\deflate.obj" : $(SOURCE) $(DEP_CPP_DEFLA) "$(INTDIR)"
|
||||
|
||||
"$(INTDIR)\deflate.sbr" : $(SOURCE) $(DEP_CPP_DEFLA) "$(INTDIR)"
|
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
DEP_CPP_DEFLA=\
|
||||
".\deflate.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
NODEP_CPP_DEFLA=\
|
||||
".\local"\
|
||||
|
||||
|
||||
"$(INTDIR)\deflate.obj" : $(SOURCE) $(DEP_CPP_DEFLA) "$(INTDIR)"
|
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\gzio.c
|
||||
DEP_CPP_GZIO_=\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
|
||||
"$(INTDIR)\gzio.obj" : $(SOURCE) $(DEP_CPP_GZIO_) "$(INTDIR)"
|
||||
|
||||
"$(INTDIR)\gzio.sbr" : $(SOURCE) $(DEP_CPP_GZIO_) "$(INTDIR)"
|
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
|
||||
"$(INTDIR)\gzio.obj" : $(SOURCE) $(DEP_CPP_GZIO_) "$(INTDIR)"
|
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\infblock.c
|
||||
DEP_CPP_INFBL=\
|
||||
".\infblock.h"\
|
||||
".\infcodes.h"\
|
||||
".\inftrees.h"\
|
||||
".\infutil.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
|
||||
"$(INTDIR)\infblock.obj" : $(SOURCE) $(DEP_CPP_INFBL) "$(INTDIR)"
|
||||
|
||||
"$(INTDIR)\infblock.sbr" : $(SOURCE) $(DEP_CPP_INFBL) "$(INTDIR)"
|
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
|
||||
"$(INTDIR)\infblock.obj" : $(SOURCE) $(DEP_CPP_INFBL) "$(INTDIR)"
|
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\infcodes.c
|
||||
DEP_CPP_INFCO=\
|
||||
".\infblock.h"\
|
||||
".\infcodes.h"\
|
||||
".\inffast.h"\
|
||||
".\inftrees.h"\
|
||||
".\infutil.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
|
||||
"$(INTDIR)\infcodes.obj" : $(SOURCE) $(DEP_CPP_INFCO) "$(INTDIR)"
|
||||
|
||||
"$(INTDIR)\infcodes.sbr" : $(SOURCE) $(DEP_CPP_INFCO) "$(INTDIR)"
|
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
|
||||
"$(INTDIR)\infcodes.obj" : $(SOURCE) $(DEP_CPP_INFCO) "$(INTDIR)"
|
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\inffast.c
|
||||
DEP_CPP_INFFA=\
|
||||
".\infblock.h"\
|
||||
".\infcodes.h"\
|
||||
".\inffast.h"\
|
||||
".\inftrees.h"\
|
||||
".\infutil.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
|
||||
"$(INTDIR)\inffast.obj" : $(SOURCE) $(DEP_CPP_INFFA) "$(INTDIR)"
|
||||
|
||||
"$(INTDIR)\inffast.sbr" : $(SOURCE) $(DEP_CPP_INFFA) "$(INTDIR)"
|
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
|
||||
"$(INTDIR)\inffast.obj" : $(SOURCE) $(DEP_CPP_INFFA) "$(INTDIR)"
|
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\inflate.c
|
||||
DEP_CPP_INFLA=\
|
||||
".\infblock.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
|
||||
"$(INTDIR)\inflate.obj" : $(SOURCE) $(DEP_CPP_INFLA) "$(INTDIR)"
|
||||
|
||||
"$(INTDIR)\inflate.sbr" : $(SOURCE) $(DEP_CPP_INFLA) "$(INTDIR)"
|
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
|
||||
"$(INTDIR)\inflate.obj" : $(SOURCE) $(DEP_CPP_INFLA) "$(INTDIR)"
|
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\inftrees.c
|
||||
DEP_CPP_INFTR=\
|
||||
".\inftrees.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
|
||||
"$(INTDIR)\inftrees.obj" : $(SOURCE) $(DEP_CPP_INFTR) "$(INTDIR)"
|
||||
|
||||
"$(INTDIR)\inftrees.sbr" : $(SOURCE) $(DEP_CPP_INFTR) "$(INTDIR)"
|
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
|
||||
"$(INTDIR)\inftrees.obj" : $(SOURCE) $(DEP_CPP_INFTR) "$(INTDIR)"
|
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\infutil.c
|
||||
DEP_CPP_INFUT=\
|
||||
".\infblock.h"\
|
||||
".\infcodes.h"\
|
||||
".\inftrees.h"\
|
||||
".\infutil.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
|
||||
"$(INTDIR)\infutil.obj" : $(SOURCE) $(DEP_CPP_INFUT) "$(INTDIR)"
|
||||
|
||||
"$(INTDIR)\infutil.sbr" : $(SOURCE) $(DEP_CPP_INFUT) "$(INTDIR)"
|
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
|
||||
"$(INTDIR)\infutil.obj" : $(SOURCE) $(DEP_CPP_INFUT) "$(INTDIR)"
|
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\trees.c
|
||||
DEP_CPP_TREES=\
|
||||
".\deflate.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
|
||||
"$(INTDIR)\trees.obj" : $(SOURCE) $(DEP_CPP_TREES) "$(INTDIR)"
|
||||
|
||||
"$(INTDIR)\trees.sbr" : $(SOURCE) $(DEP_CPP_TREES) "$(INTDIR)"
|
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
|
||||
"$(INTDIR)\trees.obj" : $(SOURCE) $(DEP_CPP_TREES) "$(INTDIR)"
|
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\uncompr.c
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
DEP_CPP_UNCOM=\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
|
||||
|
||||
"$(INTDIR)\uncompr.obj" : $(SOURCE) $(DEP_CPP_UNCOM) "$(INTDIR)"
|
||||
|
||||
"$(INTDIR)\uncompr.sbr" : $(SOURCE) $(DEP_CPP_UNCOM) "$(INTDIR)"
|
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
DEP_CPP_UNCOM=\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
|
||||
NODEP_CPP_UNCOM=\
|
||||
".\uncompress"\
|
||||
|
||||
|
||||
"$(INTDIR)\uncompr.obj" : $(SOURCE) $(DEP_CPP_UNCOM) "$(INTDIR)"
|
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\zutil.c
|
||||
DEP_CPP_ZUTIL=\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
|
||||
"$(INTDIR)\zutil.obj" : $(SOURCE) $(DEP_CPP_ZUTIL) "$(INTDIR)"
|
||||
|
||||
"$(INTDIR)\zutil.sbr" : $(SOURCE) $(DEP_CPP_ZUTIL) "$(INTDIR)"
|
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
|
||||
"$(INTDIR)\zutil.obj" : $(SOURCE) $(DEP_CPP_ZUTIL) "$(INTDIR)"
|
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\zlib.rc
|
||||
|
||||
"$(INTDIR)\zlib.res" : $(SOURCE) "$(INTDIR)"
|
||||
$(RSC) $(RSC_PROJ) $(SOURCE)
|
||||
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\zlib.def
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\GVMAT32.obj
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\gvmat32c.c
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release"
|
||||
|
||||
DEP_CPP_GVMAT=\
|
||||
".\deflate.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
"$(INTDIR)\gvmat32c.obj" : $(SOURCE) $(DEP_CPP_GVMAT) "$(INTDIR)"
|
||||
|
||||
"$(INTDIR)\gvmat32c.sbr" : $(SOURCE) $(DEP_CPP_GVMAT) "$(INTDIR)"
|
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug"
|
||||
|
||||
DEP_CPP_GVMAT=\
|
||||
".\deflate.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
"$(INTDIR)\gvmat32c.obj" : $(SOURCE) $(DEP_CPP_GVMAT) "$(INTDIR)"
|
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# End Target
|
||||
# End Project
|
||||
################################################################################
|
||||
24
contrib/iostream/test.cpp
Normal file
24
contrib/iostream/test.cpp
Normal file
@@ -0,0 +1,24 @@
|
||||
|
||||
#include "zfstream.h"
|
||||
|
||||
int main() {
|
||||
|
||||
// Construct a stream object with this filebuffer. Anything sent
|
||||
// to this stream will go to standard out.
|
||||
gzofstream os( 1, ios::out );
|
||||
|
||||
// This text is getting compressed and sent to stdout.
|
||||
// To prove this, run 'test | zcat'.
|
||||
os << "Hello, Mommy" << endl;
|
||||
|
||||
os << setcompressionlevel( Z_NO_COMPRESSION );
|
||||
os << "hello, hello, hi, ho!" << endl;
|
||||
|
||||
setcompressionlevel( os, Z_DEFAULT_COMPRESSION )
|
||||
<< "I'm compressing again" << endl;
|
||||
|
||||
os.close();
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
329
contrib/iostream/zfstream.cpp
Normal file
329
contrib/iostream/zfstream.cpp
Normal file
@@ -0,0 +1,329 @@
|
||||
|
||||
#include <memory.h>
|
||||
#include "zfstream.h"
|
||||
|
||||
gzfilebuf::gzfilebuf() :
|
||||
file(NULL),
|
||||
mode(0),
|
||||
own_file_descriptor(0)
|
||||
{ }
|
||||
|
||||
gzfilebuf::~gzfilebuf() {
|
||||
|
||||
sync();
|
||||
if ( own_file_descriptor )
|
||||
close();
|
||||
|
||||
}
|
||||
|
||||
gzfilebuf *gzfilebuf::open( const char *name,
|
||||
int io_mode ) {
|
||||
|
||||
if ( is_open() )
|
||||
return NULL;
|
||||
|
||||
char char_mode[10];
|
||||
char *p;
|
||||
memset(char_mode,'\0',10);
|
||||
p = char_mode;
|
||||
|
||||
if ( io_mode & ios::in ) {
|
||||
mode = ios::in;
|
||||
*p++ = 'r';
|
||||
} else if ( io_mode & ios::app ) {
|
||||
mode = ios::app;
|
||||
*p++ = 'a';
|
||||
} else {
|
||||
mode = ios::out;
|
||||
*p++ = 'w';
|
||||
}
|
||||
|
||||
if ( io_mode & ios::binary ) {
|
||||
mode |= ios::binary;
|
||||
*p++ = 'b';
|
||||
}
|
||||
|
||||
// Hard code the compression level
|
||||
if ( io_mode & (ios::out|ios::app )) {
|
||||
*p++ = '9';
|
||||
}
|
||||
|
||||
if ( (file = gzopen(name, char_mode)) == NULL )
|
||||
return NULL;
|
||||
|
||||
own_file_descriptor = 1;
|
||||
|
||||
return this;
|
||||
|
||||
}
|
||||
|
||||
gzfilebuf *gzfilebuf::attach( int file_descriptor,
|
||||
int io_mode ) {
|
||||
|
||||
if ( is_open() )
|
||||
return NULL;
|
||||
|
||||
char char_mode[10];
|
||||
char *p;
|
||||
memset(char_mode,'\0',10);
|
||||
p = char_mode;
|
||||
|
||||
if ( io_mode & ios::in ) {
|
||||
mode = ios::in;
|
||||
*p++ = 'r';
|
||||
} else if ( io_mode & ios::app ) {
|
||||
mode = ios::app;
|
||||
*p++ = 'a';
|
||||
} else {
|
||||
mode = ios::out;
|
||||
*p++ = 'w';
|
||||
}
|
||||
|
||||
if ( io_mode & ios::binary ) {
|
||||
mode |= ios::binary;
|
||||
*p++ = 'b';
|
||||
}
|
||||
|
||||
// Hard code the compression level
|
||||
if ( io_mode & (ios::out|ios::app )) {
|
||||
*p++ = '9';
|
||||
}
|
||||
|
||||
if ( (file = gzdopen(file_descriptor, char_mode)) == NULL )
|
||||
return NULL;
|
||||
|
||||
own_file_descriptor = 0;
|
||||
|
||||
return this;
|
||||
|
||||
}
|
||||
|
||||
gzfilebuf *gzfilebuf::close() {
|
||||
|
||||
if ( is_open() ) {
|
||||
|
||||
sync();
|
||||
gzclose( file );
|
||||
file = NULL;
|
||||
|
||||
}
|
||||
|
||||
return this;
|
||||
|
||||
}
|
||||
|
||||
int gzfilebuf::setcompressionlevel( short comp_level ) {
|
||||
|
||||
return gzsetparams(file, comp_level, -2);
|
||||
|
||||
}
|
||||
|
||||
int gzfilebuf::setcompressionstrategy( short comp_strategy ) {
|
||||
|
||||
return gzsetparams(file, -2, comp_strategy);
|
||||
|
||||
}
|
||||
|
||||
|
||||
streampos gzfilebuf::seekoff( streamoff off, ios::seek_dir dir, int which ) {
|
||||
|
||||
return streampos(EOF);
|
||||
|
||||
}
|
||||
|
||||
int gzfilebuf::underflow() {
|
||||
|
||||
// If the file hasn't been opened for reading, error.
|
||||
if ( !is_open() || !(mode & ios::in) )
|
||||
return EOF;
|
||||
|
||||
// if a buffer doesn't exists, allocate one.
|
||||
if ( !base() ) {
|
||||
|
||||
if ( (allocate()) == EOF )
|
||||
return EOF;
|
||||
setp(0,0);
|
||||
|
||||
} else {
|
||||
|
||||
if ( in_avail() )
|
||||
return (unsigned char) *gptr();
|
||||
|
||||
if ( out_waiting() ) {
|
||||
if ( flushbuf() == EOF )
|
||||
return EOF;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Attempt to fill the buffer.
|
||||
|
||||
int result = fillbuf();
|
||||
if ( result == EOF ) {
|
||||
// disable get area
|
||||
setg(0,0,0);
|
||||
return EOF;
|
||||
}
|
||||
|
||||
return (unsigned char) *gptr();
|
||||
|
||||
}
|
||||
|
||||
int gzfilebuf::overflow( int c ) {
|
||||
|
||||
if ( !is_open() || !(mode & ios::out) )
|
||||
return EOF;
|
||||
|
||||
if ( !base() ) {
|
||||
if ( allocate() == EOF )
|
||||
return EOF;
|
||||
setg(0,0,0);
|
||||
} else {
|
||||
if (in_avail()) {
|
||||
return EOF;
|
||||
}
|
||||
if (out_waiting()) {
|
||||
if (flushbuf() == EOF)
|
||||
return EOF;
|
||||
}
|
||||
}
|
||||
|
||||
int bl = blen();
|
||||
setp( base(), base() + bl);
|
||||
|
||||
if ( c != EOF ) {
|
||||
|
||||
*pptr() = c;
|
||||
pbump(1);
|
||||
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
int gzfilebuf::sync() {
|
||||
|
||||
if ( !is_open() )
|
||||
return EOF;
|
||||
|
||||
if ( out_waiting() )
|
||||
return flushbuf();
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
int gzfilebuf::flushbuf() {
|
||||
|
||||
int n;
|
||||
char *q;
|
||||
|
||||
q = pbase();
|
||||
n = pptr() - q;
|
||||
|
||||
if ( gzwrite( file, q, n) < n )
|
||||
return EOF;
|
||||
|
||||
setp(0,0);
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
int gzfilebuf::fillbuf() {
|
||||
|
||||
int required;
|
||||
char *p;
|
||||
|
||||
p = base();
|
||||
|
||||
required = blen();
|
||||
|
||||
int t = gzread( file, p, required );
|
||||
|
||||
if ( t <= 0) return EOF;
|
||||
|
||||
setg( base(), base(), base()+t);
|
||||
|
||||
return t;
|
||||
|
||||
}
|
||||
|
||||
gzfilestream_common::gzfilestream_common() :
|
||||
ios( gzfilestream_common::rdbuf() )
|
||||
{ }
|
||||
|
||||
gzfilestream_common::~gzfilestream_common()
|
||||
{ }
|
||||
|
||||
void gzfilestream_common::attach( int fd, int io_mode ) {
|
||||
|
||||
if ( !buffer.attach( fd, io_mode) )
|
||||
clear( ios::failbit | ios::badbit );
|
||||
else
|
||||
clear();
|
||||
|
||||
}
|
||||
|
||||
void gzfilestream_common::open( const char *name, int io_mode ) {
|
||||
|
||||
if ( !buffer.open( name, io_mode ) )
|
||||
clear( ios::failbit | ios::badbit );
|
||||
else
|
||||
clear();
|
||||
|
||||
}
|
||||
|
||||
void gzfilestream_common::close() {
|
||||
|
||||
if ( !buffer.close() )
|
||||
clear( ios::failbit | ios::badbit );
|
||||
|
||||
}
|
||||
|
||||
gzfilebuf *gzfilestream_common::rdbuf() {
|
||||
|
||||
return &buffer;
|
||||
|
||||
}
|
||||
|
||||
gzifstream::gzifstream() :
|
||||
ios( gzfilestream_common::rdbuf() )
|
||||
{
|
||||
clear( ios::badbit );
|
||||
}
|
||||
|
||||
gzifstream::gzifstream( const char *name, int io_mode ) :
|
||||
ios( gzfilestream_common::rdbuf() )
|
||||
{
|
||||
gzfilestream_common::open( name, io_mode );
|
||||
}
|
||||
|
||||
gzifstream::gzifstream( int fd, int io_mode ) :
|
||||
ios( gzfilestream_common::rdbuf() )
|
||||
{
|
||||
gzfilestream_common::attach( fd, io_mode );
|
||||
}
|
||||
|
||||
gzifstream::~gzifstream() { }
|
||||
|
||||
gzofstream::gzofstream() :
|
||||
ios( gzfilestream_common::rdbuf() )
|
||||
{
|
||||
clear( ios::badbit );
|
||||
}
|
||||
|
||||
gzofstream::gzofstream( const char *name, int io_mode ) :
|
||||
ios( gzfilestream_common::rdbuf() )
|
||||
{
|
||||
gzfilestream_common::open( name, io_mode );
|
||||
}
|
||||
|
||||
gzofstream::gzofstream( int fd, int io_mode ) :
|
||||
ios( gzfilestream_common::rdbuf() )
|
||||
{
|
||||
gzfilestream_common::attach( fd, io_mode );
|
||||
}
|
||||
|
||||
gzofstream::~gzofstream() { }
|
||||
142
contrib/iostream/zfstream.h
Normal file
142
contrib/iostream/zfstream.h
Normal file
@@ -0,0 +1,142 @@
|
||||
|
||||
#ifndef _zfstream_h
|
||||
#define _zfstream_h
|
||||
|
||||
#include <fstream.h>
|
||||
#include "zlib.h"
|
||||
|
||||
class gzfilebuf : public streambuf {
|
||||
|
||||
public:
|
||||
|
||||
gzfilebuf( );
|
||||
virtual ~gzfilebuf();
|
||||
|
||||
gzfilebuf *open( const char *name, int io_mode );
|
||||
gzfilebuf *attach( int file_descriptor, int io_mode );
|
||||
gzfilebuf *close();
|
||||
|
||||
int setcompressionlevel( short comp_level );
|
||||
int setcompressionstrategy( short comp_strategy );
|
||||
|
||||
inline int is_open() const { return (file !=NULL); }
|
||||
|
||||
virtual streampos seekoff( streamoff, ios::seek_dir, int );
|
||||
|
||||
virtual int sync();
|
||||
|
||||
protected:
|
||||
|
||||
virtual int underflow();
|
||||
virtual int overflow( int = EOF );
|
||||
|
||||
private:
|
||||
|
||||
gzFile file;
|
||||
short mode;
|
||||
short own_file_descriptor;
|
||||
|
||||
int flushbuf();
|
||||
int fillbuf();
|
||||
|
||||
};
|
||||
|
||||
class gzfilestream_common : virtual public ios {
|
||||
|
||||
friend class gzifstream;
|
||||
friend class gzofstream;
|
||||
friend gzofstream &setcompressionlevel( gzofstream &, int );
|
||||
friend gzofstream &setcompressionstrategy( gzofstream &, int );
|
||||
|
||||
public:
|
||||
virtual ~gzfilestream_common();
|
||||
|
||||
void attach( int fd, int io_mode );
|
||||
void open( const char *name, int io_mode );
|
||||
void close();
|
||||
|
||||
protected:
|
||||
gzfilestream_common();
|
||||
|
||||
private:
|
||||
gzfilebuf *rdbuf();
|
||||
|
||||
gzfilebuf buffer;
|
||||
|
||||
};
|
||||
|
||||
class gzifstream : public gzfilestream_common, public istream {
|
||||
|
||||
public:
|
||||
|
||||
gzifstream();
|
||||
gzifstream( const char *name, int io_mode = ios::in );
|
||||
gzifstream( int fd, int io_mode = ios::in );
|
||||
|
||||
virtual ~gzifstream();
|
||||
|
||||
};
|
||||
|
||||
class gzofstream : public gzfilestream_common, public ostream {
|
||||
|
||||
public:
|
||||
|
||||
gzofstream();
|
||||
gzofstream( const char *name, int io_mode = ios::out );
|
||||
gzofstream( int fd, int io_mode = ios::out );
|
||||
|
||||
virtual ~gzofstream();
|
||||
|
||||
};
|
||||
|
||||
template<class T> class gzomanip {
|
||||
friend gzofstream &operator<<(gzofstream &, const gzomanip<T> &);
|
||||
public:
|
||||
gzomanip(gzofstream &(*f)(gzofstream &, T), T v) : func(f), val(v) { }
|
||||
private:
|
||||
gzofstream &(*func)(gzofstream &, T);
|
||||
T val;
|
||||
};
|
||||
|
||||
template<class T> gzofstream &operator<<(gzofstream &s,
|
||||
const gzomanip<T> &m) {
|
||||
return (*m.func)(s, m.val);
|
||||
|
||||
}
|
||||
|
||||
inline gzofstream &setcompressionlevel( gzofstream &s, int l ) {
|
||||
(s.rdbuf())->setcompressionlevel(l);
|
||||
return s;
|
||||
}
|
||||
|
||||
inline gzofstream &setcompressionstrategy( gzofstream &s, int l ) {
|
||||
(s.rdbuf())->setcompressionstrategy(l);
|
||||
return s;
|
||||
}
|
||||
|
||||
inline gzomanip<int> setcompressionlevel(int l)
|
||||
{
|
||||
return gzomanip<int>(&setcompressionlevel,l);
|
||||
}
|
||||
|
||||
inline gzomanip<int> setcompressionstrategy(int l)
|
||||
{
|
||||
return gzomanip<int>(&setcompressionstrategy,l);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
307
contrib/iostream2/zstream.h
Normal file
307
contrib/iostream2/zstream.h
Normal file
@@ -0,0 +1,307 @@
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1997
|
||||
* Christian Michelsen Research AS
|
||||
* Advanced Computing
|
||||
* Fantoftvegen 38, 5036 BERGEN, Norway
|
||||
* http://www.cmr.no
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Christian Michelsen Research AS makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef ZSTREAM__H
|
||||
#define ZSTREAM__H
|
||||
|
||||
/*
|
||||
* zstream.h - C++ interface to the 'zlib' general purpose compression library
|
||||
* $Id: zstream.h 1.1 1997-06-25 12:00:56+02 tyge Exp tyge $
|
||||
*/
|
||||
|
||||
#include <strstream.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "zlib.h"
|
||||
|
||||
#if defined(_WIN32)
|
||||
# include <fcntl.h>
|
||||
# include <io.h>
|
||||
# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
|
||||
#else
|
||||
# define SET_BINARY_MODE(file)
|
||||
#endif
|
||||
|
||||
class zstringlen {
|
||||
public:
|
||||
zstringlen(class izstream&);
|
||||
zstringlen(class ozstream&, const char*);
|
||||
size_t value() const { return val.word; }
|
||||
private:
|
||||
struct Val { unsigned char byte; size_t word; } val;
|
||||
};
|
||||
|
||||
// ----------------------------- izstream -----------------------------
|
||||
|
||||
class izstream
|
||||
{
|
||||
public:
|
||||
izstream() : m_fp(0) {}
|
||||
izstream(FILE* fp) : m_fp(0) { open(fp); }
|
||||
izstream(const char* name) : m_fp(0) { open(name); }
|
||||
~izstream() { close(); }
|
||||
|
||||
/* Opens a gzip (.gz) file for reading.
|
||||
* open() can be used to read a file which is not in gzip format;
|
||||
* in this case read() will directly read from the file without
|
||||
* decompression. errno can be checked to distinguish two error
|
||||
* cases (if errno is zero, the zlib error is Z_MEM_ERROR).
|
||||
*/
|
||||
void open(const char* name) {
|
||||
if (m_fp) close();
|
||||
m_fp = ::gzopen(name, "rb");
|
||||
}
|
||||
|
||||
void open(FILE* fp) {
|
||||
SET_BINARY_MODE(fp);
|
||||
if (m_fp) close();
|
||||
m_fp = ::gzdopen(fileno(fp), "rb");
|
||||
}
|
||||
|
||||
/* Flushes all pending input if necessary, closes the compressed file
|
||||
* and deallocates all the (de)compression state. The return value is
|
||||
* the zlib error number (see function error() below).
|
||||
*/
|
||||
int close() {
|
||||
int r = ::gzclose(m_fp);
|
||||
m_fp = 0; return r;
|
||||
}
|
||||
|
||||
/* Binary read the given number of bytes from the compressed file.
|
||||
*/
|
||||
int read(void* buf, size_t len) {
|
||||
return ::gzread(m_fp, buf, len);
|
||||
}
|
||||
|
||||
/* Returns the error message for the last error which occurred on the
|
||||
* given compressed file. errnum is set to zlib error number. If an
|
||||
* error occurred in the file system and not in the compression library,
|
||||
* errnum is set to Z_ERRNO and the application may consult errno
|
||||
* to get the exact error code.
|
||||
*/
|
||||
const char* error(int* errnum) {
|
||||
return ::gzerror(m_fp, errnum);
|
||||
}
|
||||
|
||||
gzFile fp() { return m_fp; }
|
||||
|
||||
private:
|
||||
gzFile m_fp;
|
||||
};
|
||||
|
||||
/*
|
||||
* Binary read the given (array of) object(s) from the compressed file.
|
||||
* If the input file was not in gzip format, read() copies the objects number
|
||||
* of bytes into the buffer.
|
||||
* returns the number of uncompressed bytes actually read
|
||||
* (0 for end of file, -1 for error).
|
||||
*/
|
||||
template <class T, class Items>
|
||||
inline int read(izstream& zs, T* x, Items items) {
|
||||
return ::gzread(zs.fp(), x, items*sizeof(T));
|
||||
}
|
||||
|
||||
/*
|
||||
* Binary input with the '>' operator.
|
||||
*/
|
||||
template <class T>
|
||||
inline izstream& operator>(izstream& zs, T& x) {
|
||||
::gzread(zs.fp(), &x, sizeof(T));
|
||||
return zs;
|
||||
}
|
||||
|
||||
|
||||
inline zstringlen::zstringlen(izstream& zs) {
|
||||
zs > val.byte;
|
||||
if (val.byte == 255) zs > val.word;
|
||||
else val.word = val.byte;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read length of string + the string with the '>' operator.
|
||||
*/
|
||||
inline izstream& operator>(izstream& zs, char* x) {
|
||||
zstringlen len(zs);
|
||||
::gzread(zs.fp(), x, len.value());
|
||||
x[len.value()] = '\0';
|
||||
return zs;
|
||||
}
|
||||
|
||||
inline char* read_string(izstream& zs) {
|
||||
zstringlen len(zs);
|
||||
char* x = new char[len.value()+1];
|
||||
::gzread(zs.fp(), x, len.value());
|
||||
x[len.value()] = '\0';
|
||||
return x;
|
||||
}
|
||||
|
||||
// ----------------------------- ozstream -----------------------------
|
||||
|
||||
class ozstream
|
||||
{
|
||||
public:
|
||||
ozstream() : m_fp(0), m_os(0) {
|
||||
}
|
||||
ozstream(FILE* fp, int level = Z_DEFAULT_COMPRESSION)
|
||||
: m_fp(0), m_os(0) {
|
||||
open(fp, level);
|
||||
}
|
||||
ozstream(const char* name, int level = Z_DEFAULT_COMPRESSION)
|
||||
: m_fp(0), m_os(0) {
|
||||
open(name, level);
|
||||
}
|
||||
~ozstream() {
|
||||
close();
|
||||
}
|
||||
|
||||
/* Opens a gzip (.gz) file for writing.
|
||||
* The compression level parameter should be in 0..9
|
||||
* errno can be checked to distinguish two error cases
|
||||
* (if errno is zero, the zlib error is Z_MEM_ERROR).
|
||||
*/
|
||||
void open(const char* name, int level = Z_DEFAULT_COMPRESSION) {
|
||||
char mode[4] = "wb\0";
|
||||
if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
|
||||
if (m_fp) close();
|
||||
m_fp = ::gzopen(name, mode);
|
||||
}
|
||||
|
||||
/* open from a FILE pointer.
|
||||
*/
|
||||
void open(FILE* fp, int level = Z_DEFAULT_COMPRESSION) {
|
||||
SET_BINARY_MODE(fp);
|
||||
char mode[4] = "wb\0";
|
||||
if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
|
||||
if (m_fp) close();
|
||||
m_fp = ::gzdopen(fileno(fp), mode);
|
||||
}
|
||||
|
||||
/* Flushes all pending output if necessary, closes the compressed file
|
||||
* and deallocates all the (de)compression state. The return value is
|
||||
* the zlib error number (see function error() below).
|
||||
*/
|
||||
int close() {
|
||||
if (m_os) {
|
||||
::gzwrite(m_fp, m_os->str(), m_os->pcount());
|
||||
delete[] m_os->str(); delete m_os; m_os = 0;
|
||||
}
|
||||
int r = ::gzclose(m_fp); m_fp = 0; return r;
|
||||
}
|
||||
|
||||
/* Binary write the given number of bytes into the compressed file.
|
||||
*/
|
||||
int write(const void* buf, size_t len) {
|
||||
return ::gzwrite(m_fp, (voidp) buf, len);
|
||||
}
|
||||
|
||||
/* Flushes all pending output into the compressed file. The parameter
|
||||
* _flush is as in the deflate() function. The return value is the zlib
|
||||
* error number (see function gzerror below). flush() returns Z_OK if
|
||||
* the flush_ parameter is Z_FINISH and all output could be flushed.
|
||||
* flush() should be called only when strictly necessary because it can
|
||||
* degrade compression.
|
||||
*/
|
||||
int flush(int _flush) {
|
||||
os_flush();
|
||||
return ::gzflush(m_fp, _flush);
|
||||
}
|
||||
|
||||
/* Returns the error message for the last error which occurred on the
|
||||
* given compressed file. errnum is set to zlib error number. If an
|
||||
* error occurred in the file system and not in the compression library,
|
||||
* errnum is set to Z_ERRNO and the application may consult errno
|
||||
* to get the exact error code.
|
||||
*/
|
||||
const char* error(int* errnum) {
|
||||
return ::gzerror(m_fp, errnum);
|
||||
}
|
||||
|
||||
gzFile fp() { return m_fp; }
|
||||
|
||||
ostream& os() {
|
||||
if (m_os == 0) m_os = new ostrstream;
|
||||
return *m_os;
|
||||
}
|
||||
|
||||
void os_flush() {
|
||||
if (m_os && m_os->pcount()>0) {
|
||||
ostrstream* oss = new ostrstream;
|
||||
oss->fill(m_os->fill());
|
||||
oss->flags(m_os->flags());
|
||||
oss->precision(m_os->precision());
|
||||
oss->width(m_os->width());
|
||||
::gzwrite(m_fp, m_os->str(), m_os->pcount());
|
||||
delete[] m_os->str(); delete m_os; m_os = oss;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
gzFile m_fp;
|
||||
ostrstream* m_os;
|
||||
};
|
||||
|
||||
/*
|
||||
* Binary write the given (array of) object(s) into the compressed file.
|
||||
* returns the number of uncompressed bytes actually written
|
||||
* (0 in case of error).
|
||||
*/
|
||||
template <class T, class Items>
|
||||
inline int write(ozstream& zs, const T* x, Items items) {
|
||||
return ::gzwrite(zs.fp(), (voidp) x, items*sizeof(T));
|
||||
}
|
||||
|
||||
/*
|
||||
* Binary output with the '<' operator.
|
||||
*/
|
||||
template <class T>
|
||||
inline ozstream& operator<(ozstream& zs, const T& x) {
|
||||
::gzwrite(zs.fp(), (voidp) &x, sizeof(T));
|
||||
return zs;
|
||||
}
|
||||
|
||||
inline zstringlen::zstringlen(ozstream& zs, const char* x) {
|
||||
val.byte = 255; val.word = ::strlen(x);
|
||||
if (val.word < 255) zs < (val.byte = val.word);
|
||||
else zs < val;
|
||||
}
|
||||
|
||||
/*
|
||||
* Write length of string + the string with the '<' operator.
|
||||
*/
|
||||
inline ozstream& operator<(ozstream& zs, const char* x) {
|
||||
zstringlen len(zs, x);
|
||||
::gzwrite(zs.fp(), (voidp) x, len.value());
|
||||
return zs;
|
||||
}
|
||||
|
||||
#ifdef _MSC_VER
|
||||
inline ozstream& operator<(ozstream& zs, char* const& x) {
|
||||
return zs < (const char*) x;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Ascii write with the << operator;
|
||||
*/
|
||||
template <class T>
|
||||
inline ostream& operator<<(ozstream& zs, const T& x) {
|
||||
zs.os_flush();
|
||||
return zs.os() << x;
|
||||
}
|
||||
|
||||
#endif
|
||||
25
contrib/iostream2/zstream_test.cpp
Normal file
25
contrib/iostream2/zstream_test.cpp
Normal file
@@ -0,0 +1,25 @@
|
||||
#include "zstream.h"
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <iomanip.h>
|
||||
|
||||
void main() {
|
||||
char h[256] = "Hello";
|
||||
char* g = "Goodbye";
|
||||
ozstream out("temp.gz");
|
||||
out < "This works well" < h < g;
|
||||
out.close();
|
||||
|
||||
izstream in("temp.gz"); // read it back
|
||||
char *x = read_string(in), *y = new char[256], z[256];
|
||||
in > y > z;
|
||||
in.close();
|
||||
cout << x << endl << y << endl << z << endl;
|
||||
|
||||
out.open("temp.gz"); // try ascii output; zcat temp.gz to see the results
|
||||
out << setw(50) << setfill('#') << setprecision(20) << x << endl << y << endl << z << endl;
|
||||
out << z << endl << y << endl << x << endl;
|
||||
out << 1.1234567890123456789 << endl;
|
||||
|
||||
delete[] x; delete[] y;
|
||||
}
|
||||
14
contrib/untgz/Makefile
Normal file
14
contrib/untgz/Makefile
Normal file
@@ -0,0 +1,14 @@
|
||||
CC=cc
|
||||
CFLAGS=-g
|
||||
|
||||
untgz: untgz.o ../../libz.a
|
||||
$(CC) $(CFLAGS) -o untgz untgz.o -L../.. -lz
|
||||
|
||||
untgz.o: untgz.c ../../zlib.h
|
||||
$(CC) $(CFLAGS) -c -I../.. untgz.c
|
||||
|
||||
../../libz.a:
|
||||
cd ../..; make
|
||||
|
||||
clean:
|
||||
rm -f untgz untgz.o *~
|
||||
63
contrib/untgz/makefile.w32
Normal file
63
contrib/untgz/makefile.w32
Normal file
@@ -0,0 +1,63 @@
|
||||
# Makefile for zlib. Modified for mingw32
|
||||
# For conditions of distribution and use, see copyright notice in zlib.h
|
||||
|
||||
# To compile,
|
||||
#
|
||||
# make -fmakefile.w32
|
||||
#
|
||||
|
||||
CC=gcc
|
||||
|
||||
# Generate dependencies (see end of the file)
|
||||
|
||||
CPPFLAGS=-MMD
|
||||
|
||||
#CFLAGS=-MMD -O
|
||||
#CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7
|
||||
#CFLAGS=-MMD -g -DDEBUG
|
||||
CFLAGS=-O3 $(BUTT) -Wall -Wwrite-strings -Wpointer-arith -Wconversion \
|
||||
-Wstrict-prototypes -Wmissing-prototypes
|
||||
|
||||
# If cp.exe is not found, replace with copy /Y .
|
||||
CP=cp -f
|
||||
|
||||
# The default value of RM is "rm -f."
|
||||
# If "rm.exe" is not found, uncomment:
|
||||
# RM=del
|
||||
|
||||
LD=gcc
|
||||
LDLIBS=-L. -lz
|
||||
LDFLAGS=-s
|
||||
|
||||
|
||||
INCL=zlib.h zconf.h
|
||||
LIBS=libz.a
|
||||
|
||||
AR=ar rcs
|
||||
|
||||
OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \
|
||||
zutil.o inflate.o infblock.o inftrees.o infcodes.o infutil.o \
|
||||
inffast.o
|
||||
|
||||
TEST_OBJS = minigzip.o untgz.o
|
||||
|
||||
all: minigzip.exe untgz.exe
|
||||
|
||||
rebuild: clean all
|
||||
|
||||
libz.a: $(OBJS)
|
||||
$(AR) $@ $(OBJS)
|
||||
|
||||
%.exe : %.o $(LIBS)
|
||||
$(LD) $(LDFLAGS) -o $@ $< $(LDLIBS)
|
||||
|
||||
.PHONY : clean
|
||||
|
||||
clean:
|
||||
$(RM) *.d *.o *.exe libz.a foo.gz
|
||||
|
||||
DEPS := $(wildcard *.d)
|
||||
ifneq ($(DEPS),)
|
||||
include $(DEPS)
|
||||
endif
|
||||
|
||||
478
contrib/untgz/untgz.c
Normal file
478
contrib/untgz/untgz.c
Normal file
@@ -0,0 +1,478 @@
|
||||
/*
|
||||
* untgz.c -- Display contents and/or extract file from
|
||||
* a gzip'd TAR file
|
||||
* written by "Pedro A. Aranda Guti\irrez" <paag@tid.es>
|
||||
* adaptation to Unix by Jean-loup Gailly <jloup@gzip.org>
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <utime.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#ifdef unix
|
||||
# include <unistd.h>
|
||||
#else
|
||||
# include <direct.h>
|
||||
# include <io.h>
|
||||
#endif
|
||||
|
||||
#include "zlib.h"
|
||||
|
||||
/* Values used in typeflag field. */
|
||||
|
||||
#define REGTYPE '0' /* regular file */
|
||||
#define AREGTYPE '\0' /* regular file */
|
||||
#define LNKTYPE '1' /* link */
|
||||
#define SYMTYPE '2' /* reserved */
|
||||
#define CHRTYPE '3' /* character special */
|
||||
#define BLKTYPE '4' /* block special */
|
||||
#define DIRTYPE '5' /* directory */
|
||||
#define FIFOTYPE '6' /* FIFO special */
|
||||
#define CONTTYPE '7' /* reserved */
|
||||
|
||||
#define BLOCKSIZE 512
|
||||
|
||||
struct tar_header
|
||||
{ /* byte offset */
|
||||
char name[100]; /* 0 */
|
||||
char mode[8]; /* 100 */
|
||||
char uid[8]; /* 108 */
|
||||
char gid[8]; /* 116 */
|
||||
char size[12]; /* 124 */
|
||||
char mtime[12]; /* 136 */
|
||||
char chksum[8]; /* 148 */
|
||||
char typeflag; /* 156 */
|
||||
char linkname[100]; /* 157 */
|
||||
char magic[6]; /* 257 */
|
||||
char version[2]; /* 263 */
|
||||
char uname[32]; /* 265 */
|
||||
char gname[32]; /* 297 */
|
||||
char devmajor[8]; /* 329 */
|
||||
char devminor[8]; /* 337 */
|
||||
char prefix[155]; /* 345 */
|
||||
/* 500 */
|
||||
};
|
||||
|
||||
union tar_buffer {
|
||||
char buffer[BLOCKSIZE];
|
||||
struct tar_header header;
|
||||
};
|
||||
|
||||
enum { TGZ_EXTRACT = 0, TGZ_LIST };
|
||||
|
||||
static char *TGZfname OF((const char *));
|
||||
void TGZnotfound OF((const char *));
|
||||
|
||||
int getoct OF((char *, int));
|
||||
char *strtime OF((time_t *));
|
||||
int ExprMatch OF((char *,char *));
|
||||
|
||||
int makedir OF((char *));
|
||||
int matchname OF((int,int,char **,char *));
|
||||
|
||||
void error OF((const char *));
|
||||
int tar OF((gzFile, int, int, int, char **));
|
||||
|
||||
void help OF((int));
|
||||
int main OF((int, char **));
|
||||
|
||||
char *prog;
|
||||
|
||||
/* This will give a benign warning */
|
||||
|
||||
static char *TGZprefix[] = { "\0", ".tgz", ".tar.gz", NULL };
|
||||
|
||||
/* Return the real name of the TGZ archive */
|
||||
/* or NULL if it does not exist. */
|
||||
|
||||
static char *TGZfname OF((const char *fname))
|
||||
{
|
||||
static char buffer[1024];
|
||||
int origlen,i;
|
||||
|
||||
strcpy(buffer,fname);
|
||||
origlen = strlen(buffer);
|
||||
|
||||
for (i=0; TGZprefix[i]; i++)
|
||||
{
|
||||
strcpy(buffer+origlen,TGZprefix[i]);
|
||||
if (access(buffer,F_OK) == 0)
|
||||
return buffer;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* error message for the filename */
|
||||
|
||||
void TGZnotfound OF((const char *fname))
|
||||
{
|
||||
int i;
|
||||
|
||||
fprintf(stderr,"%s : couldn't find ",prog);
|
||||
for (i=0;TGZprefix[i];i++)
|
||||
fprintf(stderr,(TGZprefix[i+1]) ? "%s%s, " : "or %s%s\n",
|
||||
fname,
|
||||
TGZprefix[i]);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
||||
/* help functions */
|
||||
|
||||
int getoct(char *p,int width)
|
||||
{
|
||||
int result = 0;
|
||||
char c;
|
||||
|
||||
while (width --)
|
||||
{
|
||||
c = *p++;
|
||||
if (c == ' ')
|
||||
continue;
|
||||
if (c == 0)
|
||||
break;
|
||||
result = result * 8 + (c - '0');
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
char *strtime (time_t *t)
|
||||
{
|
||||
struct tm *local;
|
||||
static char result[32];
|
||||
|
||||
local = localtime(t);
|
||||
sprintf(result,"%2d/%02d/%4d %02d:%02d:%02d",
|
||||
local->tm_mday, local->tm_mon+1, local->tm_year+1900,
|
||||
local->tm_hour, local->tm_min, local->tm_sec);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/* regular expression matching */
|
||||
|
||||
#define ISSPECIAL(c) (((c) == '*') || ((c) == '/'))
|
||||
|
||||
int ExprMatch(char *string,char *expr)
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
if (ISSPECIAL(*expr))
|
||||
{
|
||||
if (*expr == '/')
|
||||
{
|
||||
if (*string != '\\' && *string != '/')
|
||||
return 0;
|
||||
string ++; expr++;
|
||||
}
|
||||
else if (*expr == '*')
|
||||
{
|
||||
if (*expr ++ == 0)
|
||||
return 1;
|
||||
while (*++string != *expr)
|
||||
if (*string == 0)
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (*string != *expr)
|
||||
return 0;
|
||||
if (*expr++ == 0)
|
||||
return 1;
|
||||
string++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* recursive make directory */
|
||||
/* abort if you get an ENOENT errno somewhere in the middle */
|
||||
/* e.g. ignore error "mkdir on existing directory" */
|
||||
/* */
|
||||
/* return 1 if OK */
|
||||
/* 0 on error */
|
||||
|
||||
int makedir (char *newdir)
|
||||
{
|
||||
char *buffer = strdup(newdir);
|
||||
char *p;
|
||||
int len = strlen(buffer);
|
||||
|
||||
if (len <= 0) {
|
||||
free(buffer);
|
||||
return 0;
|
||||
}
|
||||
if (buffer[len-1] == '/') {
|
||||
buffer[len-1] = '\0';
|
||||
}
|
||||
if (mkdir(buffer, 0775) == 0)
|
||||
{
|
||||
free(buffer);
|
||||
return 1;
|
||||
}
|
||||
|
||||
p = buffer+1;
|
||||
while (1)
|
||||
{
|
||||
char hold;
|
||||
|
||||
while(*p && *p != '\\' && *p != '/')
|
||||
p++;
|
||||
hold = *p;
|
||||
*p = 0;
|
||||
if ((mkdir(buffer, 0775) == -1) && (errno == ENOENT))
|
||||
{
|
||||
fprintf(stderr,"%s: couldn't create directory %s\n",prog,buffer);
|
||||
free(buffer);
|
||||
return 0;
|
||||
}
|
||||
if (hold == 0)
|
||||
break;
|
||||
*p++ = hold;
|
||||
}
|
||||
free(buffer);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int matchname (int arg,int argc,char **argv,char *fname)
|
||||
{
|
||||
if (arg == argc) /* no arguments given (untgz tgzarchive) */
|
||||
return 1;
|
||||
|
||||
while (arg < argc)
|
||||
if (ExprMatch(fname,argv[arg++]))
|
||||
return 1;
|
||||
|
||||
return 0; /* ignore this for the moment being */
|
||||
}
|
||||
|
||||
|
||||
/* Tar file list or extract */
|
||||
|
||||
int tar (gzFile in,int action,int arg,int argc,char **argv)
|
||||
{
|
||||
union tar_buffer buffer;
|
||||
int len;
|
||||
int err;
|
||||
int getheader = 1;
|
||||
int remaining = 0;
|
||||
FILE *outfile = NULL;
|
||||
char fname[BLOCKSIZE];
|
||||
time_t tartime;
|
||||
|
||||
if (action == TGZ_LIST)
|
||||
printf(" day time size file\n"
|
||||
" ---------- -------- --------- -------------------------------------\n");
|
||||
while (1)
|
||||
{
|
||||
len = gzread(in, &buffer, BLOCKSIZE);
|
||||
if (len < 0)
|
||||
error (gzerror(in, &err));
|
||||
/*
|
||||
* if we met the end of the tar
|
||||
* or the end-of-tar block,
|
||||
* we are done
|
||||
*/
|
||||
if ((len == 0) || (buffer.header.name[0]== 0))
|
||||
break;
|
||||
|
||||
/*
|
||||
* Always expect complete blocks to process
|
||||
* the tar information.
|
||||
*/
|
||||
if (len != BLOCKSIZE)
|
||||
error("gzread: incomplete block read");
|
||||
|
||||
/*
|
||||
* If we have to get a tar header
|
||||
*/
|
||||
if (getheader == 1)
|
||||
{
|
||||
tartime = (time_t)getoct(buffer.header.mtime,12);
|
||||
strcpy(fname,buffer.header.name);
|
||||
|
||||
switch (buffer.header.typeflag)
|
||||
{
|
||||
case DIRTYPE:
|
||||
if (action == TGZ_LIST)
|
||||
printf(" %s <dir> %s\n",strtime(&tartime),fname);
|
||||
if (action == TGZ_EXTRACT)
|
||||
makedir(fname);
|
||||
break;
|
||||
case REGTYPE:
|
||||
case AREGTYPE:
|
||||
remaining = getoct(buffer.header.size,12);
|
||||
if (action == TGZ_LIST)
|
||||
printf(" %s %9d %s\n",strtime(&tartime),remaining,fname);
|
||||
if (action == TGZ_EXTRACT)
|
||||
{
|
||||
if ((remaining) && (matchname(arg,argc,argv,fname)))
|
||||
{
|
||||
outfile = fopen(fname,"wb");
|
||||
if (outfile == NULL) {
|
||||
/* try creating directory */
|
||||
char *p = strrchr(fname, '/');
|
||||
if (p != NULL) {
|
||||
*p = '\0';
|
||||
makedir(fname);
|
||||
*p = '/';
|
||||
outfile = fopen(fname,"wb");
|
||||
}
|
||||
}
|
||||
fprintf(stderr,
|
||||
"%s %s\n",
|
||||
(outfile) ? "Extracting" : "Couldn't create",
|
||||
fname);
|
||||
}
|
||||
else
|
||||
outfile = NULL;
|
||||
}
|
||||
/*
|
||||
* could have no contents
|
||||
*/
|
||||
getheader = (remaining) ? 0 : 1;
|
||||
break;
|
||||
default:
|
||||
if (action == TGZ_LIST)
|
||||
printf(" %s <---> %s\n",strtime(&tartime),fname);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
unsigned int bytes = (remaining > BLOCKSIZE) ? BLOCKSIZE : remaining;
|
||||
|
||||
if ((action == TGZ_EXTRACT) && (outfile != NULL))
|
||||
{
|
||||
if (fwrite(&buffer,sizeof(char),bytes,outfile) != bytes)
|
||||
{
|
||||
fprintf(stderr,"%s : error writing %s skipping...\n",prog,fname);
|
||||
fclose(outfile);
|
||||
unlink(fname);
|
||||
}
|
||||
}
|
||||
remaining -= bytes;
|
||||
if (remaining == 0)
|
||||
{
|
||||
getheader = 1;
|
||||
if ((action == TGZ_EXTRACT) && (outfile != NULL))
|
||||
{
|
||||
struct utimbuf settime;
|
||||
|
||||
settime.actime = settime.modtime = tartime;
|
||||
|
||||
fclose(outfile);
|
||||
outfile = NULL;
|
||||
utime(fname,&settime);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (gzclose(in) != Z_OK)
|
||||
error("failed gzclose");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* =========================================================== */
|
||||
|
||||
void help(int exitval)
|
||||
{
|
||||
fprintf(stderr,
|
||||
"untgz v 0.1\n"
|
||||
" an sample application of zlib 1.0.4\n\n"
|
||||
"Usage : untgz TGZfile to extract all files\n"
|
||||
" untgz TGZfile fname ... to extract selected files\n"
|
||||
" untgz -l TGZfile to list archive contents\n"
|
||||
" untgz -h to display this help\n\n");
|
||||
exit(exitval);
|
||||
}
|
||||
|
||||
void error(const char *msg)
|
||||
{
|
||||
fprintf(stderr, "%s: %s\n", prog, msg);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
||||
/* ====================================================================== */
|
||||
|
||||
int _CRT_glob = 0; /* disable globbing of the arguments */
|
||||
|
||||
int main(int argc,char **argv)
|
||||
{
|
||||
int action = TGZ_EXTRACT;
|
||||
int arg = 1;
|
||||
char *TGZfile;
|
||||
gzFile *f;
|
||||
|
||||
|
||||
prog = strrchr(argv[0],'\\');
|
||||
if (prog == NULL)
|
||||
{
|
||||
prog = strrchr(argv[0],'/');
|
||||
if (prog == NULL)
|
||||
{
|
||||
prog = strrchr(argv[0],':');
|
||||
if (prog == NULL)
|
||||
prog = argv[0];
|
||||
else
|
||||
prog++;
|
||||
}
|
||||
else
|
||||
prog++;
|
||||
}
|
||||
else
|
||||
prog++;
|
||||
|
||||
if (argc == 1)
|
||||
help(0);
|
||||
|
||||
if (strcmp(argv[arg],"-l") == 0)
|
||||
{
|
||||
action = TGZ_LIST;
|
||||
if (argc == ++arg)
|
||||
help(0);
|
||||
}
|
||||
else if (strcmp(argv[arg],"-h") == 0)
|
||||
{
|
||||
help(0);
|
||||
}
|
||||
|
||||
if ((TGZfile = TGZfname(argv[arg])) == NULL)
|
||||
TGZnotfound(argv[arg]);
|
||||
|
||||
++arg;
|
||||
if ((action == TGZ_LIST) && (arg != argc))
|
||||
help(1);
|
||||
|
||||
/*
|
||||
* Process the TGZ file
|
||||
*/
|
||||
switch(action)
|
||||
{
|
||||
case TGZ_LIST:
|
||||
case TGZ_EXTRACT:
|
||||
f = gzopen(TGZfile,"rb");
|
||||
if (f == NULL)
|
||||
{
|
||||
fprintf(stderr,"%s: Couldn't gzopen %s\n",
|
||||
prog,
|
||||
TGZfile);
|
||||
return 1;
|
||||
}
|
||||
exit(tar(f, action, arg, argc, argv));
|
||||
break;
|
||||
|
||||
default:
|
||||
error("Unknown option!");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
57
contrib/visual-basic.txt
Normal file
57
contrib/visual-basic.txt
Normal file
@@ -0,0 +1,57 @@
|
||||
From: "Jon Caruana" <jon-net@usa.net>
|
||||
To: "Jean-loup Gailly" <gzip@prep.ai.mit.edu>
|
||||
Subject: Re: How to port zlib declares to vb?
|
||||
Date: Mon, 28 Oct 1996 18:33:03 -0600
|
||||
|
||||
Got the answer! (I haven't had time to check this but it's what I got, and
|
||||
looks correct):
|
||||
|
||||
He has the following routines working:
|
||||
compress
|
||||
uncompress
|
||||
gzopen
|
||||
gzwrite
|
||||
gzread
|
||||
gzclose
|
||||
|
||||
Declares follow: (Quoted from Carlos Rios <c_rios@sonda.cl>, in Vb4 form)
|
||||
|
||||
#If Win16 Then 'Use Win16 calls.
|
||||
Declare Function compress Lib "ZLIB.DLL" (ByVal compr As
|
||||
String, comprLen As Any, ByVal buf As String, ByVal buflen
|
||||
As Long) As Integer
|
||||
Declare Function uncompress Lib "ZLIB.DLL" (ByVal uncompr
|
||||
As String, uncomprLen As Any, ByVal compr As String, ByVal
|
||||
lcompr As Long) As Integer
|
||||
Declare Function gzopen Lib "ZLIB.DLL" (ByVal filePath As
|
||||
String, ByVal mode As String) As Long
|
||||
Declare Function gzread Lib "ZLIB.DLL" (ByVal file As
|
||||
Long, ByVal uncompr As String, ByVal uncomprLen As Integer)
|
||||
As Integer
|
||||
Declare Function gzwrite Lib "ZLIB.DLL" (ByVal file As
|
||||
Long, ByVal uncompr As String, ByVal uncomprLen As Integer)
|
||||
As Integer
|
||||
Declare Function gzclose Lib "ZLIB.DLL" (ByVal file As
|
||||
Long) As Integer
|
||||
#Else
|
||||
Declare Function compress Lib "ZLIB32.DLL"
|
||||
(ByVal compr As String, comprLen As Any, ByVal buf As
|
||||
String, ByVal buflen As Long) As Integer
|
||||
Declare Function uncompress Lib "ZLIB32.DLL"
|
||||
(ByVal uncompr As String, uncomprLen As Any, ByVal compr As
|
||||
String, ByVal lcompr As Long) As Long
|
||||
Declare Function gzopen Lib "ZLIB32.DLL"
|
||||
(ByVal file As String, ByVal mode As String) As Long
|
||||
Declare Function gzread Lib "ZLIB32.DLL"
|
||||
(ByVal file As Long, ByVal uncompr As String, ByVal
|
||||
uncomprLen As Long) As Long
|
||||
Declare Function gzwrite Lib "ZLIB32.DLL"
|
||||
(ByVal file As Long, ByVal uncompr As String, ByVal
|
||||
uncomprLen As Long) As Long
|
||||
Declare Function gzclose Lib "ZLIB32.DLL"
|
||||
(ByVal file As Long) As Long
|
||||
#End If
|
||||
|
||||
-Jon Caruana
|
||||
jon-net@usa.net
|
||||
Microsoft Sitebuilder Network Level 1 Member - HTML Writer's Guild Member
|
||||
Reference in New Issue
Block a user