Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 6638 → Rev 6639

/programs/fs/kfar/trunk/zlib/crc32.asm
94,32 → 94,12
je @f ;if (..)
call make_crc_table
@@:
end if ;DYNAMIC_CRC_TABLE
end if
mov eax,crc_table
ret
endp
 
; =========================================================================
macro DO1
{
xor al,byte[esi]
xor al,ah
mov eax,[crc_table+eax*4]
inc esi
}
macro DO8
{
DO1
DO1
DO1
DO1
DO1
DO1
DO1
DO1
}
 
; =========================================================================
;unsigned long (crc, buf, len)
; unsigned long crc
; unsigned char *buf
140,26 → 120,8
end if
 
mov eax,[p1crc]
xor eax,0xffffffff
mov [p1crc],eax
mov ecx,[len]
align 4
.cycle0:
cmp ecx,8
jl @f
DO8
sub ecx,8
jmp .cycle0
align 4
@@:
cmp ecx,1
jl @f
DO1
dec ecx
jmp @b
@@:
mov eax,[p1crc]
xor eax,0xffffffff
call crc
.end_f:
ret
endp
/programs/fs/kfar/trunk/zlib/deflate.asm
198,10 → 198,10
 
; =========================================================================
;int (strm, level, version, stream_size)
; z_streamp strm;
; int level;
; const char *version;
; int stream_size;
; z_streamp strm
; int level
; const char *version
; int stream_size
align 4
proc deflateInit_, strm:dword, level:dword, version:dword, stream_size:dword
stdcall deflateInit2_, [strm], [level], Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,\
220,14 → 220,14
; =========================================================================
;int (strm, level, method, windowBits, memLevel, strategy,
; version, stream_size)
; z_streamp strm;
; int level;
; int method;
; int windowBits;
; int memLevel;
; int strategy;
; const char *version;
; int stream_size;
; z_streamp strm
; int level
; int method
; int windowBits
; int memLevel
; int strategy
; const char *version
; int stream_size
align 4
proc deflateInit2_ uses ebx ecx edx edi, strm:dword, level:dword, method:dword,\
windowBits:dword, memLevel:dword, strategy:dword, version:dword, stream_size:dword
433,9 → 433,9
 
; =========================================================================
;int (strm, dictionary, dictLength)
; z_streamp strm;
; const Bytef *dictionary;
; uInt dictLength;
; z_streamp strm
; const Bytef *dictionary
; uInt dictLength
align 4
proc deflateSetDictionary uses ebx edi, strm:dword, dictionary:dword, dictLength:dword
locals
518,7 → 518,7
 
; =========================================================================
;int (strm)
; z_streamp strm;
; z_streamp strm
align 4
proc deflateResetKeep uses ebx edi, strm:dword
; deflate_state *s;
563,7 → 563,7
if GZIP eq 1
cmp dword[edi+deflate_state.wrap],2
jne @f
stdcall calc_crc32, 0, Z_NULL, 0
xor eax,eax ;stdcall calc_crc32, 0, Z_NULL, 0
@@:
end if
mov dword[ebx+z_stream.adler],eax
578,11 → 578,11
 
; =========================================================================
;int (strm)
; z_streamp strm;
; z_streamp strm
align 4
proc deflateReset uses ebx, strm:dword
mov ebx,[strm]
;zlib_debug 'deflateReset'
zlib_debug 'deflateReset'
stdcall deflateResetKeep, ebx
cmp eax,0
jne @f ;if (..==Z_OK)
593,8 → 593,8
 
; =========================================================================
;int (strm, head)
; z_streamp strm;
; gz_headerp head;
; z_streamp strm
; gz_headerp head
align 4
proc deflateSetHeader uses ebx, strm:dword, head:dword
mov ebx,[strm]
621,9 → 621,9
 
; =========================================================================
;int (strm, pending, bits)
; unsigned *pending;
; int *bits;
; z_streamp strm;
; unsigned *pending
; int *bits
; z_streamp strm
align 4
proc deflatePending uses ebx edi, strm:dword, pending:dword, bits:dword
mov ebx,[strm]
655,9 → 655,9
 
; =========================================================================
;int (strm, bits, value)
; z_streamp strm;
; int bits;
; int value;
; z_streamp strm
; int bits
; int value
align 4
proc deflatePrime uses ebx edi, strm:dword, bits:dword, value:dword
; int put;
691,9 → 691,9
 
; =========================================================================
;int (strm, level, strategy)
; z_streamp strm;
; int level;
; int strategy;
; z_streamp strm
; int level
; int strategy
align 4
proc deflateParams uses ebx edi, strm:dword, level:dword, strategy:dword
; compress_func func;
748,11 → 748,11
 
; =========================================================================
;int (strm, good_length, max_lazy, nice_length, max_chain)
; z_streamp strm;
; int good_length;
; int max_lazy;
; int nice_length;
; int max_chain;
; z_streamp strm
; int good_length
; int max_lazy
; int nice_length
; int max_chain
align 4
proc deflateTune uses ebx, strm:dword, good_length:dword, max_lazy:dword,\
nice_length:dword, max_chain:dword
797,14 → 797,14
; allocation.
 
;uLong (strm, sourceLen)
; z_streamp strm;
; uLong sourceLen;
; z_streamp strm
; uLong sourceLen
align 4
proc deflateBound, strm:dword, sourceLen:dword
; deflate_state *s;
; uLong complen, wraplen;
; Bytef *str;
;zlib_debug 'deflateBound'
zlib_debug 'deflateBound'
 
; conservative upper bound for compressed data
; complen = sourceLen +
863,8 → 863,8
; pending_buf.
 
;void (s, b)
; deflate_state *s;
; uInt b;
; deflate_state *s
; uInt b
align 4
proc putShortMSB uses ebx ecx, s:dword, b:dword
mov ebx,[s]
881,13 → 881,13
; (See also read_buf()).
 
;void (strm)
; z_streamp strm;
; z_streamp strm
align 4
proc flush_pending uses eax ebx ecx edx, strm:dword
;ecx - len
;edx - deflate_state *s
;ebx - strm
;zlib_debug 'flush_pending'
zlib_debug 'flush_pending'
mov ebx,[strm]
mov edx,[ebx+z_stream.state]
 
916,8 → 916,8
 
; =========================================================================
;int (strm, flush)
; z_streamp strm;
; int flush;
; z_streamp strm
; int flush
align 4
proc deflate uses ebx ecx edx edi esi, strm:dword, flush:dword
locals
973,7 → 973,7
if GZIP eq 1
cmp dword[edi+deflate_state.wrap],2
jne .end1 ;if (..==..)
stdcall calc_crc32, 0, Z_NULL, 0
xor eax,eax ;stdcall calc_crc32, 0, Z_NULL, 0
mov [ebx+z_stream.adler],eax
put_byte edi, 31
put_byte edi, 139
1107,7 → 1107,7
bswap ecx
put_dword edi, ecx
@@:
stdcall calc_crc32, 0, Z_NULL, 0
xor eax,eax ;stdcall calc_crc32, 0, Z_NULL, 0
mov [ebx+z_stream.adler],eax
.end2:
if GZIP eq 1
1307,7 → 1307,7
mov ecx,[ebx+z_stream.adler]
put_byte edi, cl
put_byte edi, ch
stdcall calc_crc32, 0, Z_NULL, 0
xor eax,eax ;stdcall calc_crc32, 0, Z_NULL, 0
mov [ebx+z_stream.adler],eax
mov dword[edi+deflate_state.status],BUSY_STATE
@@:
1447,7 → 1447,7
.end11:
cmp word[ebx+z_stream.avail_out],0
jg @f
zlib_debug 'bug2' ;Assert(..>0)
zlib_assert 'bug2' ;Assert(..>0)
@@:
 
cmp dword[flush],Z_FINISH
1496,7 → 1496,7
 
; =========================================================================
;int (strm)
; z_streamp strm;
; z_streamp strm
align 4
proc deflateEnd uses ebx ecx edx, strm:dword
mov ebx,[strm]
1553,13 → 1553,11
; doesn't have enough memory anyway to duplicate compression states).
 
;int (dest, source)
; z_streamp dest;
; z_streamp source;
; z_streamp dest
; z_streamp source
align 4
proc deflateCopy uses edx edi esi, dest:dword, source:dword
locals
overlay dd ? ;uint_16p
endl
proc deflateCopy uses ebx edx edi esi, dest:dword, source:dword
;ebx = overlay ;uint_16p
;edi = ds; deflate_state*
;esi = ss; deflate_state*
 
1597,7 → 1595,7
ZALLOC edx, [edi+deflate_state.hash_size], 4 ;sizeof.dd
mov dword[edi+deflate_state.head],eax
ZALLOC edx, [edi+deflate_state.lit_bufsize], 4 ;sizeof.dw+2
mov [overlay],eax
mov ebx,eax
mov dword[edi+deflate_state.pending_buf],eax
 
cmp dword[edi+deflate_state.window],Z_NULL
1618,13 → 1616,26
mov eax,[edi+deflate_state.w_size]
shl eax,1 ;*= 2*sizeof.db
stdcall zmemcpy, [edi+deflate_state.window], [esi+deflate_state.window], eax
; zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos));
; zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos));
; zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
mov eax,[edi+deflate_state.w_size]
shl eax,2 ;*= sizeof.dd
stdcall zmemcpy, [edi+deflate_state.prev], [esi+deflate_state.prev], eax
mov eax,[edi+deflate_state.hash_size]
shl eax,2 ;*= sizeof.dd
stdcall zmemcpy, [edi+deflate_state.head], [esi+deflate_state.head], eax
stdcall zmemcpy, [edi+deflate_state.pending_buf], [esi+deflate_state.pending_buf], [edi+deflate_state.pending_buf_size]
 
; ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
; ds->d_buf = overlay + ds->lit_bufsize/sizeof(uint_16);
; ds->l_buf = ds->pending_buf + (1+sizeof(uint_16))*ds->lit_bufsize;
mov eax,[edi+deflate_state.pending_buf]
add eax,[esi+deflate_state.pending_out]
sub eax,[esi+deflate_state.pending_buf]
mov [edi+deflate_state.pending_out],eax
mov eax,[edi+deflate_state.lit_bufsize]
shr eax,1 ;/=sizeof.uint_16
add eax,ebx
mov [edi+deflate_state.d_buf],eax
mov eax,[edi+deflate_state.lit_bufsize]
imul eax,3 ;*=1+sizeof.uint_16
add eax,[edi+deflate_state.pending_buf]
mov [edi+deflate_state.l_buf],eax
 
mov eax,edi
add eax,deflate_state.dyn_ltree
1647,9 → 1658,9
; (See also flush_pending()).
 
;int (strm, buf, size)
; z_streamp strm;
; Bytef *buf;
; unsigned size;
; z_streamp strm
; Bytef *buf
; unsigned size
align 4
proc read_buf uses ebx ecx, strm:dword, buf:dword, size:dword
mov ebx,[strm]
1739,8 → 1750,8
endp
 
;uInt (s, cur_match)
; deflate_state *s;
; IPos cur_match; /* current match */
; deflate_state *s
; IPos cur_match ;current match
align 4
proc longest_match uses ebx ecx edx edi esi, s:dword, cur_match:dword
if FASTEST eq 0
1771,18 → 1782,9
; Posf *prev = s->prev;
; uInt wmask = s->w_mask;
 
if UNALIGNED_OK eq 1
; 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 uint_16 scan_start = *(uint_16p*)scan;
; register uint_16 scan_end = *(uint_16p*)(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];
end if
 
; 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.
1812,41 → 1814,6
; However the length of the match is limited to the lookahead, so
; the output of deflate is not affected by the uninitialized values.
 
if ((UNALIGNED_OK eq 1) & MAX_MATCH == 258)
; This code assumes sizeof(unsigned short) == 2. Do not use
; UNALIGNED_OK if your compiler uses a different size.
 
; if (*(uint_16p*)(match+best_len-1) != scan_end ||
; *(uint_16p*)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 (*(uint_16p*)(scan+=2) == *(uint_16p*)(match+=2) &&
; *(uint_16p*)(scan+=2) == *(uint_16p*)(match+=2) &&
; *(uint_16p*)(scan+=2) == *(uint_16p*)(match+=2) &&
; *(uint_16p*)(scan+=2) == *(uint_16p*)(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 ||
1876,18 → 1843,12
; len = MAX_MATCH - (int)(strend - scan);
; scan = strend - MAX_MATCH;
 
end if ;UNALIGNED_OK
 
; if (len > best_len) {
; s->match_start = cur_match;
; best_len = len;
; if (len >= nice_match) break;
if UNALIGNED_OK eq 1
; scan_end = *(uint_16p*)(scan+best_len-1);
else
; scan_end1 = scan[best_len-1];
; scan_end = scan[best_len];
end if
; }
; } while ((cur_match = prev[cur_match & wmask]) > limit
; && --chain_length != 0);
1901,7 → 1862,7
; ---------------------------------------------------------------------------
; Optimized version for FASTEST only
mov edx,[s]
;zlib_debug 'longest_match'
zlib_debug 'longest_match'
 
; 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.
1909,7 → 1870,7
if MAX_MATCH <> 258
cmp dword[edx+deflate_state.hash_bits],8
jge @f
zlib_debug 'Code too clever' ;Assert(..>=.. && ..==..)
zlib_assert 'Code too clever' ;Assert(..>=.. && ..==..)
@@:
end if
mov eax,[edx+deflate_state.window_size]
1916,12 → 1877,12
sub eax,MIN_LOOKAHEAD
cmp [edx+deflate_state.strstart],eax
jle @f
zlib_debug 'need lookahead' ;Assert(..<=..)
zlib_assert 'need lookahead' ;Assert(..<=..)
@@:
mov eax,[edx+deflate_state.strstart]
cmp [cur_match],eax
jl @f
zlib_debug 'no future' ;Assert(..<..)
zlib_assert 'no future' ;Assert(..<..)
@@:
 
mov esi,[edx+deflate_state.window]
1950,7 → 1911,7
mov al,byte[edi]
cmp al,byte[esi]
je @f
zlib_debug 'match[2]?' ;Assert(..==..)
zlib_assert 'match[2]?' ;Assert(..==..)
@@:
 
; We check for insufficient lookahead only every 8th comparison;
1969,7 → 1930,7
add eax,[edx+deflate_state.window]
cmp edi,eax
jle @f
zlib_debug 'wild scan' ;Assert(..<=..)
zlib_assert 'wild scan' ;Assert(..<=..)
@@:
sub edi,ebx
;edi = len
1997,9 → 1958,9
; Check that the match at match_start is indeed a match.
 
;void (s, start, match, length)
; deflate_state *s;
; IPos start, match;
; int length;
; deflate_state *s
; IPos start, match
; int length
align 4
proc check_match, s:dword, start:dword, p3match:dword, length:dword
if DEBUG eq 1
2042,17 → 2003,17
;Объем свободного пространства в конце окна.
;ecx = wsize ;uInt
;edx = s.strm
;zlib_debug 'fill_window'
zlib_debug 'fill_window'
mov edi,[s]
cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
jl @f
zlib_debug 'already enough lookahead' ;Assert(..<..)
zlib_assert 'already enough lookahead' ;Assert(..<..)
@@:
 
mov ecx,[edi+deflate_state.w_size]
mov edx,[edi+deflate_state.strm]
.cycle0: ;do
;zlib_debug 'do'
zlib_debug 'do'
mov ebx,[edi+deflate_state.window_size]
sub ebx,[edi+deflate_state.lookahead]
sub ebx,[edi+deflate_state.strstart]
2135,7 → 2096,7
 
cmp ebx,2
jge @f
zlib_debug 'more < 2' ;Assert(..>=..)
zlib_assert 'more < 2' ;Assert(..>=..)
@@:
mov eax,[edi+deflate_state.window]
add eax,[edi+deflate_state.strstart]
2260,7 → 2221,7
sub eax,MIN_LOOKAHEAD
cmp [edi+deflate_state.strstart],eax
jle @f
zlib_debug 'not enough room for search' ;Assert(..<=..)
zlib_assert 'not enough room for search' ;Assert(..<=..)
@@:
popad
ret
2317,8 → 2278,8
; window to pending_buf.
 
;block_state (s, flush)
; deflate_state *s;
; int flush;
; deflate_state *s
; int flush
align 4
proc deflate_stored uses ebx ecx edi, s:dword, flush:dword
; Stored blocks are limited to 0xffff bytes, pending_buf is limited
2741,7 → 2702,7
.cycle0end:
cmp dword[flush],Z_NO_FLUSH
jne @f
zlib_debug 'no flush?' ;Assert (..!=..)
zlib_assert 'no flush?' ;Assert (..!=..)
@@:
cmp dword[edi+deflate_state.match_available],0
je @f ;if (..)
2780,8 → 2741,8
; deflate switches away from Z_RLE.)
 
;block_state (s, flush)
; deflate_state *s;
; int flush;
; deflate_state *s
; int flush
align 4
proc deflate_rle uses ecx edx edi esi, s:dword, flush:dword
locals
2846,7 → 2807,7
add eax,[edx+deflate_state.window]
cmp edi,eax
jle .end1
zlib_debug 'wild scan' ;Assert(..<=..)
zlib_assert 'wild scan' ;Assert(..<=..)
.end1:
 
; Emit match if have run of MIN_MATCH or longer, else emit literal
2903,8 → 2864,8
; (It will be regenerated if this run of deflate switches away from Huffman.)
 
;block_state (s, flush)
; deflate_state *s;
; int flush;
; deflate_state *s
; int flush
align 4
proc deflate_huff uses ebx edi, s:dword, flush:dword
locals
/programs/fs/kfar/trunk/zlib/deflate.inc
247,8 → 247,7
}
macro put_dword s, d
{
;mov eax,d
;zlib_debug '(%d)',eax
zlib_debug '(%d)',d
movzx eax,word[s+deflate_state.pending]
add eax,[s+deflate_state.pending_buf]
mov dword[eax],d
/programs/fs/kfar/trunk/zlib/example1.asm
106,9 → 106,9
cmp ah,1
jne still
 
.exit:
.exit: ; ª®­¥æ ¯à®£à ¬¬ë
mcall SF_SYS_MISC,SSF_MEM_FREE,[m2]
mcall SF_TERMINATE_PROCESS ; ¨­ ç¥ ª®­¥æ ¯à®£à ¬¬ë
mcall SF_TERMINATE_PROCESS
 
align 4
draw_window:
164,8 → 164,12
mov ecx,[m0size]
mov word[eax+z_stream.avail_in],cx ;à §¬¥à ᦨ¬ ¥¬ë¦ ¤ ­­ëå
mov [eax+z_stream.next_out],m1 ;ãáâ ­ ¢«¨¢ ¥¬ ¡ãä¥à ¤«ï ᦠâ¨ï
mov word[eax+z_stream.avail_out],1024 ;à §¬¥à ¡ãä¥à  ¤«ï ᦠâ¨ï
mov word[eax+z_stream.avail_out],1024 ;à §¬¥à ¡ãä¥à  ¤«ï ᦠâ¨ï (¬ ªá¨¬ã¬ 16 Š¡)
 
;¢ëç¨á«ï¥¬ crc ¤«ï ᦨ¬ ¥¬ë¦ ¤ ­­ëå
stdcall [calc_crc32], 0,m0,ecx
mov edx,eax
 
;call print_z_struct
 
stdcall [deflate], my_strm, Z_FINISH ;Z_NO_FLUSH
172,21 → 176,30
 
;call print_z_struct
 
;à §¬¥à ᦠâëå ¤ ­­ëå: 1024-word[eax+z_stream.avail_out]
mov eax,my_strm
;à §¬¥à ᦠâëå ¤ ­­ëå: 1024-word[my_strm.avail_out]
mov ecx,1024
sub cx,word[eax+z_stream.avail_out]
sub cx,word[my_strm.avail_out]
mov [m1size],ecx
 
;assert(ret != Z_STREAM_ERROR)
;while (strm.avail_out == 0)
 
;áâ ¢¨¬ crc ­  ᦠâë¥ ¤ ­­ë¥
mov ecx,[m1size]
sub ecx,4
add ecx,m1
mov [ecx],edx
 
;ä®à¬¨à®¢ ­¨¥ ⥪áâ  ¤«ï ®â®¡à ¦¥­¨ï ᦠâëå ¤ ­­ëå
;¢ 16-à¨ç­®¬ ¢¨¤¥, ­ã¦­® ⮫쪮 ¤«ï ¯à¨¬¥à 
mov ebx,[m1size]
mov esi,m1
mov edi,buf
mov edx,7
align 4
.cycle1: ;rows
mov ecx,32
align 4
.cycle0: ;cols
stdcall hex_in_str, edi,[esi],2
add edi,2
199,10 → 212,10
mov byte[edi-1],0
dec edx
jnz .cycle1
 
.cycle1end:
mov byte[edi],0
 
;㤠«¥­¨¥ ¡ãä¥à  á à ­¥¥ à á¯ ª®¢ ­­ë¬¨ ¤ ­­ë¬¨
mcall SF_SYS_MISC,SSF_MEM_FREE,[m2]
mov eax,[m1size]
211,7 → 224,7
mov eax,m1
add eax,2
stdcall [deflate_unpack],eax,m2size
mov [m2],eax
mov [m2],eax ;§ ¯¨áì ­®¢ëå à á¯ ª®¢ ­­ëå ¤ ­­ëå
mov ecx,[m0size] ;;; ???
mov [m2size],ecx
ret
243,6 → 256,7
deflateReset dd sz_deflateReset
deflate dd sz_deflate
deflateEnd dd sz_deflateEnd
calc_crc32 dd sz_calc_crc32
 
dd 0,0
 
252,6 → 266,8
sz_deflateReset db 'deflateReset',0
sz_deflate db 'deflate',0
sz_deflateEnd db 'deflateEnd',0
sz_calc_crc32 db 'calc_crc32',0
 
;--------------------------------------------------
system_dir_0 db '/sys/lib/'
lib_name_0 db 'archiver.obj',0
/programs/fs/kfar/trunk/zlib/trees.asm
172,7 → 172,7
align 4
proc send_bits uses eax ecx edi, s:dword, value:dword, length:dword
; Tracevv((stderr," l %2d v %4x ", length, value));
;zlib_debug 'send_bits value = %d',[value]
zlib_debug 'send_bits value = %d',[value]
;if DEBUG eq 1
mov eax,[length]
cmp eax,0
180,7 → 180,7
cmp eax,15
jle .end1
@@:
zlib_debug 'invalid length' ;Assert(..>0 && ..<=15)
zlib_assert 'invalid length' ;Assert(..>0 && ..<=15)
.end1:
mov edi,[s]
add [edi+deflate_state.bits_sent],eax
390,7 → 390,7
align 4
proc _tr_init uses eax edi, s:dword
mov edi,[s]
;zlib_debug '_tr_init'
zlib_debug '_tr_init'
call tr_static_init
 
mov eax,edi
530,7 → 530,7
pushad
mov edi,[s]
mov eax,[k]
;zlib_debug 'pqdownheap k = %d',eax
zlib_debug 'pqdownheap k = %d',eax
mov esi,eax
shl esi,1
mov ax,[edi+deflate_state.heap+2*eax]
604,7 → 604,7
overflow dd 0 ;int ;number of elements with bit length too large
endl
pushad
;zlib_debug 'gen_bitlen'
zlib_debug 'gen_bitlen'
mov edi,[s]
mov edx,[desc]
mov eax,[edx+tree_desc.dyn_tree]
817,7 → 817,7
endl
; The distribution counts are first used to generate the code values
; without bit reversal.
;zlib_debug 'gen_codes'
zlib_debug 'gen_codes'
mov ebx,ebp
sub ebx,2*(MAX_BITS+1)
 
846,7 → 846,7
dec ax
cmp ax,(1 shl MAX_BITS)-1
je @f
zlib_debug 'inconsistent bit counts' ;Assert(..==..)
zlib_assert 'inconsistent bit counts' ;Assert(..==..)
@@:
; Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
 
910,7 → 910,7
mov ecx,[ecx+static_tree_desc.elems]
mov [elems],ecx
mov edi,[s]
;zlib_debug 'build_tree cycle0 ecx = %d',ecx
zlib_debug 'build_tree cycle0 ecx = %d',ecx
 
mov dword[edi+deflate_state.heap_len],0
mov dword[edi+deflate_state.heap_max],HEAP_SIZE
1103,7 → 1103,7
min_count dd 4 ;int ;min repeat count
endl
mov edi,[s]
;zlib_debug 'scan_tree'
zlib_debug 'scan_tree'
mov eax,[tree]
movzx eax,word[eax+Len]
mov [nextlen],eax
1227,7 → 1227,7
min_count dd 4 ;int ;min repeat count
endl
mov edi,[s]
;zlib_debug 'send_tree'
zlib_debug 'send_tree'
; *** tree[max_code+1].Len = -1 ;guard already set
mov eax,[tree]
movzx eax,word[eax+Len]
1287,7 → 1287,7
cmp dword[count],6
jle .end8
@@:
zlib_debug ' 3_6?' ;Assert(..>=.. && ..<=..)
zlib_assert ' 3_6?' ;Assert(..>=.. && ..<=..)
.end8:
mov ebx,edi
add ebx,deflate_state.bl_tree
1410,7 → 1410,7
align 4
proc send_all_trees uses eax ebx ecx edi, s:dword, lcodes:dword, dcodes:dword, blcodes:dword
;ecx = index in bl_order
;zlib_debug 'send_all_trees'
zlib_debug 'send_all_trees'
cmp dword[lcodes],257
jl @f
cmp dword[dcodes],1
1418,7 → 1418,7
cmp dword[blcodes],4
jge .end0
@@:
zlib_debug 'not enough codes' ;Assert(..>=.. && ..>=.. && ..>=..)
zlib_assert 'not enough codes' ;Assert(..>=.. && ..>=.. && ..>=..)
.end0:
cmp dword[lcodes],L_CODES
jg @f
1427,7 → 1427,7
cmp dword[blcodes],BL_CODES
jle .end1
@@:
zlib_debug 'too many codes' ;Assert(..<=.. && ..<=.. && ..<=..)
zlib_assert 'too many codes' ;Assert(..<=.. && ..<=.. && ..<=..)
.end1:
; Tracev((stderr, "\nbl counts: "));
mov edi,[s]
1549,7 → 1549,7
endl
; Build the Huffman trees unless a stored block is forced
mov edi,[s]
;zlib_debug '_tr_flush_block'
zlib_debug '_tr_flush_block'
cmp word[edi+deflate_state.level],0
jle .end0 ;if (..>0)
 
1601,7 → 1601,7
.end0: ;else
cmp dword[buf],0
jne @f
zlib_debug 'lost buf' ;Assert(..!=0)
zlib_assert 'lost buf' ;Assert(..!=0)
@@:
mov eax,[stored_len]
add eax,5
1705,7 → 1705,7
align 4
proc _tr_tally uses ebx edi, s:dword, dist:dword, lc:dword
mov edi,[s]
;zlib_debug '_tr_tally'
zlib_debug '_tr_tally'
mov eax,[edi+deflate_state.last_lit]
shl eax,1
add eax,[edi+deflate_state.d_buf]
1737,7 → 1737,7
cmp ax,D_CODES
jl .end2
@@:
zlib_debug '_tr_tally: bad match' ;Assert(..<.. && ..<=.. && ..<..)
zlib_assert '_tr_tally: bad match' ;Assert(..<.. && ..<=.. && ..<..)
.end2:
mov eax,[lc]
add eax,_length_code
1853,7 → 1853,7
mov [u_code],eax
cmp eax,D_CODES
jl @f
zlib_debug 'bad d_code' ;Assert(..<..)
zlib_assert 'bad d_code' ;Assert(..<..)
@@:
send_code edi, [u_code], [dtree] ;send the distance code
mov eax,[u_code]
1877,7 → 1877,7
add eax,[edi+deflate_state.lit_bufsize]
cmp word[edi+deflate_state.pending],ax
jl @f
zlib_debug 'pendingBuf overflow' ;Assert(..<..)
zlib_assert 'pendingBuf overflow' ;Assert(..<..)
@@:
mov eax,[edi+deflate_state.last_lit]
cmp [lx],eax
1911,10 → 1911,9
; 0xf3ffc07f = binary 11110011111111111100000001111111
locals
black_mask dd 0xf3ffc07f
; int n;
endl
mov edi,[s]
;zlib_debug 'detect_data_type'
zlib_debug 'detect_data_type'
 
; Check for non-textual ("black-listed") bytes.
xor ecx,ecx
1985,7 → 1984,7
; int len ;its bit length
align 4
proc bi_reverse uses ebx, p1code:dword, len:dword
;zlib_debug 'bi_reverse'
zlib_debug 'bi_reverse'
xor eax,eax
@@: ;do
mov ebx,[p1code]
/programs/fs/kfar/trunk/zlib/zconf.inc
5,10 → 5,6
; Compile with -DMAXSEG_64K if the alloc function cannot allocate more
; than 64k bytes at a time (needed on systems with 16-bit int).
 
;if MSDOS
;# define UNALIGNED_OK
;end if
 
; Maximum value for memLevel in deflateInit2
MAX_MEM_LEVEL equ 9
 
30,136 → 26,3
; The memory requirements for inflate are (in bytes) 1 << windowBits
; that is, 32K for windowBits=15 (default value) plus a few kilobytes
; for small objects.
 
; /* Type declarations */
 
;#ifndef OF /* function prototypes */
;# ifdef STDC
;# define OF(args) args
;# else
;# define OF(args) ()
;# endif
;end if
 
;#ifndef Z_ARG /* function prototypes for stdarg */
;# if defined(STDC) || defined(Z_HAVE_STDARG_H)
;# define Z_ARG(args) args
;# else
;# define Z_ARG(args) ()
;# endif
;end if
 
; The following definitions for FAR are needed only for MSDOS mixed
; model programming (small or medium model with some far allocations).
; This was tested only with MSC; for other MSDOS compilers you may have
; to define NO_MEMCPY in zutil.h. If you don't need the mixed model,
; just define FAR to be empty.
 
;#if defined(WINDOWS) || defined(WIN32)
; If building or using zlib as a DLL, define ZLIB_DLL.
; This is not mandatory, but it offers a little performance increase.
 
;# ifdef ZLIB_DLL
;# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
;# ifdef ZLIB_INTERNAL
;# define ZEXTERN extern __declspec(dllexport)
;# else
;# define ZEXTERN extern __declspec(dllimport)
;# endif
;# endif
;# endif /* ZLIB_DLL */
; If building or using zlib with the WINAPI/WINAPIV calling convention,
; define ZLIB_WINAPI.
; Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
 
;#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
;# include <limits.h>
;# if (UINT_MAX == 0xffffffffUL)
;# define Z_U4 unsigned
;# elif (ULONG_MAX == 0xffffffffUL)
;# define Z_U4 unsigned long
;# elif (USHRT_MAX == 0xffffffffUL)
;# define Z_U4 unsigned short
;# endif
;end if
 
;if Z_U4
; typedef Z_U4 z_crc_t;
;else
; typedef unsigned long z_crc_t;
;end if
 
;if HAVE_UNISTD_H /* may be set to #if 1 by ./configure */
;# define Z_HAVE_UNISTD_H
;end if
 
;if HAVE_STDARG_H /* may be set to #if 1 by ./configure */
;# define Z_HAVE_STDARG_H
;end if
 
;if STDC
;# ifndef Z_SOLO
;# include <sys/types.h> /* for off_t */
;# endif
;end if
 
;#if defined(STDC) || defined(Z_HAVE_STDARG_H)
;# ifndef Z_SOLO
;# include <stdarg.h> /* for va_list */
;# endif
;end if
 
; a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
; "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
; though the former does not conform to the LFS document), but considering
; both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
; equivalently requesting no 64-bit operations
 
;#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
;# undef _LARGEFILE64_SOURCE
;end if
 
;#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
;# define Z_HAVE_UNISTD_H
;end if
;#ifndef Z_SOLO
;# if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
;# include <unistd.h> /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
;# ifdef VMS
;# include <unixio.h> /* for off_t */
;# endif
;# ifndef z_off_t
;# define z_off_t off_t
;# endif
;# endif
;end if
 
;#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
;# define Z_LFS64
;end if
 
;#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
;# define Z_LARGE64
;end if
 
;#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
;# define Z_WANT64
;end if
 
;#if !defined(SEEK_SET) && !defined(Z_SOLO)
;# define SEEK_SET 0 /* Seek from beginning of file. */
;# define SEEK_CUR 1 /* Seek from current position. */
;# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
;end if
 
;# define z_off_t long
 
;#if !defined(_WIN32) && defined(Z_LARGE64)
;# define z_off64_t off64_t
;else
;# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
;# define z_off64_t __int64
;# else
;# define z_off64_t z_off_t
;# endif
;end if
/programs/fs/kfar/trunk/zlib/zlib.asm
11,6 → 11,7
GEN_TREES_H equ 0
DEBUG equ 0
DYNAMIC_CRC_TABLE equ 1
Z_SOLO equ 0
 
; define NO_GZIP when compiling if you want to disable gzip header and
; trailer creation by deflate(). NO_GZIP would be used to avoid linking in
20,6 → 21,13
 
macro zlib_debug fmt,p1
{
if DEBUG eq 1
zlib_assert fmt,p1
end if
}
 
macro zlib_assert fmt,p1
{
local .end_t
local .m_fmt
jmp .end_t
36,6 → 44,7
include 'zlib.inc'
include 'deflate.inc'
include 'zutil.asm'
include '../kfar_arc/crc.inc'
include 'crc32.asm'
include 'adler32.asm'
include 'trees.asm'
169,6 → 178,9
dd adeflateReset, deflateReset
dd adeflate, deflate
dd adeflateEnd, deflateEnd
dd adeflateCopy, deflateCopy
dd azError, zError
dd acalc_crc32, calc_crc32
dd 0
 
; exported names
176,4 → 188,7
adeflateInit2 db 'deflateInit2',0
adeflateReset db 'deflateReset',0
adeflate db 'deflate',0
adeflateEnd db 'deflateEnd',0
adeflateEnd db 'deflateEnd',0
adeflateCopy db 'deflateCopy',0
azError db 'zError',0
acalc_crc32 db 'calc_crc32',0
/programs/fs/kfar/trunk/zlib/zlib.inc
212,7 → 212,7
; inflateBackInit_((strm), (windowBits), (window), \
; ZLIB_VERSION, (int)sizeof(z_stream))
 
;#ifndef Z_SOLO
if Z_SOLO eq 0
 
; gzgetc() macro and its supporting function and exposed data structure. Note
; that the real internal state is much larger than the exposed structure.
234,7 → 234,7
;#else
;# define gzgetc(g) \
; ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
;end if
end if
 
; provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
; change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
252,11 → 252,4
;gzFile gzopen_w OF((const wchar_t *path,
; const char *mode));
;end if
;#if defined(STDC) || defined(Z_HAVE_STDARG_H)
;# ifndef Z_SOLO
;int ZEXPORTVA gzvprintf Z_ARG((gzFile file,
; const char *format,
; va_list va));
;# endif
;end if
 
/programs/fs/kfar/trunk/zlib/zutil.asm
107,13 → 107,8
ret
endp
 
;if DEBUG
 
;# define verbose 0
;int z_verbose = verbose;
 
;void (m)
; char *m;
; char *m
align 4
proc z_error, m:dword
; fprintf(stderr, "%s\n", m);
120,16 → 115,16
; exit(1);
ret
endp
;end if
 
; exported to allow conversion of error code to string for compress() and
; uncompress()
 
;const char * (err)
; int err;
; int err
align 4
proc zError, err:dword
; return ERR_MSG(err);
proc zError uses ecx, err:dword
ERR_MSG [err]
mov eax,ecx
ret
endp
 
136,9 → 131,9
;#ifndef HAVE_MEMCPY
 
;void (dest, source, len)
; Bytef* dest;
; const Bytef* source;
; uInt len;
; Bytef* dest
; const Bytef* source
; uInt len
align 4
proc zmemcpy uses ecx edi esi, dest:dword, source:dword, len:dword
mov ecx,[len]
155,9 → 150,9
endp
 
;int (s1, s2, len)
; const Bytef* s1;
; const Bytef* s2;
; uInt len;
; const Bytef* s1
; const Bytef* s2
; uInt len
align 4
proc zmemcmp, s1:dword, s2:dword, len:dword
; uInt j;
170,8 → 165,8
endp
 
;void (dest, len)
; Bytef* dest;
; uInt len;
; Bytef* dest
; uInt len
align 4
proc zmemzero, dest:dword, len:dword
; if (len == 0) return;
182,8 → 177,6
endp
;end if
 
;#ifndef Z_SOLO
 
;voidpf (voidpf opaque, unsigned items, unsigned size)
align 4
proc zcalloc uses ebx ecx, opaque:dword, items:dword, size:dword
200,4 → 193,3
ret
endp
 
;end if /* !Z_SOLO */
/programs/fs/kfar/trunk/zlib/zutil.inc
9,7 → 9,8
 
macro ERR_MSG err
{
mov ecx,Z_NEED_DICT-err
mov ecx,Z_NEED_DICT
sub ecx,err
mov ecx,[4*ecx+z_errmsg]
}