lha-исходники

Роман я тебя как Асамблерщик Асамблерщика прошу выложи... Что мне С учить с нуля? тут все равно не кто не знает....

Тебе нужет распаковщик? или паковщик тоже?

Просто распаковщик могу попробовать вытянуть из
старых исходиков аварда...

Просто распаковщик могу попробовать вытянуть из
старых исходиков аварда... и то и то.... хотя распаковщик нужнее! из каких исходников?....

Просто распаковщик могу попробовать вытянуть из
старых исходиков аварда... и то и то.... хотя распаковщик нужнее! из каких исходников?....
Исходники Award BIOS для всяких там 430VX/TX/HX...
Цельно тянутые предположительно в 1997 году...
Я вроде их тут уже предлогал, но это было до скоропостижного
переезда сервера...

выложи или на мыло!!!очень прошу!!! это будет бомба!!! для меня точно.....

плиииииз..... народ.....

Нет, ну, ты, мёртвого заколебёшь... Разбирайся сам - это точно рабочее:
;[]------------------------------------------------------------------[]
; Start of Decompress Engine
;[]------------------------------------------------------------------[]

;[]==============================================================[]
;Entry: ES : SEGMENT of Source Data
; BX : OFFSET of Source Data
; DX : Segment of Expand Data buffer
;if BP=0 -> it`s no BIOS-file
;Exit: ECX: Compressed Size
; EDX: Original Size
;[]==============================================================[]
Expand:
;vyvod msg_tochka
push ds
push si
push di
push bx
assume ds, EXP_DATA

; Init data segment registers
mov [cs:unpack_seg], dx ;store segment where to unpack

push es ; save source segment

;Initialize EXP_DATA segment, in case there's garbage left
assume es, EXP_DATA;fx00;ds
xor di, di
mov cx, length_exp_data;4000h
rep stosb;w
pop es

; Read compressed data from segment:offset
;assume - fos seg->seg operations
push es
mov [ds:SrcSegment], es
mov [ds:SrcOffset], bx
mov [cs:temp_word], bx ;store TEMP for save files...
; Temp Target Segment, Offset

; make CRC table
call MakeCRCTable
; read header
call ReadHeader
jc error_exit_decompress ; error, something wrong

;-- calculate compressed total size and return when decompress complete
mov ecx, [ds:compsize] ;compressed size
xor eax, eax
mov al, [ds:headersize] ;compressed header size
add ecx, eax
add ecx, COMPRESSED_UNKNOW_BYTE;unknow bytes
mov edx, [ds:origsize]
;now in ECX - compressed size, in EDX - original size
cmp bp, 0 ;check - it`s decompress for BIOS or another files?...
jne BIOSpart

;bp=0 -> it`s no BIOS-part...
assume [ds:TgtSegment], [cs:unpack_0]
assume [ds:TgtOffset], 0 ;clear offset
jmp go_decompress

BIOSpart:

;----output EXTEND INFO--------------------------------------------
cmp byte [cs:Extend_Info], 1
jne .skip_Extend_Info
BK
pushad
push ds
push es
push ecx
assume es, [ds:SrcSegment]
mov di, [cs:temp_word];- becose [ds:SrcOffset] is changing to begin of 'compressed_data'
assume ds, es

;output PART_NAME
mov dx, di
add dx, 16h ;=begin of NAME_FIL in LHA-header
movzx cx, [es:di+15h] ;=length of NAME_FIL
cmp cx, 12
jbe @F
mov cx, 12 ;cut CX if more than 12 (for aligning on next step)
@@:
push cx
mov bx, 1 ;output to screen
mov ah, 40h
int 21h
;aligning...
pop ax ;length of NAME_FIL in AX
mov cx, 13
sub cx, ax
@@:
._.
loop @B
;output SEG_OFF_Target
._.
mov ecx, [es:di+0fh]
_test32reg ecx
;output Compress Size
._.
mov ecx, [es:di+7]
_test32reg ecx
;output Real Size
vyvod msg_slash
mov ecx, [es:di+0bh]
_test32reg ecx
pop ecx ;restore length of BIOS-part
._.

;for ultrapack---------------
cmp dword [es:di+0fh], 50000000h
je .skip_ultrapack
cmp byte [cs:ultrapack], 1
jne .skip_ultrapack
BK
vyvod msg_for_remove_this_module_press_r_or_any_another_key_for_continue;
;wait for key...;
mov ah ,1;
int 21h;
;check press key...;
cmp al, 'r';
je .skip_ultrapack;
cmp al, 'R';
je .skip_ultrapack;

write_file_check [cs:id_ost_rrr], [cs:temp_word], cx;write ost.rrr
.skip_ultrapack:
;end ultrapack-operations=====[]

pop es
pop ds
popad

mov ax, [ds:ExpSegment]

cmp ax, 4000h ;microcodes
jne @F
vyvod msg_its_logo
@@:
cmp ax, 4001h ;microcodes
jne @F
vyvod msg_its_cpucode_bin
@@:
cmp ax, 4002h ;EPA
jne @F
vyvod msg_its_EPA
@@:
cmp ax, 4003h ;ACPITBL
jne @F
vyvod msg_its_ACPITBL
@@:

cmp ax, 4007h ;antivirus
jne @F
vyvod msg_its_antivirus
@@:

cmp ax, 4029h ;Phoenix_Setup
jne @F
vyvod msg_its_Phoenix_Setup
@@:

cmp ax, 4080h ;VGA
jne @F
vyvod msg_its_VGA
@@:

cmp ax, 0800h ;~scsi
jne @F
vyvod msg_may_be_scsi
@@:

cmp ax, 4086h ;ncr
jne @F
vyvod msg_its_ncr_4086
@@:
cmp ax, 4087h ;aha
jne @F
vyvod msg_its_aha_4087
@@:

cmp ax, 5000h ;original
jne @F
vyvod msg_its_original_tmp
@@:
cmp ax, 407fh ;awardext
jne @F
vyvod msg_its_awardext_rom
@@:
cmp ax, 4100h ;awardext
jne @F
vyvod msg_its_awardext_rom
@@:
cmp ax, 6000h ;awardext
jne @F
vyvod msg_its_awardext_rom
@@:
cmp ax, 400eh ;awardeYt
jne @F
vyvod msg_its_awardeyt_rom
@@:

cmp ax, 4e00h ;rom.by
jne @F
vyvod msg_its_rom_by_modul
@@:

cmp ax, 5000h ;...this compare must be in the end...
jbe .skip_Extend_Info
cmp ax, 6FFFh
ja .skip_Extend_Info
vyvod msg_its_original_tm1 ;second part of original.tmp

.skip_Extend_Info:
;=== END Extend_Info =====================================================[]
;vsad
mov ax, [ds:ExpSegment] ;[cs:unpack_seg];

;new unpack/save-method - expand to unpack_0/unpack_1 and after select-saving...
assume [ds:TgtSegment], [cs:unpack_0]
assume [ds:TgtOffset], 0 ;clear offset

; cmp dword [cs:TCCS], 0
; je @F
cmp ax, 4001h ;it`s 'cpucode.bin'?
je @F ;yes - skip (becose it release with cbrom in future)...

add [cs:TCCS], ecx ;add compressed size of this part...
;pushad
;vyvod msg_tochka
; mov ecx, [cs:TCCS] ;add compressed size of this part...
;_test32reg ecx
;popad
@@:
cmp ax, 4086h
jne @F
mov [cs:ncr_exist], ecx
@@:
cmp ax, 4087h
jne @F
mov [cs:aha_exist], ecx
@@:
cmp ax, 4007h
jne @F
mov [cs:vrs_exist], ecx
@@:

cmp ax, 4001h ;cpucode.bin
je decompress_cpucode
cmp ax, 4029h ;_en_code.bin
je decompress__en_code_tmp
cmp ax, 4100h ;awardext.rom
je decompress_awext
cmp ax, 407fh ;awardext.rom
je decompress_awext
cmp ax, 6000h ;ASUS-awardext.rom
je decompress_awext
cmp ax, 5000h
je decompress_orig
jb _done_exit ;it`s not a 'awardext.rom' or 'original.tmp''(1)'
cmp ax, 6FFFh
ja _done_exit ;it`s not a 'awardext.rom' or 'original.tmp''(1)'

;it`s second half of tiled BIOS...
jmp go_decompress
;cpucode.bin...
decompress_cpucode:
jmp go_decompress
;_en_code.bin...
decompress__en_code_tmp:
jmp go_decompress
;awardext.rom...
decompress_awext:
jmp go_decompress
;original.tmp...
decompress_orig:

go_decompress:
push edx
push ecx

;check data is store type or compress type
push bx
add bx, 5 ;offset 5 ('-lh0-' or '-lh5-')
call Get_Exp_Src_Byte ;get compress or store type value
pop bx
cmp al, '0' ;Is store type?
jne Not_Store ;No, jump

;-lh0- type...
push ds
push si
push bx
mov di, [ds:ExpOffset]
movzx ax, byte [ds:headersize];compressed header size
add ax, 2 ;store unknow bytes
add bx, ax
mov cx, word [ds:compsize];compressed size
mov ax, [ds:ExpSegment]
mov es, ax
add cx, 3 ;transfer to dword unit
shr cx, 2 ;-------

Get_Store_Data_Loop:
call Get_Exp_Src_Dword ;get compress or store type value
add bx, 4 ;next data offset
stosd ;store to buffer
loop Get_Store_Data_Loop

pop bx ;restore BX
pop si
pop ds
jmp Expand_Over

;-lh5- type...
Not_Store:
push word [ds:TgtSegment]
push word [ds:TgtOffset]
push dword [ds:origsize]

; extract content from compressed file
call Extract

pop dword [ds:origsize]
pop word [ds:TgtOffset]
pop word [ds:TgtSegment]

Expand_Over: ;R137
;;722; clean up temp target buffer, so that no garbage left in user's base memory
;;722; if data decompression stub is called before memory testing, then
;;722; we don't need to call this cleanup routine.
;;722 call CleanUpBaseMemory
pop ecx ;return compressed total size
pop edx

; done, exit.
_done_exit:
clc
error_exit_decompress:
pop es
pop bx
pop di
pop si
pop ds
ret

;********************************************************************
;********************* LHA subs *************************************
;********************************************************************

MakeCRCTable:
; Input : None
; Destroy : None
; Modify Global Variable : CRCTABLE[]
push cx
push bx
push ax
push si
mov si, crctable;offset of crctable->si
mov cx, 100h ; for (i = 0; i <= 0xff; i++)

MCRCT_1:
mov ax, 100h
sub ax, cx ; r = i;
push ax ; save index
MCRCT_2:
mov bx, 0 ; for (j = 0; j < 8; j++)
MCRCT_2_1:
test ax, 1 ; (r & 1)
jz MCRCT_3

shr ax, 1
xor ax, CRCPOLY
jmp MCRCT_4
MCRCT_3:
shr ax, 1
MCRCT_4:
inc bx
cmp bx, 8
jb MCRCT_2_1

pop bx ; pop out saved index to !!! REG BX !!! so that
; we won't destroy AX

mov word [ds:si + bx], ax
inc si ; since this is an array of word, we increase bx
; and si respectively so that totaly make up a 2
; bytes increment.
loop MCRCT_1

pop si
pop ax
pop bx
pop cx
ret

; Input : None
; Output : Carry Set - several reason might cause the carry flag be set
; 1. header size is 0
; 2. header check sum is not correct
; 3. data pattern does not match in some specific
; location.
; : Carry clear - header size is not 0
ReadHeader:
pusha

; read in headersize byte
push es
mov bx, [ds:SrcOffset]
call Get_Exp_Src_Byte ;R171
inc word [ds:SrcOffset]
mov byte [ds:headersize], al
pop es

cmp byte [ds:headersize], 0
jne RH_2
RH_1:
stc
jmp RH_Exit
RH_2:
; read in headersum byte
push es
mov bx, [ds:SrcOffset]
call Get_Exp_Src_Byte ;R171
inc word [ds:SrcOffset]
mov byte [ds:headersum], al
pop es

call FreadCRC ; CRC not used

call CalcHeadersum

; compare headersum and result of CalcHeadersum
cmp al, byte [ds:headersum]
je @F
jmp RH_1
@@:
mov bx, 5
mov cx, 4
call GetFromHeader
mov dword [ds:compsize], eax

mov bx, 9
mov cx, 4
call GetFromHeader
mov dword [ds:origsize], eax

mov bx, 13
mov cx, 2
call GetFromHeader
mov word [ds:ExpOffset], ax
mov word [cs:ExpOffset_], ax ;/////store copy in CS

mov bx, 15
mov cx, 2
call GetFromHeader
mov word [ds:ExpSegment], ax
mov word [cs:ExpSegment_], ax ;/////store copy in CS

cmp byte [ds:Header + 17], 20h ; check specific spot of header
jne RH_1

cmp byte [ds:Header + 18], 01h ; check specific spot of header
jne RH_1

movzx bx, byte [ds:headersize]
sub bx, 5
mov cx, 2
call GetFromHeader
mov word [ds:file_crc], ax ; truncate upper word

mov bx, NAMELENIDX
mov bl, byte [ds:Header + bx]
mov ax, OUTFILENAME
add bx, ax
mov byte [ds:Header + bx], '$' ; assembly version
mov byte [ds:Header + bx+1], 0 ; assembly version

clc
RH_Exit:
popa
ret

;[]------------------------------------------------------------------[]
;Get_Exp_Src_Byte : Get decompressed source data from SrcSegment:BX
;
;Input : SrcSegment = source data of segment
; BX = source data of offset
; DS = expand data of segment
;Output: AX = get source data to AL and clear AH
;[]------------------------------------------------------------------[]
Get_Exp_Src_Byte:
push es
call Enter_Expand_Prot
movzx ax, byte [es:bx]
pop es
ret

;Set_Exp_Src_Byte:
;push es
;call Enter_Expand_Prot
; mov [es:bx], al
;pop es
; ret

Get_Exp_Src_Dword:
push es
call Enter_Expand_Prot
mov eax, dword [es:bx]

pop es
ret

Enter_Expand_Prot:
;.....
;CHANGE!!!!
assume es, [ds:SrcSegment];[cs:orig_0];fx00
;CHANGE !!!!!!!!extract_seg
ret

; Globally parameters passing : Header, Headersize, InpFileHandle
; Modify global variable: origsize
FreadCRC:
push ax
push bx
push cx
push dx
movzx cx, byte [ds:headersize]
push es
push si
mov bx, word [ds:SrcOffset]
mov si, Header ;offset Header to SI
FCRC_0:
call Get_Exp_Src_Byte
mov byte [ds:si], al
inc bx
inc si
loop FCRC_0 ;store header...

mov ax, bx
sub ax, word [ds:SrcOffset]; how many bytes we have read ?
mov word [ds:SrcOffset], bx
pop si
pop es

mov byte [ds:headersize], al

mov cx, ax ; save a copy
add word [ds:origsize], ax
inc cx
mov bx, Header
FCRC_1:
movzx ax, byte [ds:bx] ;offset Header to BX
dec cx
jcxz FCRC_2

call UpdateCRC

inc bx ; increment pointer
jmp FCRC_1
FCRC_2:
pop dx
pop cx
pop bx
pop ax
ret

;from macro UpdateCRC...
UpdateCRC:
push ax
push bx
push si
mov si, ax
mov ax, word [ds:crc]
xor ax, si
and ax, 0ffh
mov si, ax
shl si, 1
mov bx, word [ds:crctable + si]
mov ax, word [ds:crc]
shr ax, 8
xor ax, bx
mov word [ds:crc], ax
pop si
pop bx
pop ax
ret

; Input : None
; Output : AX
; Destroy : AX
; Global variable : None
CalcHeadersum:
push bx
push cx
push dx
mov ax, 0 ; clear sum
movzx cx, byte [ds:headersize]
CH_1:
movzx bx, byte [ds:headersize]
sub bx, cx
movzx dx, byte [ds:Header + bx]
add ax, dx
loop CH_1

pop dx
pop cx
pop bx
and ax, 0ffh
ret

;---------------
;Extract--------
;---------------
Extract:
pusha
; Get file name string starting point

; save file name length
mov bx, NAMELENIDX
mov bl, byte [ds:Header + bx]
mov byte [ds:namelen], bl
; print message on screen

; compress/decompress method recognition
mov word [ds:crc], INIT_CRC
movzx dx, byte [ds:Header + 3] ; get mrthod
mov byte [ds:Header + 3], 20h ; fill with blank

; decompress starts here
call DecodeStart

Ex_1:
cmp dword [ds:origsize], 0;1c000h
je Ex_3
mov ecx, DICSIZ ; assume origsize is smalller than DIGSIZ
cmp dword [ds:origsize], DICSIZ
ja @F
mov ecx, dword [ds:origsize]
@@:
push ecx

; with parameter cx and buffer
call Decode

; with buffer, cx andOutFileHandle
call FwriteCRC

; display '.' to tell user the program is running
pop ecx
mov eax, dword [ds:origsize]
sub eax, ecx
mov dword [ds:origsize], eax
;_test32reg eax
jmp Ex_1
Ex_3:
popa
ret

;------------------------------------------------
;-------------LHA`s Algoritm---------------------
;------------------------------------------------
DecodeStart:
call HufDecodeStart
mov word [ds:j], 0 ; remaining bytes to copy
ret

HufDecodeStart:
call InitGetBits
mov word [ds:blocksize], 0
ret

InitGetBits:
mov word [ds:bitbuf], 0
mov word [ds:subbitbuf], 0
mov word [ds:bitcount], 0

mov ax, BITBUFSIZ
call FillBuf ; with parameter pass-in BITBUFSIZ (16)
ret

; Input : AX
; Output : None
FillBuf:
pusha
mov word [ds:temp_param], ax ; save
mov cx, ax
mov ax, word [ds:bitbuf]
shl ax, cl
mov word [ds:bitbuf], ax
FB_1:
mov ax, word [ds:temp_param]
cmp ax, word [ds:bitcount]
jbe FB_3

sub ax, word [ds:bitcount]
mov word [ds:temp_param], ax
push ax
mov ax, word [ds:subbitbuf]
pop cx ; pop out temp_param
shl ax, cl
or word [ds:bitbuf], ax
cmp dword [ds:compsize], 0
je FB_2

dec dword [ds:compsize]
push es
mov bx, word [ds:SrcOffset]
call Get_Exp_Src_Byte ;R171
mov word [ds:subbitbuf], ax
inc word [ds:SrcOffset]
jnz @F
;R84
add word [ds:SrcSegment], 1000h ;R84
@@: ;R84
pop es
jmp @F
FB_2:
mov word [ds:subbitbuf], 0
@@:
mov word [ds:bitcount], CHAR_BIT
jmp FB_1
FB_3:
mov ax, word [ds:bitcount]
sub ax, word [ds:temp_param]
mov word [ds:bitcount], ax
push ax
mov ax, word [ds:subbitbuf]
pop cx
shr ax, cl
or word [ds:bitbuf], ax
popa
ret

; Input : CX and Buffer
Decode:
pusha
mov bx, word [ds:s_i]
xor si, si ; r
D_2:
dec word [ds:j] ; remaining bytes to copy to
cmp word [ds:j], 0
js D_3

mov al, byte [ds:buffer + bx]
mov byte [ds:buffer + si], al
inc bx
mov ax, DICSIZ
dec ax
and bx, ax
inc si
cmp si, cx ;
jne D_2

mov word [ds:s_i], bx ; save
popa
ret
D_3:
call DecodeC ; return result in AX
cmp ax, UCHAR_MAX
ja D_4
mov byte [ds:buffer + si], al
inc si
cmp si, cx
jne D_3

mov word [ds:s_i], bx ; save
popa
ret
D_4: ; j = c - (UCHAR_MAX + 1 - THRESHOLD)
sub ax, UCHAR_MAX
dec ax
add ax, THRESHOLD
mov word [ds:j], ax

mov ax, si
call DecodeP ; return result in BX
sub ax, bx
dec ax
mov bx, ax
mov ax, DICSIZ
dec ax
and bx, ax ; i = BX
D_4_1:
dec word [ds:j]
cmp word [ds:j], 0
js D_3
mov al, byte [ds:buffer + bx]
mov byte [ds:buffer + si], al
mov ax, DICSIZ
dec ax
inc bx
and bx, ax ; i = BX
inc si
cmp si, cx
je D_6 ; bye now!
jmp D_4_1 ; go back to while loop
; D_5:
; jmp D_3
D_6:
mov word [ds:s_i], bx ; save
popa
ret

; Input : None
; OutPut : AX
DecodeC:
push bx
push cx
push si
push di

cmp word [ds:blocksize], 0
jne DC_1
mov ax, 16
call GetBits
mov word [ds:blocksize], ax

mov si, NT
mov ax, TBIT
mov di, 3

call ReadPtLen ; NT, TBIT, 3

call ReadCLen

mov si, NP
mov ax, PBIT
mov di, -1

call ReadPtLen ; NP, PBIT, -1

DC_1:
dec word [ds:blocksize]
mov cx, BITBUFSIZ
sub cx, 12
mov ax, word [ds:bitbuf]
shr ax, cl
mov bx, ax ; used as index
shl bx, 1 ; adjust to word index
mov ax, word [ds:c_table + bx]
mov si, ax ; use SI to represent J

cmp ax, NC
jb DC_4
mov ax, 1
mov cx, BITBUFSIZ
sub cx, 13
shl ax, cl
DC_2:
; variable MASK is stored in AX
mov bx, word [ds:bitbuf]
and bx, ax
mov bx, si ; get variable j, prepare word index
jnz DC_3
shl bx, 1 ; adjust to word index
mov si, word [ds:left + bx]
jmp DC_3_1
DC_3:
shl bx, 1 ; adjust to word index
mov si, word [ds:right + bx]
DC_3_1:
shr ax, 1
cmp si, NC
jae DC_2

DC_4:
movzx ax, byte [ds:c_len + si]
call FillBuf
mov ax, si ; value to be returned

DC_Exit :
pop di
pop si
pop cx
pop bx
ret

; Input : None
; Output : BX
DecodeP:
push ax
push cx
push si
mov cx, BITBUFSIZ
sub cx, 8
mov ax, word [ds:bitbuf]
shr ax, cl
mov bx, ax ; used as index
shl bx, 1 ; adjust to word index
mov ax, word [ds:pt_table + bx]
mov si, ax ; use SI to represent J

cmp ax, NP
jb DP_4

mov cx, BITBUFSIZ
sub cx, 9
mov ax, 1
shl ax, cl
DP_1:
; variable MASK is stored in AX
mov bx, word [ds:bitbuf]
and bx, ax
mov bx, si ; get variable j, prepare word index
jnz DP_2

shl bx, 1 ; adjust to word index
mov si, word [ds:left + bx]
jmp DP_3
DP_2:
shl bx, 1 ; adjust to word index
mov si, word [ds:right + bx]
DP_3:
shr ax, 1
cmp si, NP
jae DP_1
DP_4:
movzx ax, byte [ds:pt_len + si]
call FillBuf

cmp si, 0
je DP_5

mov cx, si
dec cx
mov ax, 1
shl ax, cl
mov cx, ax ; store temp result
mov ax, si
dec ax
call GetBits
add ax, cx
mov si, ax
DP_5:
mov bx, si
DP_Exit:
pop si
pop cx
pop ax
ret

; Input : AX
; Output : AX
GetBits:
push cx
push bx

mov cx, BITBUFSIZ
sub cx, ax
mov bx, ax ; save a copy for later use

mov ax, word [ds:bitbuf]
shr ax, cl

push ax ; save returned result

mov ax, bx ; restore original parameter
call FillBuf

pop ax ; returned value
pop bx
pop cx
ret

; Input : CX -- number of bytes to write to output file
FwriteCRC:
push ax
push bx
push dx
push cx
push es
push si
mov ax, word [ds:TgtSegment]
mov es, ax
mov bx, word [ds:TgtOffset]
mov si, buffer
FWCRC_0:
mov al, [ds:si]
mov [es:bx], al
inc si
inc bx
loop FWCRC_0

mov word [ds:TgtOffset], bx
or bx, bx ; if bx is zero means we need to change segment
jnz @F

add word [ds:TgtSegment], 1000h
@@:
pop si
pop es
pop cx
cmp ax, cx
jb FWCRC_Err

inc cx
mov bx, buffer
FWCRC_1:
movzx ax, byte [ds:bx]
dec cx
jcxz FWCRC_2

call UpdateCRC
inc bx
jmp FWCRC_1
FWCRC_Err:
FWCRC_2:
pop dx
pop bx
pop ax
ret

InitLocalVars:
push bx
mov word [ds:i], 0
mov word [ds:k], 0
mov word [ds:len], 0
mov word [ds:jutbits], 0
mov word [ds:avail], 0
mov word [ds:nextcode], 0
mov word [ds:vmask], 0

xor bx, bx
ILV_1:
cmp bx, 34
jae ILV_2

mov word [ds:count + bx], 0
mov word [ds:weight + bx], 0
mov word [ds:start_decomp + bx], 0
add bx, 2
jmp ILV_1
ILV_2:
mov word [ds:start_decomp + 34], 0
pop bx
ret

; Input : BX, SI, DX, DI
; Output :
MakeTable:
pusha
call InitLocalVars ; init local variables and arrays
push bx
mov bx, 2
MT_1:
cmp bx, 32
ja MT_2

mov word [ds:count + bx], 0
inc bx
inc bx
jmp MT_1
MT_2:
pop cx ; get nchar parameter to cx
push cx ; save nchar for later use
xor bx, bx
MT_3:
cmp bx, cx
jae MT_4

push si
add si, bx
movzx ax, byte [ds:si]
shl ax, 1 ; adjust to word index
mov si, ax
inc word [ds:count + si]
pop si
inc bx
jmp MT_3
MT_4:
mov word [ds:start_decomp + 2], 0 ; adjust to word index (from 1 to 2)

mov bx, 1
MT_5:
cmp bx, 16
ja MT_6

mov cx, 16
sub cx, bx
push bx
shl bx, 1
mov ax, word [ds:count + bx]
shl ax, cl
add ax, word [ds:start_decomp + bx]
mov word [ds:start_decomp + bx + 2], ax
pop bx
inc bx
jmp MT_5
MT_6:
mov ax, 1
shl ax, 16
cmp ax, word [ds:start_decomp + 34]
je MT_7
MT_Err:
;error
jmp MT_Exit ; bye ! now
MT_7:
mov cx, 16
sub cx, dx
mov word [ds:jutbits], cx
mov bx, 1
MT_8:
cmp bx, dx
ja MT_9

push bx ; save bx
shl bx, 1 ; adjust to word index
mov ax, word [ds:start_decomp + bx]
mov cx, word [ds:jutbits]
shr ax, cl
mov word [ds:start_decomp + bx], ax
pop bx ; get original index
mov cx, dx
sub cx, bx
mov ax, 1
shl ax, cl
push bx ; save index
shl bx, 1 ; adjust to word index
mov word [ds:weight + bx], ax
pop bx ; get original index
inc bx
jmp MT_8
MT_9:
cmp bx, 16
ja MT_10
mov cx, 16
sub cx, bx
mov ax, 1
shl ax, cl
push bx ; save original index
shl bx, 1 ; adjust to word index
mov word [ds:weight + bx], ax
pop bx ;restore original index
inc bx
jmp MT_9
MT_10:
mov cx, word [ds:jutbits]
mov bx, dx
inc bx
shl bx, 1 ; adjust to word index
mov ax, word [ds:start_decomp + bx]
shr ax, cl
mov bx, ax ; store in bx for var i
mov ax, 1
shl ax, 16
cmp bx, ax
je MT_12

mov cx, dx
mov ax, 1
shl ax, cl
MT_11:
cmp bx, ax
je MT_12
push bx ; save original index
shl bx, 1 ; adjust to word index
add bx, di ; di contains the offset of array table
mov word [ds:bx], 0
pop bx
inc bx
jmp MT_11
MT_12:
pop cx ; restore nchar

; from this point we start using global variable for result
; storing. We might consider to change to use global variable
; instead of pushing/poping a lot of registers later.
mov word [ds:avail], cx
mov word [ds:nchar], cx ; move this line to the upper
; part of this subroutine
mov cx, 15
sub cx, dx
mov ax, 1
shl ax, cl
mov word [ds:vmask], ax
xor bx, bx ; BX stand for variable ch
MT_13:
cmp bx, word [ds:nchar]
jae MT_Exit

movzx ax, byte [bx+si] ; si contains the offset of array bitlen
mov word [ds:len], ax
cmp word [ds:len], 0
je MT_20 ; continue looping

push bx ; bx contains value of variable ch
mov bx, word [ds:len]
shl bx, 1 ; adjust to word index
mov ax, word [ds:start_decomp + bx]
add ax, word [ds:weight + bx]
mov word [ds:nextcode], ax
cmp word [ds:len], dx ; dx contains the value of tablebits
ja MT_15

mov bx, word [ds:len]
shl bx, 1 ; adjust to word index
mov ax, word [ds:start_decomp + bx]
pop bx ; now bx contains the value of ch
MT_14:
cmp ax, word [ds:nextcode]
jae MT_19
push di
add di, ax
add di, ax ; adjust to word index
mov word [ds:di], bx
pop di
inc ax
jmp MT_14
MT_15:
; stack is not yet balanced

; Now BX stored in the stack still contains value of var ch
mov bx, word [ds:len]
shl bx, 1 ; adjust to word index
mov ax, word [ds:start_decomp + bx]
mov word [ds:k], ax
mov cx, word [ds:jutbits]
shr ax, cl
mov bx, ax
shl bx, 1 ; adjust to word index
add bx, di
mov word [ds:p], bx ; get the pointer of table[k>>jutbits]
mov bx, word [ds:len]
sub bx, dx
mov word [ds:i], bx
MT_16:
cmp word [ds:i], 0
je MT_18

mov bx, word [ds:p]
cmp word [ds:bx], 0
jne MT_17

mov bx, word [ds:avail]
shl bx, 1 ; adjust to word index
mov word [ds:right + bx], 0
mov word [ds:left + bx], 0
mov bx, word [ds:p]
mov ax, word [ds:avail]
mov word [ds:bx], ax
inc ax
mov word [ds:avail], ax
MT_17:
mov ax, word [ds:k]
mov bx, word [ds:vmask]
and ax, bx
jz MT_17_1

; the following 5 lines of code are converted from "p = &right[*p]"
mov bx, word [ds:p]
mov ax, word [ds:bx]
shl ax, 1 ; adjust to word index
mov bx, right
add bx, ax
mov word [ds:p], bx
jmp MT_17_2
MT_17_1:
; the following 5 lines of code are converted from "p = &left[*p]
mov bx, word [ds:p]
mov ax, word [bx]
shl ax, 1 ; adjust to word index
mov bx, left
add bx, ax
mov word [ds:p], bx
MT_17_2:
mov ax, word [ds:k]
shl ax, 1
mov word [ds:k], ax
dec word [ds:i]
jmp MT_16
MT_18:
pop bx ; get ch back, and stack now is balanced
xchg ax, bx
mov bx, word [ds:p]
mov word [ds:bx], ax
xchg ax, bx

MT_19: ; to here BX should contains the value of var ch
push bx
mov bx, word [ds:len]
shl bx, 1 ; adjust to word index
mov ax, word [ds:nextcode]
mov word [ds:start_decomp + bx], ax
pop bx
MT_20:
inc bx
jmp MT_13
MT_Exit:
;pop bx
popa
ret

; Input : None
; Output : None
ReadCLen:
pusha
mov ax, CBIT
call GetBits
cmp ax, 0
jne RCL_3

mov ax, CBIT
call GetBits ; AX contains the value of var c
mov cx, NC
RCL_1:
mov bx, NC
sub bx, cx
mov byte [ds:c_len + bx], 0
loop RCL_1

mov cx, 4096
RCL_2:
mov bx, 4096
sub bx, cx
mov di, bx
shl di, 1 ; prepare word index
mov word [ds:c_table + di], ax
loop RCL_2
jmp RCL_Exit
RCL_3:
mov dx, ax ; AX carry result of n, save n
mov si, 0 ; i
RCL_4:
cmp dx, si ; dx -> n, si -> i
jbe RCL_10

mov cx, word BITBUFSIZ
sub cx, 8
mov bx, word [ds:bitbuf]
shr bx, cl
shl bx, 1 ; prepare word index
mov di, word [ds:pt_table + bx] ; c
cmp di, NT
jb RCL_7

mov cx, word BITBUFSIZ
sub cx, 9
mov bx, 1
shl bx, cl ; BX is used to store MASK temporarily
RCL_5:
mov ax, word [ds:bitbuf]
and ax, bx
jz RCL_6

shl di, 1 ; prepare word index
mov di, word [ds:right + di]
jmp RCL_6_1
RCL_6:
shl di, 1 ; prepare word index
mov di, word [ds:left + di]
RCL_6_1:
shr bx, 1
cmp di, NT
jae RCL_5
RCL_7:
movzx ax, byte [ds:pt_len + di]

call FillBuf
cmp di, 2
ja RCL_9

cmp di, 0
jne RCL_7_1

mov di, 1
jmp RCL_8
RCL_7_1:
cmp di, 1
jne RCL_7_2

mov ax, 4 ; prepare input for GetBits
call GetBits ; get a result from AX
add ax, 3
mov di, ax
jmp RCL_8
RCL_7_2:
mov ax, CBIT
call GetBits
add ax, 20
mov di, ax
RCL_8: ; while (--c >= 0) c_len[i++] = 0
dec di
cmp di, 0
js RCL_4

mov byte [ds:c_len + si], 0
inc si
jmp RCL_8
RCL_9:
mov ax, di
sub ax, 2
mov byte [ds:c_len + si], al
inc si
jmp RCL_4

RCL_10: ; when i >= n
cmp si, NC
jae RCL_11

mov byte [ds:c_len + si], 0
inc si
jmp RCL_10
RCL_11:
mov bx, NC ; bx -- parameter 1
mov si, c_len ; prepare parameter 2
mov dx, 12 ; dx -- parameter 3
mov di, c_table ; prepare parameter 4
call MakeTable
RCL_Exit:
popa
ret

; Input : SI->nn(int), AX->nbit(int), DI->i_special(int)
; Output : None
ReadPtLen:
pusha
push ax ; save nbits for later use
call GetBits
mov dx, ax ; save n

cmp dx, 0
pop ax
jne RPL_3_1
call GetBits ; get a result put it in AX for var c

xor bx, bx
RPL_1:
cmp bx, si
jae RPL_2
mov byte [ds:pt_len + bx], 0
inc bx
jmp RPL_1
RPL_2:
xor bx, bx
RPL_3:
cmp bx, 512 ; word index
jae RPL_Exit ; bye !
mov word [ds:pt_table + bx], ax
add bx, 2 ; moving pointer 1 word forward
jmp RPL_3
RPL_3_1:
xor bx, bx ; i
RPL_4:
cmp bx, dx ; i < n ?
jae RPL_10

mov cx, BITBUFSIZ
sub cx, 3
mov ax, word [ds:bitbuf]
shr ax, cl

push di ; save parameter since we want to use di
mov di, ax ; save for later var c referencing

cmp di, 7
jne RPL_6

mov cx, BITBUFSIZ
sub cx, 4
mov ax, 1
shl ax, cl ; variable mask is ready
RPL_5:
mov cx, word [ds:bitbuf]
and cx, ax
jz RPL_6
shr ax, 1
inc di
jmp RPL_5

RPL_6: ; fillbuf((c < 7) ? 3 : c - 3)
mov ax, 3
cmp di, 7
jb RPL_7
mov ax, di
sub ax, 3
RPL_7:
call FillBuf

mov ax, di
mov byte [ds:pt_len + bx], al
inc bx

pop di
cmp bx, di
jne RPL_4
mov ax, 2
call GetBits
RPL_8:
dec ax
cmp ax, 0
js RPL_4 ; loop back
mov byte [ds:pt_len + bx], 0
inc bx
jmp RPL_8

RPL_10: ; while (i >= n)
cmp bx, si ; while (i < nn) loop
jae RPL_11
mov byte [ds:pt_len + bx], 0
inc bx
jmp RPL_10
RPL_11:
mov bx, si ; prepare parameter for MakeTable call
mov si, pt_len
mov dx, 8
mov di, pt_table

call MakeTable

RPL_Exit:
popa
ret

; Input : BX -- from
; CX -- count
; Output : EAX
; Destroy : EAX
GetFromHeader:
push bx
push edx
push si
xor eax, eax ; prepare unsigned long variable output

dec bx
inc cx
GFH_1:
dec cx
jcxz GFH_2

shl eax, 8
mov si, bx
add si, cx
movzx edx, byte [ds:Header + si]
add eax, edx ; little endian
jmp GFH_1
GFH_2:
pop si
pop edx
pop bx
ret

;.....................vars.......................................
; Equates File for Data Decompression

;ReadDataFromFile EQU 1
;WriteDataToFile EQU 1
;DOSVERSION EQU 1

FNAME_MAX = 255 - 25
CRCPOLY = 0A001h ; ANSI CRC-16
; CCITT: 08408h

INIT_CRC = 0 ; CCITT: 0xFFFF
DICBIT = 13 ; 12(-lh4-) or 13(-lh5-)
DICSIZ = 2000h ; (1 << DICBIT)
UCHAR_MAX = 0ffh ; maximum unsigned char value
MAXMATCH = 256 ; formerly F (not more than UCHAR_MAX + 1)
THRESHOLD = 3 ; choose optimal value
BITBUFSIZ = 16 ; (CHAR_BIT * sizeof bitbuf)
; CHAR_BIT is 8 for PC and
; bitbuf is claimed as unsigned int which is 2 bytes

CHAR_BIT = 8
NC = (UCHAR_MAX + MAXMATCH + 2 - THRESHOLD)
; alphabet = {0, 1, 2, ..., NC - 1}
CBIT = 9 ; $\lfloor \log_2 NC \rfloor + 1$
CODE_BIT = 16 ; codeword length

NP = (DICBIT + 1)
NT = (CODE_BIT + 3)

PBIT = 4 ; smallest integer such that (1U << PBIT) > NP
TBIT = 5 ; smallest integer such that (1U << TBIT) > NT

IF NT > NP
NPT = NT
ELSE
NPT = NP
END IF

OUTFILENAME = 20
NAMELENIDX = 19

;;SRC_SEGMENT EQU 0e000h
;TGT_SEGMENT = 8000h

;R01 start
COMPRESSED_UNKNOW_BYTE = 3
;BootExt_Off = 0
;DecmpCode_Off = 2
;Extract_Off = 0ah
;Expand_Off = 0eh
;BootExt_Size = 17h
;DecmpCode_Size = 18h
;OutHook_Off = 19h
;P6UPD_Start_Seg = 1bh

;BtExtRom_Seg = 0e000h

;[]------------------------------------------------------------------[]
; End of Decompress Engine
;[]------------------------------------------------------------------[]

Ромка ты не обижайся.... мне тежеловато самому все допирать\дизасамблить! да и ты сам говорил настойчивость... и т.д. и т.п.

-------------------------------------------------
не буду убивать форум а спрошу здесь... как извесно юзаю я твое ноу-хау модул.тмп.... для правки биоса! Надо мне переслать довольно большой масив в 58 байт( соответствинно добавляю по адресам x00300h(данные куда и сколько слать) и 000380h(собственно данные)) комп наглухо виснет (на экране пустота).... розбиваю по 29 байт все фурычит.... в чем Баг

Алгоритм работы патчера "универсален", потому предусматривает несколько способов внесения измения - и по адресам и по действию и по "времени выполнения" (сразу, в середине POST, в конце). Потому поясни - что ты имеешь в виду или что нужно сделать?