📄 gzio.cod
字号:
0021a 75 17 jne SHORT $LN2@gzread
0021c 8b 76 38 mov esi, DWORD PTR [esi+56]
0021f 83 fe fd cmp esi, -3 ; fffffffdH
00222 74 05 je SHORT $LN37@gzread
00224 83 fe ff cmp esi, -1
00227 75 0a jne SHORT $LN2@gzread
$LN37@gzread:
00229 5d pop ebp
0022a 5f pop edi
0022b 5e pop esi
; 494 : return -1;
0022c 83 c8 ff or eax, -1
0022f 5b pop ebx
; 496 : }
00230 c2 0c 00 ret 12 ; 0000000cH
$LN2@gzread:
00233 5d pop ebp
00234 5f pop edi
00235 5e pop esi
; 495 : return (int)(len - s->stream.avail_out);
00236 2b c1 sub eax, ecx
00238 5b pop ebx
; 496 : }
00239 c2 0c 00 ret 12 ; 0000000cH
$LN36@gzread:
0023c 5f pop edi
0023d 5e pop esi
; 404 :
; 405 : if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1;
0023e 83 c8 ff or eax, -1
00241 5b pop ebx
; 496 : }
00242 c2 0c 00 ret 12 ; 0000000cH
$LN24@gzread:
00245 5e pop esi
; 401 : Byte *next_out; /* == stream.next_out but not forced far (for MSDOS) */
; 402 :
; 403 : if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
00246 b8 fe ff ff ff mov eax, -2 ; fffffffeH
0024b 5b pop ebx
; 496 : }
0024c c2 0c 00 ret 12 ; 0000000cH
_gzread@12 ENDP
_TEXT ENDS
PUBLIC _gzsetparams@12
; Function compile flags: /Ogtpy
; COMDAT _gzsetparams@12
_TEXT SEGMENT
_file$ = 8 ; size = 4
_level$ = 12 ; size = 4
_strategy$ = 16 ; size = 4
_gzsetparams@12 PROC ; COMDAT
; 238 : {
00000 56 push esi
; 239 : gz_stream *s = (gz_stream*)file;
; 240 :
; 241 : if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
00001 8b 74 24 08 mov esi, DWORD PTR _file$[esp]
00005 85 f6 test esi, esi
00007 74 4f je SHORT $LN3@gzsetparam
00009 80 7e 5c 77 cmp BYTE PTR [esi+92], 119 ; 00000077H
0000d 75 49 jne SHORT $LN3@gzsetparam
; 242 :
; 243 : /* Make room to allow flushing */
; 244 : if (s->stream.avail_out == 0) {
0000f 83 7e 10 00 cmp DWORD PTR [esi+16], 0
00013 75 2f jne SHORT $LN2@gzsetparam
; 245 :
; 246 : s->stream.next_out = s->outbuf;
; 247 : if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) {
00015 8b 4e 40 mov ecx, DWORD PTR [esi+64]
00018 8b 46 48 mov eax, DWORD PTR [esi+72]
0001b 51 push ecx
0001c 68 00 40 00 00 push 16384 ; 00004000H
00021 6a 01 push 1
00023 50 push eax
00024 89 46 0c mov DWORD PTR [esi+12], eax
00027 e8 00 00 00 00 call _fwrite
0002c 83 c4 10 add esp, 16 ; 00000010H
0002f 3d 00 40 00 00 cmp eax, 16384 ; 00004000H
00034 74 07 je SHORT $LN1@gzsetparam
; 248 : s->z_err = Z_ERRNO;
00036 c7 46 38 ff ff
ff ff mov DWORD PTR [esi+56], -1
$LN1@gzsetparam:
; 249 : }
; 250 : s->stream.avail_out = Z_BUFSIZE;
0003d c7 46 10 00 40
00 00 mov DWORD PTR [esi+16], 16384 ; 00004000H
$LN2@gzsetparam:
; 251 : }
; 252 :
; 253 : return deflateParams (&(s->stream), level, strategy);
00044 8b 54 24 10 mov edx, DWORD PTR _strategy$[esp]
00048 8b 44 24 0c mov eax, DWORD PTR _level$[esp]
0004c 52 push edx
0004d 50 push eax
0004e 56 push esi
0004f e8 00 00 00 00 call _deflateParams@12
00054 5e pop esi
; 254 : }
00055 c2 0c 00 ret 12 ; 0000000cH
$LN3@gzsetparam:
; 239 : gz_stream *s = (gz_stream*)file;
; 240 :
; 241 : if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR;
00058 b8 fe ff ff ff mov eax, -2 ; fffffffeH
0005d 5e pop esi
; 254 : }
0005e c2 0c 00 ret 12 ; 0000000cH
_gzsetparams@12 ENDP
; Function compile flags: /Ogtpy
_TEXT ENDS
; COMDAT _gz_open
_TEXT SEGMENT
_strategy$ = -88 ; size = 4
_m$ = -84 ; size = 4
_fmode$ = -80 ; size = 80
_path$ = 8 ; size = 4
_fd$ = 12 ; size = 4
_gz_open PROC ; COMDAT
; _mode$ = eax
; 97 : {
00000 83 ec 58 sub esp, 88 ; 00000058H
00003 53 push ebx
00004 55 push ebp
; 98 : int err;
; 99 : int level = Z_DEFAULT_COMPRESSION; /* compression level */
; 100 : int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
00005 33 db xor ebx, ebx
00007 83 cd ff or ebp, -1
; 101 : char *p = (char*)mode;
; 102 : gz_stream *s;
; 103 : char fmode[80]; /* copy of mode, without the compression level */
; 104 : char *m = fmode;
; 105 :
; 106 : if (!path || !mode) return Z_NULL;
0000a 39 5c 24 64 cmp DWORD PTR _path$[esp+92], ebx
0000e 8d 4c 24 10 lea ecx, DWORD PTR _fmode$[esp+96]
00012 57 push edi
00013 89 5c 24 0c mov DWORD PTR _strategy$[esp+100], ebx
00017 8b f8 mov edi, eax
00019 89 4c 24 10 mov DWORD PTR _m$[esp+100], ecx
0001d 0f 84 19 02 00
00 je $LN28@gz_open
00023 3b c3 cmp eax, ebx
00025 0f 84 11 02 00
00 je $LN28@gz_open
0002b 56 push esi
; 107 :
; 108 : s = (gz_stream *)ALLOC(sizeof(gz_stream));
0002c 6a 74 push 116 ; 00000074H
0002e e8 00 00 00 00 call _malloc
00033 8b f0 mov esi, eax
00035 83 c4 04 add esp, 4
; 109 : if (!s) return Z_NULL;
00038 3b f3 cmp esi, ebx
0003a 0f 84 38 01 00
00 je $LN41@gz_open
; 110 :
; 111 : s->stream.zalloc = (alloc_func)0;
; 112 : s->stream.zfree = (free_func)0;
; 113 : s->stream.opaque = (voidpf)0;
; 114 : s->stream.next_in = s->inbuf = Z_NULL;
; 115 : s->stream.next_out = s->outbuf = Z_NULL;
; 116 : s->stream.avail_in = s->stream.avail_out = 0;
; 117 : s->file = NULL;
; 118 : s->z_err = Z_OK;
; 119 : s->z_eof = 0;
; 120 : s->in = 0;
; 121 : s->out = 0;
; 122 : s->back = EOF;
; 123 : s->crc = crc32(0L, Z_NULL, 0);
00040 53 push ebx
00041 53 push ebx
00042 53 push ebx
00043 89 5e 20 mov DWORD PTR [esi+32], ebx
00046 89 5e 24 mov DWORD PTR [esi+36], ebx
00049 89 5e 28 mov DWORD PTR [esi+40], ebx
0004c 89 5e 44 mov DWORD PTR [esi+68], ebx
0004f 89 1e mov DWORD PTR [esi], ebx
00051 89 5e 48 mov DWORD PTR [esi+72], ebx
00054 89 5e 0c mov DWORD PTR [esi+12], ebx
00057 89 5e 10 mov DWORD PTR [esi+16], ebx
0005a 89 5e 04 mov DWORD PTR [esi+4], ebx
0005d 89 5e 40 mov DWORD PTR [esi+64], ebx
00060 89 5e 38 mov DWORD PTR [esi+56], ebx
00063 89 5e 3c mov DWORD PTR [esi+60], ebx
00066 89 5e 64 mov DWORD PTR [esi+100], ebx
00069 89 5e 68 mov DWORD PTR [esi+104], ebx
0006c 89 6e 6c mov DWORD PTR [esi+108], ebp
0006f e8 00 00 00 00 call _crc32@12
00074 89 46 4c mov DWORD PTR [esi+76], eax
; 124 : s->msg = NULL;
; 125 : s->transparent = 0;
; 126 :
; 127 : s->path = (char*)ALLOC(strlen(path)+1);
00077 8b 44 24 6c mov eax, DWORD PTR _path$[esp+100]
0007b 89 5e 50 mov DWORD PTR [esi+80], ebx
0007e 89 5e 58 mov DWORD PTR [esi+88], ebx
00081 8d 50 01 lea edx, DWORD PTR [eax+1]
$LL37@gz_open:
00084 8a 08 mov cl, BYTE PTR [eax]
00086 83 c0 01 add eax, 1
00089 3a cb cmp cl, bl
0008b 75 f7 jne SHORT $LL37@gz_open
0008d 2b c2 sub eax, edx
0008f 83 c0 01 add eax, 1
00092 50 push eax
00093 e8 00 00 00 00 call _malloc
00098 83 c4 04 add esp, 4
; 128 : if (s->path == NULL) {
0009b 3b c3 cmp eax, ebx
0009d 89 46 54 mov DWORD PTR [esi+84], eax
; 129 : return destroy(s), (gzFile)Z_NULL;
000a0 0f 84 cd 00 00
00 je $LN7@gz_open
; 130 : }
; 131 : strcpy(s->path, path); /* do this early for debugging */
000a6 8b 4c 24 6c mov ecx, DWORD PTR _path$[esp+100]
000aa 8b d0 mov edx, eax
000ac 8d 64 24 00 npad 4
$LL32@gz_open:
000b0 8a 01 mov al, BYTE PTR [ecx]
000b2 88 02 mov BYTE PTR [edx], al
000b4 83 c1 01 add ecx, 1
000b7 83 c2 01 add edx, 1
000ba 3a c3 cmp al, bl
000bc 75 f2 jne SHORT $LL32@gz_open
; 132 :
; 133 : s->mode = '\0';
000be 88 5e 5c mov BYTE PTR [esi+92], bl
000c1 b1 72 mov cl, 114 ; 00000072H
$LL25@gz_open:
; 134 : do {
; 135 : if (*p == 'r') s->mode = 'r';
000c3 38 0f cmp BYTE PTR [edi], cl
000c5 75 03 jne SHORT $LN22@gz_open
000c7 88 4e 5c mov BYTE PTR [esi+92], cl
$LN22@gz_open:
; 136 : if (*p == 'w' || *p == 'a') s->mode = 'w';
000ca 8a 07 mov al, BYTE PTR [edi]
000cc 3c 77 cmp al, 119 ; 00000077H
000ce 74 04 je SHORT $LN20@gz_open
000d0 3c 61 cmp al, 97 ; 00000061H
000d2 75 04 jne SHORT $LN21@gz_open
$LN20@gz_open:
000d4 c6 46 5c 77 mov BYTE PTR [esi+92], 119 ; 00000077H
$LN21@gz_open:
; 137 : if (*p >= '0' && *p <= '9') {
000d8 8a 07 mov al, BYTE PTR [edi]
000da 3c 30 cmp al, 48 ; 00000030H
000dc 7c 0c jl SHORT $LN19@gz_open
000de 3c 39 cmp al, 57 ; 00000039H
000e0 7f 08 jg SHORT $LN19@gz_open
; 138 : level = *p - '0';
000e2 0f be e8 movsx ebp, al
000e5 83 ed 30 sub ebp, 48 ; 00000030H
000e8 eb 37 jmp SHORT $LN24@gz_open
$LN19@gz_open:
; 139 : } else if (*p == 'f') {
000ea 3c 66 cmp al, 102 ; 00000066H
000ec 75 0a jne SHORT $LN17@gz_open
; 140 : strategy = Z_FILTERED;
000ee c7 44 24 10 01
00 00 00 mov DWORD PTR _strategy$[esp+104], 1
000f6 eb 29 jmp SHORT $LN24@gz_open
$LN17@gz_open:
; 141 : } else if (*p == 'h') {
000f8 3c 68 cmp al, 104 ; 00000068H
000fa 75 0a jne SHORT $LN15@gz_open
; 142 : strategy = Z_HUFFMAN_ONLY;
000fc c7 44 24 10 02
00 00 00 mov DWORD PTR _strategy$[esp+104], 2
00104 eb 1b jmp SHORT $LN24@gz_open
$LN15@gz_open:
; 143 : } else if (*p == 'R') {
00106 3c 52 cmp al, 82 ; 00000052H
00108 75 0a jne SHORT $LN13@gz_open
; 144 : strategy = Z_RLE;
0010a c7 44 24 10 03
00 00 00 mov DWORD PTR _strategy$[esp+104], 3
; 145 : } else {
00112 eb 0d jmp SHORT $LN24@gz_open
$LN13@gz_open:
; 146 : *m++ = *p; /* copy the mode */
00114 8b 54 24 14 mov edx, DWORD PTR _m$[esp+104]
00118 88 02 mov BYTE PTR [edx], al
0011a 83 c2 01 add edx, 1
0011d 89 54 24 14 mov DWORD PTR _m$[esp+104], edx
$LN24@gz_open:
; 147 : }
; 148 : } while (*p++ && m != fmode + sizeof(fmode));
00121 83 c7 01 add edi, 1
00124 3a c3 cmp al, bl
00126 74 0a je SHORT $LN11@gz_open
00128 8d 54 24 68 lea edx, DWORD PTR _fmode$[esp+184]
0012c 39 54 24 14 cmp DWORD PTR _m$[esp+104], edx
00130 75 91 jne SHORT $LL25@gz_open
$LN11@gz_open:
; 149 : if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL;
00132 8a 46 5c mov al, BYTE PTR [esi+92]
00135 3a c3 cmp al, bl
00137 74 3a je SHORT $LN7@gz_open
; 150 :
; 151 : if (s->mode == 'w') {
00139 3c 77 cmp al, 119 ; 00000077H
0013b 75 45 jne SHORT $LN9@gz_open
; 152 : #ifdef NO_GZCOMPRESS
; 153 : err = Z_STREAM_ERROR;
; 154 : #else
; 155 : err = deflateInit2(&(s->stream), level,
; 156 : Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy);
0013d 8b 44 24 10 mov eax, DWORD PTR _strategy$[esp+104]
00141 6a 38 push 56 ; 00000038H
00143 68 00 00 00 00 push OFFSET ??_C@_05GDHACFMB@1?42?43?$AA@
00148 50 push eax
00149 6a 08 push 8
0014b 6a f1 push -15 ; fffffff1H
0014d 6a 08 push 8
0014f 55 push ebp
00150 56 push esi
00151 e8 00 00 00 00 call _deflateInit2_@32
; 157 : /* windowBits is passed < 0 to suppress zlib header */
; 158 :
; 159 : s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE);
00156 68 00 40 00 00 push 16384 ; 00004000H
0015b 8b f8 mov edi, eax
0015d e8 00 00 00 00 call _malloc
00162 83 c4 04 add esp, 4
; 160 : #endif
; 161 : if (err != Z_OK || s->outbuf == Z_NULL) {
00165 3b fb cmp edi, ebx
00167 89 46 48 mov DWORD PTR [esi+72], eax
0016a 89 46 0c mov DWORD PTR [esi+12], eax
0016d 75 04 jne SHORT $LN7@gz_open
0016f 3b c3 cmp eax, ebx
00171 75 39 jne SHORT $LN5@gz_open
$LN7@gz_open:
; 162 : return destroy(s), (gzFile)Z_NULL;
00173 e8 00 00 00 00 call _destroy
$LN41@gz_open:
00178 5e pop esi
00179 5f pop edi
0017a 5d pop ebp
0017b 33 c0 xor eax, eax
0017d 5b pop ebx
; 203 : }
0017e 83 c4 58 add esp, 88 ; 00000058H
00181 c3 ret 0
$LN9@gz_open:
; 163 : }
; 164 : } else {
; 165 : s->stream.next_in = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE);
00182 68 00 40 00 00 push 16384 ; 00004000H
00187 e8 00 00 00 00 call _malloc
0018c 83 c4 04 add esp, 4
; 166 :
; 167 : err = inflateInit2(&(s->stream), -MAX_WBITS);
0018f 6a 38 push 56 ; 00000038H
00191 68 00 00 00 00 push OFFSET ??_C@_05GDHACFMB@1?42?43?$AA@
00196 6a f1 push -15 ; fffffff1H
00198 56 push esi
00199 89 46 44 mov DWORD PTR [esi+68], eax
0019c 89 06 mov DWORD PTR [esi], eax
0019e e8 00 00 00 00 call _inflateInit2_@16
; 168 : /* windowBits is passed < 0 to tell that there is no zlib header.
; 169 : * Note that in this case inflate *requires* an extra "dummy" byte
; 170 : * after the compressed stream in order to complete decompression and
; 171 : * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
; 172 : * present after the compressed stream.
; 173 : */
; 174 : if (err != Z_OK || s->inbuf == Z_NULL) {
001a3 85 c0 test eax, eax
001a5 75 cc jne⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -