; lzarchivator.inc
;################# Created by Bearchik http://crazyasm.blogspot.com ###############################
include     windows.inc
include     kernel32.inc
include     user32.inc
include     Comctl32.inc
include     shell32.inc

includelib  kernel32.lib
includelib  user32.lib
includelib  Comctl32.lib
includelib  shell32.lib

compress    PROTO:DWORD,:DWORD,:DWORD,:DWORD
decompress  PROTO:DWORD,:DWORD,:DWORD,:DWORD
writeStr    PROTO:DWORD,:DWORD,:DWORD
addDictStr  PROTO:DWORD,:DWORD,:DWORD
findStr     PROTO:DWORD,:DWORD
getStr      PROTO:DWORD,:DWORD
clearDict   PROTO

dict    struc
    pos     dd          ?
    string  db 0Ch  dup(?)
dict    ends
sdict       equ sizeof dict

.const
DICTSIZE    equ     200h

;#########################################################################

.data
src         db  "KARL_KARAL_KAR!",0
countDict   dd  1

;#########################################################################

.data?
dst         db  100h dup(?)
decstr      db  100h dup(?)
myDict      dict DICTSIZE dup (<>)
buf         db  0Ch dup(?)
bufcount    dd  ?

;#########################################################################




; lzarchivator.asm
.386
.model flat, stdcall  ;32 bit memory model
option casemap :none  ;case sensitive

include lzarchivator.inc

.code

start:
    invoke  compress, offset src, sizeof src, offset dst, sizeof dst
    invoke  clearDict
    invoke  decompress, offset dst, sizeof dst, offset decstr, sizeof decstr
    invoke  ExitProcess,0

decompress  proc    pSrcString:DWORD, lSrcString:DWORD, pDstString:DWORD, lDstString:DWORD
LOCAL   curDstPos:DWORD
    mov     edi, pSrcString
    xor     ecx, ecx
    mov     eax, pDstString
    mov     curDstPos, eax
nextcode:
    xor     eax, eax
    mov     al, BYTE PTR [edi]
    push    eax
    invoke  getStr, eax , edi
    pop     eax
    lea     esi, buf
    invoke  addDictStr, esi, eax, ebx
    invoke  writeStr, curDstPos, esi, ebx
    mov     curDstPos, eax
    add     edi, 2
    .if BYTE PTR [edi] == 0
        jmp     decodeend
    .endif
    jmp     nextcode
decodeend:

    ret
decompress endp

writeStr proc   uses ecx edi esi pdstString:DWORD, pBuf:DWORD, num:DWORD
    mov     ecx, num
    mov     edi, pdstString
    mov     esi, pBuf
    rep     movsb
    mov     eax, edi
    ret
writeStr endp

getStr  proc    uses ecx edi edx    num:DWORD, codeStr:DWORD
    mov     eax, num
    .if eax == 1
        mov     eax, codeStr
        mov     al, BYTE PTR [eax+1]
        mov     BYTE PTR [buf], al
        mov     ebx, 1
        jmp     endGetStr
    .endif

    mov     edi, offset buf
    dec     eax
    imul    edx, eax, sdict
    xor     ecx, ecx
nextDictChr:
    mov     al, myDict.string[edx+ecx]
    mov     BYTE PTR [edi+ecx], al
    inc     ecx
    .if al == 0
        mov     eax, codeStr
        mov     al, BYTE PTR [eax+1]
        mov     BYTE PTR [edi+ecx-1], al
        mov     ebx, ecx
        jmp     endGetStr
    .endif
    jmp     nextDictChr
endGetStr:

    ret
getStr endp

clearDict   proc uses ecx edi
    mov     countDict, 1h
    mov     ecx, sdict
    imul    ecx, ecx, DICTSIZE
    lea     edi, myDict
nextclr:
    mov     BYTE PTR [edi],0h
    inc     edi
    loop    nextclr
    ret
clearDict endp

compress    proc    pSrcString:DWORD, lSrcString:DWORD, pDstString:DWORD, lDstString:DWORD
LOCAL   prevPos:DWORD
    mov     prevPos, 1
    mov     edi, pSrcString
    mov     ebx, 1
    xor     ecx, ecx
compnext:
    invoke  findStr, edi, ebx
    .if eax == 1
        invoke  addDictStr, edi, prevPos, ebx
        jmp strnotfound
    .endif
    mov     prevPos,eax
    inc     ebx
    jmp     compnext
strnotfound:
    mov     edx, pDstString
    mov     eax, prevPos
    mov     BYTE PTR [edx], al
    mov     al, BYTE PTR [edi+ebx-1]
    mov     BYTE PTR [edx+1], al
    add     pDstString, 2h
    mov     prevPos, 1
    .if     ecx >= lSrcString
        jmp     compend
    .endif
    add     edi, ebx
    add     ecx, ebx
    mov     ebx, 1
    jmp     compnext
compend:
    ret
compress endp

addDictStr  proc    uses ecx ebx edi esi    string:DWORD, num:DWORD, lenght:DWORD
    mov     ebx, num
    mov     eax, countDict
    imul    eax, eax, sdict
    mov     myDict.pos[eax], ebx
    mov     esi, string
    lea     edi, myDict.string[eax]
    xor     ecx, ecx
    mov     ecx, lenght
    rep     movsb
    mov     BYTE PTR [edi], 0h
    inc     countDict
    ret
addDictStr endp

findStr proc    uses ecx edx edi    string:DWORD, num:DWORD
LOCAL   count:DWORD
    mov     count, 1h

nextserach:
    imul    eax, count, sdict
    lea     edi, myDict.string[eax]
    .if BYTE PTR [edi] == 0
        jmp     notfound
    .endif
    mov     esi, string
    mov     ecx, num
    inc     count
    repe    cmpsb
    jz      found
    jmp     nextserach
found:
    .if BYTE PTR [edi] != 0
        jmp     nextserach
    .endif
    mov     eax, count
    jmp     endsearch
notfound:
    mov     eax, 1
endsearch:
    ret
findStr endp

end start