Lzss unidad

Lzss unidad

Lzss unidad : Multi-millones de consejos para hacer su vida mas facil.

Comprimir y descomprimir unidad utilizando el algoritmo LZ77 para
Borland (Turbo Pascal version 7.0

Colaborador: ANDREW EIGUS

la Unidad de LZSSUnit
{
LZSSUNIT - Comprimir y descomprimir unidad utilizando el algoritmo LZ77 para
Borland (Turbo Pascal version 7.0.

Ensamblador Programador: Andy Tam, Pascal Conversion: Douglas Webb,
la Conversion de la Unidad y la Asignacion Dinamica de Memoria: Andrew Eigus.

Dominio Publico de la version 1.02, modificada en 30.11.94.
plataformas de Destino: DOS, DPMI, Windows.

Escrito por Andrew Eigus (aka: el Señor de Bytes) de:
Fidonet: 2:5100/33,
Internet: [email protected], [email protected].
}

interfaz

{#Z }
{ Esta unidad esta lista para su uso con Dj. Murdoch & #39 s ScanHelp utilidad que
va a hacer un Borland .TPH archivo. }
{#Z}

const
LZRWBufSize = 8192 { tamaño de bufer de Lectura }

{#Z }
N = 4096 { Mayor N -> Mejor compresion de archivos de gran tamaño solamente. }
F = 18
Umbral = 2
Nul = N * 2
InBufPtr : palabra = LZRWBufSize
InBufSize : palabra = LZRWBufSize
OutBufPtr : palabra = 0
{#Z}

tipo
{#X TWriteProc}{#X LZSquash}{#X LZUnsquash}

TReadProc = function(var ReadBuf var NumRead : word) : word
{ Esta es la declaracion para la costumbre de la funcion de lectura. Deberia leer
#LZRWBufSize# bytes de ReadBuf. El valor de retorno es ignorado. }

{#X TReadProc}{#X LZSquash}{#X LZUnsquash}
TWriteProc = function(var WriteBuf Count : word var NumWritten : word) :
palabra { Esta es la declaracion para la costumbre de escribir la funcion. Se debe escribir
el Recuento de bytes en WriteBuf y devuelve el numero de bytes escritos
en NumWritten variable. El valor de retorno es ignorado. }

{#Z }
PLZRWBuffer = ^TLZRWBuffer
TLZRWBuffer = array[0..LZRWBufSize - 1] of Byte { archivo de buferes }

PLZTextBuf = ^TLZTextBuf
TLZTextBuf = array[0..N F - 2] of Byte

PLeftMomTree = ^TLeftMomTree
TLeftMomTree = array[0..N] de la Palabra
PRightTree = ^TRightTree
TRightTree = array[0..N 256] de la Palabra

const
LZSSMemRequired = SizeOf(TLZRWBuffer) * 2
SizeOf(TLZTextBuf) SizeOf(TLeftMomTree) * 2 SizeOf(TRightTree)
{#Z}

la funcion de LZInit : boolean
{ Esta funcion debe ser llamada antes de cualquier otra rutinas de compresion
desde esta unidad se asigna memoria e inicializa todos los internos
las variables requeridas por la compresion de los procedimientos. Si la asignacion de falla,
LZInit devuelve False, esto significa que no hay & #39 t de memoria suficiente para
la compresion o descompresion de proceso. Devuelve True si la inicializacion
fue un exito. }
{#X LZDone}{#X LZSquash}{#X LZUnsquash}

procedimiento LZSquash(ReadProc : TReadProc WriteProc : TWriteProc)
{ Este procedimiento se utiliza para la compresion. ReadProc especifica personalizado
la funcion de lectura que lee los datos, y WriteProc especifica de escritura personalizado
la funcion que escribe datos comprimidos. }
{#X LZUnsquash}{#X LZInit}{#X LZDone}

procedimiento LZUnSquash(ReadProc : TReadProc WriteProc : TWriteProc)
{ Este procedimiento se utiliza para la descompresion. ReadProc especifica personalizado
la funcion de lectura que lee datos comprimidos, y WriteProc especifica
la costumbre de escribir la funcion que escribe los datos comprimidos. }
{#X LZSquash}{#X LZInit}{#X LZDone}

procedimiento LZDone
{ Este procedimiento debe ser llamado despues de terminada la compresion o
la descompresion. Se desasigna (libera) toda la memoria asignada por LZInit.
Nota: Usted debe llamar siempre LZDone despues de terminado el uso de la compresion
rutinas de esta unidad. }
{#X LZInit}{#X LZSquash}{#X LZUnsquash}

aplicacion

var
Altura, MatchPos, MatchLen, LastLen : word
TextBufP : PLZTextBuf
LeftP, MomP : PLeftMomTree
RightP : PRightTree
CodeBuf : array[0..16] de Bytes
LZReadProc : TReadProc
LZWriteProc : TWriteProc
InBufP, OutBufP : PLZRWBuffer
Bytes : word
Inicializa : boolean

la Funcion de LZSS_Read : palabra { Devuelve # de bytes leidos }
Begin
LZReadProc(InBufP^, Bytes)
LZSS_Read := Bytes
End { LZSS_Read }

la Funcion de LZSS_Write : palabra { Devuelve # de bytes escritos }
Begin
LZWriteProc(OutBufP^, OutBufPtr, Bytes)
LZSS_Write := Bytes
End { LZSS_Write }

Procedimiento Getc ensamblador
Asm
{
getc : devolver un caracter en el buffer
de RETORNO : AL = entrada char
Llevar el set al EF
}
push bx
mov bx, inBufPtr
cmp bx, inBufSize
jb @getc1
push cx
push dx
push di
empuje si
llame LZSS_Read
pop si
pop-di
pop dx
pop cx
mov inBufSize, ax
o ax, ax
jz @getc2 { EF }
xor bx, bx
@getc1:
PUSH DI
LES DI,[InBufP]
MOV AL,BYTE PTR [ES:DI BX]
POP-DI
inc bx
mov inBufPtr, bx
pop bx
clc { borrar el llevar la bandera }
jmp @finales
@getc2: pop bx
stc { set llevar a indicar EF }
@final:
End { Getc }

Procedimiento Putc ensamblador
{
putc : poner un caracter en el buffer de salida
Entrada : AL = salida char
}
Asm
push bx
mov bx, outBufPtr
PUSH DI
LES DI,[OutBufP]
MOV BYTE PTR [ES:DI BX],AL
POP-DI
inc bx
cmp bx, LZRWBufSize
jb @putc1
mov OutBufPtr,LZRWBufSize { Solo para el vaciado de trabajo. }
push cx
push dx
push di
empuje si
llame LZSS_Write
pop si
pop-di
pop dx
pop cx
xor bx, bx
@putc1: mov outBufPtr, bx
pop bx
End { Putc }

Procedimiento InitTree ensamblador
{
initTree : inicializar todos los arboles de busqueda binaria. Hay 256 BST & #39 s,
para todas las cadenas se inicio con un personaje en particular. La
padre es el arbol K es el nodo N K 1 y solo tiene un
boton derecho del niño
}
Asm
cld
push ds
pop es
LES DI,[RightP]
{ mov di,offset derecho}
add di, (N 1) * 2
mov cx, 256
mov ax, NUL
rep stosw
LES DI,[MomP]
{ mov di, offset mama}
mov cx, N
rep stosw
End { InitTree }

Procedimiento de Separacion ensamblador
{
separacion : el uso de separacion arbol de operaciones para mover el nodo a la & #39 top & #39 de
arbol. Nota que no es real se convierten en la raiz del arbol
debido a que la raiz de cada arbol es un nodo especial. En su lugar,
se convertira en el derecho del hijo de este nodo especial.

ENTRADA : di = el nodo a girarse
}
Asm
@Splay1:
PUSH BX
LES BX,[MomP]
MOV SI,[ES:BX DI]
POP BX
{ mov si, [Offset Mama di]}
cmp si, NUL { exit si su padre es un especial
nodo } ja @Splay4
PUSH DI
LES DI,[MomP]
ADD DI,SI
MOV BX,[ES:DI]
{ mov bx, [Offset Mama si]}
POP-DI
cmp bx, NUL { comprobar si su abuelo es especial
} jbe @Splay5 { si no, entonces skip }
PUSH BX
LES BX,[LeftP]
CMP DI,[ES:BX SI]
POP BX
{ cmp di, [Desplazamiento a la Izquierda si]} { es el nodo actual es un
a la izquierda niño ? } jne @Splay2
PUSH BX
LES BX,[RightP]
MOV DX,[ES:BX DI]
{ mov dx, [Offset Derecho di]} { realizar una izquierda zig
operacion } LES BX,[LeftP]
MOV [ES:BX SI],DX
{ mov [Desplazamiento a la Izquierda si], dx}
LES BX,[RightP]
MOV [ES:BX DI] SI
POP BX
{ mov [Offset Derecho di], si}
jmp @Splay3
@Splay2:
PUSH BX
LES BX,[LeftP]
MOV DX,[ES:BX DI]
{ mov dx, [Desplazamiento a la Izquierda de di]} { realizar un derecho de zig }
LES BX,[RightP]
MOV [ES:BX SI],DX
{ mov [Desplazamiento a la Derecha si], dx}
LES BX,[LeftP]
MOV [ES:BX DI] SI
POP BX
{ mov [Desplazamiento a la Izquierda de di], si}
@Splay3:
EMPUJE SI
LES SI,[RightP]
MOV [ES:SI BX],DI
POP SI
{ mov [Offset Derecho bx], di}
xchg bx, dx
PUSH AX
MOV AX,BX
LES BX,[MomP]
ADD BX,AX
MOV [ES:BX],SI
LES BX,[MomP]
MOV [ES:BX SI],DI
LES BX,[MomP]
MOV [ES:BX DI],DX
MOV BX,AX
POP AX
{ mov [Offset Mama bx], si
mov [Offset Mama si], di
mov [Offset Mama di], dx}
@Splay4: jmp @finales
@Splay5:
PUSH DI
LES DI,[MomP]
MOV CX,[ES:DI BX]
POP-DI
{ mov cx, [Offset Mama bx]}
PUSH BX
LES BX,[LeftP]
CMP DI,[ES:BX SI]
POP BX
{ cmp di, [Desplazamiento a la Izquierda si]}
jne @Splay7
PUSH DI
LES DI,[LeftP]
CMP SI,[ES:DI BX]
POP-DI
{ cmp si, [Desplazamiento a la Izquierda bx]}
jne @Splay6
PUSH AX
MOV AX,DI
LES DI,[RightP]
ADD DI,SI
MOV DX,[ES:DI]
{ mov dx, [Desplazamiento a la Derecha si] } { realizar una izquierda zig-zig
operacion } LES DI,[LeftP]
MOV [ES:DI BX],DX
{ mov [Desplazamiento a la Izquierda bx], dx}
xchg bx, dx
LES DI,[MomP]
MOV [ES:DI BX],DX
{ mov [Offset Mama bx], dx}
LES DI,[RightP]
ADD DI,AX
MOV BX,[ES:DI]
{ mov bx, [Offset Derecho di]}
LES DI,[LeftP]
ADD DI,SI
MOV [ES:DI],BX
LES DI,[MomP]
MOV [ES:DI BX],SI
{ mov [Desplazamiento a la Izquierda si], bx
mov [Offset Mama bx], si}
mov bx, dx
LES DI,[RightP]
ADD DI,SI
MOV [ES:DI],BX
LES DI,[RightP]
ADD DI,AX
MOV [ES:DI] SI
{ mov [Desplazamiento a la Derecha si], bx
mov [Offset Derecho di], si}
LES DI,[MomP]
MOV [ES:DI BX],SI
LES DI,[MomP]
ADD DI,SI
STOSW
MOV DI,AX
POP AX
{ mov [Offset Mama bx], si
mov [Offset Mama si], di}
jmp @Splay9
@Splay6:
PUSH AX
MOV AX,SI
LES SI,[LeftP]
AGREGAR SI,DI
MOV DX,[ES:SI]
{ mov dx, [Desplazamiento a la Izquierda de di]} { realizar una izquierda en zigzag
operacion } LES SI,[RightP]
MOV [ES:SI BX],DX
{ mov [Offset Derecho bx], dx}
xchg bx, dx
LES SI,[MomP]
MOV [ES:SI BX],DX
{ mov [Offset Mama bx], dx}
LES SI,[RightP]
AGREGAR SI,DI
MOV BX,[ES:SI]
{ mov bx, [Offset Derecho di]}
LES SI,[LeftP]
AGREGAR SI,AX
MOV [ES:SI],BX
{ mov [Desplazamiento a la Izquierda si], bx}
LES SI,[MomP]
MOV [ES:SI BX],AX
{ mov [Offset Mama bx], si}
mov bx, dx
LES SI,[LeftP]
AGREGAR SI,DI
MOV [ES:SI],BX
{ mov [Desplazamiento a la Izquierda de di], bx}
LES SI,[RightP]
AGREGAR SI,DI
MOV [ES:SI],AX
{ mov [Offset Derecho di], si}
LES SI,[MomP]
AGREGAR SI,AX
MOV [ES:SI],DI
{ mov [Offset Mama si], di}
LES SI,[MomP]
MOV [ES:SI BX],DI
MOV SI,AX
POP AX
{ mov [Offset Mama bx], di}
jmp @Splay9
@Splay7:
PUSH DI
LES DI,[RightP]
CMP SI,[ES:DI BX]
POP-DI
{ cmp si, [Offset Derecho bx]}
jne @Splay8
PUSH AX
MOV AX,SI
LES SI,[LeftP]
AGREGAR SI,AX
MOV DX,[ES:SI]
{ mov dx, [Desplazamiento a la Izquierda si]} { realizar un derecho de zig-zig
} LES SI,[RightP]
MOV [ES:SI BX],DX
{ mov [Offset Derecho bx], dx}
xchg bx, dx
LES SI,[MomP]
MOV [ES:SI BX],DX
{ mov [Offset Mama bx], dx}
LES SI,[LeftP]
AGREGAR SI,DI
MOV BX,[ES:SI]
{ mov bx, [Desplazamiento a la Izquierda de di]}
LES SI,[RightP]
AGREGAR SI,AX
MOV [ES:SI],BX
{ mov [Desplazamiento a la Derecha si], bx}
LES SI,[MomP]
MOV [ES:SI BX],AX
{ mov [Offset Mama bx], si}
mov bx, dx
LES SI,[LeftP]
AGREGAR SI,AX
MOV [ES:SI],BX
{ mov [Desplazamiento a la Izquierda si], bx}
LES SI,[LeftP]
AGREGAR SI,DI
MOV [ES:SI],AX
{ mov [Desplazamiento a la Izquierda de di], si}
LES SI,[MomP]
MOV [ES:SI BX],AX
{ mov [Offset Mama bx], si}
LES SI,[MomP]
AGREGAR SI,AX
MOV [ES:SI],DI
{ mov [Offset Mama si], di}
MOV SI,AX
POP AX
jmp @Splay9
@Splay8:
PUSH AX
MOV AX,SI
LES SI,[RightP]
AGREGAR SI,DI
MOV DX,[ES:SI]
{ mov dx, [Offset Derecho di]} { realizar un derecho de zigzag
} LES SI,[LeftP]
MOV [ES:SI BX],DX
{ mov [Desplazamiento a la Izquierda bx]dx}
xchg bx, dx
LES SI,[MomP]
MOV [ES:SI BX],DX
{ mov [Offset Mama bx], dx}
LES SI,[LeftP]
AGREGAR SI,DI
MOV BX,[ES:SI]
{ mov bx, [Desplazamiento a la Izquierda de di]}
LES SI,[RightP]
AGREGAR SI,AX
MOV [ES:SI],BX
{ mov [Desplazamiento a la Derecha si], bx}
LES SI,[MomP]
MOV [ES:SI BX],AX
{ mov [Offset Mama bx], si}
mov bx, dx
LES SI,[RightP]
AGREGAR SI,DI
MOV [ES:SI],BX
{ mov [Offset Derecho di], bx}
LES SI,[LeftP]
AGREGAR SI,DI
MOV [ES:SI],AX
{ mov [Desplazamiento a la Izquierda de di], si}
LES SI,[MomP]
AGREGAR SI,AX
MOV [ES:SI],DI
LES SI,[MomP]
MOV [ES:SI BX],DI
{ mov [Offset Mama si], di
mov [Offset Mama bx], di}
MOV SI,AX
POP AX
@Splay9: mov si, cx
cmp si, NUL
ja @Splay10
PUSH DI
LES DI,[LeftP]
ADD DI,SI
CMP BX,[ES:DI]
POP-DI
{ cmp bx, [Desplazamiento a la Izquierda si]}
jne @Splay10
PUSH BX
LES BX,[LeftP]
MOV [ES:BX SI],DI
POP BX
{ mov [Desplazamiento a la Izquierda si], di}
jmp @Splay11
@Splay10:
PUSH BX
LES BX,[RightP]
MOV [ES:BX SI],DI
POP BX
{ mov [Desplazamiento a la Derecha si], di}
@Splay11:
PUSH BX
LES BX,[MomP]
MOV [ES:BX DI] SI
POP BX
{ mov [Offset Mama di], si}
jmp @Splay1
@final:
End { Separacion }

Procedimiento InsertNode ensamblador
{
insertNode : insertar el nuevo nodo al arbol correspondiente. Tenga en cuenta que el
la posicion de una cadena de caracteres en el bufer tambien sirvio como el nodo
numero.
ENTRADA : di = posicion en el bufer
}
Asm
empuje si
push dx
push cx
push bx
mov dx, 1
xor ax, ax
mov matchLen, ax
mov altura, ax
LES SI,[TextBufP]
AGREGAR SI,DI
MOV AL,BYTE PTR [ES:SI]
{ mov al, byte ptr [Offset TextBuf di]}
shl di, 1
add ax, N 1
shl ax, 1
mov si, ax
mov ax, NUL
PUSH BX
LES BX,[RightP]
MOV WORD PTR [ES:BX DI],AX
{ mov word ptr [Offset Derecho di], ax}
LES BX,[LeftP]
MOV WORD PTR [ES:BX DI],AX
POP BX
{ mov word ptr [Desplazamiento a la Izquierda de di], ax}
@Ins1:inc altura
cmp dx, 0
jl @Ins3
PUSH DI
LES DI,[RightP]
ADD DI,SI
MOV AX,WORD PTR [ES:DI]
POP-DI
{ mov ax, word ptr [Desplazamiento a la Derecha si]}
cmp ax, NUL
je @Ins2
mov si, ax
jmp @Ins5
@Ins2:
PUSH BX
LES BX,[RightP]
MOV WORD PTR [ES:BX SI],DI
{ mov word ptr [Desplazamiento a la Derecha si], di}
LES BX,[MomP]
MOV WORD PTR [ES:BX DI],SI
POP BX
{ mov word ptr [Offset Mama di], si}
jmp @Ins11
@Ins3:
PUSH BX
LES BX,[LeftP]
ADD BX,SI
MOV AX,WORD PTR [ES:BX]
POP BX
{ mov ax, word ptr [Desplazamiento a la Izquierda si]}
cmp ax, NUL
je @Ins4
mov si, ax
jmp @Ins5
@Ins4:
PUSH BX
LES BX,[LeftP]
ADD BX,SI
MOV WORD PTR [ES:BX],DI
{ mov word ptr [Desplazamiento a la Izquierda si], di}
LES BX,[MomP]
ADD BX,DI
MOV WORD PTR [ES:BX],SI
POP BX
{ mov word ptr [Offset Mama di], si}
jmp @Ins11
@Ins5: mov bx, 1
shr si, 1
shr di, 1
xor ch, ch
xor dh, dh
@Ins6:
EMPUJE SI
LES SI,[TextBufP]
AGREGAR SI,DI
MOV DL,BYTE PTR [ES:SI BX]
POP SI
PUSH DI
LES DI,[TextBufP]
ADD DI,SI
MOV CL,BYTE PTR [ES:DI BX]
POP-DI
{ mov dl, byte ptr [Offset Textbuf di bx]
mov cl, byte ptr [Offset TextBuf si bx]}
sub dx, cx
jnz @Ins7
inc bx
cmp bx, F
jb @Ins6
@Ins7: shl si, 1
shl di, 1
cmp bx, matchLen
jbe @Ins1
mov ax, si
shr ax, 1
mov matchPos, ax
mov matchLen, bx
cmp bx, F
jb @Ins1
@Ins8:
PUSH CX
LES BX,[MomP]
MOV AX,WORD PTR [ES:BX SI]
{ mov ax, word ptr [Offset Mama si]}
LES BX,[MomP]
MOV WORD PTR [ES:BX DI],AX
{ mov word ptr [Offset Mama di], ax}
LES BX,[LeftP]
MOV CX,WORD PTR [ES:BX SI]
{ mov bx, word ptr [Desplazamiento a la Izquierda si]}
LES BX,[LeftP]
MOV WORD PTR [ES:BX DI],CX
{ mov word ptr [Desplazamiento a la Izquierda de di], bx}
LES BX,[MomP]
ADD BX,CX
MOV WORD PTR [ES:BX],DI
{ mov word ptr [Offset Mama bx], di}
LES BX,[RightP]
MOV CX,WORD PTR [ES:BX SI]
{ mov bx, word ptr [Desplazamiento a la Derecha si]}
LES BX,[RightP]
MOV WORD PTR [ES:BX DI],CX
{ mov word ptr [Offset Derecho di], bx}
LES BX,[MomP]
ADD BX,CX
MOV WORD PTR [ES:BX],DI
{ mov word ptr [Offset Mama bx], di}
LES BX,[MomP]
MOV CX,WORD PTR [ES:BX SI]
{ mov bx, word ptr [Offset Mama si]}
MOV BX,CX
POP CX
PUSH DI
LES DI,[RightP]
CMP SI,WORD PTR [ES:DI BX]
POP-DI
{ cmp si, word ptr [Offset Derecho bx]}
jne @Ins9
EMPUJE SI
LES SI,[RightP]
MOV WORD PTR [ES:SI BX],DI
POP SI
{ mov word ptr [Offset Derecho bx], di}
jmp @Ins10
@Ins9:
EMPUJE SI
LES SI,[LeftP]
MOV WORD PTR [ES:SI BX],DI
POP SI
{ mov word ptr [Desplazamiento a la Izquierda bx], di}
@Ins10:
PUSH DI
LES DI,[MomP]
ADD DI,SI
MOV WORD PTR [ES:DI],NULL
POP-DI
{ mov word ptr [Offset Mama si], NULL}
@Ins11: cmp altura, 30
jb @Ins12
llame Splay
@Ins12: pop bx
pop cx
pop dx
pop si
shr di, 1
End { InsertNode }

Procedimiento DeleteNode ensamblador
{
deleteNode : eliminar el nodo del arbol

ENTRADA : SI = posicion en el bufer
}
Asm
push di
push bx
shl si, 1
PUSH DI
LES DI,[MomP]
ADD DI,SI
CMP WORD PTR [ES:DI],NULL
POP-DI
{ cmp word ptr [Offset Mama si], NULL} { si es que no tiene
los padres, a continuacion, salir } je @del7
PUSH DI
LES DI,[RightP]
ADD DI,SI
CMP WORD PTR [ES:DI],NUL
POP-DI
{ cmp word ptr [Desplazamiento a la Derecha si], NULL} { tiene
boton derecho del niño ? } je @del8
PUSH BX
LES BX,[LeftP]
MOV DI,WORD PTR [ES:BX SI]
POP BX
{ mov di, word ptr [Desplazamiento a la Izquierda si] } { tiene a la izquierda
niño ? } cmp di, NUL
je @del9
EMPUJE SI
LES SI,[RightP]
AGREGAR SI,DI
MOV AX,WORD PTR [ES:SI]
POP SI
{ mov ax, word ptr [Offset Derecho di]} { tiene
a la derecha nieto ? } cmp ax, NUL
je @del2 { si no, skip }
@del1: mov di, ax { encontrar a la derecha
nodo } PUSH SI
LES SI,[RightP]
AGREGAR SI,DI
MOV AX,WORD PTR [ES:SI]
POP SI
{ mov ax, word ptr [Offset Derecho di] } { el derecho
subarbol } cmp ax, NUL
jne @del1
PUSH CX
MOV CX,SI
LES SI,[MomP]
AGREGAR SI,DI
MOV BX,WORD PTR [ES:SI]
{ mov bx, word ptr [Offset Mama di] } { mover este nodo como
la raiz de } LES SI,[LeftP]
AGREGAR SI,DI
MOV AX,WORD PTR [ES:SI]
{ mov ax, word ptr [Desplazamiento a la Izquierda de di]} { el subarbol }
LES SI,[RightP]
MOV WORD PTR [ES:SI BX],AX
{ mov word ptr [Offset Derecho bx], ax}
xchg ax, bx
LES SI,[MomP]
MOV WORD PTR [ES:SI BX],AX
{ mov word ptr [Offset Mama bx], ax}
LES SI,[LeftP]
AGREGAR SI,CX
MOV BX,WORD PTR [ES:SI]
{ mov bx, word ptr [Desplazamiento a la Izquierda si]}
LES SI,[LeftP]
AGREGAR SI,DI
MOV WORD PTR [ES:SI],BX
{ mov word ptr [Desplazamiento a la Izquierda de di], bx}
LES SI,[MomP]
MOV WORD PTR [ES:SI BX],DI
{ mov word ptr [Offset Mama bx], di}
MOV SI,CX
POP CX
@del2:
PUSH CX
MOV CX,SI
LES SI,[RightP]
AGREGAR SI,CX
MOV BX,WORD PTR [ES:SI]
{ mov bx, word ptr [Desplazamiento a la Derecha si]}
LES SI,[RightP]
AGREGAR SI,DI
MOV WORD PTR [ES:SI],BX
{ mov word ptr [Offset Derecho di], bx}
LES SI,[MomP]
MOV WORD PTR [ES:SI BX],DI
MOV SI,CX
POP CX
{ mov word ptr [Offset Mama bx], di}
@del3:
PUSH CX
MOV CX,DI
LES DI,[MomP]
ADD DI,SI
MOV BX,WORD PTR [ES:DI]
{ mov bx, word ptr [Offset Mama si]}
LES DI,[MomP]
ADD DI,CX
MOV WORD PTR [ES:DI],BX
{ mov word ptr [Offset Mama di], bx}
MOV DI,CX
POP CX
PUSH DI
LES DI,[RightP]
CMP SI,WORD PTR [ES:DI BX]
POP-DI
{ cmp si, word ptr [Offset Derecho bx]}
jne @del4
EMPUJE SI
LES SI,[RightP]
MOV WORD PTR [ES:SI BX],DI
POP SI
{ mov word ptr [Offset Derecho bx], di}
jmp @del5
@del4:
EMPUJE SI
LES SI,[LeftP]
MOV WORD PTR [ES:SI BX],DI
POP SI
{ mov word ptr [Desplazamiento a la Izquierda bx], di}
@del5:
PUSH DI
LES DI,[MomP]
ADD DI,SI
MOV WORD PTR [ES:DI],NULL
POP-DI
{ mov word ptr [Offset Mama si], NULL}
@del7: pop bx
pop-di
shr si, 1
jmp @finales
@del8:
PUSH BX
LES BX,[LeftP]
MOV DI,WORD PTR [ES:BX SI]
POP BX
{ mov di, word ptr [Desplazamiento a la Izquierda si]}
jmp @del3
@del9:
PUSH BX
LES BX,[RightP]
MOV DI,WORD PTR [ES:BX SI]
POP BX
{ mov di, word ptr [Desplazamiento a la Derecha si]}
jmp @del3
@final:
End { DeleteNode }

el Procedimiento de Codificar ensamblador
Asm
llame initTree
xor bx, bx
mov [Offset CodeBuf bx], bl
mov dx, 1
mov ch, dl
xor si, si
mov di, N - F
@Encode2: llame getc
jc @Encode3
EMPUJE SI
LES SI,[TextBufP]
AGREGAR SI,DI
MOV BYTE PTR [ES:SI BX],AL
POP SI
{ mov byte ptr [Offset TextBuf di bx], al}
inc bx
cmp bx, F
jb @Encode2
@Encode3: o bx, bx
jne @Encode4
jmp @Encode19
@Encode4: mov cl, bl
mov bx, 1
push di
sub di, 1
@Encode5: llame InsertNode
inc bx
dec di
cmp bx, F
jbe @Encode5
pop-di
llame InsertNode
@Encode6: mov ax, matchLen
cmp al, cl
jbe @Encode7
mov al, cl
mov matchLen, ax
@Encode7: cmp al, UMBRAL
ja @Encode8
mov matchLen, 1
o byte ptr codeBuf, ch
mov bx, dx
EMPUJE SI
LES SI,[TextBufP]
AGREGAR SI,DI
MOV AL,BYTE PTR [ES:SI]
POP SI
{ mov al, byte ptr [Offset TextBuf di]}
mov byte ptr [Offset CodeBuf bx], al
inc dx
jmp @Encode9
@Encode8: mov bx, dx
mov al, byte ptr matchPos
mov byte ptr [Offset Codebuf bx], al
inc bx
mov al, byte ptr (matchPos 1)
push cx
mov cl, 4
shl al, cl
pop cx
mov ah, byte ptr matchLen
sub ah, UMBRAL 1
agregar al, ah
mov byte ptr [Offset Codebuf bx], al
inc bx
mov dx, bx
@Encode9: shl cad, 1
jnz @Encode11
xor bx, bx
@Encode10: mov al, byte ptr [Offset CodeBuf bx]
llame putc
inc bx
cmp bx, dx
jb @Encode10
mov dx, 1
mov ch, dl
mov byte ptr codeBuf, dh
@Encode11: mov bx, matchLen
mov lastLen, bx
xor bx, bx
@Encode12: llame getc
{ jc @Encode14}
jc @Encode15
push ax
llame deleteNode
pop ax
PUSH DI
LES DI,[TextBufP]
ADD DI,SI
stosb
POP DI br /> { mov byte ptr [Offset TextBuf si], al}
cmp si, F - 1
jae @Encode13
PUSH DI
LES DI,[TextBufP]
ADD DI,SI
MOV BYTE PTR [ES:DI N],AL
POP-DI
{ mov byte ptr