![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to zmatch.asm CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [PGP] / pgp / src|
Return to zmatch.asm CVS log | Up to [PGP] / pgp / src |
1.1 root 1: ;
2: ; Copyright (C) 1990-1992 Mark Adler, Richard B. Wales, and Jean-loup Gailly.
3: ; Permission is granted to any individual or institution to use, copy, or
4: ; redistribute this software so long as all of the original files are included
5: ; unmodified, that it is not sold for profit, and that this copyright notice
6: ; is retained.
7: ;
8: ; match.asm by Jean-loup Gailly.
9:
10: ; match.asm, optimized version of longest_match() in deflate.c
11: ; Must be assembled with masm -ml. To be used only with C large model.
12: ; (For compact model, follow the instructions given below.)
13: ; This file is only optional. If you don't have masm or tasm, use the
14: ; C version (add -DNO_ASM to CFLAGS in makefile.msc and remove match.obj
15: ; from OBJI). If you have reduced WSIZE in zip.h, then change its value
16: ; below.
17: ;
18: ; Turbo C 2.0 does not support static allocation of more than 64K bytes per
19: ; file, and does not have SS == DS. So TC and BC++ users must use:
20: ; tasm -ml -DDYN_ALLOC -DSS_NEQ_DS match;
21: ;
22: ; To simplify the code, the option -DDYN_ALLOC is supported for OS/2
23: ; only if the arrays are guaranteed to have zero offset (allocated by
24: ; halloc). We also require SS==DS. This is satisfied for MSC but not Turbo C.
25:
26: name match
27:
28: ; define LCODE as follows:
29: ; model: compact large (small and medium not supported here)
30: ; LCODE 0 1
31:
32: LCODE equ 1
33: DYN_ALLOC equ 1
34: SS_NEQ_DS equ 1
35: ; For Turbo C, define SS_NEQ_DS as 1, but for MSC you can leave it undefined.
36: ; The code is a little better when SS_NEQ_DS is not defined.
37:
38: ifndef DYN_ALLOC
39: extrn _prev : word
40: extrn _window : byte
41: prev equ _prev ; offset part
42: window equ _window
43: endif
44:
45: _DATA segment word public 'DATA'
46: extrn _match_start : word
47: extrn _prev_length : word
48: extrn _good_match : word
49: extrn _strstart : word
50: extrn _max_chain_length : word
51: ifdef DYN_ALLOC
52: extrn _prev : word
53: extrn _window : word
54: prev equ 0 ; offset forced to zero
55: window equ 0
56: window_seg equ _window[2]
57: window_off equ 0
58: else
59: wseg dw seg _window
60: window_seg equ wseg
61: window_off equ offset _window
62: endif
63: _DATA ends
64:
65: DGROUP group _DATA
66:
67: if LCODE
68: extrn _exit : far
69: else
70: extrn _exit : near
71: endif
72:
73: _TEXT segment word public 'CODE'
74: assume cs: _TEXT, ds: DGROUP
75:
76: public _match_init
77: public _longest_match
78:
79: MIN_MATCH equ 3
80: MAX_MATCH equ 258
81: WSIZE equ 8192 ; keep in sync with zip.h !
82: WMASK equ (WSIZE-1)
83: MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1)
84: MAX_DIST equ (WSIZE-MIN_LOOKAHEAD)
85:
86: prev_ptr dw seg _prev ; pointer to the prev array
87: ifdef SS_NEQ_DS
88: match_start dw 0 ; copy of _match_start if SS != DS
89: endif
90:
91: ; initialize or check the variables used in match.asm.
92:
93: if LCODE
94: _match_init proc far
95: else
96: _match_init proc near
97: endif
98: ifdef SS_NEQ_DS
99: ma_start equ cs:match_start ; does not work on OS/2
100: else
101: assume ss: DGROUP
102: ma_start equ ss:_match_start
103: mov ax,ds
104: mov bx,ss
105: cmp ax,bx ; SS == DS?
106: jne error
107: endif
108: ifdef DYN_ALLOC
109: mov ax,_window[0] ; force zero offset
110: add ax,15
111: mov cx,4
112: shr ax,cl
113: add _window[2],ax
114: mov _window[0],0
115:
116: mov ax,_prev[0] ; force zero offset
117: add ax,15
118: mov cx,4
119: shr ax,cl
120: add _prev[2],ax
121: mov _prev[0],0
122: ifdef SS_NEQ_DS
123: mov ax,_prev[2] ; segment value
124: mov cs:prev_ptr,ax ; ugly write to code, crash on OS/2
125: prev_seg equ cs:prev_ptr
126: else
127: prev_seg equ ss:_prev[2] ; works on OS/2 if SS == DS
128: endif
129: else
130: prev_seg equ cs:prev_ptr
131: endif
132: ret
133: error: call _exit
134:
135: _match_init endp
136:
137: ; -----------------------------------------------------------------------
138: ; Set match_start to the longest match starting at the given string and
139: ; return its length. Matches shorter or equal to prev_length are discarded,
140: ; in which case the result is equal to prev_length and match_start is
141: ; garbage.
142: ; IN assertions: cur_match is the head of the hash chain for the current
143: ; string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
144:
145: ; int longest_match(cur_match)
146:
147: if LCODE
148: _longest_match proc far
149: else
150: _longest_match proc near
151: endif
152: push bp
153: mov bp,sp
154: push di
155: push si
156: push ds
157:
158: if LCODE
159: cur_match equ word ptr [bp+6]
160: else
161: cur_match equ word ptr [bp+4]
162: endif
163: ; window equ es:window (es:0 for DYN_ALLOC)
164: ; prev equ ds:prev
165: ; match equ es:si
166: ; scan equ es:di
167: ; chain_length equ bp
168: ; best_len equ bx
169: ; limit equ dx
170:
171: mov si,cur_match ; use bp before it is destroyed
172: mov bp,_max_chain_length ; chain_length = max_chain_length
173: mov di,_strstart
174: mov dx,di
175: sub dx,MAX_DIST ; limit = strstart-MAX_DIST
176: jae limit_ok
177: sub dx,dx ; limit = NIL
178: limit_ok:
179: add di,2+window_off ; di = offset(window + strstart + 2)
180: mov bx,_prev_length ; best_len = prev_length
181: mov es,window_seg
182: mov ax,es:[bx+di-3] ; ax = scan[best_len-1..best_len]
183: mov cx,es:[di-2] ; cx = scan[0..1]
184: cmp bx,_good_match ; do we have a good match already?
185: mov ds,prev_seg ; (does not destroy the flags)
186: assume ds: nothing
187: jb do_scan ; good match?
188: shr bp,1 ; chain_length >>= 2
189: shr bp,1
190: jmp short do_scan
191:
192: even ; align destination of branch
193: long_loop:
194: ; at this point, ds:di == scan+2, ds:si == cur_match
195: mov ax,[bx+di-3] ; ax = scan[best_len-1..best_len]
196: mov cx,[di-2] ; cx = scan[0..1]
197: mov ds,prev_seg ; reset ds to address the prev array
198: short_loop:
199: dec bp ; --chain_length
200: jz the_end
201: ; at this point, di == scan+2, si = cur_match,
202: ; ax = scan[best_len-1..best_len] and cx = scan[0..1]
203: if (WSIZE-32768)
204: and si,WMASK
205: endif
206: shl si,1 ; cur_match as word index
207: mov si,prev[si] ; cur_match = prev[cur_match]
208: cmp si,dx ; cur_match <= limit ?
209: jbe the_end
210: do_scan:
211: cmp ax,word ptr es:window[bx+si-1] ; check match at best_len-1
212: jne short_loop
213: cmp cx,word ptr es:window[si] ; check min_match_length match
214: jne short_loop
215:
216: lea si,window[si+2] ; si = match
217: mov ax,di ; ax = scan+2
218: mov cx,es
219: mov ds,cx ; ds = es = window
220: mov cx,(MAX_MATCH-2)/2 ; scan for at most MAX_MATCH bytes
221: repe cmpsw ; loop until mismatch
222: je maxmatch ; match of length MAX_MATCH?
223: mismatch:
224: mov cl,[di-2] ; mismatch on first or second byte?
225: sub cl,[si-2] ; cl = 0 if first bytes equal
226: xchg ax,di ; di = scan+2, ax = end of scan
227: sub ax,di ; ax = len
228: sub si,ax ; si = cur_match + 2 + offset(window)
229: sub si,2+window_off ; si = cur_match
230: sub cl,1 ; set carry if cl == 0 (can't use DEC)
231: adc ax,0 ; ax = carry ? len+1 : len
232: cmp ax,bx ; len > best_len ?
233: jle long_loop
234: mov ma_start,si ; match_start = cur_match
235: mov bx,ax ; bx = best_len = len
236: cmp ax,MAX_MATCH ; len >= MAX_MATCH ?
237: jl long_loop
238: the_end:
239: pop ds
240: assume ds: DGROUP
241: ifdef SS_NEQ_DS
242: mov ax,ma_start ; garbage if no match found
243: mov ds:_match_start,ax
244: endif
245: pop si
246: pop di
247: pop bp
248: mov ax,bx ; result = ax = best_len
249: ret
250: maxmatch: ; come here if maximum match
251: cmpsb ; increment si and di
252: jmp mismatch ; force match_length = MAX_LENGTH
253:
254: _longest_match endp
255:
256: _TEXT ends
257: end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.