lzss16.pas

delhpi下lzss加密算法源码及例子

{              mov     dx, [Offset Left + di]}     { ; perform a left zig-zag operation }
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:SI+BX+OFFSET TBinaryTree.Right],DX
{              mov     [Offset Right + bx], dx}
              xchg    bx, dx
              MOV     [ES:SI+BX+OFFSET TBinaryTree.Mom],DX
{              mov     [Offset Mom + bx], dx}
              ADD     SI,DI
              MOV     BX,[ES:SI+OFFSET TBinaryTree.Right]
{              mov     bx, [Offset Right + di]}
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     SI,AX
              MOV     [ES:SI+OFFSET TBinaryTree.Left],BX
{              mov     [Offset Left + si], bx}
              MOV     SI, PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:SI+BX+OFFSET TBinaryTree.Mom],AX
{              mov     [Offset Mom + bx], si}
              mov     bx, dx
              ADD     SI,DI
              MOV     [ES:SI+OFFSET TBinaryTree.Left],BX
{              mov     [Offset Left + di], bx}
              MOV     SI, PtrRec[OFFSET BinaryTree].Ofs
              ADD     SI,DI
              MOV     [ES:SI+OFFSET TBinaryTree.Right],AX
{              mov     [Offset Right + di], si}
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     SI,AX
              MOV     [ES:SI+OFFSET TBinaryTree.Mom],DI
{              mov     [Offset Mom + si], di}
              MOV     SI, PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:SI+BX+OFFSET TBinaryTree.Mom],DI
              MOV     SI,AX
              POP     AX
{              mov     [Offset Mom + bx], di}
              jmp     @Splay9
  @Splay7:
              PUSH    DI
              MOV     DI,PtrRec[OFFSET BinaryTree].Ofs
              CMP     SI,[ES:DI+BX+OFFSET TBinaryTree.Right]
              POP     DI
{              cmp     si, [Offset Right + bx]}
              jne     @Splay8
              PUSH    AX
              MOV     AX,SI
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     SI,AX
              MOV     DX,[ES:SI+OFFSET TBinaryTree.Left]
{              mov     dx, [Offset Left + si]}     { ; perform a right zig-zig }
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:SI+BX+OFFSET TBinaryTree.Right],DX
{              mov     [Offset Right + bx], dx}
              xchg    bx, dx
              MOV     SI, PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:SI+BX+OFFSET TBinaryTree.Mom],DX
{              mov     [Offset Mom + bx], dx}
              ADD     SI,DI
              MOV     BX,[ES:SI+OFFSET TBinaryTree.Left]
{              mov     bx, [Offset Left + di]}
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     SI,AX
              MOV     [ES:SI+OFFSET TBinaryTree.Right],BX
{              mov     [Offset Right + si], bx}
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:SI+BX+OFFSET TBinaryTree.Mom],AX
{              mov     [Offset Mom + bx], si}
              mov     bx, dx
              ADD     SI,AX
              MOV     [ES:SI+OFFSET TBinaryTree.Left],BX
{              mov     [Offset Left + si], bx}
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     SI,DI
              MOV     [ES:SI+OFFSET TBinaryTree.Left],AX
{              mov     [Offset Left + di], si}
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:SI+BX+OFFSET TBinaryTree.Mom],AX
{              mov     [Offset Mom + bx], si}
              ADD     SI,AX
              MOV     [ES:SI+OFFSET TBinaryTree.Mom],DI
{              mov     [Offset Mom + si], di}
              MOV     SI,AX
              POP     AX
              jmp     @Splay9
  @Splay8:
              PUSH    AX
              MOV     AX,SI
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     SI,DI
              MOV     DX,[ES:SI+OFFSET TBinaryTree.Right]
{              mov     dx, [Offset Right + di]}    { ; perform a right zig-zag }
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:SI+BX+OFFSET TBinaryTree.Left],DX
{              mov     [Offset Left + bx], dx}
              xchg    bx, dx
              MOV     [ES:SI+BX+OFFSET TBinaryTree.Mom],DX
{              mov     [Offset Mom + bx], dx}
              ADD     SI,DI
              MOV     BX,[ES:SI+OFFSET TBinaryTree.Left]
{              mov     bx, [Offset Left + di]}
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     SI,AX
              MOV     [ES:SI+OFFSET TBinaryTree.Right],BX
{              mov     [Offset Right + si], bx}
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:SI+BX+OFFSET TBinaryTree.Mom],AX
{              mov     [Offset Mom + bx], si}
              mov     bx, dx
              ADD     SI,DI
              MOV     [ES:SI+OFFSET TBinaryTree.Right],BX
{              mov     [Offset Right + di], bx}
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     SI,DI
              MOV     [ES:SI+OFFSET TBinaryTree.Left],AX
{              mov     [Offset Left + di], si}
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     SI,AX
              MOV     [ES:SI+OFFSET TBinaryTree.Mom],DI
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:SI+BX+OFFSET TBinaryTree.Mom],DI
{              mov     [Offset Mom + si], di
              mov     [Offset Mom + bx], di}
              MOV     SI,AX
              POP     AX
  @Splay9:    mov     si, cx
              cmp     si, NUL
              ja      @Splay10
              PUSH    DI
              MOV     DI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     DI,SI
              CMP     BX,[ES:DI+OFFSET TBinaryTree.Left]
              POP     DI
{              cmp     bx, [Offset Left + si]}
              jne     @Splay10
              PUSH    BX
              MOV     BX,PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:BX+SI+OFFSET TBinaryTree.Left],DI
              POP     BX
{              mov     [Offset Left + si], di}
              jmp     @Splay11
  @Splay10:
              PUSH    BX
              MOV     BX,PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:BX+SI+OFFSET TBinaryTree.Right],DI
              POP     BX
{              mov     [Offset Right + si], di}
  @Splay11:
              PUSH    BX
              MOV     BX,PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:BX+DI+OFFSET TBinaryTree.Mom],SI
              POP     BX
{              mov     [Offset Mom + di], si}
              jmp     @Splay1
  @end:
End; { SPlay }

Procedure InsertNode; assembler;
{
  insertNode : insert the new node to the corresponding tree.  Note that the
               position of a string in the buffer also served as the node
               number.
             ENTRY : di = position in the buffer
}
Asm
              push    si
              push    dx
              push    cx
              push    bx
              mov     dx, 1
              xor     ax, ax
              mov     matchLen, ax
              mov     height, ax
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     SI,DI
              MOV     AL,BYTE PTR [ES:SI]
{             mov     al, byte ptr [Offset TextBuf + di]}
              shl     di, Log2TLZSSWord
              add     ax, N + 1
              shl     ax, Log2TLZSSWord
              mov     si, ax
              mov     ax, NUL
              PUSH    BX
              MOV     BX,PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:BX+DI+OFFSET TBinaryTree.Right],AX
{              mov     word ptr [Offset Right + di], ax}
              MOV     [ES:BX+DI+OFFSET TBinaryTree.Left],AX
              POP     BX
{              mov     word ptr [Offset Left + di], ax}
  @Ins1:      inc     height
              test    dx, dx
              mov     dx, Nul
              js      @Ins3
              PUSH    DI
              MOV     DI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     DI,SI
              MOV     AX,[ES:DI+OFFSET TBinaryTree.Right]
              POP     DI
{              mov     ax, word ptr [Offset Right + si]}
              cmp     ax, dx
              jne      @Ins5
              PUSH    BX
              MOV     BX,PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:BX+SI+OFFSET TBinaryTree.Right],DI
{              mov     word ptr [Offset Right + si], di}
              MOV     [ES:BX+DI+OFFSET TBinaryTree.Mom],SI
              POP     BX
{              mov     word ptr [Offset Mom + di], si}
              jmp     @Ins11
  @Ins3:
              PUSH    BX
              MOV     BX,PtrRec[OFFSET BinaryTree].Ofs
              MOV     AX,[ES:BX+SI+OFFSET TBinaryTree.Left]
              POP     BX
{              mov     ax, word ptr [Offset Left + si]}
              cmp     ax, dx
              jne      @Ins5
              PUSH    BX
              MOV     BX,PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:BX+SI+OFFSET TBinaryTree.Left],DI
{              mov     word ptr [Offset Left + si], di}
              MOV     [ES:BX+DI+OFFSET TBinaryTree.Mom],SI
              POP     BX
{              mov     word ptr [Offset Mom + di], si}
              jmp     @Ins11

  @Ins5:      mov     si, ax
              mov     bx, 1
              shr     si, Log2TLZSSWord
              shr     di, Log2TLZSSWord
              xor     ch, ch
              xor     dh, dh
  @Ins6:
              PUSH    SI
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     SI,DI
              MOV     DL,[ES:SI+BX]
              POP     SI
              PUSH    DI
              MOV     DI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     DI,SI
              MOV     CL,[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:      mov     ax, si
              shl     si, Log2TLZSSWord
              shl     di, Log2TLZSSWord
              cmp     bx, matchLen
              jbe     @Ins1
              mov     matchPos, ax
              mov     matchLen, bx
              cmp     bx, F
              jb      @Ins1
  @Ins8:
              PUSH    CX
              MOV     BX,PtrRec[OFFSET BinaryTree].Ofs
              MOV     AX,[ES:BX+SI+OFFSET TBinaryTree.Mom]
{              mov     ax, word ptr [Offset Mom + si]}
              MOV     [ES:BX+DI+OFFSET TBinaryTree.Mom],AX
{              mov     word ptr [Offset Mom + di], ax}
              MOV     CX,[ES:BX+SI+OFFSET TBinaryTree.Left]
{              mov     bx, word ptr [Offset Left + si]}
              MOV     [ES:BX+DI+OFFSET TBinaryTree.Left],CX
{              mov     word ptr [Offset Left + di], bx}
              ADD     BX,CX
              MOV     [ES:BX+OFFSET TBinaryTree.Mom],DI
{              mov     word ptr [Offset Mom + bx], di}
              MOV     BX,PtrRec[OFFSET BinaryTree].Ofs
              MOV     CX,[ES:BX+SI+OFFSET TBinaryTree.Right]
{              mov     bx, word ptr [Offset Right + si]}
              MOV     [ES:BX+DI+OFFSET TBinaryTree.Right],CX
{              mov     word ptr [Offset Right + di], bx}
              ADD     BX,CX
              MOV     [ES:BX+OFFSET TBinaryTree.Mom],DI
{              mov     word ptr [Offset Mom + bx], di}
              MOV     BX,PtrRec[OFFSET BinaryTree].Ofs
              MOV     BX,[ES:BX+SI+OFFSET TBinaryTree.Mom]
{              mov     bx, word ptr [Offset Mom + si]}
              POP     CX
              PUSH    DI
              MOV     DI,PtrRec[OFFSET BinaryTree].Ofs
              CMP     SI,[ES:DI+BX+OFFSET TBinaryTree.Right]
              POP     DI
{              cmp     si, word ptr [Offset Right + bx]}
              jne     @Ins9
              PUSH    SI
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:SI+BX+OFFSET TBinaryTree.Right],DI
              POP     SI
{              mov     word ptr [Offset Right + bx], di}
              jmp     @Ins10
  @Ins9:
              PUSH    SI
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              MOV     [ES:SI+BX+OFFSET TBinaryTree.Left],DI
              POP     SI
{              mov     word ptr [Offset Left + bx], di}
  @Ins10:
              PUSH    DI
              MOV     DI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     DI,SI
              MOV     WORD PTR [ES:DI+OFFSET TBinaryTree.Mom],Nul
              POP     DI
{              mov     word ptr [Offset Mom + si], NUL}
  @Ins11:     cmp     height, 30
              jb      @Ins12
              call    Splay
  @Ins12:     pop     bx
              pop     cx
              pop     dx
              pop     si
              shr     di, Log2TLZSSWord
End; { InsertNode }


Procedure DeleteNode; assembler;
{
   deleteNode : delete the node from the tree

            ENTRY : SI = position in the buffer
}
Asm
              push    di
              push    bx
              shl     si, Log2TLZSSWord
              PUSH    DI
              MOV     DI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     DI,SI
              CMP     WORD PTR [ES:DI+OFFSET TBinaryTree.Mom], Nul
              POP     DI
{              cmp     word ptr [Offset Mom + si], NUL}   { ; if it has no parent then exit }
              je      @del7
              PUSH    DI
              MOV     DI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     DI,SI
              CMP     WORD PTR [ES:DI+OFFSET TBinaryTree.Right],Nul
              POP     DI
{              cmp     word ptr [Offset Right + si], NUL} { ; does it have right child ? }
              jne      @HasRight
              PUSH    BX
              MOV     BX,PtrRec[OFFSET BinaryTree].Ofs
              MOV     DI,[ES:BX+SI+OFFSET TBinaryTree.Left]
              POP     BX
{              mov     di, word ptr [Offset Left + si]}
              jmp     @del3
  @HasRight:  PUSH    BX
              MOV     BX,PtrRec[OFFSET BinaryTree].Ofs
              MOV     DI,[ES:BX+SI+OFFSET TBinaryTree.Left]
              POP     BX
{              mov     di, word ptr [Offset Left + si] }  { ; does it have left child ? }
              cmp     di, Nul
              jne     @HasLeft
              PUSH    BX
              MOV     BX,PtrRec[OFFSET BinaryTree].Ofs
              MOV     DI,[ES:BX+SI+OFFSET TBinaryTree.Right]
              POP     BX
{              mov     di, word ptr [Offset Right + si]}
              jmp     @del3
  @HasLeft:   PUSH    SI
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     SI,DI
              MOV     AX,[ES:SI+OFFSET TBinaryTree.Right]
              POP     SI
{              mov     ax, word ptr [Offset Right + di]}  { ; does it have right grandchild ? }
              cmp     ax, Nul
              je      @del2                             { ; if no then skip }
  @del1:      mov     di, ax                            { ; find the rightmost node in }
              PUSH    SI
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     SI,DI
              MOV     AX,[ES:SI+OFFSET TBinaryTree.Right]
              POP     SI
{              mov     ax, word ptr [Offset Right + di] } { ;   the right subtree }
              cmp     ax, Nul
              jne     @del1
              PUSH    CX
              MOV     CX,SI
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs
              ADD     SI,DI
              MOV     BX,[ES:SI+OFFSET TBinaryTree.Mom]
{              mov     bx, word ptr [Offset Mom + di] }   { ; move this node as the root of }
              MOV     SI,PtrRec[OFFSET BinaryTree].Ofs