/programs/other/archer/trunk/@RCHER.ASM |
---|
0,0 → 1,424 |
; @RCHER - DEflate unpacker v1.0 |
; |
; Written in pure assembler by Ivushkin Andrey aka Willow |
; |
; Created: May 6, 2005 |
; |
; Last changed: July 14, 2005 |
; |
; Compile with FASM |
SYS equ meos |
PARAM_PTR equ png_image |
DUMPFILE equ '/hd/1/out.txt' |
SHOW_RBLOCK equ 0;1 |
SHOW_PNG_SEC equ 0;1 |
SHOW_METH equ 0;1 |
FILE_NUM equ 0 |
MEMORY equ 0x800000 |
BITS equ 16 |
BUFSIZE equ 32 |
BUFPTR equ area |
PASSW_LEN equ 32 |
NO_STOPS equ 1 |
SHOW_CHARS equ 0 |
BSIZE equ 512 |
INBUF equ BUFSIZE*BSIZE*2 |
OUTBUF equ 4*1024*1024 |
IGNORE_DIRS equ 0 |
MOVE_SLINE_LEV equ 8 |
DECRYPT_MODE equ 100b |
PNG_MODE equ 10b |
TAR_MODE equ 1000b |
STAY_MODE equ 10000b |
IPC_MODE equ 100000b |
RAW_MODE equ 1000000b |
THREAD_YES equ 10000000b |
if SYS eq win |
format PE console |
entry start |
;match =win,SYS |
;{ |
; include 'D:\Ivushkin\projects\fasmw\INCLUDE\win32a.inc' |
;} |
else |
use32 |
org 0x0 |
db 'MENUET01' |
dd 0x01 |
dd start |
dd I_END |
dd MEMORY |
dd MEMORY-2048 |
if PARAM_PTR eq param |
dd 0 |
else |
dd PARAM_PTR |
end if |
dd 0x0 |
include "lang.inc" |
if PARAM_PTR eq param |
param db 'RQ' |
db '000037' |
db '/hd/1/zip/png.zip',0 |
end if |
;match =meos,SYS |
;{ |
include "macros.inc" |
; purge mov |
include "debug.inc" |
;} |
end if |
language equ en |
if SYS eq win |
section '.text' code readable executable writeable |
end if |
include "arcmacro.inc" |
include "parser.inc" |
include "deflate.inc" |
include "sys.inc" |
FileNum dd FILE_NUM |
;FNAME equ '/hd/1/zip/pngsuite/s01n3p01.png' |
start: |
if SYS eq win |
invoke GetStdHandle, STD_OUTPUT_HANDLE |
mov [cons],eax |
invoke GetStdHandle, STD_INPUT_HANDLE |
mov [cons_in],eax |
Msg 0 |
Msg 1 |
else |
Msg 0 |
Msg 1 |
mcall 40,10000101b |
; jmp again |
CmdLine |
red: |
call draw_window |
mcall 12,2 |
still: |
mcall 10 |
cmp eax,1 |
je red |
cmp eax,2 |
jne .nokey |
mcall 2 |
cmp ah,9 |
jz quit |
jmp still |
.nokey: |
cmp eax,3 |
jne still |
mcall 17 |
cmp ah,1 |
jne still |
mcall 23,30 |
cmp eax,3 |
jne .noquit |
call KillViewer |
mcall -1 |
.noquit: |
mcall 17 |
QueryFile |
and [FileNum],0 |
test eax,eax |
jnz still |
end if |
again: |
Newline |
xor eax,eax |
; and [Flags],STAY_MODE |
and [CRC32],eax |
and [IDATsize],eax |
mov [Adler32],1 |
call OpenFile |
test ebx,ebx |
jnz .sizeok2 |
.sizebad2: |
Msg 14 |
jmp quit |
.sizeok2: |
mov [filesize],ebx |
test [Flags],RAW_MODE |
jz .norawm |
mov eax,[arc_base] |
xor ebx,ebx |
call FileSeek |
jmp .sizeok |
.norawm: |
call SfxParse |
call ZipParse |
cmp edx,52 |
je .notzip |
mov ecx,[FileNum] |
call ZipFindN |
cmp edx,4 |
je quit |
test [Flags],DECRYPT_MODE |
jz .nopass |
call ZipDecrypt |
push esi |
mov ecx,31 |
._: |
mov al,[esi] |
push eax |
call decrypt_byte |
xor al,byte[esp] |
add esp,4 |
call UKeys |
mov [esi],al |
inc esi |
loop ._ |
pop esi |
ud2 |
.nopass: |
cmp [unp_size],0 |
jne .sizeok |
.sizebadq: |
Msg 13 |
jmp quit |
.notzip: |
call GzipParse |
test edx,edx |
jne .notgzip |
jmp .sizeok |
.notgzip: |
call PngParse |
test edx,edx |
jz .sizeok1 |
cmp edx,21 |
je .sizebad |
test [Flags],RAW_MODE |
jne .sizeok |
Msg 40 |
jmp exit |
.sizebad: |
Msg 17 |
jmp exit |
.sizeok1: |
if ~ SYS eq win |
call KillViewer |
end if |
Msg 39 |
mov edi,[outp] |
call Deflate.blkbegin |
jmp .defl_end |
.sizeok: |
call Deflate ; <=========== |
.defl_end: |
test [bits],7 |
jnz .esi_ok |
dec esi |
.esi_ok: |
push dword[esi] ; <- Adler !!! |
mov esi,output |
sub edi,esi |
mov ecx,edi |
mov [outfile.size],ecx |
test [Flags],RAW_MODE |
jnz .skipAdler |
test [Flags],PNG_MODE |
jnz .skipCRC |
push esi ecx |
call UCRC |
Msg 11 |
mov eax,[CRC32] |
mov edx,36 |
cmp eax,[CRC_check] |
je .crcok |
dec edx |
.crcok: |
Msg edx |
if SYS eq win |
else |
dph eax |
end if |
pop ecx esi |
jmp .skipAdler |
.skipCRC: |
call UAdler |
Msg 10 |
mov eax,[Adler32] |
bswap eax ; <- calculated Adler !!! |
mov edx,36 |
cmp eax,[esp] |
je .adlok |
dec edx |
.adlok: |
Msg edx |
if SYS eq win |
else |
dph eax |
end if |
.skipAdler: |
pop eax |
Newline |
.nomoreIDAT: |
mov ebx,output |
if SYS eq win |
Msg 37 |
invoke CloseHandle, [hnd] |
invoke CreateFile,dumpfile,GENERIC_WRITE, FILE_SHARE_WRITE, NULL, \ |
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,NULL |
mov [hnd],eax |
invoke WriteFile, eax,ebx,[outfile.size],cparam1,NULL |
invoke CloseHandle, [hnd] |
else |
test [Flags],PNG_MODE |
jnz .nosave |
test [Flags],TAR_MODE |
jnz .nomsg |
Msg 37 |
.nomsg: |
mov [outfile.out],ebx |
mcall 58,outfile |
test [Flags],TAR_MODE |
jnz .nosave |
call StartPad |
.nosave: |
end if |
test [Flags],PNG_MODE |
jz NoPng |
xor eax,eax |
mov edi,filters |
mov ecx,6 |
rep stosd |
mov edi,png_image |
mov esi,output |
;// |
mov [outp],edi |
;// |
call PngFilter |
call FiltStats |
mov [outfile.size],edi |
mov ebx,[outp];png_image |
if SYS eq win |
exit: |
Msg 12 |
invoke CreateFile,outfile,GENERIC_WRITE, FILE_SHARE_WRITE, NULL, \ |
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,NULL |
mov [hnd],eax |
invoke WriteFile, eax,ebx,[outfile.size],cparam1,NULL |
invoke CloseHandle, [hnd] |
call RunViewer |
and [arc_base],0 |
and [Flags],STAY_MODE |
quit: |
QueryFile |
test eax,eax |
jnz again |
invoke ExitProcess,0 |
else |
exit: |
mov [outfile.out],ebx |
test [Flags],TAR_MODE |
jz .notar |
Msg 37 |
mcall 58,outfile |
call StartPad |
.notar: |
Msg 12 |
call RunViewer |
and [arc_base],0 |
and [Flags],STAY_MODE |
quit: |
test [Flags],STAY_MODE |
jnz red |
mcall -1 |
end if |
NoPng: |
test [Flags],TAR_MODE |
if SYS eq win |
jz quit |
else |
jz still |
end if |
mov ecx,dumpf_len |
mov esi,dumpfile |
mov edi,filename |
rep movsb |
call OpenFile |
test ebx,ebx |
jz again.sizebadq |
call TarParse |
mov ecx,[FileNum] |
call TarFindN |
cmp [outfile.size],0 |
jz again.sizebadq |
mov ebx,esi |
jmp exit |
if ~ SYS eq win |
draw_window: |
mcall 12,1 |
mov ebx,15 |
mov ecx,ebx |
mov edx,0x0e26830 |
mov edi,edx |
mcall 0,,,,0x1f2a870 |
mcall 8,,,1+1 shl 30 |
mcall 4,<6,5>,0x10d0d0d0,msgs+5,1 |
mcall ,<5,5>,0x10202020 |
ret |
end if |
include 'data.inc' |
if SYS eq win |
section '.idata' import data readable writeable |
library kernel,'KERNEL32.DLL',\ |
comdlg,'COMDLG32.DLL',\ |
user,'USER32.DLL' |
import kernel,\ |
CreateFile,'CreateFileA',\ |
GetFileSize,'GetFileSize',\ |
ReadFile,'ReadFile',\ |
WriteFile,'WriteFile',\ |
SetFilePointer,'SetFilePointer',\ |
CloseHandle,'CloseHandle',\ |
GetStdHandle,'GetStdHandle',\ |
WriteConsole,'WriteConsoleA',\ |
ReadConsole,'ReadConsoleA',\ |
CreateProcess,'CreateProcessA',\ |
WritePrivateProfileString,'WritePrivateProfileStringA',\ |
ExitProcess,'ExitProcess' |
import comdlg,\ |
GetOpenFileName,'GetOpenFileNameA' |
import user,\ |
wsprintf,'wsprintfA',\ |
SendMessage,'SendMessageA',\ |
FindWindowEx,'FindWindowExA',\ |
WaitForInputIdle,'WaitForInputIdle' |
section '.reloc' fixups data readable discardable |
end if |
if ~ SYS in <meos,win> |
error "Please specify SYS: meos OR win" |
end if |
/programs/other/archer/trunk/archer.txt |
---|
0,0 → 1,176 |
@RCHER FOR MENUET v1.0 July 14, 2005 |
Written in pure assembler by Ivushkin Andrey aka Willow |
Deflate unpacker |
Vivat assembler et MENUETOS! |
I tender thanks to everyone who spends his time in feasible effortsfor that |
little OS evolution. Now in my own rating the Mario79's distro named Kolibri4 |
takes 1th place. It is always pleasant to use modern software. Go on! |
@RCHER is intended to view & unpack data compressed by Deflate method |
(including both static and dynamic Huffman). This method (although it isn't the |
best already) is used by such file formats as ZIP (modern versions: PKZIP for |
MS-DOS can create archives using other, less effective compression methods, |
which @RCHER doesn't support), GZIP, JAR, OpenOffice files, SFX ZIP executables |
and some others. I couldn't prevent myself to include support of PNG images |
(they use the similar compression) and TAR and TAR+GZIP archives. |
When the program is started, a little button carrying a @ symbol appears in the |
left top corner of screen. Clicking this button opens a SYSXTREE dialog to |
select a file being unpacked. Doubleclick closes the application. @RCHER |
outputs its information messages to Debug Board. If an archive contains more |
than one file, the 1st is by default unpacked into /HD/1/OUT.TXT (you may |
change the DUMPFILE constant in @RCHER.ASM) and is opened through TINYPAD |
or - if it's a PNG image - in the built-in viewer. |
These are unpacking flags that may exist in a commandline before an archive |
filename: |
s - do not close the program after unpacking; |
n - decompress the K-th archive file, where K is the following dword in |
commandline; |
N - decompress the K-th archive file, where K is ASCII number from the |
following 6 bytes of commandline; |
R - "raw" Deflate data, without descriptors and headers; |
q - begin file parsing from offset of K, where K is following dword in |
commandline; |
Q - begin file parsing from offset of K, where K is ASCII number from the |
following 6 bytes of commandline. |
Commandline example: |
cmd_string: |
db 'sN000037q' |
dd 1465 |
db '/hd/1/png.zip',0 |
It means to open the 34th (counting from 0) file of archive /hd/1/png.zip |
and do not terminate. Archive will be parsed starting at offset 1465. |
To-Do list: |
1. Support for interlaced PNG, alpha-channels, gamma-correction, background, |
Significant bits and a lot of cool parts of that format. |
2. Output of archive content through IPC or into a built-in window like SYSTREE |
(as we are going to decide with the respected colleagues). |
3. Searching of archive files by name and wildcards! |
4. Unpacking into a file specified. |
5. Means on saving memory space (now @RCHER gorges 8 Mb!): moving RAM areas, |
blocked file output. To do the last thing it is necessary to test carefully |
the reliability of harddisk I/O, directory creation and file deletion. These |
kernel capabilities aren't still documented. |
6. Archive contents integration into SYSXTREE & MFAR filemanagers. We have to |
unify the calling format (like a structure in the sysfunc 58). |
7. Add comments to source. |
8. Correct bugs to be found |
Special thanks to: |
Explanation of algorythm of Deflate format decoder with decoding samples |
(evm.narod.ru) |
RFC 1951 DEFLATE Compressed Data Format Specification version 1.3 |
ZIP File Format Specification version 4.5 by PKWARE Inc. |
"An Explanation of the Deflate Algorithm" by Antaeus Feldspar |
RFC 1952 GZIP file format specification version 4.3 |
TAR Format. Information from File Format List 2.0 by Max Maischein. |
RFC 1950 ZLIB Compressed Data Format Specification version 3.3 |
PNG (Portable Network Graphics) Specification version 1.0 |
Michael Dipperstein's Huffman Code Page |
I expect your remarks and suggestions on the @RCHER's topic, "Coding" section |
at meos.sysbin.com forum. |
See you later! |
**************************************** |
**************************************** |
@RCHER MENUET v1.0 14 ¨î«ï 2005 £. |
¯¨á ç¨á⮬ áᥬ¡«¥à¥ ¢ãèª¨ë¬ ¤à¥¥¬ (Willow) |
Deflate à ᯠª®¢é¨ª |
Vivat assembler et MenuetOS! |
ëà ¦ î ¨áªà¥îî ¡« £®¤ à®áâì ¢á¥¬ ⥬, ªâ® ¥ ¦ «¥ï ᢮¥£® ¢à¥¬¥¨, |
¤¥« ¥â ¯®á¨«ìë© ¢ª« ¤ ¢ à §¢¨â¨¥ í⮩ ¬ «¥ìª®© . ¥©ç á ¢ ¬®¥¬ ᮡá⢥®¬ |
३⨣¥ 1-¥ ¬¥áâ® § ¨¬ ¥â ¤¨áâਡã⨢ Mario79 Kolibri4. ᥣ¤ ¯à¨ïâ® |
¯®«ì§®¢ âìáï ᮢ६¥ë¬ . ª ¤¥à¦ âì! |
@RCHER ¯à¥¤ § ç¥ ¤«ï ¯à®á¬®âà ¨ à ᯠª®¢ª¨ ¤ ëå, ᦠâëå á ¯®¬®éìî ¬¥â®¤ |
Deflate (¢ª«îç ï áâ â¨ç¥áª¨© ¨ ¤¨ ¬¨ç¥áª¨© ää¬ ). ë¬ ¬¥â®¤®¬ (å®âï ® |
㦥 ¥ ¯à¥â¥¤ã¥â §¢ ¨¥ ¨«ãç襣®) ¯®«ì§ãîâáï ä®à¬ âë ä ©«®¢ ZIP |
(ᮢ६¥ë¥ ¢¥àᨨ: PKZIP ¤«ï MS-DOS ¬®¦¥â ᮧ¤ ¢ âì à娢ë á ¤à㣨¬¨, ¬¥¥¥ |
íä䥪⨢묨 ¬¥â®¤ ¬¨ ᦠâ¨ï, ª®â®àë¥ @RCHER ¥ ¯®¤¤¥à¦¨¢ ¥â), GZIP, JAR, |
ä ©«ë OpenOffice, SFX-ZIP ¯à¨«®¦¥¨ï ¨ àï¤ ¤à㣨å. ¥ ¬®£ 㤥ঠâìáï ¨ ¥ |
ᤥ« âì ¯®¤¤¥à¦ªã ¨§®¡à ¦¥¨© ¢ ä®à¬ ⥠PNG (¨á¯®«ì§ãîé¨å தáâ¢¥ë© ¬¥â®¤ |
ᦠâ¨ï) ¨ à娢®¢ TAR ¨ TAR+GZIP. |
ਠ§ ¯ã᪥ ¯à®£à ¬¬ë ¢ «¥¢®¬ ¢¥à奬 㣫ã íªà ¯®ï¢«ï¥âáï ¬ «¥ìª ï ª®¯ª |
á® § 窮¬ @. ਠ¦ ⨨ ¥¥ ®âªàë¢ ¥âáï ®ª® ¢ë¡®à ä ©« (SYSXTREE) ¤«ï |
à ᯠª®¢ª¨. ¢®©®© 饫箪 § ªàë¢ ¥â ¯à¨«®¦¥¨¥. ä®à¬ æ¨®ë¥ á®®¡é¥¨ï |
@RCHER ¢ë¢®¤¨â ¤®áªã ®â« ¤ª¨. ᫨ à娢 ᮤ¥à¦¨â ¥áª®«ìª® ä ©«®¢, ¯® |
㬮«ç ¨î ¯¥à¢ë© ¨§ ¨å à ᯠª®¢ë¢ ¥âáï /HD/1/OUT.TXT (¯®¬¥ï©â¥ ¯à¨ |
¥®¡å®¤¨¬®á⨠ª®áâ âã DUMPFILE ¢ @RCHER.ASM) ¨ ®âªàë¢ ¥âáï ç¥à¥§ TINYPAD |
¨«¨ - ¢ á«ãç ¥ ª à⨪¨ PNG - ¢ ®ª¥ ¢áâ஥®£® ¯à®á¬®âà騪 . |
ª®¬ ¤®© áâப¥ ¯¥à¥¤ ¨¬¥¥¬ à娢 ¬®£ãâ ¢ ¯à®¨§¢®«ì®¬ ¯®à浪¥ 㪠§ë¢ âìáï |
ä« £¨ à ᯠª®¢ª¨: |
s - ¥ § ªàë¢ âì ¯à®£à ¬¬ã ¯®á«¥ à ᯠª®¢ª¨; |
n - à ᯠª®¢ âì K-© ä ©« à娢 , £¤¥ K - á«¥¤ãî騩 dword ¢ ª®¬ ¤®© áâப¥; |
N - à ᯠª®¢ âì K-© ä ©« à娢 , £¤¥ K - ASCII ç¨á«® ¨§ á«¥¤ãîé¨å 6 ¡ ©â |
ª®¬ ¤®© áâப¨; |
R - "áëàë¥" Deflate-¤ ë¥, ¡¥§ ®¯¨á ⥫¥© ¨ § £®«®¢ª®¢; |
q - ¯à®á¬®âà ä ©« ç âì ᮠᬥ饨ï K, £¤¥ K - á«¥¤ãî騩 dword ¢ ª®¬ ¤®© |
áâப¥; |
Q - ¯à®á¬®âà ä ©« ç âì ᮠᬥ饨ï K, £¤¥ K - ASCII ç¨á«® ¨§ á«¥¤ãîé¨å 6 |
¡ ©â ª®¬ ¤®© áâப¨. |
ਬ¥à ª®¬ ¤®© áâப¨: |
cmd_string: |
db 'sN000037q' |
dd 1465 |
db '/hd/1/png.zip',0 |
â® ®§ ç ¥â, çâ® á«¥¤ã¥â ®âªàëâì 34-© (áç¨â ï ®â 0) ä ©« à娢 /hd/1/png.zip |
¨ ¥ § ¢¥àè âì à ¡®âã. à®á¬®âà à娢 ç¥âáï ᮠᬥ饨ï 1465. |
â® ¥é¥ 㦮 ᤥ« âì: |
1. ®¤¤¥à¦ª ç¥à¥ááâà®çëå (interlaced) PNG, â ª¦¥ «ìä -ª «®¢, £ ¬¬ë, |
ä® , Significant bits ¨ ªãç¨ ¤àã£¨å ¯à¨¬®ç¥ª í⮣® ä®à¬ â . |
2. 뢮¤ ᮤ¥à¦¨¬®£® à娢®¢ ç¥à¥§ IPC ¨«¨ ¢® ¢áâ஥®¬ ®ª¥ ¯®¤®¡¨¥ SYSTREE |
(íâ® ª ª à¥è¨¬ á 㢠¦ ¥¬ë¬¨ ª®««¥£ ¬¨). |
3. ®¨áª ä ©«®¢ ¢ à娢¥ ¯® ¨¬¥¨ ¨ ¤ ¦¥ ¬ ᪥! |
4. ᯠª®¢ª ¢ 㪠§ ë© ä ©«. |
5. ¥à®¯à¨ïâ¨ï ¯® íª®®¬¨¨ ¯ ¬ï⨠(ᥩç á @RCHER ¦à¥â 8 ¡!): ¯¥à¥¬¥é¥¨¥ |
ãç á⪮¢ ¯ ¬ïâ¨, ¡«®çë© ¢ë¢®¤ ¢ ä ©«. «ï ¯®á«¥¤¥£® ¥®¡å®¤¨¬® âé â¥«ì® |
¯à®â¥áâ¨à®¢ âì ¤¥¦®áâì ¢®®¤ -¢ë¢®¤ , ᮧ¤ ¨ï ª â «®£®¢ ¨ 㤠«¥¨ï |
ä ©«®¢. ®ª í⨠¢®§¬®¦®á⨠ï¤à ¥ ¤®ªã¬¥â¨à®¢ ë. |
6. ⥣à æ¨ï à娢ëå ª â «®£®¢ ¢ ä ©«®¢ë¥ ¬¥¥¤¦¥àë SYSXTREE, MFAR. |
®âॡã¥âáï ã¨ä¨æ¨à®¢ âì ä®à¬ ⠢맮¢ ( ¯®¤®¡¨¥ áâàãªâãàë ¢ 58 äãªæ¨¨). |
7. ⪮¬¬¥â¨à®¢ âì ª®¤. |
8. á¯à ¢¨âì ¡ £¨, ª®â®àë¥, ¥á®¬¥®, ©¤ãâáï ;-) |
á®¡ë¥ ¡« £®¤ à®áâ¨: |
¯¨á ¨¥ «£®à¨â¬ ¤¥ª®¤¥à ä®à¬ â Deflate ¯à¨¬¥à å ¤¥ª®¤¨à®¢ ¨ï |
(evm.narod.ru) |
RFC 1951 DEFLATE Compressed Data Format Specification version 1.3 |
ZIP File Format Specification version 4.5 by PKWARE Inc. |
"An Explanation of the Deflate Algorithm" by Antaeus Feldspar |
RFC 1952 GZIP file format specification version 4.3 |
TAR Format. Information from File Format List 2.0 by Max Maischein. |
RFC 1950 ZLIB Compressed Data Format Specification version 3.3 |
PNG (Portable Network Graphics) Specification version 1.0 |
Michael Dipperstein's Huffman Code Page |
¤ã ¢ è¨å § ¬¥ç ¨© ¨ ¯à¥¤«®¦¥¨© ®¤®¨¬¥®© ¢¥âª¥ à §¤¥« "®¤¨£" ä®à㬠|
meos.sysbin.com |
® ®¢ëå ¢áâà¥ç! |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |
/programs/other/archer/trunk/arcmacro.inc |
---|
0,0 → 1,440 |
; @RCHER macros and messages |
; Written in pure assembler by Ivushkin Andrey aka Willow |
macro stop |
{ |
if SYS eq win & NO_STOPS eq 0 |
int3 |
end if |
} |
macro wait |
{ |
if ~ SYS eq win |
local .nodrw,.ex |
pusha |
mcall 10 |
cmp eax,1 |
jne .nodrw |
call draw_window |
.nodrw: |
mcall 17 |
.ex: |
popa |
end if |
} |
macro rbits dest,cnt |
{ |
if ~ cnt eq |
mov ecx,cnt |
end if |
if dest eq 0 |
xor eax,eax |
else |
mov eax,dest |
end if |
call read_bits |
} |
macro rep_err cond_ok, result, msg |
{ |
local .m |
j#cond_ok .m |
if ~ msg eq |
Msg msg |
end if |
mov edx,result |
jmp .err |
.m: |
} |
macro memcpy_esi dest, count,_add |
{ |
push esi |
if ~ _add eq |
add esi,_add |
end if |
mov edi,dest |
mov ecx,count |
rep movsb |
pop esi |
} |
DebugPrint: |
; in: edx-asciiz string ptr |
pusha |
if SYS eq win |
mov ecx,255 |
xor eax,eax |
mov edi,edx |
repne scasb |
sub edi,edx |
dec edi |
invoke WriteConsole,[cons],edx,edi,cparam1,NULL |
else |
call debug_outstr |
end if |
popa |
ret |
macro DebugPrintDec |
{ |
if SYS eq win |
call int2str |
mov edx,os_work |
call DebugPrint |
else |
call debug_outdec |
end if |
} |
macro Newline |
{ |
if SYS eq win |
pusha |
invoke WriteConsole,[cons],cr_lf,2,cparam1,NULL |
popa |
else |
newline |
end if |
} |
Msgcall: |
; edx - msg number |
pusha |
movzx edx,word[strs+edx*2] |
add edx,msgs |
call DebugPrint |
popa |
ret |
macro Msg num |
{ |
if ~ num eq edx |
mov edx,num |
end if |
call Msgcall |
} |
MSG_COUNT=0 |
macro str_table [str] |
{ |
forward |
local label |
dw label-msgs |
common |
msgs: |
forward |
label db str,0 |
MSG_COUNT=MSG_COUNT+1 |
} |
strs: |
if language eq ru |
str_table \ |
<'*** @RCHER - Deflate Unpacker ***',13,10>,\ ;0 |
<'*** Copyright Wiland Inc., 2005 ***',13,10>,\ ;1 |
' ©«®¢ ¢ à娢¥: ',\ ;2 |
<'End of Directory ¤®á⨣ãâ',13,10>,\ ;3 |
'¥â ä ©« á â ª¨¬ ®¬¥à®¬',\ ;4 |
<'FindByNumber ',13,10>,\ ;5 |
<'¥¢¥àë© ID ¡«®ª ää¬ ',13,10>,\ ;6 |
<'訡ª ¢ ª®¤ å ää¬ !',13,10>,\ ;7 |
<13,10,' áç¥â â ¡«¨æë CRC32',13,10>,\ ;8 |
'.',\ ;9 |
'Adler32',\ ;10 |
'CRC32',\ ;11 |
<' ¢¥à襮.',13,10>,\ ;12 |
<' ©« ¨¬¥¥â ã«¥¢ãî ¤«¨ã, à ᯠª®¢ª ®â¬¥¥ .',13,10>,\ ;13 |
<'âà ï ¤«¨ ä ©« -¨áâ®ç¨ª . 訡ª ¢ ¨¬¥¨? ⬥ .',13,10>,\ ;14 |
<'¥ GZIP à娢',13,10>,\ ;15 |
<'«¨èª®¬ ¡®«ì让 à §¬¥à ¢ë室®£® ä ©« ',13,10>,\ ;16 |
<"訡ª ¯à¨ à ᯠª®¢ª¥.",13,10>,\ ; 17 |
<'¥ à¨á㮪 PNG',13,10>,\ ; 18 |
<13,10,'*¤'>,\ ;19 |
<13,10,'*á'>,\ ;20 |
'¥®¦¨¤ ë© ª®¥æ ¡«®ª®¢ IDAT',\ ;21 |
'¥ä¨«ìâà æ¨ï:',\ ;22 |
'¨«ìâàë: None ',\ ;23 |
' Sub ',\ ;24 |
' Up ',\ ;25 |
' Avg ',\ ;26 |
' Paeth ',\ ;27 |
' 訡®ª: ',\ ;28 |
<'¥à¥ááâà®çë© PNG',13,10>,\ ;29 |
<'«®ª ¡¥§ ᦠâ¨ï',13,10>,\ ;30 |
<'¨¯ 梥⠥ ¯®¤¤¥à¦¨¢ ¥âáï',13,10>,\ ;31 |
<'¢¥¤¨â¥ ¯ à®«ì ¤«ï § è¨ä஢ ®£® ä ©« :',13,10>,\ ;32 |
<'®¨áª ä ©« ...',13,10>,\ ;33 |
'¥ ¬®¤ã«ì SFX',\ ;34 |
' ¥¢¥à ! ',\ ;35 |
' OK: ',\ ;36 |
<' ¯¨áì OUT.TXT',13,10>,\ ;37 |
' ',\ ;38 |
<'®¤£®â®¢ª ¨§®¡à ¦¥¨ï...',13,10>,\ ;39 |
<'ª ¦¨â¥ "R" ¤«ï ®¡à ¡®âª¨ áëàëå ¤ ëå. ⬥ .',13,10>,\ ;40 |
' ',\ ; |
' ',\ ; |
' ',\ ; |
' ',\ ; |
' ',\ ; |
' ',\ ; |
' ',\ ; |
' ',\ ; |
' ',\ ; |
' <- ¥¨§¢¥áâë© ¬¥â®¤ ᦠâ¨ï',\ ;50 |
' <- § è¨ä஢ ',\ ;51 |
<'¥ ZIP à娢',13,10> ; 52 |
else |
str_table \ |
<'*** @RCHER - Deflate Unpacker ***',13,10>,\ ;0 |
<'*** Copyright Wiland Inc., 2005 ***',13,10>,\ ;1 |
'Files in archive: ',\ ;2 |
<'End of Directory reached',13,10>,\ ;3 |
'No file has this number',\ ;4 |
<'FindByNumber succeded',13,10>,\ ;5 |
<'Invalid Huffman block ID',13,10>,\ ;6 |
<'Error while getting Huffman codes!',13,10>,\ ;7 |
<13,10,'Rebuilding CRC32 table',13,10>,\ ;8 |
'.',\ ;9 |
'Adler32',\ ;10 |
'CRC32',\ ;11 |
<'Job finished.',13,10>,\ ;12 |
<'File of zero length, unpacking aborted.',13,10>,\ ;13 |
<'Source file has strange length, may be missing? Abort.',13,10>,\ ;14 |
<'Not a GZIP archive',13,10>,\ ;15 |
<'Destination file is too large for now',13,10>,\ ;16 |
<"Can't unpack content.",13,10>,\ ; 17 |
<'Not a PNG image',13,10>,\ ; 18 |
<13,10,'*d'>,\ ;19 |
<13,10,'*s'>,\ ;20 |
'Unexpected end of IDAT chunks',\ ;21 |
'Unfiltering:',\ ;22 |
'Filters: None ',\ ;23 |
' Sub ',\ ;24 |
' Up ',\ ;25 |
' Avg ',\ ;26 |
' Paeth ',\ ;27 |
' Invalid ',\ ;28 |
<'Interlaced PNG',13,10>,\ ;29 |
<'Stored block',13,10>,\ ;30 |
<'Color type not supported',13,10>,\ ;31 |
<'Enter password for encrypted file:',13,10>,\ ;32 |
<'Searching for file...',13,10>,\ ;33 |
'Not a SFX module',\ ;34 |
' error! ',\ ;35 |
' OK: ',\ ;36 |
<'Creating OUT.TXT',13,10>,\ ;37 |
' ',\ ;38 |
<'Preparing bitmap...',13,10>,\ ;39 |
<'Specify "R" to force raw data. Abort.',13,10>,\ ;40 |
' ',\ ; |
' ',\ ; |
' ',\ ; |
' ',\ ; |
' ',\ ; |
' ',\ ; |
' ',\ ; |
' ',\ ; |
' ',\ ; |
' <- unknown compression method',\ ;50 |
' <- encrypted',\ ;51 |
<'Not a ZIP archive',13,10> ; 52 |
end if |
macro opendialog redproc,openoff,erroff,path |
{ |
local new_d, get_loops, dlg_pid_get, DLGPID, num_of_proc |
local run_fileinfo, param |
local getmesloop, loox, mred, mkey, mbutton, mgetmes |
local dlg_is_work, ready |
; |
; STEP 1 Run SYSXTREE with parametrs MYPID 4 bytes in dec, |
; 1 byte space, 1 byte type of dialog (O - Open ,S - Save) |
; |
cld |
;; mov esi,path |
mov edi,path |
xor eax,eax |
mov ecx,200 |
rep stosb |
;mov [get_loops],0 |
mov [dlg_pid_get],0 |
; Get my PID in dec format 4 bytes |
mcall 9,os_work,-1 |
; convert eax bin to param dec |
mov eax,dword [os_work+30] ;offset of myPID |
mov edi,param+4-1 ;offset to 4 bytes |
mov ecx,4 |
mov ebx,10 |
cld |
new_d: |
xor edx,edx |
div ebx |
add dl,'0' |
mov [edi],dl |
dec edi |
loop new_d |
; write 1 byte space to param |
mov [param+4],byte 32 ;Space for next parametr |
; and 1 byte type of dialog to param |
mov [param+5],byte 'O' ;Get Open dialog (Use 'S' for Save dialog) |
; |
; STEP2 prepare IPC area for get messages |
; |
; prepare IPC area |
mov [path],dword 0 |
mov [path+4],dword 8 |
; define IPC memory |
mov eax,60 |
mov ebx,1 ; define IPC |
mov ecx,path ; offset of area |
mov edx,150 ; size 150 bytes |
int 0x40 |
mcall 40,1000111b |
; |
; STEP 3 run SYSTEM XTREE with parameters |
; |
mcall 58,run_fileinfo |
call redproc |
mov [get_loops],0 |
getmesloop: |
mov eax,23 |
mov ebx,50 ;0.5 sec |
int 0x40 |
cmp eax,1 |
je mred |
cmp eax,2 |
je mkey |
cmp eax,3 |
je mbutton |
cmp eax,7 |
je mgetmes |
; Get number of procces |
mcall 9,os_work,-1 |
mov ebp,eax |
loox: |
mcall 9,os_work,ebp |
mov eax,[DLGPID] |
cmp dword[os_work+30],eax ;IF Dialog find |
je dlg_is_work ;jmp to dlg_is_work |
dec ebp |
jnz loox |
jmp erroff |
dlg_is_work: |
cmp word[os_work+50],word 9 ;If slot state 9 - dialog is terminated |
je erroff ;TESTODP2 terminated too |
cmp [dlg_pid_get],dword 1 |
je getmesloop |
inc [get_loops] |
cmp [get_loops],4 ;2 sec if DLG_PID not get, TESTOP2 terminated |
jae erroff |
jmp getmesloop |
mred: |
call redproc |
jmp getmesloop |
mkey: |
mcall 2 ; read (eax=2) |
jmp getmesloop |
mbutton: |
mov eax,17 ; get id |
int 0x40 |
cmp ah,1 ; button id=1 ? |
jne getmesloop |
mov eax,-1 ; close this program |
int 0x40 |
mgetmes: |
; If dlg_pid_get then second message get jmp to still |
cmp [dlg_pid_get],dword 1 |
je ready |
; First message is number of PID SYSXTREE dialog |
; convert PID dec to PID bin |
movzx eax,byte [path+16] |
sub eax,48 |
imul eax,10 |
movzx ebx,byte [path+16+1] |
add eax,ebx |
sub eax,48 |
imul eax,10 |
movzx ebx,byte [path+16+2] |
add eax,ebx |
sub eax,48 |
imul eax,10 |
movzx ebx,byte [path+16+3] |
add eax,ebx |
sub eax,48 |
mov [DLGPID],eax |
; Claear and prepare IPC area for next message |
mov [path],dword 0 |
mov [path+4],dword 8 |
mov [path+8],dword 0 |
mov [path+12],dword 0 |
mov [path+16],dword 0 |
; Set dlg_pid_get for get next message |
mov [dlg_pid_get],dword 1 |
call redproc ;show DLG_PID |
jmp getmesloop |
ready: |
; |
; The second message get |
; Second message is 100 bytes path to SAVE/OPEN file |
; shl path string on 16 bytes |
; |
cld |
mov esi,path+16 |
mov edi,path |
mov ecx,200 |
rep movsb |
mov [edi],byte 0 |
jmp openoff |
; DATA AREA |
get_loops dd 0 |
dlg_pid_get dd 0 |
DLGPID dd 0 |
param: |
dd 0 ; My dec PID |
dd 0,0 ; Type of dialog |
run_fileinfo: |
dd 16 |
dd 0 |
dd param |
dd 0 |
dd os_work ; 0x10000 |
;run_filepath |
db '/RD/1/SYSXTREE',0 |
} |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |
/programs/other/archer/trunk/build_en.bat |
---|
0,0 → 1,4 |
@erase lang.inc |
@echo lang fix en >lang.inc |
@fasm @rcher.asm @rcher |
@pause |
/programs/other/archer/trunk/build_ru.bat |
---|
0,0 → 1,4 |
@erase lang.inc |
@echo lang fix ru >lang.inc |
@fasm @rcher.asm @rcher |
@pause |
/programs/other/archer/trunk/data.inc |
---|
0,0 → 1,158 |
; @RCHER data area |
; Written in pure assembler by Ivushkin Andrey aka Willow |
if SYS eq win |
dumpfile: |
db 'D:\Ivushkin\projects\zip\output.dmp',0 |
dumpf_len=$-dumpfile |
end if |
outfile: |
if SYS eq win |
db 'D:\Ivushkin\projects\zip\output.raw',0 |
end if |
dd 1 |
dd 0 |
.size dd 0 |
.out dd output |
dd os_work |
if ~SYS eq win |
dumpfile: |
db DUMPFILE,0 |
dumpf_len=$-dumpfile |
end if |
Finfo: |
dd 0 |
.block dd 0 |
.count dd BUFSIZE*2 |
.ptr dd BUFPTR |
dd os_work |
filename: |
if SYS eq win |
db 'png\absolut0.png',0 |
;db 'fasm-1.54.tgz',0 |
;include 'testsu~1.inc' |
; db 'pngsuite\pngsuite.tar.gz',0 ; OK |
; db 'pngsuite\basn4a08.png',0 ; OK |
; db 'goldhill.png',0 ; beeping |
; db 'arl_logo.png',0 ; wrong out |
; db 'tech.png',0 ; wrong out |
; db 'png\lena0000.png',0 |
; db 'arcs\' |
; db 'NTOSKRNL.gz' |
; db 'msg_enc.zip' |
;db 'msgplain.zip' |
; db 'c_866.gz' |
; db 'zalman_2.png' ;OK |
; db 'arcs\headerbar.png',0 ;OK |
; db 'fonts1.png' ;OK |
; db 'fonts.png' ; |
; db 'skin.png' ;OK |
; db 'JavaPowered8.png'; OK |
; db 'opr008S8.png' |
; db 'goldhill.png' |
; db 'k3b.png',0 |
; db 'image0051.png' |
; db 'window-elements.png',0 |
; db 'WWW.zip',0 |
; db 'png.zip',0 |
; db 'zlib09.zip',0 |
else |
if ~ FNAME eq |
db FNAME |
end if |
; db '/hd/1/zip/png.zip',0 |
; db '/hd/1/zip/files/opossum.png' |
; db '/rd/1/www.zip',0 |
; db '/hd/1/zip/test2.zip',0 |
end if |
db 0 |
rb 256-($-filename) |
I_END: |
if SYS eq win |
cr_lf db 0xa,0xd |
hnd dd ? |
cons dd ? |
cons_in dd ? |
cparam1 dd ? |
cparam2 dd ? |
end if |
DKeys rd 3 |
Dheader rb 12 |
Dpassword rb PASSW_LEN |
png_bpp dd ? |
sline_len dd ? |
IDATcount dd ? |
IDATsize dd ? |
PNG_info: |
.Width dd ? |
.Height dd ? |
.Bit_depth db ? |
.Color_type db ? |
.Compression_method db ? |
.Filter_method db ? |
.Interlace_method db ? |
.Palette rb 3*256 |
gpbf dw ? |
file_count dd ? |
filters rd 6 |
arc_base dd ? |
outp dd ? |
unp_size dd ? |
CRC_check dd ? |
CRC32 dd ? |
CRC32table rd 256 |
Adler32 dd ? |
child dd ? |
clientPID dd ? |
filesize dd ? |
bits db ? |
cur_byte dd ? |
lastblk db ? |
Flags dd ? |
tblCount dw ? |
tblLen dw ? |
hclen db ? |
max_len dw ? |
bl_count rb BITS |
next_code rw BITS |
tmp_clit: |
rw 20 |
calph: |
rw 20 |
sorted_clit rw 20 |
seql_c db ? |
seql rb BITS |
seqd_c db ? |
seqd rb BITS |
hlit dw ? |
Literal rw 286 |
Lit_c rw 286 |
hdist db ? |
Distance rw 32 |
Dist_c rw 32 |
area: |
rb INBUF |
os_work rb 4*1024 |
output: |
rb OUTBUF |
png_image: |
if SYS eq win |
rb OUTBUF |
end if |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |
/programs/other/archer/trunk/debug.inc |
---|
0,0 → 1,131 |
macro debug_print str |
{ |
local ..string, ..label |
jmp ..label |
..string db str,0 |
..label: |
pushf |
pushad |
mov edx,..string |
call debug_outstr |
popad |
popf |
} |
dps fix debug_print |
macro debug_print_dec arg |
{ |
pushf |
pushad |
if ~arg eq eax |
mov eax,arg |
end if |
call debug_outdec |
popad |
popf |
} |
dpd fix debug_print_dec |
;--------------------------------- |
debug_outdec: ;(eax - num, edi-str) |
push 10 ;2 |
pop ecx ;1 |
push -'0' ;2 |
.l0: |
xor edx,edx ;2 |
div ecx ;2 |
push edx ;1 |
test eax,eax ;2 |
jnz .l0 ;2 |
.l1: |
pop eax ;1 |
add al,'0' ;2 |
call debug_outchar ; stosb |
jnz .l1 ;2 |
ret ;1 |
;--------------------------------- |
debug_outchar: ; al - char |
pushf |
pushad |
mov cl,al |
mov eax,63 |
mov ebx,1 |
int 0x40 |
popad |
popf |
ret |
debug_outstr: |
mov eax,63 |
mov ebx,1 |
@@: |
mov cl,[edx] |
test cl,cl |
jz @f |
int 40h |
inc edx |
jmp @b |
@@: |
ret |
macro newline |
{ |
dps <13,10> |
} |
macro print message |
{ |
dps message |
newline |
} |
macro pregs |
{ |
dps "EAX: " |
dpd eax |
dps " EBX: " |
dpd ebx |
newline |
dps "ECX: " |
dpd ecx |
dps " EDX: " |
dpd edx |
newline |
} |
macro debug_print_hex arg |
{ |
pushf |
pushad |
if ~arg eq eax |
mov eax, arg |
end if |
call debug_outhex |
popad |
popf |
} |
dph fix debug_print_hex |
debug_outhex: |
; eax - number |
mov edx, 8 |
.new_char: |
rol eax, 4 |
movzx ecx, al |
and cl, 0x0f |
mov cl, [__hexdigits + ecx] |
pushad |
mcall 63, 1 |
popad |
dec edx |
jnz .new_char |
ret |
__hexdigits: |
db '0123456789ABCDEF' |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |
/programs/other/archer/trunk/deflate.inc |
---|
0,0 → 1,615 |
; @RCHER main algorythm |
; Written in pure assembler by Ivushkin Andrey aka Willow |
macro get_a _type,_size,c1,c2,c3,c4,c5 |
{ |
get_#_type: |
local .no,.no0,.ex |
push edx |
and [Flags],not 1 |
if _type eq Len |
cmp eax,c4 |
jne .no |
mov eax,c5 |
jmp .ex |
.no: |
end if |
sub eax,c1 |
ja .no0 |
add eax,c2 |
jmp .ex |
.no0: |
add eax,c3 |
push eax |
mov ecx,eax |
shr ecx,_size |
xor eax,eax |
call read_bits |
pop edx |
and edx,1 shl _size-1 |
shl edx,cl |
movzx ecx,[tblH#_type+ecx*2] |
add edx,ecx |
add eax,edx |
.ex: |
or [Flags],1 |
pop edx |
ret |
} |
; ************************* |
Deflate: |
mov edi,[outp] |
.init: |
mov [bits],8 |
lodsb |
call setcurb |
.blkbegin: |
and [lastblk],0 |
and [Flags],not 1 |
rbits 0,1 |
test eax,eax |
je .nolast |
mov [lastblk],1 |
.nolast: |
rbits 0,2 |
cmp eax,10b |
je .DynHuff |
cmp eax,01b |
je .static |
test eax,eax |
jnz .errorID |
Msg 30 |
movzx ecx,[bits] |
call read_bits |
movzx ecx,word[esi-1] |
add esi,3 |
rep movsb |
jmp .check_last |
.errorID: |
Msg 6 |
ret |
; Static Huffman |
.static: |
if SHOW_METH eq 1 |
Msg 20 |
end if |
mov edi,[outp] |
or [Flags],1 |
.next: |
rbits 0,7 |
; stop |
cmp eax,0x17 |
ja .no7 |
add eax,256 |
cmp eax,256 |
jne .noend |
.check_last: |
mov [outp],edi |
cmp [lastblk],1 |
je .ex |
jmp .blkbegin |
.noend: |
call get_Len |
mov ebx,eax |
rbits 0,5 |
call get_Dist |
neg eax |
push esi |
lea esi,[edi+eax] |
mov ecx,ebx |
rep movsb |
pop esi |
jmp .next |
.no7: |
rbits eax,1 |
cmp eax,0xc8 |
jb .no9 |
rbits eax,1 |
sub eax,0xd0 |
jmp .no81 |
.no9: |
cmp eax,0xc0 |
jb .no81 |
add eax,0x58 |
jmp .noend |
.no81: |
sub eax,0x30 |
stosb |
jmp .next |
.ex: |
ret |
; ************* dynamic Huffman ************ |
.DynHuff: |
; dps '##' |
if SHOW_METH eq 1 |
Msg 19 |
end if |
pusha |
xor eax,eax |
mov ecx,(area-bl_count) / 4 |
mov edi,bl_count |
rep stosd |
popa |
; max_len=0 |
and [max_len],0 |
rbits 0,5 |
; hlit-257 |
add eax,257 |
mov [hlit],ax |
rbits 0,5 |
; hdist-1 |
inc eax |
mov [hdist],al |
rbits 0,4 |
; hclen-4 |
add eax,4 |
mov [hclen],al |
mov ecx,eax |
push edi |
mov edi,tmp_clit |
; read code lengths for code lengths |
.alphloop: |
push ecx |
rbits 0,3 |
stosb |
pop ecx |
loop .alphloop |
; sort code lengths for code lengths |
push esi |
movzx ecx,[hclen] |
xor eax,eax |
mov edi,tmp_clit |
mov esi,tblSort |
.sortloop: |
lodsb |
movzx bx,byte[edi] |
mov [sorted_clit+eax*2],bx |
inc edi |
loop .sortloop |
pop esi edi |
.generate: |
mov ecx,19 |
mov ebx,calph |
mov edx,seql |
mov eax,sorted_clit |
call Huffc |
and [tblCount],0 |
or [Flags],1 |
mov edi,Lit_c |
mov ebp,sorted_clit |
.again: |
cmp edi,output+OUTBUF |
jb ._ok |
Msg 16 |
jmp .ex |
._ok: |
mov edx,seql |
mov ebx,calph |
call get_code |
call ExpLen |
cmp [hlit],ax |
ja .again |
if SHOW_CHARS eq 1 |
mov edi,Lit_c |
call Show_codes |
end if |
mov edi,Dist_c |
and [tblCount],0 |
.again2: |
mov ebx,calph |
call get_code |
call ExpLen |
cmp [hdist],al |
ja .again2 |
movzx ecx,[hlit] |
mov ebx,Literal |
mov edx,seql |
mov eax,Lit_c |
call Huffc |
movzx ecx,[hdist] |
mov ebx,Distance |
mov edx,seqd |
mov eax,Dist_c |
call Huffc |
push [hlit] |
pop [tblLen] |
mov ebp,Lit_c |
mov edx,seql |
mov ebx,Literal |
mov edi,[outp] |
and [tblCount],0 |
.again3: ; <------------ |
call get_code |
cmp eax,256 |
je .check_last |
ja .dist |
stosb |
jmp .again3 |
.dist: |
call get_Len |
push eax ebx edx ebp |
mov ecx,32 |
mov ebp,Dist_c |
mov edx,seqd |
mov ebx,Distance |
mov [tblLen],32 |
call get_code |
call get_Dist |
push [hlit] |
pop [tblLen] |
neg eax |
pop ebp edx ebx ecx |
push esi |
lea esi,[edi+eax] |
rep movsb |
pop esi |
jmp .again3 |
; ****************************************** |
Huffc: |
; EBX - dest array, ECX - length, EDX - br_seq dest, EAX - source array |
push esi edi eax ecx |
mov edi,bl_count |
xor eax,eax |
mov ecx,BITS |
rep stosw |
pop ecx |
mov esi,[esp] |
mov [tblLen],cx |
mov [max_len],ax |
; Count the number of codes for each code length |
.cnt_loop: |
lodsw |
cmp [max_len],ax |
jae .skip |
mov [max_len],ax |
.skip: |
inc byte[bl_count+eax] |
loop .cnt_loop |
movzx ecx,[max_len] |
xor eax,eax |
and [bl_count],al |
xor esi,esi ; edx - bits |
mov edi,next_code+2 |
push ebx |
; Find the numerical value of the smallest code for each code length |
.nc_loop: |
movzx bx,byte[bl_count+esi] |
add ax,bx |
shl ax,1 |
stosw |
inc esi |
loop .nc_loop |
pop ebx |
; clear table |
movzx ecx,[tblLen] |
xor eax,eax |
dec eax |
mov edi,ebx |
rep stosw |
inc eax |
movzx ecx,[tblLen] |
mov esi,[esp] |
mov edi,ebx |
; Assign numerical values to all codes |
.loop3: |
lodsw |
test eax,eax |
jz .lp |
push [next_code+eax*2] |
pop word[edi] |
inc [next_code+eax*2] |
.lp: |
add edi,2 |
loop .loop3 |
; Clear all codes |
xor eax,eax |
mov edi,edx |
movzx ecx,[max_len] |
mov [edi-1],al |
; Prepare read bit sequences |
.rebiloop: |
inc eax |
cmp [bl_count+eax],0 |
jz .sk |
stosb |
inc byte[edx-1] |
.sk: |
loop .rebiloop |
movzx ecx,byte[edx-1] |
dec ecx |
jecxz .noreb2 |
.reb2loop: |
mov al,[edx+ecx-1] |
sub [edx+ecx],al |
loop .reb2loop |
.noreb2: |
pop eax edi esi |
ret |
; ****************************************** |
; get Codes of variable sizes |
get_code: |
; EDX - br_seq, EBX - source table, EBP - codelength table |
push edx edi |
xor eax,eax |
movzx ecx,byte[edx-1] |
mov [codel],ax |
.rb3: |
push ecx |
movzx ecx,byte[edx] |
add [codel],cx |
call read_bits |
movzx ecx,[tblLen] |
inc ecx |
mov edi,ebx |
.scas: |
repne scasw |
jecxz .notfound |
push edi ecx |
sub edi,ebx |
sub edi,2 |
mov cx,[codel] |
cmp cx,[ds:ebp+edi] |
jne .notfound2 |
mov eax,edi |
shr eax,1 |
add esp,12 |
.pp: |
pop edi edx |
ret |
.notfound2: |
pop ecx |
pop edi |
jmp .scas |
.notfound: |
pop ecx |
inc edx |
loop .rb3 |
Msg 7 |
jmp .pp |
codel dw ? |
; ****************************************** |
ExpLen: |
cmp eax,16 |
jae .noliteral |
inc [tblCount] |
stosw |
jmp .nomatch |
.noliteral: |
and [Flags],not 1 |
mov ebx,3 |
cmp eax,17 |
jae .code1718 |
mov ecx,2 |
xor eax,eax |
call read_bits |
lea ecx,[eax+ebx] |
mov ax,[edi-2] |
.cc: |
add [tblCount],cx |
rep stosw |
or [Flags],1 |
jmp .nomatch |
.code1718: |
jne .code18 |
mov ecx,3 |
.cc2: |
xor eax,eax |
call read_bits |
lea ecx,[eax+ebx] |
xor eax,eax |
jmp .cc |
.code18: |
mov ebx,11 |
mov ecx,7 |
jmp .cc2 |
.nomatch: |
mov ax,[tblCount] |
ret |
get_a Len,2,256+8,10,3,285,258 |
get_a Dist,1,3,4,1 |
; ****************************************** |
read_bits: ; eax-dest; ecx-count |
push edx ecx |
.shift: |
if RBLOCK eq 4 |
ror [cur_byte],1 |
else |
ror byte[cur_byte],1 |
end if |
pushf |
test [Flags],1 |
je .noh1 |
popf |
rcl eax,1 |
jmp .dec |
.noh1: |
popf |
rcr eax,1 |
.dec: |
dec [bits] |
jnz .loop1 |
.push: |
push eax |
mov eax,[esi] |
call setcurb |
pop eax |
if RBLOCK eq 1 |
inc esi |
inc [IDATcount] |
else |
inc esi |
inc [IDATcount] |
end if |
cmp esi,area+INBUF-BSIZE |
jbe .ok |
pusha |
if SHOW_RBLOCK eq 1 |
Msg 9 |
end if |
mov eax,0 |
mov ebx,1 |
call FileSeek |
mov [esp+4],esi |
popa |
.ok: |
test [Flags],PNG_MODE |
jz .idatok |
mov edx,[IDATcount] |
cmp edx,[IDATsize] |
jbe .idatok |
pusha |
lodsd |
call PngParse.nxt_sec |
mov [IDATcount],1 |
mov [esp+4],esi |
mov [esp+20],edx |
popa |
cmp edx,21 |
jne .idatok |
mov eax,256 |
pop ecx |
jmp .exx |
.idatok: |
mov [bits],8 |
.loop1: |
loop .shift2 |
jmp .popc |
.shift2: |
jmp .shift |
.popc: |
pop ecx |
test [Flags],1 |
jne .exx |
.noh2: |
rol eax,cl |
.exx: |
pop edx |
ret |
if SHOW_CHARS eq 1 |
Show_codes: |
pusha |
movzx ecx,[tblLen] |
mov ecx,256 |
xor eax,eax |
.lp2: |
mov [braces+1],al |
push eax ecx |
invoke StrFormat,eax,strbuf,20 |
invoke WriteConsole,[cons],strbuf,16,param1,NULL |
invoke WriteConsole,[cons],braces,6,param1,NULL |
mov eax,[esp+4] |
movzx eax,word[edi+eax*2] |
test eax,eax |
jz .skip |
invoke WriteConsole,[cons],exist,6,param1,NULL |
.skip: |
invoke WriteConsole,[cons],braces+6,2,param1,NULL |
pop ecx eax |
inc eax |
loop .lp |
jmp .ex |
.lp: |
jmp .lp2 |
.ex: |
popa |
ret |
cons dd ? |
param1 dd ? |
braces db '( ) = ',0xa, 0xd |
strbuf rb 20 |
exist db 'exists' |
end if |
makeCRC: |
pusha |
Msg 8 |
mov edi,CRC32table |
add edi,255*4 |
std |
mov ecx,255 |
mov ebx,0xedb88320 |
.m1: |
mov eax,ecx |
push ecx |
mov ecx,8 |
.m2: |
shr eax,1 |
jnc .m3 |
xor eax,ebx |
.m3: |
loop .m2 |
pop ecx |
stosd |
loop .m1 |
popa |
cld |
ret |
UCRC: |
; in: esi - data to calculate CRC |
; ecx - its length |
; [CRC32] - previous CRC32 |
; out: [CRC32]- partial CRC32 (no pre- & post-conditioning!) |
pusha |
cmp dword[CRC32table+4],0x77073096 |
je .tbl_rdy |
call makeCRC |
.tbl_rdy: |
mov eax,[CRC32] |
not eax |
.m1: |
movzx ebx,al |
shr eax,8 |
xor bl,[esi] |
xor eax,[CRC32table+ebx*4] |
inc esi |
loop .m1 |
not eax |
mov [CRC32],eax |
popa |
ret |
UAdler: |
; in: esi - data to calculate CRC |
; ecx - its length |
; [Adler32] - previous Adler32 |
; out: [Adler32]- partial Adler32 |
pusha |
mov ebp,65521 |
movzx ebx,word[Adler32] ; s1-ebx |
movzx edi,word[Adler32+2] ; s2-edi |
.m1: |
movzx eax,byte[esi] |
add eax,ebx |
xor edx,edx |
div ebp |
mov ebx,edx |
lea eax,[edi+ebx] |
xor edx,edx |
div ebp |
mov edi,edx |
inc esi |
loop .m1 |
shl edi,16 |
add edi,ebx |
mov [Adler32],edi |
popa |
ret |
tblSort db 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 |
tblHLen dw 7,11,19,35,67,131 |
tblHDist dw 3,5,9,17,33,65,129,257,513,1025,2049,4097,8193,16385 |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |
/programs/other/archer/trunk/macros.inc |
---|
0,0 → 1,266 |
; new application structure |
macro meos_app_start |
{ |
use32 |
org 0x0 |
db 'MENUET01' |
dd 0x01 |
dd __start |
dd __end |
dd __memory |
dd __stack |
if used __params & ~defined __params |
dd __params |
else |
dd 0x0 |
end if |
dd 0x0 |
} |
MEOS_APP_START fix meos_app_start |
macro code |
{ |
__start: |
} |
CODE fix code |
macro data |
{ |
__data: |
} |
DATA fix data |
macro udata |
{ |
if used __params & ~defined __params |
__params: |
db 0 |
__end: |
rb 255 |
else |
__end: |
end if |
__udata: |
} |
UDATA fix udata |
macro meos_app_end |
{ |
align 32 |
rb 2048 |
__stack: |
__memory: |
} |
MEOS_APP_END fix meos_app_end |
; macro for defining multiline text data |
struc mstr [sstring] |
{ |
forward |
local ssize |
virtual at 0 |
db sstring |
ssize = $ |
end virtual |
dd ssize |
db sstring |
common |
dd -1 |
} |
; strings |
macro sz name,[data] { ; from MFAR [mike.dld] |
common |
if used name |
label name |
end if |
forward |
if used name |
db data |
end if |
common |
if used name |
.size = $-name |
end if |
} |
macro lsz name,[lng,data] { ; from MFAR [mike.dld] |
common |
if used name |
label name |
end if |
forward |
if (used name)&(lang eq lng) |
db data |
end if |
common |
if used name |
.size = $-name |
end if |
} |
; easy system call macro |
macro mpack dest, hsrc, lsrc |
{ |
if (hsrc eqtype 0) & (lsrc eqtype 0) |
mov dest, (hsrc) shl 16 + lsrc |
else |
if (hsrc eqtype 0) & (~lsrc eqtype 0) |
mov dest, (hsrc) shl 16 |
add dest, lsrc |
else |
mov dest, hsrc |
shl dest, 16 |
add dest, lsrc |
end if |
end if |
} |
macro __mov reg,a,b { ; mike.dld |
if (~a eq)&(~b eq) |
mpack reg,a,b |
else if (~a eq)&(b eq) |
mov reg,a |
end if |
} |
macro mcall a,b,c,d,e,f { ; mike.dld |
__mov eax,a |
__mov ebx,b |
__mov ecx,c |
__mov edx,d |
__mov esi,e |
__mov edi,f |
int 0x40 |
} |
; optimize the code for size |
__regs fix <eax,ebx,ecx,edx,esi,edi,ebp,esp> |
macro add arg1,arg2 |
{ |
if (arg2 eqtype 0) |
if (arg2) = 1 |
inc arg1 |
else |
add arg1,arg2 |
end if |
else |
add arg1,arg2 |
end if |
} |
macro sub arg1,arg2 |
{ |
if (arg2 eqtype 0) |
if (arg2) = 1 |
dec arg1 |
else |
sub arg1,arg2 |
end if |
else |
sub arg1,arg2 |
end if |
} |
macro mov arg1,arg2 |
{ |
if (arg1 in __regs) & (arg2 eqtype 0) |
if (arg2) = 0 |
xor arg1,arg1 |
else if (arg2) = 1 |
xor arg1,arg1 |
inc arg1 |
else if (arg2) = -1 |
or arg1,-1 |
else if (arg2) > -128 & (arg2) < 128 |
push arg2 |
pop arg1 |
else |
mov arg1,arg2 |
end if |
else |
mov arg1,arg2 |
end if |
} |
macro struct name |
{ |
virtual at 0 |
name name |
sizeof.#name = $ - name |
end virtual |
} |
; structures used in MeOS |
struc process_information |
{ |
.cpu_usage dd ? ; +0 |
.window_stack_position dw ? ; +4 |
.window_stack_value dw ? ; +6 |
.not_used1 dw ? ; +8 |
.process_name rb 12 ; +10 |
.memory_start dd ? ; +22 |
.used_memory dd ? ; +26 |
.PID dd ? ; +30 |
.x_start dd ? ; +34 |
.y_start dd ? ; +38 |
.x_size dd ? ; +42 |
.y_size dd ? ; +46 |
.slot_state dw ? ; +50 |
rb (1024-52) |
} |
struct process_information |
struc system_colors |
{ |
.frame dd ? |
.grab dd ? |
.grab_button dd ? |
.grab_button_text dd ? |
.grab_text dd ? |
.work dd ? |
.work_button dd ? |
.work_button_text dd ? |
.work_text dd ? |
.work_graph dd ? |
} |
struct system_colors |
; constants |
; events |
EV_IDLE = 0 |
EV_TIMER = 0 |
EV_REDRAW = 1 |
EV_KEY = 2 |
EV_BUTTON = 3 |
EV_EXIT = 4 |
EV_BACKGROUND = 5 |
EV_MOUSE = 6 |
EV_IPC = 7 |
EV_STACK = 8 |
; event mask bits for function 40 |
EVM_REDRAW = 1b |
EVM_KEY = 10b |
EVM_BUTTON = 100b |
EVM_EXIT = 1000b |
EVM_BACKGROUND = 10000b |
EVM_MOUSE = 100000b |
EVM_IPC = 1000000b |
EVM_STACK = 10000000b |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |
/programs/other/archer/trunk/parser.inc |
---|
0,0 → 1,896 |
; @RCHER parser and filter routines |
; Written in pure assembler by Ivushkin Andrey aka Willow |
fhs_local equ 0x04034b50 |
fhs_central equ 0x02014b50 |
fhs_end equ 0x06054b50 |
fhs_enc equ 0x08074b50 |
SkipASCIIZ: |
xor eax,eax |
mov ecx,255 |
mov edi,esi |
repne scasb |
mov esi,edi |
ret |
PrintFilename: |
pusha |
mov esi,edx |
mov edi,os_work |
mov edx,edi |
rep movsb |
mov dword[edi],0x00a0d |
call DebugPrint |
; mcall 10 |
; mcall 2 |
popa |
ret |
; Parse routines: |
; out: edx= 0 if all ok, 1 - central dir, 2-EOD |
; 50 - encrypted |
; 51 - not deflated |
; 52 - invalid format |
; 53 - dir skipped |
; 1 - encrypted |
; **************************************************** |
ZipParse: |
call ResetFile |
.nxt: |
call ZipCrawl |
cmp edx,3 |
je .ex |
cmp edx,1 |
je .skipinc |
if IGNORE_DIRS eq 1 |
cmp edx,53 |
jne .skipinc |
end if |
inc [file_count] |
.skipinc: |
cmp edx,52 |
je .er1 |
cmp edx,50 |
jne .seek |
.er1: |
Msg edx |
ret |
.seek: |
add eax,ecx |
mov ebx,1 |
call FileSeek |
jmp .nxt |
.ex: |
Msg 2 |
mov eax,[file_count] |
if ~ SYS eq win |
dpd eax |
else |
pusha |
call int2str |
mov edx,os_work |
call DebugPrint |
popa |
end if |
Newline |
ret |
ZipFindN: |
; ecx - file # |
Msg 33 |
cmp ecx,[file_count] |
jae .err |
push ecx |
call ResetFile |
.nxt: |
call ZipCrawl |
cmp edx,51 |
je .ok2 |
.noenc: |
test edx,edx |
jnz .err |
.ok2: |
add eax,ecx |
cmp dword[esp],0 |
jz .ok |
dec dword[esp] |
mov ebx,1 |
call FileSeek |
jmp .nxt |
.err: |
mov edx,4 |
jmp .ex |
.ok: |
pop ecx |
sub eax,[esi+18] |
add esi,eax |
mov edx,5 |
.ex: |
push edx |
Msg edx |
pop edx |
ret |
ZipCrawl: |
mov edx,52 |
cmp dword[esi],fhs_central |
jne .noc |
mov eax,46 |
movzx ecx,word[esi+28] |
add eax,ecx |
movzx ecx,word[esi+30] |
add eax,ecx |
movzx ecx,word[esi+32] |
mov edx,1 |
ret |
.noc: |
cmp dword[esi],fhs_end |
jne .noe |
.edx3: |
Msg 3 |
mov edx,3 |
ret |
.noe: |
cmp dword[esi],fhs_local |
je .loc |
cmp dword[esi],fhs_enc |
jne .err |
mov eax,16 |
xor ecx,ecx |
mov edx,1 |
ret |
.loc: |
push word[esi+6] |
pop [gpbf] |
push dword[esi+14] |
pop [CRC_check] |
push dword[esi+22] |
pop [unp_size] |
movzx ecx,word[esi+26] |
mov eax,30 |
lea edx,[esi+eax] |
add eax,ecx |
if IGNORE_DIRS eq 1 |
cmp byte[edx+ecx-1],'/' |
je .skipdp |
end if |
call PrintFilename |
.skipdp: |
movzx ecx,word[esi+28] |
add eax,[esi+18] |
test [gpbf],1 |
jz .no_enc |
or [Flags],DECRYPT_MODE ; encrypted |
mov edx,51 |
jmp .err |
.no_enc: |
test word[esi+8],7 |
rep_err z,50 |
.ok: |
xor edx,edx |
.err: |
ret |
; *********************************************** |
GzipParse: |
ID1ID2 equ 0x8b1f |
FTEXT equ 1b |
FHCRC equ 10b |
FEXTRA equ 100b |
FNAME equ 1000b |
FCOMMENT equ 10000b |
mov eax,7 |
mov ebx,2 |
call FileSeek |
push dword[esi] |
pop [CRC_check] |
push dword[esi+4] |
pop [unp_size] |
call ResetFile |
xor edx,edx |
cmp word[esi],ID1ID2 |
rep_err e, 52, 15 |
cmp byte[esi+2],8 |
rep_err e, 52, 50 |
mov bl,[esi+3] ; bl - FLG |
add esi,10 ; esi->extra |
test bl,FEXTRA |
jz .noextr |
movzx eax,word[esi] |
lea esi,[esi+eax+2] ; esi->FNAME |
.noextr: |
test bl,FNAME |
jz .nofname |
mov edx,esi |
call DebugPrint |
call SkipASCIIZ |
cmp dword[esi-5],'.tar' |
jne .nofname |
or [Flags],TAR_MODE |
.nofname: ; esi->FCOMMENT |
test bl,FCOMMENT |
jz .nocomm |
call SkipASCIIZ |
.nocomm: ; esi->HCRC |
test bl,FHCRC |
jz .noCRC16 |
add esi,2 |
.noCRC16: |
cmp [unp_size],OUTBUF |
jb .sizeok2 |
Msg 16 |
mov edx,15 |
ret |
.sizeok2: |
xor edx,edx |
.err: |
ret |
PngParse: |
ID1 equ 0x474e5089 |
ID2 equ 0x0a1a0a0d |
FDICT equ 100000b |
InitIDAT equ 2 |
mov [IDATcount],InitIDAT |
call ResetFile |
cmp dword[esi],ID1 |
rep_err e, 52, 18 |
cmp dword[esi+4],ID2 |
rep_err e, 52, 18 |
add esi,8 |
cmp dword[esi+4],'IHDR' |
rep_err e,52, 18 |
or [Flags],PNG_MODE |
memcpy_esi PNG_info,13,8 |
mov eax,[PNG_info.Width] |
bswap eax |
mov [PNG_info.Width],eax |
mov eax,[PNG_info.Height] |
bswap eax |
mov [PNG_info.Height],eax |
add esi,25 |
cmp byte[esi-5],0 |
rep_err e,52,29 |
.nxt_sec: |
lodsd |
bswap eax ; eax - section size |
push eax |
lodsd |
mov edi,Png_ch |
mov ecx,(E_ch-Png_ch) / 4 |
repne scasd |
pop eax |
mov ebx,[esi-4] |
mov edx,os_work |
mov [edx],ebx |
mov dword[edx+4],0x0a0d |
.dp: |
sub edi,Png_ch |
shr edi,2 ; edi- chunk # |
if SHOW_PNG_SEC eq 1 |
call DebugPrint |
end if |
cmp edi,1 |
jne .noend |
mov edx,21 |
jmp .err |
.noend: |
cmp edi,2 |
jne .noplte |
memcpy_esi PNG_info.Palette,eax |
jmp .noidat |
.noplte: |
cmp edi,3 |
jne .noidat |
mov [IDATsize],eax |
cmp [IDATcount],InitIDAT |
jne .ex |
mov [bits],8 |
if RBLOCK eq 4 |
lodsd |
else |
lodsb |
end if |
call setcurb |
rbits 0,16 |
test ah,FDICT |
jz .ex |
rbits 0,32 |
add [IDATcount],4 |
jmp .ex |
.noidat: |
add eax,4 |
mov ebx,1 |
call FileSeek |
jmp .nxt_sec |
.ex: |
xor edx,edx |
.err: |
ret |
Png_ch: |
dd 'IEND','PLTE','IDAT','????' |
E_ch: |
ZipDecrypt: |
push edi |
mov ecx,3 |
mov edi,Dheader |
rep movsd |
pop edi |
call QueryPwd |
jecxz .ex |
push esi |
mov [DKeys], 305419896 |
mov [DKeys+4],591751049 |
mov [DKeys+8],878082192 |
xor eax,eax |
mov esi,Dpassword |
.enc_init: |
lodsb |
call UKeys |
loop .enc_init |
mov ecx,12 |
mov esi,Dheader |
.dec_header: |
call decrypt_byte |
xor al,[esi] |
call UKeys |
mov [esi],al |
inc esi |
loop .dec_header |
mov eax,[CRC_check] |
pop esi |
.ex: |
ret |
QueryPwd: |
; out: ecx - passwd len |
if SYS eq win |
Msg 32 |
invoke ReadConsole,[cons_in],Dpassword,PASSW_LEN,cparam1,NULL |
test eax,eax |
jnz .inp_ok |
xor ecx,ecx |
jmp .ex |
.inp_ok: |
mov ecx,[cparam1] |
cmp ecx,PASSW_LEN |
je .ex |
sub ecx,2 |
else |
end if |
.ex: |
ret |
UKeys: |
; in: al - char |
pusha |
mov edi,134775813 |
mov ebx,DKeys |
mov esi,os_work |
mov byte[esi],al |
mov ecx,1 |
push dword[ebx] |
pop [CRC32] |
call UCRC |
push [CRC32] |
pop dword[ebx] |
mov eax,[ebx] |
and eax,0xff |
add eax,[ebx+4] |
mul edi |
inc eax |
mov [ebx+4],eax |
shr eax,24 |
mov byte[esi],al |
push dword[ebx+8] |
pop [CRC32] |
call UCRC |
push [CRC32] |
pop dword[ebx+8] |
popa |
ret |
decrypt_byte: |
; out: al |
push ebx edx |
movzx ebx,word[DKeys+8] |
or ebx,2 |
mov eax,ebx |
xor eax,1 |
mul ebx |
shr eax,8 |
pop edx ebx |
ret |
setcurb: |
; in: eax |
test [Flags],DECRYPT_MODE |
jz .noenc |
push eax |
call decrypt_byte |
xor al,byte[esp] |
add esp,4 |
call UKeys |
.noenc: |
mov [cur_byte],eax |
ret |
TarParse: |
call ResetFile |
.nxt: |
call TarCrawl |
; wait |
cmp edx,3 |
je ZipParse.ex |
if IGNORE_DIRS eq 1 |
cmp edx,53 |
jne .skipinc |
end if |
inc [file_count] |
.skipinc: |
add eax,ecx |
mov ebx,1 |
call FileSeek |
jmp .nxt |
TarFindN: |
; in: ecx - file number |
; ecx - file # |
Msg 33 |
cmp ecx,[file_count] |
jae .err |
push ecx |
call ResetFile |
.nxt: |
call TarCrawl |
if IGNORE_DIRS eq 1 |
cmp edx,53 |
je .seek |
end if |
test edx,edx |
jnz .err |
cmp dword[esp],0 |
jz .ok |
dec dword[esp] |
.seek: |
add eax,ecx |
mov ebx,1 |
call FileSeek |
jmp .nxt |
.err: |
mov edx,4 |
jmp .ex |
.ok: |
pop ecx |
add esi,eax |
mov edx,5 |
.ex: |
Msg edx |
ret |
TarCrawl: |
cmp byte[esi],0 |
jz ZipCrawl.edx3 |
push esi |
mov ecx,11 |
add esi,0x7c |
call Octal_str |
mov esi,[esp] |
mov [outfile.size],eax |
call SkipASCIIZ |
if IGNORE_DIRS eq 1 |
cmp byte[esi-2],'/' |
je .skipdp |
end if |
mov edx,[esp] |
lea ecx,[esi-1] |
sub ecx,edx |
call PrintFilename |
.skipdp: |
mov ecx,[outfile.size] |
jecxz .zerolen |
shr ecx,9 |
inc ecx |
shl ecx,9 |
.zerolen: |
mov eax,512 |
pop esi |
jmp ZipCrawl.ok |
Octal_str: |
; in: esi - ASCIIZ octal string |
; ecx - its length |
; out: eax - value |
push esi ebx ecx |
xor ebx,ebx |
xor eax,eax |
.jec: |
jecxz .zero |
cmp byte[esi+ecx-1],' ' |
jne .lp |
dec ecx |
jmp .jec |
.lp: |
lodsb |
shl ebx,3 |
cmp eax,' ' |
je .space |
lea ebx,[ebx+eax-'0'] |
.space: |
loop .lp |
mov eax,ebx |
.zero: |
pop ecx ebx esi |
ret |
TRAILING_BUF equ 2048 |
SfxParse: |
call ResetFile |
cmp word[esi],'MZ' |
rep_err e, 34 |
mov eax,TRAILING_BUF |
mov ecx,eax |
mov ebx,2 |
call FileSeek |
mov edi,esi |
mov al,'P' |
.lp: |
repne scasb |
cmp dword[edi-1],fhs_end |
je .end_found |
jecxz .err |
jmp .lp |
.end_found: |
dec edi |
mov esi,edi |
mov eax,[edi+12] |
neg eax |
mov ebx,1 |
call FileSeek |
push dword[esi+42] |
pop [arc_base] |
.err: |
ret |
; Created: May 31, 2005 |
FiltCall: |
dd PngFilter.nofilt,Filt_sub,Filt_up,Filt_av,Filt_paeth,PngFilter.nofilt |
PngFilter: |
; esi - filtered uncompressed image data |
; edi - destination |
mov cl,[PNG_info.Color_type] |
mov eax,1 |
cmp cl,3 |
je .palette |
test cl,2 |
jz .notriple |
add eax,2 |
.notriple: |
test cl,4 |
jz .calc_bpp |
inc eax |
.calc_bpp: |
mul [PNG_info.Bit_depth] |
.palette: |
mov ecx,eax ; in bits |
shr eax,3 ; in bytes |
test eax,eax |
jnz .noz |
inc eax |
.noz: |
mov [png_bpp],eax |
mov eax,[PNG_info.Width] |
mov ebp,eax |
imul ecx |
shr eax,3 |
test eax,eax |
jnz .noz2 |
inc eax |
.noz2: |
mov [sline_len],eax ; scanline length |
push edi |
and [Flags],not 1 |
mov ecx,[PNG_info.Height] |
.scanline: |
; Msg 9,1 |
push ecx |
lodsb |
movzx eax,al |
cmp eax,5 |
jb .f_ok |
mov eax,5 |
.f_ok: |
inc dword[filters+eax*4] |
jmp dword[FiltCall+eax*4] |
.nofilt: |
mov dl,[PNG_info.Color_type] |
cmp dl,3 |
jne .nopalette |
lodsb |
mov [cur_byte],eax |
mov [bits],8 |
mov ecx,ebp |
.pixel: |
push ecx |
movzx ecx,[PNG_info.Bit_depth] |
call rb_png |
push esi |
lea esi,[eax+eax*2] |
add esi,PNG_info.Palette |
call PngStore |
pop esi |
pop ecx |
loop .pixel |
cmp [bits],8 |
jne .lp |
dec esi |
.lp: |
pop ecx |
loop .sl |
jmp .sl2 |
.sl: |
;// |
MV equ 1 |
; mov eax,ecx |
; and eax,1 shl MOVE_SLINE_LEV-1 |
; jnz .scanline |
;stop |
if MV eq 0 |
push ecx |
mov ecx,edi |
sub ecx,esi |
sub [outp],esi |
mov edi,output |
add [outp],edi |
rep movsb |
mov esi,output |
pop ecx |
pop eax |
push [outp] |
end if |
;;// |
jmp .scanline |
.sl2: |
;// |
; call MoveScanline |
sub edi,[outp] |
;// |
; sub edi,[esp] |
pop eax |
ret |
.nopalette: |
test dl,2 |
jz .notriple1 |
.__: |
mov ecx,[PNG_info.Width] |
.RGBcp: |
call PngStore |
add esi,[png_bpp] |
loop .RGBcp |
jmp .lp |
.notriple1: |
test dl,dl |
jz .gray |
cmp dl,4 |
jne .__ |
; Msg 31 |
; ud2 |
.gray: |
; stop |
push ecx |
mov ecx,[PNG_info.Width] |
mov [bits],8 |
lodsb |
mov [cur_byte],eax |
.gray2: |
push ecx |
movzx ecx,[PNG_info.Bit_depth] |
push ecx |
call rb_png |
pop ecx |
cmp ecx,8 |
jbe .lo |
add esi,2 |
shr eax,8 |
jmp .stsb |
.lo: |
neg ecx |
add ecx,8 |
shl eax,cl |
.stsb: |
mov ecx,3 |
rep stosb |
pop ecx |
loop .gray2 |
dec esi |
pop ecx |
jmp .lp |
Filt_sub: |
; dps '-' |
mov ecx,[sline_len] |
sub ecx,[png_bpp] |
push esi edi |
mov edi,esi |
add edi,[png_bpp] |
.scan: ; esi - previous, edi - current |
lodsb |
add [edi],al |
inc edi |
loop .scan |
pop edi esi |
; dps '-' |
jmp PngFilter.nofilt |
Filt_up: |
cmp ecx,[PNG_info.Height] |
je PngFilter.nofilt |
push esi edi |
mov ecx,[sline_len] |
mov edi,esi |
sub esi,ecx |
dec esi |
jmp Filt_sub.scan |
Filt_av: |
pusha |
mov ecx,[sline_len] |
mov ebp,[PNG_info.Height] |
mov edx,[png_bpp] ; edx-raw |
neg edx |
mov ebx,ecx |
sub ebx,[png_bpp] |
mov edi,esi |
sub esi,ecx |
dec esi ; esi-prior |
.lpavg: |
xor eax,eax |
cmp [esp+24h],ebp |
je .1stl |
movzx eax,byte[esi] |
.1stl: |
cmp ecx,ebx |
ja .leftbad |
push ecx |
movzx ecx,byte[edi+edx] |
add eax,ecx |
pop ecx |
.leftbad: |
shr eax,1 |
add [edi],al |
inc esi |
inc edi |
loop .lpavg |
popa |
jmp PngFilter.nofilt |
Filt_paeth: |
pusha |
mov ecx,[sline_len] |
mov edx,[png_bpp] |
neg edx |
lea ebp,[ecx+edx] ; left edge |
mov edi,esi |
sub esi,ecx |
dec esi |
.lpaeth: |
push ecx |
movzx eax,byte[edi+edx] |
movzx ebx,byte[esi] |
movzx ecx,byte[esi+edx] |
push eax |
mov eax,[esp+28h] |
cmp eax,[PNG_info.Height] ; 1st line |
jne .no1stlineok |
xor ebx,ebx |
xor ecx,ecx |
.no1stlineok: |
pop eax |
cmp [esp],ebp ; ecx |
jbe .leftok ; x-bpp>=0 |
xor eax,eax |
xor ecx,ecx |
.leftok: |
pusha ; eax-28, ebx-16, ecx-24 |
lea edx,[eax+ebx] |
sub edx,ecx ; p=edx |
sub eax,edx ; pa := abs(p - a) |
jge .eaxp |
neg eax |
.eaxp: |
sub ebx,edx ; pb := abs(p - b) |
jge .ebxp |
neg ebx |
.ebxp: |
sub ecx,edx ; pc := abs(p - c) |
jge .ecxp |
neg ecx |
.ecxp: |
cmp eax,ebx |
ja .noa |
cmp eax,ecx |
jbe .ex ; pa-min |
.noa: |
cmp ebx,ecx |
ja .nob |
mov eax,[esp+16] |
jmp .ex2 |
.nob: |
mov eax,[esp+24] |
.ex2: |
mov [esp+28],eax |
.ex: |
popa |
add [edi],al |
inc esi |
inc edi |
pop ecx |
loop .lpaeth |
popa |
jmp PngFilter.nofilt |
rb_png: ; eax-dest; ecx-count |
push ecx |
xor eax,eax |
.shift: |
rol byte[cur_byte],1 |
rcl eax,1 |
.dec: |
dec [bits] |
jnz .loop1 |
.push: |
push dword[esi] |
pop [cur_byte] |
mov [bits],8 |
inc esi |
.loop1: |
loop .shift |
pop ecx |
ret |
PngStore: |
push esi |
cmp [PNG_info.Bit_depth],8 |
jbe .lo |
add esi,3 |
.lo: |
if ~ SYS eq win |
mov esi,[esi] |
bswap esi |
shr esi,8 |
mov [edi],esi |
add edi,3 |
else |
movsw |
movsb |
end if |
pop esi |
ret |
FiltStats: |
pusha |
xor ebx,ebx |
mov edx,23 |
mov ecx,6 |
.lp: |
push ecx edx |
Msg edx |
mov eax,[filters+ebx*4] |
DebugPrintDec |
pop edx ecx |
inc edx |
inc ebx |
loop .lp |
Newline |
popa |
ret |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |
/programs/other/archer/trunk/sys.inc |
---|
0,0 → 1,326 |
; @RCHER system-dependent and other stuff |
; Written in pure assembler by Ivushkin Andrey aka Willow |
OpenFile: |
mov [outp],output |
mov esi,area |
and [Finfo.block],0 |
if SYS eq win |
invoke CreateFile, filename, GENERIC_READ, FILE_SHARE_READ, NULL, \ |
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,NULL |
inc eax |
test eax,eax |
jz .ex |
dec eax |
mov [hnd],eax |
invoke GetFileSize,eax,NULL |
.ex: |
mov ebx,eax |
mov [filesize],eax |
else |
mcall 58,Finfo |
mov [filesize],ebx |
end if |
ret |
ResetFile: |
and [file_count],0 |
mov eax,[arc_base] |
xor ebx,ebx |
mov esi,area |
call FileSeek |
ret |
FileSeek: |
; eax - offset |
; esi - current pointer (in memory!) |
; ebx - translation method: 0 - beginning, 1 - current, 2 - end |
push eax ecx edx |
mov edx,[Finfo.block] |
imul edx,BSIZE |
sub esi,BUFPTR |
add esi,edx |
cmp ebx,1 |
je .cur |
jb .begin |
mov esi,[filesize] |
not eax |
.cur: |
add eax,esi |
.begin: |
mov ecx,BSIZE |
xor edx,edx |
div ecx |
lea esi,[BUFPTR+edx] |
mov [Finfo.block],eax |
if SYS eq win |
mul ecx |
invoke SetFilePointer,[hnd],eax,NULL,FILE_BEGIN |
invoke ReadFile,[hnd],area,INBUF, os_work, NULL |
; add [byte_count],area |
else |
; pregs |
; wait |
mov [Finfo.count],BUFSIZE*2 |
mcall 58,Finfo |
; mov [byte_count],area+INBUF |
end if |
pop edx ecx eax |
ret |
macro QueryFile |
{ |
local ex |
if SYS eq win |
invoke GetOpenFileName,ofstruc |
else |
opendialog draw_window,QFok,QFcanc,filename |
QFok: |
xor eax,eax |
jmp ex |
ret |
QFcanc: |
mov eax,1 |
end if |
ex: |
} |
RunViewer: |
test [Flags],PNG_MODE |
jz .ex |
if SYS eq win |
mov eax,[PNG_info.Width] |
call int2str |
invoke WritePrivateProfileString,ini_sec,ini_rwidth,os_work,ini_file |
mov eax,[PNG_info.Height] |
call int2str |
invoke WritePrivateProfileString,ini_sec,ini_rheight,os_work,ini_file |
invoke CreateProcess,NULL,iview_cmd,NULL,NULL,TRUE,\ |
NORMAL_PRIORITY_CLASS,NULL,NULL,suinfo,pinfo |
invoke WaitForInputIdle,dword[pinfo],0xFFFFFFFF |
invoke FindWindowEx, NULL,NULL,NULL,rawwnd_txt |
invoke FindWindowEx, eax,NULL,NULL,ok_txt |
invoke SendMessage,eax,BM_CLICK,NULL,NULL |
else |
test [Flags],THREAD_YES |
jnz .ex |
mcall 51,1,thread,MEMORY |
mov [child],eax |
end if |
.ex: |
ret |
if SYS eq win |
int2str: |
; in: eax - number |
; out: formatted string -> os_work |
invoke wsprintf,os_work,fmt_str,eax |
add esp,12 |
ret |
rawwnd_txt db 'Set RAW open parameters',0 |
ok_txt db 'OK',0 |
ini_sec db 'RAW',0 |
ini_rwidth db 'RWidth',0 |
ini_rheight db 'RHeight',0 |
ini_file db "C:\Program Files\IrfanView\i_view32.ini",0 |
fmt_str db "%d",0 |
iview_cmd db '"C:\Program Files\IrfanView\i_view32.exe"' |
db ' "D:\Ivushkin\projects\zip\output.raw"',0 |
filt_str: |
db 'Pictures (*.png)',0,'*.png',0 |
db 'Archives (*.zip;*.*gz)',0,'*.zip;*.*gz',0 |
db 'All files (*.*)',0,'*.*',0,0 |
suinfo STARTUPINFO |
pinfo PROCESS_INFORMATION |
cpstruc: |
ofstruc: |
dd ofstruc_end-ofstruc |
dd NULL |
dd NULL |
dd filt_str |
dd NULL |
dd NULL |
dd 0 |
dd filename |
dd 256 |
dd NULL |
dd 0 |
dd NULL |
dd NULL |
dd NULL |
dw NULL |
dw NULL |
dd NULL |
dd NULL |
dd NULL |
dd NULL |
dd NULL |
dd NULL |
dd NULL |
ofstruc_end: |
else |
mov ebx,-1 |
mov ecx,ebx |
mov edx,[PNG_info.Width] |
add edx,10 |
mov esi,[PNG_info.Width] |
add esi,30 |
mcall 67 |
mcall 7,outfile,[outfile.size],10 shl 16+15 |
.ex: |
ret |
MIN_WIDTH equ 300 |
thread: |
.red: |
mcall 12,1 |
mov ebx,[PNG_info.Width] |
cmp ebx,MIN_WIDTH |
jae .more |
mov ebx,MIN_WIDTH |
.more: |
add ebx,20 |
mov ecx,[PNG_info.Height] |
add ecx,30 |
mcall 0,,,0x3808080 |
mcall 4,<5,7>,0x10f0f0f0,filename,255 |
mov ecx,[PNG_info.Width] |
shl ecx,16 |
add ecx,[PNG_info.Height] |
mcall 7,png_image,,10 shl 16+25 |
mcall 12,2 |
.still: |
mcall 10 |
cmp eax,1 |
je .red |
cmp eax,2 |
jne .nokey |
mcall 2 |
cmp ah,27 ; Esc - close |
je .close |
jmp .still |
.nokey: |
cmp eax,3 |
jne .still |
.close: |
and [child],0 |
mcall -1 |
KillViewer: |
pusha |
mov edi,[child] |
test edi,edi |
jz .noth |
mcall 9,os_work,-1 |
mov ecx,eax |
.fchild: |
push ecx |
mcall 9,os_work |
cmp edi,[ebx+30] |
jne .lp |
mov ecx,[esp] |
mcall 18,2 |
pop ecx |
jmp .noth |
.lp: |
pop ecx |
loop .fchild |
.noth: |
popa |
ret |
macro CmdLine |
{ |
mov esi,PARAM_PTR |
.parse: |
lodsb |
test al,al |
jnz .noend |
or [Flags],STAY_MODE |
jmp red |
.noend: |
cmp al,' ' |
je .stay |
cmp al,'/' |
jne .yespar |
mov ecx,255 |
dec esi |
mov edi,filename |
xor al,al |
rep stosb |
mov ecx,255 |
mov edi,filename |
rep movsb |
jmp again |
.yespar: |
cmp al,'N' |
jne .nonum |
call get_6ASCII_num |
.fnum: |
mov [FileNum],eax |
jmp .parse |
.nonum: |
cmp al,'n' |
jne .nonum2 |
lodsd |
jmp .fnum |
.nonum2: |
cmp al,'s' |
jne .nostay |
.stay: |
or [Flags],STAY_MODE |
jmp .parse |
.nostay: |
cmp al,'i' |
jne .noclPID |
lodsd |
mov [clientPID],eax |
or [Flags],IPC_MODE |
jmp .parse |
.noclPID: |
cmp al,'R' |
jne .noraw |
or [Flags],RAW_MODE |
jmp .parse |
.noraw: |
cmp al,'q' |
jne .noofs |
lodsd |
.fofs: |
mov [arc_base],eax |
jmp .parse |
.noofs: |
cmp al,'Q' |
jne .noofs2 |
call get_6ASCII_num |
jmp .fofs |
.noofs2: |
jmp .parse |
get_6ASCII_num: |
; in: esi - str ptr, out: eax - num |
xor edx,edx |
mov ebx,10 |
mov ecx,6 |
.lp: |
xor eax,eax |
lodsb |
sub al,'0' |
imul edx,ebx |
add edx,eax |
loop .lp |
mov eax,edx |
ret |
} |
StartPad: |
mcall 19,editorcmd,dumpfile |
ret |
editorcmd db 'TINYPAD ' |
end if |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |