, komprimering og pakker alt ud enhed ved hjælp af lz77 algoritme for,     borland (turbo) pascal version 7. 0 bidragyder: andrew eigus, enhed lzssunit;, {,     lzssunit - komprimering og pakker alt ud enhed ved hjælp af lz77 algoritme for,     borland (turbo) pascal version 7.0.,     assembler programmør: andy tam, pascal omregningskurs: douglas webb,     enhed omstilling og dynamisk hukommelse fordeling: andrew eigus.,     offentlige version 1.02, senest ændret den 30.11.94.,     mål platforme: dos, dpmi, vinduer,     skrevet af andrew eigus (alias: mr. byte):,     fidonet: 2:5100 /33,     internet: [email protected], aeigus @ kristin. cclu. lv.}, grænseflade (# z +} {denne enhed er klar til brug med dj.murdoch og', s scanhelp nytteværdi, som    vil gøre en borland. tph dossier for det.} {# z -}, konstant,    lzrwbufsize = 8192; (læs stødpudestørrelse} {# z +),    n = 40; (større n - > bedre motorer på store filer.},    f = 18,    tærskel = 2,    nul = n * 2,    inbufptr: ord = lzrwbufsize;,    inbufsize: ord = lzrwbufsize;,    outbufptr: ord = 0,&#z {-), type, (# x twriteproc} {# x lzsquash} (# x lzunsquash},    treadproc = funktion (var - readbuf, var numread: ord): ord;,    (dette er erklæring om skik og brug læs funktion.det burde stå     &#lzrwbufsize&#bytes fra readbuf.afkastet værdi er blevet ignoreret.} {# x treadproc} {# x lzsquash} {# x lzunsquash},    twriteproc = funktion (var - writebuf; tæller: ord, var numwritten: ord): ord; (dette er erklæring for skik at skrive funktion.det burde skrive,      tæller bytes i writebuf og returnere antal faktiske bytes skrevet,      i numwritten variabel.afkastet værdi er blevet ignoreret.} {# z +),    plzrwbuffer = ^ tlzrwbuffer;,    tlzrwbuffer = system [0 - lzrwbufsize - 1] af byte; (fil puffere),    plztextbuf = ^ tlztextbuf;,    tlztextbuf = system [0 - n + f - 2] af byte;,    pleftmomtree = ^ tleftmomtree;,    tleftmomtree = system [0 - n] af ord;,    prighttree = ^ trighttree;,    trighttree = system [0 - n + 256] af ord; denne,    lzssmemrequired = 7 (tlzrwbuffer) * 2 * +,      størrelse (tlztextbuf) + 7 (tleftmomtree) * 2 * + 7 (trighttree), (# z -}, funktion lzinit: boolean, {denne funktion skal indkaldes til andre motorer rutiner,    fra denne enhed - den fordeler hukommelse og initializes alle interne,    variabler, der kræves ved kompression procedurer.hvis fordeling ikke,    lzinit afkast, falske, betyder det, at der er ' t nok hukommelse,    motorer eller dekompression proces.det vender tilbage, hvis initialization,    var vellykket.} {# x lzdone} {# x lzsquash} {# x lzunsquash}, procedure lzsquash (readproc: treadproc; writeproc: twriteproc), (denne procedure anvendes til motorer.readproc angiver skik,    læse funktion, der læser data, og writeproc angiver skik skriver,    funktion, der skriver komprimeret data.} {# x lzunsquash} {# x lzinit} {# x lzdone}, procedure lzunsquash (readproc: treadproc; writeproc: twriteproc), (denne procedure anvendes til dekompression.readproc angiver skik,    læse funktion, der læser komprimeret data, og writeproc angiver,    skik skrive funktion, der skriver decompressed data.} {# x lzsquash} {# x lzinit} {# x lzdone}, procedure (lzdone; denne procedure bør være ringede lige efter, du færdige motorer, eller    dekompression.det deallocates (fri) alle hukommelse, der tildeles af lzinit.,    note: kan du altid ringe til lzdone, efter du er færdig med motorer,    rutiner fra denne enhed.} {# x lzinit} {# x lzsquash} {# x lzunsquash}, gennemførelse, var,    højde, matchpos, matchlen, lastlen: ord;,    textbufp: plztextbuf;,    leftp, momp: pleftmomtree;,    rightp: prighttree;,    codebuf: system [0 - 16] byte;,    lzreadproc: treadproc;,    lzwriteproc: twriteproc;,    inbufp, outbufp: plzrwbuffer;,    bytes: ord;,    igangsat: boolean;, funktion lzss_read: ord; (afkast&#af bytes læse}, begynder,    lzreadproc (inbufp ^, bytes),    lzss_read: = bytes;,; (lzss_read}, funktion lzss_write: ord; (afkast&#af bytes skriftlige}, begynder,    lzwriteproc (outbufp ^, outbufptr, bytes),    lzss_write: = bytes,; (lzss_write}, procedure getc; assembler, asm {,    getc: vender tilbage -racter fra den buffer,            tilbage: al = input -                     bære, der blev fastsat, da eof,},                skubbe bx,                mov bx, inbufptr,                cmp bx, inbufsize,                jb @ getc1,                skubbe cx,                skubbe dx,                skubbe di,                push - si,                kalder lzss_read,                pop si,                pop - di,                far brugte,                pop cx,                mov inbufsize, økse,                eller økse, økse,                jz @ getc2 {; eof),                xor bx, bx,    @ getc1:,                skubbe di,                - les - di [inbufp],                mov al, byte ptr [es: di +)],                pop - di,                inc),                mov inbufptr, bx,                pop bx,                clc {, klare de bære flag),                jmp @ ende,    @ getc2: pop bx,                stc {, bære at angive eof),    @ ende:; (getc).selv putc; assembler. {,    putc: en karakter i output - buffer,               angivelse: al = output -}, asm,                skubbe bx,                mov bx, outbufptr,                skubbe di,                - les - di [outbufp],                mov byte ptr [es: di +)] al,                pop - di,                inc),                cmp bx, lzrwbufsize,                jb @ putc1,                mov outbufptr, lzrwbufsize {så skyl virker.},                skubbe cx,                skubbe dx,                skubbe di,                push - si,                kalder lzss_write,                pop - pop - pop                di,                brugte,                pop cx,                xor bx, bx,    @ putc1: mov outbufptr, bx,                pop bx,; (putc}, procedure inittree; assembler. {,    inittree: sæt alle binære søgning træer.der er 256 bst ' s. en,               for alle strengene begyndte med en særlig karakter.det,               forælder er træ k er knuden n + k + 1, og den er kun en,               ret barn,}, asm,        cld,        skubbe ds,        pop es,        - les - di [rightp] {mov di, udlignes ikke},        tilføje di (n + 1.) * 2,        mov cx, 256,        mov økse, nul,        rep stosw,        - les - di [momp] {mov di, udligne mor},        mov cx, n, n -        rep stosw,; (inittree}, procedure dele; assembler. {,    dele: spred træ operationer til at flytte den knude til ' top ' af             træ.bemærk, at det ikke vil faktisk blive roden af træ,             for til grund for hvert træ er en særlig knude.det,             vil blive ret barn i denne særlige node.,               angivelse: di = knuden skal roteres,}, asm,    @ splay1:,                skubbe bx,                les bx, [momp],                mov si [es: bx + di],                pop bx, {mov si [udligne mor + di]},                cmp si, nul {; udgang, hvis modervirksomheden er en særlig knude} - @ splay4,                skubbe di,                - les - di [momp],                tilføje di, si,                mov bx, es: di] {mov bx [udligne mor + si]).               pop - di,                cmp bx, nul {, kontrollere, om sine bedsteforældre er speciel, jbe @ splay5 {; hvis ikke, så drop),                skubbe bx,                les bx, [leftp],                cmp di, es: bx + si],                pop bx, (cmp di [modregning venstre + si]} {; er den nuværende node er en forladt barn?} jne @ splay2,                skubbe bx,                les bx, [rightp],                mov dx - es: bx + di] {mov dx, [udligne ret + di]} {og udføre en venstre zig operation} les bx, [leftp],                mov [es: bx + si] dx, {mov [udligne forlod + si] dx},                les bx, [rightp],                mov [es: bx + di], si,                pop bx, {mov [udligne ret + di], si),                jmp @ splay3,    @ splay2:,                tryk bx,                les bx, [leftp],                mov dx - es: bx + di] {mov dx, [udligne forlod + di]} {; foretage en ikke -},                les bx, [rightp],                mov [es: bx + si] dx, {mov [udligne ret + si] dx},                les bx, [leftp],                mov [es: bx + di], si,                pop bx, {mov [udligne forlod + di], si),    @ splay3:,                push - si,                les si, [rightp],                mov [es: si +)], di,                pop - {mov [udligne ret + bx] di},                xchg bx, brugte,                skubbe økse,                mov økse, bx,                les bx, [momp],                tilføje bx, økse,                mov [es: bx], si,                les bx, [momp],                mov [es: bx + si] di,                les bx, [momp],                mov [es: bx + di] dx,                mov bx, økse,                pop økse, {mov [udligne mor +)], si,                mov [udligne mor + si] di,                mov [udligne mor + di] dx},    @ splay4: jmp @ ende,    @ splay5:,                skubbe di,                - les - di [momp],                mov cx [es: di +)],                pop - di (mov cx [udligne mor + bx]},                skubbe bx,                les bx, [leftp],                cmp di, es: bx + si],                pop bx, (cmp di [udligne forlod + si]},                jne @ splay7,                skubbe di,                - les - di [leftp],                cmp si [es: di +)],                pop - di (cmp si [udligne forlod + bx]},                jne @ splay6,                tryk økse,                mov økse, di,                - les - di [rightp],                tilføje di, si,                mov dx, es: di] {mov dx, [udligne ret + si]} {og udføre en venstre zig - zag, operation} - les - di [leftp],                mov [es: (+)], dx, {mov [udligne forlod +)], dx},                xchg bx, brugte,                - les - di [momp],                mov [es: di +)], dx, {mov [udligne mor +)], dx},                - les - di [rightp],                tilføje di, økse,                mov bx, es: di] {mov bx, [udligne ret + di]},                - les - di [leftp],                tilføje di, si,                mov [es: di], bx,                - les - di [momp],                mov [es: di +)], si, {mov [udligne forlod + si] bx,                mov [udligne mor +)], si),                mov bx, brugte,                - les - di [rightp],                tilføje di, si,                mov [es: di], bx,                - les - di [rightp],                tilføje di, økse,                mov [es: di], si, {mov [udligne ret + si] bx,                mov [udligne ret + di], si),                - les - di [momp],                mov [es: di +)], si,                - les - di [momp],                tilføje di, si,                stosw,                mov di, økse,                pop økse, {mov [offset - mor +)], si,                mov [udligne mor + si] di},                jmp @ splay9,    @ splay6:,                skubbe økse,                mov økse, si,                les si, [leftp],                tilføje - di,                mov dx.[es: si] {mov dx, [udligne forlod + di]} {og udføre en venstre zig - zag, operation} les si, [rightp],                mov [es: si +)], dx, {mov [udligne ret +)], dx},                xchg bx, dx.                les si, [momp],                mov [es: si +)], dx, {mov [udligne mor +)], dx},                les si, [rightp],                tilføje - di,                mov bx, [es: si] {mov bx, [kompenseres rigtigt. di]},                les si, [leftp],                tilføje, si, økse,                mov [es: si])(mov [udligne forlod + si], bx),                les si, [momp],                mov [es: si +)], økse, {mov [udligne mor +)], si),                mov bx, brugte,                les si, [leftp],                tilføje - di,                mov [es: si], bx, {mov [udligne forlod + di], bx),                les si, [rightp],                tilføje - di,                mov [es: si], økse, {mov [udligne ret + di], si),                les si, - momp],                tilføje, si, økse,                mov [es: si]di (mov [udligne mor + si] di},                les si, [momp],                mov [es: si +)], di,                mov si, økse,                pop økse, {mov [udligne mor + bx] di},                jmp @ splay9,    @ splay7:,                skubbe di,                - les - di [rightp],                cmp si [es: di +)],                pop - di (cmp si [udligne ret + bx]},                jne @ splay8,                skubbe økse,                mov økse, si,                les si, [leftp],                tilføje, si, økse,                mov dx - es: si] {mov dx, [udligne forlod + si]} {; udføre ret zig - zag, les si, [rightp],                mov [es: si +)], dx, {mov [udligne ret +)] dx},                xchg bx, brugte,                les si, [momp],                mov [es: si +)], dx, {mov [udligne mor +)], dx},                les si, [leftp],                tilføje - di,                mov bx, [es: si] (mov bx, [udligne forlod + di]},                les si, [rightp],                tilføje, si, økse,                mov [es: si], bx, {mov [udligne ret + si], bx),                les si, [momp],                mov [es: si +)], økse, {mov [udligne mor +)], si),                mov bx, dx,                les si, [leftp],                tilføje, si, økse,                mov [es: si], bx, {mov [udligne forlod + si], bx),                les si, [leftp],                tilføje - di,                mov [es: si], økse, {mov [udligne forlod + di], si),                les si, [momp],                mov [es: si +)], økse, {mov [udligne mor +)], si),                les si, [momp],                tilføje, si, økse,                mov [es: si), di (mov [udligne mor + si] di},                mov si, økse,                pop økse,                jmp @ splay9,    @ splay8:,                skubbe økse,                mov økse, si,                les si, [rightp],                tilføje - di,                mov dx - es: si] {mov dx, [udligne ret + di]} {; udføre en ret, zig - zag, les si, [leftp],                mov [es: si +)], dx, {mov [udligne forlod +)], dx},                xchg bx, brugte,                les si, [momp],                mov [es: si +)], dx, {mov [udligne mor +)], dx},                les si, [leftp],                tilføje - di,                mov bx, [es: si] {mov bx, [udligne forlod + di]},                les si, [rightp],                tilføje, si, økse,                mov [es: si], bx, {mov [kompenseres rigtigt. si], bx),                les si, [momp],                mov [es: si + bx], økse, {mov [udligne mor +)], si),                mov bx, brugte,                les si, [rightp],                tilføje - di,                mov [es: si], bx, {mov [udligne ret + di], bx),                les si, - leftp],                tilføje - di,                mov [es: si], økse, {mov [udligne forlod + di], si),                les si, [momp],                tilføje, si, økse,                mov [es: si] di,                les si, [momp],                mov [es: si + bx), di (mov [udligne mor + si] di,                mov [udligne mor + bx] di},                mov si, økse,                pop økse,    @ splay9: mov si, cx,                cmp si, nul,                ja @ splay10,                skubbe di,                - les - di [leftp],                tilføje di, si.                cmp bx, [es: di],                pop - di (cmp), [udligne forlod + si]},                jne @ splay10,                skubbe bx,                les bx, [leftp],                mov [es: bx + si] di,                pop bx, {mov [udligne forlod + si] di},                jmp @ splay11,    @ splay10:,                skubbe bx,                les bx, [rightp],                mov [es: bx + si] di,                pop bx, {mov [udligne ret + si] di},    @ splay11:,                skubbe bx,                les bx, [momp],                mov [es: bx + di], si,                pop bx, {mov [udligne mor + di], si),                jmp @ splay1,    @ ende:; (dele), procedure insertnode; assembler. {,    insertnode: indsæt det nye knudepunkt for c -orresponding træ.bemærk, at de,                 position i en snor i bufferen fungerede også som knudepunkt,                 nummer.               angivelse: di = holdning i buffer}, asm,                push - si,                skubbe dx,                skubbe cx,                skubbe bx,                mov dx 1,                xor økse, økse,                mov matchlen, økse,                mov højde, økse,                les si, [textbufp],                tilføje - di,                mov al, byte ptr [es: si] {mov al, byte ptr [fset textbuf + di]},                sømhaj shb di, 1,                tilføje økse, n + 1,                sømhaj shb økse, 1,                mov si, økse,                mov økse, nul,                skubbe bx,                les bx, [rightp],                mov ord ptr [es: bx + di], ax (ptr [udlignes ikke mov ord + di], økse},                les bx, [leftp],                mov ord ptr [es: bx + di], økse,                pop bx, {mov ord ptr [udligne forlod + di], økse},    @ ins1: inc højde,                cmp dx, 0,                jl @ ins3,                skubbe di,                - les - di [rightp],                tilføje di, si,                mov økse, ord ptr [es: di],                pop - di (mov økse, ord ptr [udligne ret + si]},                cmp økse, nul,                je @ ins2,                mov si, økse,                jmp @ ins5,    @ ins2:,                skubbe bx,                les bx, [rightp],                mov ord ptr [es: bx + si), di (mov ord ptr [udligne ret + si] di},                les bx, [momp]                mov ord ptr [es: bx + di], si,                pop bx, {mov ord ptr [udligne mor + di], si),                jmp @ ins11,    @ ins3:,                skubbe bx,                les bx, [leftp],                tilføje bx, si,                mov økse. ord ptr [es: bx],                pop bx, {mov økse, ord ptr [udligne forlod + si]},                cmp økse, nul,                je @ ins4,                mov si, økse,                jmp @ ins5,    @ ins4:,                skubbe bx,                les bx, [leftp],                tilføje bx, si,                mov ord ptr [es: bx), di (mov ord ptr [udligne forlod + si] di},                les bx, [momp],                tilføje bx, di,                mov ord ptr [es: bx] si,                pop bx, {mov ord ptr [udligne mor + di], si),                jmp @ ins11,    @ ins5: mov bx, 1,                shr si, 1,                shr di, 1,                xor ch, ch,                xor dh, dh,    @ ins6:,                pu- si,                les si, [textbufp],                tilføje - di,                mov dl, byte ptr [es: si +)],                pop - si,                skubbe di,                - les - di [textbufp],                tilføje di, si,                mov cl, byte ptr [es: di + bx],                pop - di (mov dl, byte ptr [udligne textbuf + di +)],                mov cl, byte ptr [udligne textbuf + si + bx]},                sub dx, cx,                jnz @ ins7,                inc),                cmp bx, f,               jb @ ins6,    @ ins7: sømhaj shb si, 1,                sømhaj shb di, 1,                cmp bx, matchlen,                jbe @ ins1,                mov økse, si,                shr økse, 1,                mov matchpos, økse,                mov matchlen, bx,                cmp bx, f,                jb. ins1,    @ ins8:,                skubbe cx,                les bx, [momp],                mov økse, ord ptr [es: bx + si] {mov økse, ord ptr [udligne mor + si]},                les bx, [momp],                mov ord ptr [es: bx + di], økse, {mov ord ptr [udligne mor + di], økse},                les bx, [leftp],                mov cx, ord ptr [es: bx + si] {mov bx, ord ptr [udligne forlod + si]).                les bx, [leftp],                mov ord ptr [es: bx + di], cx, {mov ord ptr [udligne forlod + di], bx),                les bx, [momp],                tilføje bx, cx,                mov ord ptr [es: bx), di (mov ord ptr [udligne mor + bx] di},                les bx, [rightp],                mov cx, ord ptr [es: bx + si] {mov bx, ord ptr [udligne ret + si]},                les bx, [rightp],                mov ord ptr [es: bx + di], cx, {mov ord ptr [udligne ret + di], bx),                les bx, [momp],                tilføj bx, cx,                mov ord ptr [es: bx), di (mov ord ptr [udligne mor + bx] di},                les bx, [momp],                mov cx, ord ptr [es: bx + si] {mov bx, ord ptr [udligne mor + si]),                mov bx, cx,                pop cx,                skubbe di,               - les - di [rightp],                cmp - ord ptr [es: di +)],                pop - di (cmp - ord ptr [udligne ret + bx]},                jne @ ins9,                push - si,                les si, [rightp],                mov ord ptr [es: si +)], di,                pop - {mov ord ptr [udligne ret + bx] di},                jmp @ ins10,    @ ins9:,                push - si,                les si, [leftp],                mov ord ptr [es: si +)], di,                pop - {mov ord ptr [afder gik + bx] di},    @ ins10:,                skubbe di,                - les - di [momp],                tilføje di, si,                mov ord ptr [es: di], nul,                pop - di (mov ord ptr [udligne mor + si], nul},    @ ins11: cmp højde, 30,                jb @ ins12,                kalder dele,    @ ins12: pop bx,                pop cx,                far brugte,                pop - si,                shr di, 1; (insertnode}, procedure deletenode; assembler. {,     deletenode: slette node fra træet.,              angivelse: si = holdning i buffer}, asm,                skubbe di,                skubbe bx,                sømhaj shb si, 1,                skubbe di,                - les - di [momp],                tilføje di, si,                cmp ord ptr [es: di], nul,                pop - di (cmp ord ptr [udligne mor + si], nul} {; hvis det ikke har nogen forældre så exit} je @ del7,                skubbe di,                - les - di [rightp],                tilføje di, si,                cmp ord ptr [es: di], nul,                pop - di (cmp ord ptr [udligne ret + si], nul} {, har det, ikke?} je @ del8,                skubbe bx,                les bx, [leftp],                mov di, ord ptr [es: bx + si],                pop bx, {mov di, ord ptr [udligne forlod + si]} {; det har forladt barn?} cmp di, nul,                je @ del9,                push - si,                les si, [rightp],                tilføje - di,                mov økse, ord ptr [es: si],                pop - {mov økse, ord ptr [udligne ret + di]} {, har det, ret barnebarn?} cmp økse, nul,                je @ del2 {; hvis der ikke så drop),    @ del1: mov di, ax