Re: Macro2D
- From: "Rosario" <x@xxx>
- Date: Sat, 25 Oct 2008 10:50:28 +0200
"Rosario" <x@xxx> ha scritto nel messaggio
news:48ce2116$0$1092$4fafbaef@xxxxxxxxxxxxxxxxxxxxxx
Whith this post there is the directory Macro2D.zip
that has the file Macro2D.exe that it seems the zip
form has the "CRC32" == 63367343
it is my macro language traslater to assembly nasm
finished just now.
It will be full of bug, I hope that not cause too many
damages...
I hope someone use it good.
How many bug or errors you can see?
Have you some suggestion?
Buon Giorno a tutti
Rosario
This is the file that compile itself with the help of nasm-alink
or rosasm. I wrote it in 2 months: Did i to be sloow in write it?
What think about my hash function? [lookup and hash function seems the
weak part of all this because no test done and i not test what happen
if hash(string1)==hash(string2) because it seems i never find this case]
have a good read
section _DATA use32 public class=DATA
/* d4 -obj a
/* alink -oPE -subsys con a.obj win32.lib
/* per oPE linkato come console
global _main
global Isreg, Riscrivi, Hash, SeeTab, InstallGenerali, FreeTab
global InstallNasm, FreeMem, DCmp, DCopy, FindMacroWord
global FindMacro, AtoI, Installl, Install, FreeNodo
global AllocNodo, Undef
global CopyString, CopyPseudoString
global IsComment, IsLabel, combine, Next_ch, First_ch
global ScriviParola, ScriviB2, ToNasm
global CopyUntil10Or0_jki, LineToNasm, ProvaToNasm
global Next_ch1, First_ch1, AsmMain
global PrendiNomeDa_i, LevaSpaziDa_i, PrendiNomeTraVirgoletteDa_i
global PrendiNomeTraSpaziDa_i, Free_sys, Malloc_sys, MacroNasm
global HashWord, Lookup, CatStr, FaiObj, FaiPe, FaiConsole
global ConvertiNumeriTavola, sposta, GetStdIo, AppendPointName
global PrendiArgomenti, PrintError, FindLastPoint_i
global SPuts, LenStr_i, SGetLine
global PrendiWord_jki, PrendiWordTraSpazi_jki
global FindEndNextWordTraSpazi_i, WordLen_i, LenStr_i
global WordLenTraSpazi_i, FindNextWord_i, FindNextWordTraSPazi_i
global InstalMacro, PushMacro, FreeIfFindAddressInString
global UndefMacro, PopMacro, ProvaFunzioni, Copy_jki
global CopyLine_jki, FlushCloseHandle, Find, VaiUntil10Or0_i
global FindData_i, FindCode_i, FindCarattereFromEnd
global AssegnaVettori, GetData_jki, InterattivoNasm
global LineToRosAsm, InstallRos
global HaLaLineaQualcheParola_i, IsNextWordLabel_i
global FromNasmToRos, AssegnaVettoriIstruzione
global MacroRosAsm, ScriviChi
extern VirtualAlloc
extern VirtualFree
extern CreateFileA
extern CloseHandle
extern ReadFile
extern WriteFile
extern GetCommandLineA
extern GetFileSize
extern GetStdHandle
extern AllocConsole
extern FreeConsole
extern GetConsoleScreenBufferInfo
extern GetExitCodeProcess
extern GetStartupInfoA
extern CreateProcessA
extern WaitForSingleObject
extern FormatMessageA
extern GetLastError
extern FlushFileBuffers
extern GetTickCount
;*
%define VirtualAlloc 'kernel32.VirtualAlloc'
%define VirtualFree 'kernel32.VirtualFree'
%define CreateFileA 'kernel32.CreateFileA'
%define CloseHandle 'kernel32.CloseHandle'
%define ReadFile 'kernel32.ReadFile'
%define WriteFile 'kernel32.WriteFile'
%define GetCommandLineA 'kernel32.GetCommandLineA'
%define GetFileSize 'kernel32.GetFileSize'
%define GetStdHandle 'kernel32.GetStdHandle'
%define AllocConsole 'kernel32.AllocConsole'
%define FreeConsole 'kernel32.FreeConsole'
%define GetConsoleScreenBufferInfo 'kernel32.GetConsoleScreenBufferInfo'
%define GetExitCodeProcess 'kernel32.GetExitCodeProcess'
%define GetStartupInfoA 'kernel32.GetStartupInfoA'
%define CreateProcessA 'kernel32.CreateProcessA'
%define WaitForSingleObject 'kernel32.WaitForSingleObject'
%define FormatMessageA 'kernel32.FormatMessageA'
%define GetLastError 'kernel32.GetLastError'
%define FlushFileBuffers 'kernel32.FlushFileBuffers'
%define GetTickCount 'kernel32.GetTickCount'
;*
%define MEM_COMMIT 01000h
%define MEM_RESERVE 02000h
%define MEM_RELEASE 08000h
%define PAGE_READWRITE 00004h
%define GENERIC_READ 080000000h
%define GENERIC_WRITE 040000000h
%define FILE_ATTRIBUTE_NORMAL 000000080h
%define OPEN_EXISTING 000000003h
%define CREATE_ALWAYS 000000002h
%define INVALID_HANDLE_VALUE 0FFFFFFFFh
%define IVA_ 0FFFFFFFFh
%define STD_ERROR_HANDLE 0FFFFFFF4h
%define STD_INPUT_HANDLE 0FFFFFFF6h
%define STD_OUTPUT_HANDLE 0FFFFFFF5h
%define Space 6
%define Punti 9
%define EOI 5
%define HASHSIZE 4019
hashtab dd 0
TheNext dd 0
NodeMem dd 0
MacroDefinizioniGeneraliLed dd 0
NasmDefLed dd 0
RosAsmDefLed dd 0
PointerSize dd 0
TheNextPointer dd 0
StringPointers dd 0
stdin dd -1
stdout dd -1
stderr dd -1
consoley dd 1024
consolex dd 80
BufInfo: times 20 dd 0
/* dwSize.x: dw 0
/* dwSize.y: dw 0
/* dwCursorPosition.x: dw 0
/* dwCursorPosition.y: dw 0
/* wAttributes: dw 0
/* srWindow.Left: dw 0
/* srWindow.Top: dw 0
/* srWindow.Right: dw 0
/* srWindow.Bottom: dw 0
/* dwMaximumWindowSize.x: dw 0
/* dwMaximumWindowSize.y: dw 0
/* 2*11=22 24/4=6
StartInfo: times 20 dd 0
/* typedef struct _STARTUPINFO { // si
/* 4 DWORD cb;
/* 4 LPTSTR lpReserved;
/* 4 LPTSTR lpDesktop;
/* 4 LPTSTR lpTitle;
/* 4 DWORD dwX;
/* 4 DWORD dwY;
/* 4 DWORD dwXSize;
/* 4 DWORD dwYSize;
/* 4 DWORD dwXCountChars;
/* 4 DWORD dwYCountChars;
/* 4 DWORD dwFillAttribute;
/* 4 DWORD dwFlags;
/* 2 WORD wShowWindow;
/* 2 WORD cbReserved2;
/* 4 LPBYTE lpReserved2;
/* 4 HANDLE hStdInput;
/* 4 HANDLE hStdOutput;
/* 4 HANDLE hStdError;
/*} STARTUPINFO, *LPSTARTUPINFO;
ProcInfo: dd 0, 0, 0, 0, 0, 0
/*typedef struct _PROCESS_INFORMATION { // pi
/* HANDLE hProcess;
/* HANDLE hThread;
/* DWORD dwProcessId;
/* DWORD dwThreadId;
/*} PROCESS_INFORMATION;
/* numeri decimali 0x0
/* numeri hex non decimali 0x1
/* altre lettere dell'alfabeto + "_" 0x2
/* "@" "$" "%" 0x3 [alfanumerico <=3]
/* EOI 0x5
/* spazi 0x6
/* punti 0x9
TempoA dd 0,0
%define Space 6
%define Punti 9
%define EOI 5
/* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
MyTable:
db 5, 16, 16, 16, 16, 16, 16, 16, 16, 6 /* 0
db 5, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 1 10 e' fine input non
spazio
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 2
db 16, 16, 6, 9, 16, 9, 3, 3, 9, 16 /* 3
db 9, 9, 9, 9, 9, 9, 2, 16, 0, 0 /* 4 "." e' lettera
db 0, 0, 0, 0, 0, 0, 0, 0, 16, 16 /* 5
db 9, 9, 9, 9, 3, 1, 1, 1, 1, 1 /* 6
db 1, 2, 2, 2, 2, 2, 2, 2, 2, 2 /* 7
db 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 /* 8
db 2, 16, 16, 16, 9, 2, 16, 1, 1, 1 /* 9
db 1, 1, 1, 2, 2, 2, 2, 2, 2, 2 /* 10
db 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 /* 11
db 2, 2, 2, 16, 9, 16, 16, 16, 16, 16 /* 12
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 13
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 14
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 15
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 16
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 17
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 18
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 19
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 20
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 21
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 22
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 23
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 24
db 16, 16, 16, 16, 16, 16, 0, 0, 0, 0 /* 25
/* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
MyTableR:
db 5, 16, 16, 16, 16, 16, 16, 16, 16, 6 /* 0
db 12, 16, 16, 12, 16, 16, 16, 16, 16, 16 /* 1 10 e' fine input non
spazio
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 2
db 16, 16, 6, 9, 10, 9, 0, 0, 9, 10 /* 3
db 9, 9, 9, 9, 9, 9, 0, 16, 0, 0 /* 4 "." e' lettera
db 0, 0, 0, 0, 0, 0, 0, 0, 10, 10 /* 5
db 9, 9, 9, 9, 0, 0, 0, 0, 0, 0 /* 6
db 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 7
db 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 8
db 0, 11, 10, 11, 9, 0, 10, 0, 0, 0 /* 9
db 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 10
db 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 11
db 0, 0, 0, 11, 9, 11, 10, 16, 16, 16 /* 12
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 13
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 14
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 15
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 16
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 17
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 18
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 19
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 20
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 21
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 22
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 23
db 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 /* 24
db 16, 16, 16, 16, 16, 16, 0, 0, 0, 0 /* 25
"[%s]%u|" db "[%s]%u|", 0
"Questa e' la help" db "Questa e' la help", 0
"<Premi \n> " db "<Premi \n> ", 0, 0
/* PiccoloBuffer times 64 db 0
/* point to next:nx puntatore
/* name:nm nome
/* defn:df definizione
/* defnlen:dfl lenDefinizione
/* << nx=0, nm=4, df=8, dfl=12
MacroDefinizioniGenerali:
db "a" ,0, "eax", 0
db "b" ,0, "ebx", 0
db "c" ,0, "ecx", 0
db "jx",0, "di", 0
db "i" ,0, "esi", 0
db "j" ,0, "edi", 0
db "ix",0, "si", 0
db "r" ,0, "edx", 0
db "rx",0, "dx", 0
db "rl",0, "dl", 0
db "rh",0, "dh", 0
db "s" ,0, "esp", 0
db "sx",0, "sp", 0
db "k" ,0, "ebp", 0
db "kx",0, "bp", 0
/* 15
db "##õ1" ,0, "jmp õ1", 0
db "õ1=õ2" ,0, "mov õ1, õ2", 0
db "õ1+=õ2" ,0, "add õ1, õ2", 0
db "õ1-=õ2" ,0, "sub õ1, õ2", 0
db "õ1++=õ2" ,0, "adc õ1, õ2", 0
db "õ1--=õ2" ,0, "sbb õ1, õ2", 0
db "õ1<->õ2" ,0, "xchg õ1, õ2", 0
db "õ1<<=õ2" ,0, "shl õ1, õ2", 0
db "õ1>>=õ2" ,0, "shr õ1, õ2", 0
db "õ1<<<=õ2",0, "rcl õ1, õ2", 0
db "õ1>>>=õ2",0, "rcr õ1, õ2", 0
db "õ1&õ2" ,0, "test õ1, õ2", 0
db "õ1=&õ2" ,0, "lea õ1, õ2", 0
db "õ1&=õ2" ,0, "and õ1, õ2", 0
db "õ1|=õ2" ,0, "or õ1, õ2", 0
db "õ1^=õ2" ,0, "xor õ1, õ2", 0
/*----------- db "õ1=*õ2" ,0, "mov õ1, [õ2]", 0
db "<õ1" ,0, "push õ1", 0
/* 35
db ">õ1" ,0, "pop õ1", 0
db "õ1()" ,0, "call õ1", 0
/* 37
db "<õ1,õ2" ,0, "push õ1 |push õ2", 0
db ">õ1,õ2" ,0, "pop õ2 |pop õ1", 0
db "<õ1,õ2,õ3" ,0, "push õ1 |push õ2 |push õ3", 0
db ">õ1,õ2,õ3" ,0, "pop õ3 |pop õ2 |pop õ1", 0
db "<õ1,õ2,õ3,õ4" ,0, "push õ1 |push õ2 |push õ3 |push õ4", 0
db ">õ1,õ2,õ3,õ4" ,0, "pop õ4 |pop õ3 |pop õ2 |pop õ1", 0
db "<õ1,õ2,õ3,õ4,õ5" ,0, "push õ1 |push õ2 |push õ3 |push õ4 |push
õ5", 0
db ">õ1,õ2,õ3,õ4,õ5" ,0, "pop õ5 |pop õ4 |pop õ3 |pop õ2 |pop
õ1", 0
db "<õ1,õ2,õ3,õ4,õ5,õ6",0
db "push õ1 |push õ2 |push õ3 |push õ4 |push õ5 |push õ6", 0
db ">õ1,õ2,õ3,õ4,õ5,õ6" , 0
db "pop õ6 |pop õ5 |pop õ4 |pop õ3 |pop õ2 |pop õ1", 0
db "<õ1,õ2,õ3,õ4,õ5,õ6,õ7" ,0
db "push õ1 |push õ2 |push õ3 |push õ4 |push õ5 |push õ6 |push õ7",
0
db ">õ1,õ2,õ3,õ4,õ5,õ6,õ7" , 0
db "pop õ7 |pop õ6 |pop õ5 |pop õ4 |pop õ3 |pop õ2 |pop õ1",
0
db "<õ1,õ2,õ3,õ4,õ5,õ6,õ7,õ8" , 0
db "push õ1 |push õ2 |push õ3 |push õ4 |push õ5 |push õ6 |push õ7
|push õ8", 0
db ">õ1,õ2,õ3,õ4,õ5,õ6,õ7,õ8" , 0
db "pop õ8 |pop õ7 |pop õ6 |pop õ5 |pop õ4 |pop õ3 |pop õ2
|pop õ1", 0
/* 51
/*------------------------------------------*/
db "õ1=õ2()" ,0, "call õ2 |mov õ1, eax", 0
db "õ1(õ2)" ,0, "push õ2 |call õ1", 0
db "õ1=õ2(õ3)" ,0, "push õ3 |call õ2 |mov õ1, eax", 0
db "õ1<(õ2)" ,0, "push õ2 |call õ1 |add esp, 4", 0
db "õ1=õ2<(õ3)" ,0
db "push õ3 |call õ2 |add esp, 4 |mov õ1, eax", 0
/* 56
db "õ1(õ2,õ3)" ,0
db "push õ3 |push õ2 |call õ1", 0
db "õ1=õ2(õ3,õ4)" ,0
db "push õ4 |push õ3 |call õ2 |mov õ1, eax", 0
db "õ1<(õ2,õ3)" ,0
db "push õ3 |push õ2 |call õ1 |add esp, 8", 0
db "õ1=õ2<(õ3,õ4)" ,0
db "push õ4 |push õ3 |call õ2 |add esp, 8 |mov õ1, eax", 0
db "õ1(õ2,õ3,õ4)" ,0
db "push õ4 |push õ3 |push õ2 |call õ1", 0
db "õ1=õ2(õ3,õ4,õ5)" ,0
db "push õ5 |push õ4 |push õ3 |call õ2 |mov õ1, eax", 0
db "õ1<(õ2,õ3,õ4)" ,0
db "push õ4 |push õ3 |push õ2 |call õ1 |add esp, 12", 0
db "õ1=õ2<(õ3,õ4,õ5)" ,0
db "push õ5 |push õ4 |push õ3 |call õ2 |add esp, 12 |mov õ1,
eax", 0
db "õ1(õ2,õ3,õ4,õ5)" ,0
db "push õ5 |push õ4 |push õ3 |push õ2 |call õ1", 0
db "õ1=õ2(õ3,õ4,õ5,õ6)" ,0
db "push õ6 |push õ5 |push õ4 |push õ3 |call õ2 |mov õ1, eax", 0
/* 66
db "õ1<(õ2,õ3,õ4,õ5)" , 0
db "push õ5 |push õ4 |push õ3 |push õ2 |call õ1 |add esp, 16", 0
db "õ1=õ2<(õ3,õ4,õ5,õ6)" ,0
db "push õ6 |push õ5 |push õ4 |push õ3 |call õ2 |add esp, 16 |mov
õ1, eax", 0
db "õ1(õ2,õ3,õ4,õ5,õ6)" , 0
db "push õ6 |push õ5 |push õ4 |push õ3 |push õ2 |call õ1", 0
db "õ1=õ2(õ3,õ4,õ5,õ6,õ7)" ,0
db "push õ7 |push õ6 |push õ5 |push õ4 |push õ3 |call õ2 |mov õ1,
eax", 0
db "õ1<(õ2,õ3,õ4,õ5,õ6)" , 0
db "push õ6 |push õ5 |push õ4 |push õ3 |push õ2 |call õ1 |add esp,
20", 0
db "õ1=õ2<(õ3,õ4,õ5,õ6,õ7)" ,0
db "push õ7 |push õ6 |push õ5 |push õ4 |push õ3 |call õ2 |add esp,
20 |mov õ1, eax", 0
db "õ1(õ2,õ3,õ4,õ5,õ6,õ7)" , 0
db "push õ7 |push õ6 |push õ5 |push õ4 |push õ3 |push õ2 |call õ1",
0
db "õ1=õ2(õ3,õ4,õ5,õ6,õ7,õ8)" ,0
db "push õ8 |push õ7 |push õ6 |push õ5 |push õ4 |push õ3 |call õ2
|mov õ1, eax", 0
db "õ1<(õ2,õ3,õ4,õ5,õ6,õ7)" , 0
db "push õ7 |push õ6 |push õ5 |push õ4 |push õ3 |push õ2 |call õ1
|add esp, 24", 0
db "õ1=õ2<(õ3,õ4,õ5,õ6,õ7,õ8)" , 0
db "push õ8 |push õ7 |push õ6 |push õ5 |push õ4 |push õ3 |call õ2
|add esp, 24 |mov õ1, eax", 0
/* 76
db "õ1(õ2,õ3,õ4,õ5,õ6,õ7,õ8)" , 0
db "push õ8 |push õ7 |push õ6 |push õ5 |push õ4 |push õ3 |push õ2
|call õ1", 0
db "õ1=õ2(õ3,õ4,õ5,õ6,õ7,õ8,õ9)" , 0
db "push õ9 |push õ8 |push õ7 |push õ6 |push õ5 |push õ4 |push õ3
|call õ2 |mov õ1, eax", 0
db "õ1<(õ2,õ3,õ4,õ5,õ6,õ7,õ8)" , 0
db "push õ8 |push õ7 |push õ6 |push õ5 |push õ4 |push õ3 |push õ2
|call õ1 |add esp, 28", 0
db "õ1=õ2<(õ3,õ4,õ5,õ6,õ7,õ8,õ9)" , 0
db "push õ9 |push õ8 |push õ7 |push õ6 |push õ5 |push õ4 |push õ3
|call õ2 |add esp, 28 |mov õ1, eax", 0
db "õ1(õ2,õ3,õ4,õ5,õ6,õ7,õ8,õ9)" , 0
db "push õ9 |push õ8 |push õ7 |push õ6 |push õ5 |push õ4 |push õ3
|push õ2 |call õ1", 0
db "õ1=õ2(õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10)" , 0
db "push õ10 |push õ9 |push õ8 |push õ7 |push õ6 |push õ5 |push õ4
|push õ3 |call õ2 |mov õ1, eax", 0
db "õ1<(õ2,õ3,õ4,õ5,õ6,õ7,õ8,õ9)" , 0
db "push õ9 |push õ8 |push õ7 |push õ6 |push õ5 |push õ4 |push õ3
|push õ2 |call õ1 |add esp, 32", 0
db "õ1=õ2<(õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10)" , 0
db "push õ10 |push õ9 |push õ8 |push õ7 |push õ6 |push õ5 |push õ4
|push õ3 |call õ2 |add esp, 32 |mov õ1, eax", 0
db "õ1(õ2,õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10)" , 0
db "push õ10 |push õ9 |push õ8 |push õ7 |push õ6 |push õ5 |push õ4
|push õ3 |push õ2 |call õ1", 0
db "õ1=õ2(õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10,õ11)" , 0
db "push õ11 |push õ10 |push õ9 |push õ8 |push õ7 |push õ6 |push õ5
|push õ4 |push õ3 |call õ2 |mov õ1, eax", 0
/* 86
db "õ1<(õ2,õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10)" , 0
db "push õ10 |push õ9 |push õ8 |push õ7 |push õ6 |push õ5 |push õ4
|push õ3 |push õ2 |call õ1 |add esp, 36", 0
db "õ1=õ2<(õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10,õ11)" ,0
db "push õ11 |push õ10 |push õ9 |push õ8 |push õ7 |push õ6 |push õ5
|push õ4 |push õ3 |call õ2 |add esp, 36 |mov õ1, eax", 0
/*--------------taglio
db "õ1(õ2,õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10,õ11)" , 0
db "push õ11 |push õ10 |push õ9 |push õ8 |push õ7 |push õ6 |push õ5
|push õ4 |push õ3 |push õ2 |call õ1", 0
/* ------------taglio
db "õ1=õ2(õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10,õ11,õ12)" , 0
db "push õ12 |push õ11 |push õ10 |push õ9 |push õ8 |push õ7 |push
õ6 |push õ5 |push õ4 |push õ3 |call õ2 |mov õ1, eax", 0
db "õ1<(õ2,õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10,õ11)" , 0
db "push õ11 |push õ10 |push õ9 |push õ8 |push õ7 |push õ6 |push õ5
|push õ4 |push õ3 |push õ2 |call õ1 |add esp, 40", 0
db "õ1=õ2<(õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10,õ11,õ12)" , 0
db "push õ12 |push õ11 |push õ10 |push õ9 |push õ8 |push õ7 |push
õ6 |push õ5 |push õ4 |push õ3 |call õ2 |add esp, 40 |mov õ1, eax",
0
db "õ1(õ2,õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10,õ11,õ12)" , 0
db "push õ12 |push õ11 |push õ10 |push õ9 |push õ8 |push õ7 |push
õ6 |push õ5 |push õ4 |push õ3 |push õ2 |call õ1", 0
db "õ1=õ2(õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10,õ11,õ12,õ13)" , 0
db "push õ13 |push õ12 |push õ11 |push õ10 |push õ9 |push õ8 |push
õ7 |push õ6 |push õ5 |push õ4 |push õ3 |call õ2 |mov õ1, eax", 0
db "õ1<(õ2,õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10,õ11,õ12)" , 0
db "push õ12 |push õ11 |push õ10 |push õ9 |push õ8 |push õ7 |push
õ6 |push õ5 |push õ4 |push õ3 |push õ2 |call õ1 |add esp, 44", 0
db "õ1=õ2<(õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10,õ11,õ12,õ13)" , 0
db "push õ13 |push õ12 |push õ11 |push õ10 |push õ9 |push õ8 |push
õ7 |push õ6 |push õ5 |push õ4 |push õ3 |call õ2 |add esp, 44 |mov
õ1, eax", 0
/* 96
db "õ1(õ2,õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10,õ11,õ12,õ13)" , 0
db "push õ13 |push õ12 |push õ11 |push õ10 |push õ9 |push õ8 |push
õ7 |push õ6 |push õ5 |push õ4 |push õ3 |push õ2 |call õ1", 0
db "õ1=õ2(õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10,õ11,õ12,õ13,õ14)" , 0
db "push õ14 |push õ13 |push õ12 |push õ11 |push õ10 |push õ9 |push
õ8 |push õ7 |push õ6 |push õ5 |push õ4 |push õ3 |call õ2 |mov õ1,
eax", 0
db "õ1<(õ2,õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10,õ11,õ12,õ13)" , 0
db "push õ13 |push õ12 |push õ11 |push õ10 |push õ9 |push õ8 |push
õ7 |push õ6 |push õ5 |push õ4 |push õ3 |push õ2 |call õ1 |add esp,
48", 0
db "õ1=õ2<(õ3,õ4,õ5,õ6,õ7,õ8,õ9,õ10,õ11,õ12,õ13,õ14)" , 0
db "push õ14 |push õ13 |push õ12 |push õ11 |push õ10 |push õ9 |push
õ8 |push õ7 |push õ6 |push õ5 |push õ4 |push õ3 |call õ2 |add esp,
48 |mov õ1, eax", 0
/*100
/*------------------------------------------*/
db "++õ1" ,0, "inc õ1", 0
db "--õ1" ,0, "dec õ1", 0 /* --[a+si]
db "++õ1,õ2" ,0, "inc õ1 |inc õ2", 0
db "--õ1,õ2" ,0, "dec õ1 |dec õ2", 0
db "++õ1,õ2,õ3" ,0
db "inc õ1 |inc õ2 |inc õ3", 0
db "--õ1,õ2,õ3" ,0
db "dec õ1 |dec õ2 |dec õ3", 0
/* 106
db "++õ1,õ2,õ3,õ4" ,0
db "inc õ1 |inc õ2 |inc õ3 |inc õ4", 0
db "--õ1,õ2,õ3,õ4" ,0
db "dec õ1 |dec õ2 |dec õ3 |dec õ4", 0
db "--õ1#õ2" ,0, "dec õ1 |jnz õ2", 0
db "--õ1!#õ2" ,0, "dec õ1 |jz õ2", 0
db "++õ1#õ2" ,0, "inc õ1 |jnz õ2", 0
db "++õ1!#õ2" ,0, "inc õ1 |jz õ2", 0
db "õ1<>õ2" ,0, "cmp õ1, õ2", 0
db "õ1#õ2" ,0, "cmp õ1, 0 |jne õ2", 0
db "õ1!#õ2" ,0, "cmp õ1, 0 |je õ2", 0
db "õ1<õ2#õ3" ,0, "cmp õ1, õ2 |jb õ3", 0 /* numeri senza segno
/* 116
db "õ1&õ2#õ3" ,0, "test õ1, õ2 |jnz õ3", 0
db "õ1>õ2#õ3" ,0, "cmp õ1, õ2 |ja õ3", 0
db "õ1<=õ2#õ3" ,0, "cmp õ1, õ2 |jbe õ3", 0
db "õ1>=õ2#õ3" ,0, "cmp õ1, õ2 |jae õ3", 0
db "õ1==õ2#õ3" ,0, "cmp õ1, õ2 |je õ3", 0
db "õ1!=õ2#õ3" ,0, "cmp õ1, õ2 |jne õ3", 0
db "õ1>=õ2!#õ3" ,0, "cmp õ1, õ2 |jb õ3", 0
db "õ1<=õ2!#õ3" ,0, "cmp õ1, õ2 |ja õ3", 0
db "õ1>õ2!#õ3" ,0, "cmp õ1, õ2 |jbe õ3", 0
db "õ1&õ2!#õ3" ,0, "test õ1, õ2 |jz õ3", 0
db "õ1<õ2!#õ3" ,0, "cmp õ1, õ2 |jae õ3", 0
db "õ1!=õ2!#õ3" ,0, "cmp õ1, õ2 |je õ3", 0
db "õ1==õ2!#õ3" ,0, "cmp õ1, õ2 |jne õ3", 0
/* nuovi
db "õ1==õ2,õ3#õ4", 0
db "cmp õ1, õ2 |je õ4 |cmp õ1, õ3 |je õ4", 0
db "õ1==õ2,õ3,õ4#õ5", 0
db "cmp õ1, õ2 |je õ5 |cmp õ1, õ3 |je õ5 |cmp õ1, õ4 |je
õ5", 0
db "õ1==õ2,õ3,õ4,õ5#õ6", 0
db "cmp õ1, õ2 |je õ6 |cmp õ1, õ3 |je õ6 |cmp õ1, õ4 |je õ6
|cmp õ1, õ5 |je õ6", 0
db "õ1==õ2,õ3,õ4,õ5,õ6#õ7", 0
db "cmp õ1, õ2 |je õ7 |cmp õ1, õ3 |je õ7 |cmp õ1, õ4 |je õ7
|cmp õ1, õ5 |je õ7 |cmp õ1, õ6 |je õ7", 0
/* -----------------------------
/* 129
/* numeri col segno
db "õ1<õ2?#õ3" ,0, "cmp õ1, õ2 |jl õ3", 0
db "õ1>õ2?#õ3" ,0, "cmp õ1, õ2 |jg õ3", 0
db "õ1<=õ2?#õ3" ,0, "cmp õ1, õ2 |jle õ3", 0
db "õ1>=õ2?#õ3" ,0, "cmp õ1, õ2 |jge õ3", 0
db "õ1==õ2?#õ3" ,0, "cmp õ1, õ2 |je õ3", 0
db "õ1!=õ2?#õ3" ,0, "cmp õ1, õ2 |jne õ3", 0
db "õ1>=õ2!?#õ3",0, "cmp õ1, õ2 |jl õ3", 0
db "õ1<=õ2!?#õ3",0, "cmp õ1, õ2 |jg õ3", 0
db "õ1>õ2!?#õ3" ,0, "cmp õ1, õ2 |jle õ3", 0
db "õ1<õ2!?#õ3" ,0, "cmp õ1, õ2 |jge õ3", 0
db "õ1!=õ2!?#õ3",0, "cmp õ1, õ2 |je õ3", 0
db "õ1==õ2!?#õ3",0, "cmp õ1, õ2 |jne õ3", 0
/* 141
db "õ1=õ2+õ3" ,0, "mov õ1, õ2 |add õ1, õ3", 0
db "õ1=õ2-õ3" ,0, "mov õ1, õ2 |sub õ1, õ3", 0
/* 143
/* label: istruzione = istruzione \0 commento
/* numeri senza segno
db "=#õ1" ,0, "jz õ1", 0
db "<#õ1" ,0, "jb õ1", 0
db ">#õ1" ,0, "ja õ1", 0
/* 146
/* numeri con segno
db "<=#õ1" ,0, "jbe õ1", 0
db ">=#õ1" ,0, "jae õ1", 0
db "=?#õ1" ,0, "je õ1", 0
db "<?#õ1" ,0, "jl õ1", 0
db ">?#õ1" ,0, "jg õ1", 0
db "<=?#õ1",0, "jle õ1", 0
db ">=?#õ1",0, "jge õ1", 0
/* numeri senza segno
db "!#õ1" ,0, "jnz õ1", 0
db "!<#õ1" ,0, "jae õ1", 0
db "!>#õ1" ,0, "jbe õ1", 0
/* 156
db "!<=#õ1" ,0, "ja õ1", 0
db "!>=#õ1" ,0, "jb õ1", 0
/* numeri con segno
db "!?#õ1" ,0, "jne õ1", 0
db "!<?#õ1" ,0, "jge õ1", 0
db "!>?#õ1" ,0, "jle õ1", 0
db "!<=?#õ1",0, "jg õ1", 0
db "!>=?#õ1",0, "jl õ1", 0
db "(õ1,õ2)<<=õ3" ,0, "shld õ1, õ2, õ3", 0
db "(õ1,õ2)>>=õ3" ,0, "shrd õ1, õ2, õ3", 0
/* 165
db 0FFh,0FFh,0,0FFh
NasmDef:
db "D" ,0, "dword", 0
db "W" ,0, "word" , 0
db "B" ,0, "byte" , 0
db "Q" ,0, "qword", 0
db "T" ,0, "tword", 0
/* 170
db "#õ1",0, "jmp short õ1", 0
db "<<õ1=õ2" ,0, "%define õ1 õ2", 0
db ">>õ1" ,0, "%undef õ1" , 0
db "<<õ1=õ2,õ3=õ4",0
db "%define õ1 õ2 |%define õ3 õ4", 0
/* 174
db ">>õ1,õ2",0
db "%undef õ1 |%undef õ2" , 0
db "<<õ1=õ2,õ3=õ4,õ5=õ6",0
db "%define õ1 õ2 |%define õ3 õ4 |%define õ5 õ6", 0
db ">>õ1,õ2,õ3",0
db "%undef õ1 |%undef õ2 |%undef õ3" , 0
db "<<õ1=õ2,õ3=õ4,õ5=õ6,õ7=õ8",0
db "%define õ1 õ2 |%define õ3 õ4 |%define õ5 õ6 |%define õ7 õ8", 0
db ">>õ1,õ2,õ3,õ4",0
db "%undef õ1 |%undef õ2 |%undef õ3 |%undef õ4 " , 0
db "<<õ1=õ2,õ3=õ4,õ5=õ6,õ7=õ8,õ9=õ10",0
db "%define õ1 õ2 |%define õ3 õ4 |%define õ5 õ6 |%define õ7 õ8
|%define õ9 õ10", 0
db ">>õ1,õ2,õ3,õ4,õ5",0
db "%undef õ1 |%undef õ2 |%undef õ3 |%undef õ4 |%undef õ5 ", 0
db "<<õ1=õ2,õ3=õ4,õ5=õ6,õ7=õ8,õ9=õ10,õ11=õ12",0
db "%define õ1 õ2 |%define õ3 õ4 |%define õ5 õ6 |%define õ7 õ8
|%define õ9 õ10 |%define õ11 õ12 ", 0
db ">>õ1,õ2,õ3,õ4,õ5,õ6",0
db "%undef õ1 |%undef õ2 |%undef õ3 |%undef õ4 |%undef õ5 |%undef õ6
", 0
db "<<õ1=õ2,õ3=õ4,õ5=õ6,õ7=õ8,õ9=õ10,õ11=õ12,õ13=õ14", 0
db "%define õ1 õ2 |%define õ3 õ4 |%define õ5 õ6 |%define õ7 õ8
|%define õ9 õ10 |%define õ11 õ12 |%define õ13 õ14 ", 0
/* 184
db ">>õ1,õ2,õ3,õ4,õ5,õ6,õ7", 0
db "%undef õ1 |%undef õ2 |%undef õ3 |%undef õ4 |%undef õ5 |%undef õ6
|%undef õ7 ", 0
db "==õ1==õ2", 0
db "extern õ1 |import õ1 õ2 ", 0
db "==õ1,õ2==õ3",0
db "extern õ1, õ2 |import õ1 õ3 |import õ2 õ3 ", 0
db "==õ1,õ2,õ3==õ4",0
db "extern õ1, õ2, õ3 |import õ1 õ4 |import õ2 õ4 |import õ3 õ4 ", 0
db "==õ1,õ2,õ3,õ4==õ5", 0
db "extern õ1, õ2, õ3, õ4 |import õ1 õ5 |import õ2 õ5 |import õ3 õ5
|import õ4 õ5 ", 0
db "==õ1,õ2,õ3,õ4,õ5==õ6",0
db "extern õ1, õ2, õ3, õ4, õ5 |import õ1 õ6 |import õ2 õ6 |import õ3
õ6 |import õ4 õ6 |import õ5 õ6 ", 0
db "õ1,õ2=õ3" ,0
db "[section .data] |õ2 õ1 õ3 , 0 |__SECT__ ", 0
db "õ1,õ2=õ3,õ4=õ5" ,0
db "[section .data] |õ2 õ1 õ3 , 0 |õ4 õ1 õ5 , 0 |__SECT__ ", 0
db "õ1,õ2=õ3,õ4=õ5,õ6=õ7" ,0
db "[section .data] |õ2 õ1 õ3 , 0 |õ4 õ1 õ5 , 0 |õ6 õ1 õ7 , 0 |__SECT__
", 0
db "õ1,õ2=õ3,õ4=õ5,õ6=õ7,õ8=õ9" , 0
db "[section .data] |õ2 õ1 õ3 , 0 |õ4 õ1 õ5 , 0 |õ6 õ1 õ7 , 0 |õ8 õ1 õ9
, 0 |__SECT__ ", 0
/* 194
db "õ1,õ2=õ3,õ4=õ5,õ6=õ7,õ8=õ9,õ10=õ11" , 0
db "[section .data] |õ2 õ1 õ3 , 0 |õ4 õ1 õ5 , 0 |õ6 õ1 õ7 , 0 |õ8 õ1 õ9
, 0 |õ10 õ1 õ11 , 0 |__SECT__ ", 0
db "õ1,õ2=õ3,õ4=õ5,õ6=õ7,õ8=õ9,õ10=õ11,õ12=õ13" ,0
db "[section .data] |õ2 õ1 õ3 ,0 |õ4 õ1 õ5 ,0 |õ6 õ1 õ7 ,0 |õ8 õ1 õ9 ,0
|õ10 õ1 õ11 ,0 |õ12 õ1 õ13 ,0 |__SECT__ ", 0
/* 196
db 0FFh,0FFh,0,0FFh
RosAsmDef:
db "#õ1" , 0
db "jmp õ1", 0
db "dword", 0, "D" ,0
db "word" , 0, "W" ,0
db "byte" , 0, "B" ,0
db "qword", 0, "Q" ,0
db "tword", 0, "T" ,0
db "short", 0, " " ,0
db 0FFh,0FFh,0,0FFh,0
%define NL 13, 10
helpText:
db " ª V ^ ",NL
db " A E e ",NL
db " Processore Macro2D", 13,10
db "Questo programma tratta un file di input di istruzioni", NL
db "che espande (usando alcune macro) e scrive in un file", NL
db "di output. Tale file di output dovrebbe essere un file", NL
db "di testo in linguaggio assembly per la cpu 386 Intel", NL
db "scritto usando la stessa sintassi di Nasm o di RosAsm.", NL
db " ", NL
db "Questo programma e' solo un tentativo o un esperimento", NL
db "con l'obiettivo di non abolire le micro-istruzioni", NL
db "dell'assembly pur trovando un modo per evidenziare", NL
db "i loop e gli if. In pratica si usa l'indentazione ed", NL
db "le multi istruzioni per linea per ottenere", NL
db "programmazione strutturata in assembly, che mostra", NL
db "come i goto o i salti, cosi' comuni in assembly,", NL
db "possono, se correttamente indentati, costituire", NL
db "programmi molto leggibili [a differenza di quello che", NL
db "dice la gente sui goto]. In pratica si passa da un", NL
db "codice in una dimensione [1 istruzione per linea] a", NL
db "codice in 2 dimensioni [piu' istruzioni per linea +", NL
db "indentazione].", NL
db "Spero che qualche programmatore usi questo linguaggio", NL
db "e non perda la speranza nel considerare il linguaggio", NL
db "assembly il linguaggio migliore di tutti.",NL
db " ", NL
db " Nota Bene", NL
db "In poche parole se questo programma si chiama Macro2D", NL
db '"Macro2D input.m output.asm"', NL
db "ha come input il file input.m e come output il file", NL
db "output.asm da trattare con Nasm con per esempio", NL
db '"nasmw -fobj output.asm"', NL
db " ", NL
db "Per quanto riguarda l'output con RosAsm", NL
db '"Macro2D -r input.m rosoutput.asm"', NL
db "ha come risultato il file rosoutput.asm da elaborare", NL
db "usando RosAsm.", NL
db '"Macro2D -howuse"', NL
db "Da' come output le macro in esso contenute e questa", NL
db "spiegazione, per tutte le altre opzioni utilizzabili", NL
db "vedere l'opzione -h."
db " ", NL
db " Fine Nota Bene", NL
db "Il modo di procedere per imparare il linguaggio che", NL
db "e' sottointeso e' imparare a memoria tutte le macro", NL
db "istruzioni che seguono (semplicissimo perche' sono", NL
db "intuitive e poche) e usandole bene per costruire", NL
db "programmi strutturati.", NL
db " ", NL
db "Alcune particolarita'", NL
db '* Commenti di linea: "/*" ed ";" sono stringhe di ', NL
db " inizio per commenti che finisco quando finisce la", NL
db ' linea ["\n"]', NL
db " ", NL
db '* Commenti multilinea: "\n;;"'
db " e' la stringa iniziale", NL
db ' per commenti multilinea che finiscono con "\n;;\n"', NL
db " ", NL
db '* Commenti multilinea: "\n;*"'
db " e' la stringa iniziale", NL
db ' per commenti multilinea che finiscono con "\n;;\n"', NL
db ' oppure con "\n;*\n" tale tipo di commento vale per', NL
db " la traduzione verso Nasm assembly ma e' commento", NL
db " semplice per la traduzione verso RosAsm assembly", NL
db " (opzione -r)", NL
db " ", NL
db "* Per permettere a piu' istruzioni di condividere la", NL
db ' stessa linea si usa il separatore "|" che viene', NL
db ' sostituito da "\n" nella traduzione.', NL
db " ", NL
db '* ",\n" provoca '
db " l'unione delle della corrente linea", NL
db " e della linea successiva:", NL
db ' "lineacorrente,\nLineasuccessiva" ->', NL
db ' "lineacorrente,Lineasuccessiva"', NL
db " ", NL
db '* "\\n" provoca '
db " l'unione delle della corrente linea", NL
db " e della linea successiva:", NL
db ' "lineacorrente\\n Lineasuccessiva" ->', NL
db ' "lineacorrente Lineasuccessiva"', NL
db " ", NL
db '* Alcuni registri hanno nuovi nomi esempio "a" sta', NL
db " per eax: a->eax, b->ebx, c->ecx, r->edx, i->esi", NL
db " j->edi, s->esp, k->ebp, rx->dx, jx->di, ix->si", NL
db " sx->sp, kx->kp, rh->dh, rl->dl.", NL
db " (i nomi degli altri registri o sottoregistri", NL
db " sono quelli che usa nasmw ). ", NL
db " ", NL
db "* Non sono valide espressioni del tipo a=b+7 o c=a-90", NL
db " ", NL
db "* E' possibile utilizzare stringhe come nomi di", NL
db " stringhe a patto che siano di lunghezza >=5 e.g.", NL
db ".data", NL
db '"stri=%i" db "stri=%i", 0', NL
db "...", NL
db ".text", NL
db "...", NL
db 'printf<("stri=%i", eax);', NL
db "che dovrebbe avere traduzione in qualcosa come", NL
db ".data", NL
db 'striIIi db "stri=%i", 0', NL
db "...", NL
db ".text", NL
db "...", NL
db "push eax", NL
db "push striIIi", NL
db "call printf", NL
db "add esp, 8", NL
db " ", NL
db "* Le istruzioni", NL
db " mov eax, 4|98, a=4|8, mov eax, 7*9+45", NL
db " non ottengono le corrette traduzioni; quello che si", NL
db " potrebbe fare e' mettere le parentesi tonde, anche", NL
db " se non sono supportate 2 livelli di parentesi, ", NL
db " esempio:"
db " a(&questo|&qwello, 8|4, b)", NL
db " ha come risultato", NL
db " push ebx", NL
db " push 8|4", NL
db " push &questo|&qwello", NL
db " call eax", NL
db " perche' vi e' la parentesi tonda, se si usa", NL
db " un'altra parentesi tonda il risultato non compila.", NL
db " Altri esempi che dovrebbero essere ok:", NL
db " mov eax, (4|98) oppure a=(4|98)", NL
db " mov eax, (7*9+45)", NL
db " fun(8*9+45, c)", NL
db " ", NL
db "* ^ ha anche una funzione particolare di accesso allo", NL
db " stack per esempio:"
db " ^nome|=ebx -> or dword[esp+nome], ebx", NL
db " ^a-4=99 -> mov dword [esp+a-4], 99", NL
db " ", NL
db "* * ha una funzione particolare di accesso alla memoria.", NL
db " Esempio: D*a-4=99 viene tradotto in", NL
db " mov dword [eax-4], 99", NL
db " ", NL
db "* Non ho fatto molte prove su testi; quindi errori.", NL
db " ", NL
db " Note sull'uso", NL
db "Declino ogni responsabilita' per qualsiasi danno che", NL
db "potrebbe arrecare questo programma, o il suo risultato", NL
db "e declino ogni garanzia implicita o esplicita che", NL
db "questo programma serva a qualche cosa.", NL
db "Il programma si intende libero (free) per la copia e", NL
db "per il solo uso descritto sopra quando si parla", NL
db 'di "Nota Bene"; il suo uso ', NL
db "quindi e' quello di fornire", NL
db "macro-espansioni di programmi, anche a uso commerciale", NL
db "senza io aver niente a pretendere per gli eventuali", NL
db "programmi tradotti che restano di chi li scrive, come", NL
db "restano di chi li scrive tutti gli oneri e obblighi", NL
db "a tali programmi associati.", NL
db "A patto che non venga usato per: ", NL
db "* macro-espansioni di programmi a uso militare o per", NL
db " distruggere o uccidere qualsiasi essere vivente", NL
db "* macro-espansioni di programmi per tecnologie per", NL
db " armi", NL
db "* macro-espansioni di programmi per tecnologie che", NL
db " mirino alla modifica del DNA di qualsiasi essere", NL
db " vivente piante comprese", NL
db "* macro-espansioni di programmi per tecnologie che", NL
db " producono rifiuti nucleari, o rifiuti pericolosi", NL
db " al livello di pericolosita' maggiori o uguali a", NL
db " quelli dell'uranio.", NL
db " ", NL
db " Alcuni esempi ", NL
db "/* ritorna la lunghezza della stringa presa ", NL
db "/* c==1 significa raggiunto EOF", NL
db "/* c==0 significa non raggiunto EOF", NL
db "/* 0k,4j,8i,12b,16ra,", NL
db "/* 20PArr,24PArrSize,28PHandle + 8", NL
db "/* 28 j |32 k |36 i", NL
db "SGetLine:", NL
db "<b,i,j,k", NL
db "s-=8|j=^28|k=^32|i=^36|b=s", NL
db " k<=0?#.e0|j#.1", NL
db ".e0: a^=a", NL
db ".e: c^=c|stc|#.z", NL
db ".e1: B*j=0|j-=[s+28]|a=j|#.e", NL
db ".1: k+=j", NL
db ".2: j>=k#.e1", NL
db " ReadFile(i,j,1,b,0)", NL
db " a==0#.e1|D*s!=1#.3 /*raggiunto EOF", NL
db " ++j| B[j-1]!=10#.2|c^=c|#.4", NL
db ".3: c=1", NL
db ".4: B*j=0|j-=[s+28]|a=j|clc", NL
db ".z:", NL
db "s=&[s+8]", NL
db ">b,i,j,k", NL
db "ret 12", NL
db "Tradotto in:", NL
db "; ritorna la lunghezza della stringa presa", NL
db "; c==1 significa raggiunto EOF", NL
db "; c==0 significa non raggiunto EOF", NL
db "; 0k,4j,8i,12b,16ra,", NL
db "; 20PArr,24PArrSize,28PHandle + 8", NL
db "; 28 j |32 k |36 i", NL
db "SGetLine: ", NL
db " push ebx", NL
db " push esi", NL
db " push edi", NL
db " push ebp", NL
db " sub esp, 8", NL
db " mov edi, dword[esp+ 28]", NL
db " mov ebp, dword[esp+ 32]", NL
db " mov esi, dword[esp+ 36]", NL
db " mov ebx, esp", NL
db " cmp ebp, 0", NL
db " jle .e0", NL
db " cmp edi, 0", NL
db " jne .1", NL
db ".e0: xor eax, eax", NL
db ".e: xor ecx, ecx", NL
db " stc", NL
db " jmp short .z", NL
db ".e1: mov byte [edi], 0", NL
db " sub edi, [esp+28]", NL
db " mov eax, edi", NL
db " jmp short .e", NL
db ".1: add ebp, edi", NL
db ".2: cmp edi, ebp", NL
db " jae .e1", NL
db " push 0", NL
db " push ebx", NL
db " push 1", NL
db " push edi", NL
db " push esi", NL
db " call ReadFile", NL
db " cmp eax, 0", NL
db " je .e1", NL
db " cmp dword [esp], 1", NL
db " jne .3 ;raggiunto EOF", NL
db " inc edi", NL
db " cmp byte[edi-1], 10", NL
db " jne .2", NL
db " xor ecx, ecx", NL
db " jmp short .4", NL
db ".3: mov ecx, 1", NL
db ".4: mov byte [edi], 0", NL
db " sub edi, [esp+28]", NL
db " mov eax, edi", NL
db " clc", NL
db ".z: ", NL
db " lea esp, [esp+8]", NL
db " pop ebp", NL
db " pop edi", NL
db " pop esi", NL
db " pop ebx", NL
db " ret 12", NL
db "Utilizzo alcune convenzioni per le label.", NL
db "Notare come .z e' la label 'di uscita' e utilizzo", NL
db "label globali per il nome della funzione, locali", NL
db "per le label della funzione, l'ultima label e' .z", NL
db "Le uniche label locali significative sono .e, .e0", NL
db ".e1 eccetera; se necessario aggiungere label tra", NL
db "due label esempio .1 ed .2 utilizzo .1a, .1b ecc.", NL
db "/* u32 [size] CatStr(u8* dest,u32 Size,u8* stringCat)", NL
db "/* 0j,4ra,8P_dest,12P_size,16P_stringCat a,c,r,j", NL
db "CatStr:", NL
db "<j", NL
db " j=[s+8]|c=[s+12]|r=[s+16]", NL
db " j==0#.e|a^=a|c>1?#.2", NL
db ".ee: B*j=0", NL
db ".e: a^=a| stc| #.z", NL
db ".1: ++j|--c!#.e", NL
db ".2: B*j#.1", NL
db ".3: al=*r|*j=al|a==0#.4", NL
db " --c!#.ee|++r,j|#.3", NL
db ".4: a=j|B*j=0|a-=[s+8]|clc", NL
db ".z:", NL
db ">j", NL
db "ret 12", NL
db "Tradotto in:", NL
db "; u32 [size] CatStr(u8* dest,u32 Size,u8* stringCat)", NL
db "; 0j,4ra,8P_dest,12P_size,16P_stringCat a,c,r,j", NL
db "CatStr: ", NL
db " push edi", NL
db " mov edi, [esp+8]", NL
db " mov ecx, [esp+12]", NL
db " mov edx, [esp+16]", NL
db " cmp edi, 0", NL
db " je .e", NL
db " xor eax, eax", NL
db " cmp ecx, 1", NL
db " jg .2", NL
db ".ee: mov byte [edi], 0", NL
db ".e: xor eax, eax", NL
db " stc", NL
db " jmp short .z", NL
db ".1: inc edi", NL
db " dec ecx", NL
db " jz .e", NL
db ".2: cmp byte [edi], 0", NL
db " jne .1", NL
db ".3: mov al, [edx]", NL
db " mov [edi], al", NL
db " cmp eax, 0", NL
db " je .4", NL
db " dec ecx", NL
db " jz .ee", NL
db " inc edx", NL
db " inc edi", NL
db " jmp short .3", NL
db ".4: mov eax, edi", NL
db " mov byte [edi], 0", NL
db " sub eax, [esp+8]", NL
db " clc", NL
db ".z: ", NL
db " pop edi", NL
db " ret 12 ", NL
db "Oggi 9 Agosto 2008", NL
db "Saluti a tutti.", NL
db NL, NL
db " Tutte la macro sostituzioni ammesse per Nasm", NL
db 0,0
qui times 1028 db 0
nl db 13, 10, 0
Litlehelp:
db " ª V ^ ",NL
db " A E e ",NL
db "Questo programma tratta un file di input di istruzioni", NL
db "che espande (usando alcune macro) e scrive in un file", NL
db "di output. Tale file di output dovrebbe essere un file", NL
db "di testo in linguaggio assembly per la cpu 386 Intel", NL
db "scritto usando la stessa sintassi di Nasm o di RosAsm.", NL
db " ", NL
db "Uso: ", NL
db '"ThisFile.exe -h"', NL
db "per stampare questo file di help", NL
db "+", NL
db '"ThisFile.exe -howuse"', NL
db "per stampare un file di help piu' grande", NL
db "+", NL
db '"ThisFile.exe input.m output.asm"', NL
db "ha come input il file input.m e come output il file", NL
db "output.asm da trattare con Nasm con per esempio", NL
db '"nasmw -fobj output.asm"', NL
db "+", NL
db '"ThisFile.exe -r input.m rosoutput.asm"', NL
db "Per quanto riguarda l'output con RosAsm", NL
db "ha come risultato il file rosoutput.asm da elaborare", NL
db "usando RosAsm.", NL
db "+", NL
db '"ThisFile.exe input.asm"', NL
db "Questo programma serve per formattare meglio", NL
db "un programma assembly risultato del programma", NL
db "delle macro.", NL
db "Scrive il file come risultato: prog_Btf.asm", NL
db "+", NL
db '"ThisFile.exe -Ob a.m"', NL
db "Ha come risultato a.asm, a.obj in qusto modo:", NL
db "ThisFile.exe -Ob a.m -> a.asm", NL
db "nasmw -fobj a.asm -> a.obj", NL
db "+", NL
db '"ThisFile.exe -Pe a.m"', NL
db "Programma di tipo PE.", NL
db "Ha come risultato a.asm, a.obj, a.exe cosi':", NL
db "ThisFile.exe -Ob a.m -> a.asm", NL
db "nasmw -fobj a.asm -> a.obj", NL
db "alink -oPe a.obj win32.lib -> a.exe", NL
db "+", NL
db '"ThisFile.exe -Dl a.m"', NL
db "Libreria .dll.", NL
db "Ha come risultato a.asm, a.obj, a.dll cosi':", NL
db "ThisFile.exe -Ob a.m -> a.asm", NL
db "nasmw -fobj a.asm -> a.obj", NL
db "alink -oPe -dll a.obj win32.lib -> a.dll", NL
db "+", NL
db '"ThisFile.exe -Co a.m"', NL
db "Programma di tipo console.", NL
db "Ha come risultato a.asm, a.obj, a.exe cosi':", NL
db "ThisFile.exe -Co a.m -> a.asm", NL
db "nasmw -fobj a.asm -> a.obj", NL
db "alink -oPe -subsys con a.obj win32.lib -> a.exe", NL
db "+", NL
db '"ThisFile.exe -In"', NL
db "Espande le macro di Nasm inserite in input.", NL, 0, 0
"Nasmw -fobj " db "Nasmw -fobj ",0,0
"alink -oPE " db "alink -oPE ",0,0
"alink -oPE -subsys con " db "alink -oPE -subsys con ", 0, 0
"alink -oPE -dll " db "alink -oPE -dll ", 0, 0
" win32.lib" db " win32.lib", 0, 0
" ---> " db " ---> ", 0, 0
"Inserisci Nasm Macro > " db "Inserisci Nasm Macro > " , 0, 0
" ; Risultato " db " ; Risultato ", 0, 0
"Errore nell'origine; " db "Errore nell'origine; ", 0, 0
"Errore di argomenti; " db "Errore di argomenti; ", 0, 0
"\nErrore di Free\n" db 13,10,"Errore di Free", 13,10, 0, 0
"<Premi\n>" db "<Premi\n>", 0, 0
"0123456789ABCDEF" db "0123456789ABCDEF", 0, 0, 0, 0
";;Ok Delta Time: " db ";;Ok Delta Time: ", 0,0
"Macro2D\n" db "Macro2D",13,10,0,0
"ZBW D Q T" db "ZBW D Q T", 0,0
/* Rosario Pulvirenti
/* Ilnomenonnelprogra
nome db 032h, 0bh, 04fh, 035h, 01dh, 012h, 0ch, 01fh, 08h, 04fh, 050h,
035h, 07h, 04ch
db 02h, 01bh, 013h, 01h, 01bh, 06h, 01bh, 045h, 012h, 05dh, 051h,
05bh, 0, 0
nome1 db "Programma per tradurre macro ", 0, 0
section _TEXT use32 public class=CODE
Malloc_sys:
a=[s+4]|a<>0|<?#.e| =#.1
VirtualAlloc(0, a, 03000h, PAGE_READWRITE)|a==0#.f
..1: clc|#.z
..e: a^=a
..f: stc
..z:
ret 4
Free_sys:
a=[s+4]|a==0#.1|VirtualFree(a, 0, MEM_RELEASE)|a#.1
..e: r=*stderr|r==-1#.0|SPuts(r, "\nErrore di Free\n" )
..0: a=1|stc|#.z
..1: a^=a /* pone CF==0
..z:
ret 4
/* 0ra, 4P_a, 8P_sizeinbytes
Zero:
a=[s+4]|c=[s+8]
a==0#.e|c>0?#.1
..e: stc|#.z
..1: r^=r|c&=0FFFFFFFCh|#.3
..2: D[a+r]=0|r+=4
..3: r<c#.2
c=[s+8]|c&=3| =#.5| c+=r
..4: B[a+r]=0|++r
r<c#.4
..5: clc
..z:
ret 8
/* eax, ebx, ecx, edx, esi, edi
/* esp, ebp
/* 0ra,4P_a
Isreg:
r=[s+4]|r#.1
..e: a^=a|stc| ##.z
..1: a^=a|c^=c
ax=*r|cx=[r+2]
ax&=05f5fh
r^=r |rl=ch| ch^=ch /* ah,al,ch,cl
B[MyTable+c]==Space#.1a
c==',',13,10,0#.1a /* prima 2chars
al!="E"#.e
cl&=05fh
B[MyTable+r]==Space#.2
rl==',',13,10,0#.2 /* 3 chars?
#.e
..1a: ##.5
..2: c=="X"!#.3|a=="EA"#.r4
|a=="EB"#.r4
|a=="EC"#.r4
|a=="ED"#.r4
|##.e
..r4: a=4 | ##.y
..3: c=="I"!#.4|a=="ES"#.r4
|a=="ED"#.r4
|##.e
..4: c=="P"!#.e|a=="ES"#.r4
|a=="EB"#.r4
|##.e
..5: c^=c|cl=al
c=="A"#.7 |c=="B"#.8
c=="C"#.9 |c=="D"#.a
c=="S"#.6 |##.e
..6: ##.b
..7: a=="AX"#.r2
a=="AL"#.r1
a=="AH"#.r1
##.e
..8: a=="BX"#.r2
a=="BL"#.r1
a=="BH"#.r1
a=="BP"#.r2
##.e
..r2: a=2 | ##.y
..r1: a=1 | ##.y
..9: a=="CX"#.r2
a=="CL"#.r1
a=="CH"#.r1
##.e
..a: a=="DX"#.r2
a=="DL"#.r1
a=="DH"#.r1
a=="DI"#.r2
##.e
..b: a=="SI"#.r2
a=="SP"#.r2
##.e
..y: clc
..z:
ret 4
/*0r, 4c,8b,12ra,16P_string, 20P_quanti
sposta:
<b,c,r
b=^16|r=^20|++b
a^=a|r<=0?#.z
#.1
..0: ++b
..1: al=[b+r]|[b]=al|a#.0
c=&[b+r]
..2: ++b
B[b]=0|b<c#.2
..z:
b,c,rret 8
/* 0r,4b,8ra, 12P_tav
/* NB: AtoI modifica solo cl
ConvertiNumeriTavola:
<b,r | b=[s+12]|c^=c|b#.1
..e: a=-1|stc|#.z
..1: cl=*b|c#.2|B[b+1]==0FFh#.9 /* 0,0FFh => finisce
..2: c=='õ'!#.3
a^=a|al=[b+1]|B[MyTable+a]#.3
++b|AtoI(b)|a==0#.e|a>255#.e
*b=al
r=0
a>9 !#.2a| ++r
..2a: a>99!#.2b| ++r
..2b: sposta(b,r)
/* cl=al|B[MyTable+c]==0#.e
/* ci sono problemi a
/* una eventuale doppia passata della funzione
..3: ++b|#.1
..9: clc
..z:
b,rret 4
/* 0b,4ra,8P_tav
/* NB: AtoI modifica solo cl
SostituisciSbarraCon13_10:
<b| b=[s+8]|c^=c|b#.1
..e: a=-1|stc|#.z
..1: cl=*b|c#.2|B[b+1]==0FFh#.9 /* 0,0FFh => finisce
..2: c=='|'!#.3 /* sostituise " |" con \r\n
B[b-1]!=' '#.3
B[b-1]=13|B*b=10
..3: ++b|#.1
..9: clc
..z:
bret 4
/* scrive tutta la stringa da origine a destinazione
/* senza usare nessuna macro
/* j=destinazione, i=origine
/* B1limit=B1limit+8=76 [2 funzioni chiamate]
CopyString:
<< B1Limit=76
a=b /* in b vi è il carattere al=" o '
c=[s+B1Limit]
B*j=' '|j>=c#.e|++j
*j=bl|j>=c#.e|++i,j
..1: bl=*i|*j=bl|B[MyTable+b]==EOI#.e /* errore
j>=c#.e|++i,j|b!=a#.1
B*j=' '|j>=c#.e|++j
a^=a|#.z
..e: a=-1|stc
..z:
retB1Limit
/* scrive tutta la stringa da origine a destinazione
/* senza usare nessuna macro, sostituendo gli spazi
/* e le lettere non alfanumeriche con I
/* r=destinazione, i=origine
/* c e' size attuale destinazione, b e' ultimo carattere
CopyPseudoString:
<k
<< B1Limit=80
k=b|a^=a|c=[s+B1Limit]
++i /* salta il " o '
B*j=' '|j>=c#.e|++j
B*j='I'|j>=c#.e|++j
..1: bl=*i|b==k#.4
al=[MyTable+b] |b==0,10,13#.e
b=='.'#.1a
a>2!#.2
..1a: |B*j='I'|#.3
..2: |*j=bl
..3: j>=c#.e|++i,j|#.1
..e: a=-1|stc|#.z
..4: ++i /* salta ultima "
B*j=' '|j>=c#.e|++j
a^=a
..z:
retB1Limitk
/* a*31=a*(32-1)=a*32-a
/* ritorna il valore di hash della stringa puntata da b
/* in ogni caso edx==eax alla fine della funzione
/* u32 Hash(u8* b)
/* 0i,4b,8ra,12P_s
Hash:
<b,i
b=[s+12]|a^=a|c^=c|r^=r|i=8|b#.2
..e: stc|#.z
..0: B*b==0#.3|++b|#.0
..1: ++b| --i!#.0 /* a*31=a*32-a
r=a|a<<=5|a+=c|a-=r
..2: cl=*b|c#.1
..3: r=[s+12]|c=HASHSIZE|b-=r|a<<=4 /* in b e' len
r^=r|a+=b|div c|a=r|c=b /* eax==edx
clc /* c=strlen(name)
..z:
b,iret 4
/* u32* Lookup(u8* name)
/* ritorna a=0 CF==1, hashtab posizi. nodo in edx
/* strlen(name) in ecx
/* se non troavato
/* -----------------------------------------
/* altrimenti l'indirizzo del nodo trovato in eax
/* l'indirizzo del precedente in edx
/* strlen(name) in ecx
/* 0k,4i,8j,12b,16ra,20P_name
Lookup:
<b,i,j,k
i=[s+20]|k^=k|D[hashtab]!#.e|i#.1
..e: a^=a|stc|#.z
..0: a=b |clc|#.z
..1: Hash(i)|k=c
c=[hashtab]|a=&[c+r*4]
b=[a]|r=a|b==0#.e /* non trovato
..2: j=[b+4] |j==0#.e /* senza stringa???
<r|DCmp()| >r |jnc .0 /* cmp(i:lenk, j:string)
..4: r=b|b=[r]|b#.2| #.e
..z: c=k
b,i,j,kret 4
/* FindMacro per stringhe
/* u8* FindMacro(u8* name)
/* ritorna c=a=0 CF=1 se errore di parametro
/* ----------------------------------------
/* ritorna a=name, c=strlen(name)
/* CF=1 se non trovato nel lookup
/* ----------------------------------------
/* ritorna a=def, c=strlen(def), CF=0
/* se e' trovato nel lookup
/* ----------------------------------------
/* 0ra,4P_name
FindMacro:
<< nx=0, nm=4, df=8, dfl=12
r=[s+4]|Lookup(r)|jc .0
c=[a+dfl]|a=[a+df]|clc|#.z
..0: a=[s+4]
..z:
ret 4nx, nm, df, dfl
/* la funzione chiamante se trova il commento esce
/* quindi scrive il commento direttamente nell'argomento
/* della funzione j
IsComment:
<< Result=52
First_ch1()| jc .e
c=j|c+=k
a^=a |b==';'#.2
b=='/'!#.0|B[i+1]!='*'#.0|#.1
..0: ##.5
..e: B*j=0|a=-1|stc|##.z /* errore
..f: B*j=0|D[s+Result]|=1|#.f1
..f0: B*j=0|D[s+Result]|=128
..f1: a= 1|clc|#.z /* trovata
..1: ++i
..2: ++i|D[s+Result]|=8|B*j=';'|++j
..3: al=*i|*j=al|j>=c#.e
++i,j|al==10#.f|al==0#.f0|#.3
..5: B*j=0|a^=a /* non trovata
..z:
retResult
/* la funzione chiamante se trova la label esce
/* quindi scrive la label direttamente nell'argomento
/* della funzione j
IsLabel:
<< LetterCount=48, Result=52
First_ch1()| jc .e
B[MyTable+b]<=3#.0| ##.7
..0: r=i|a^=a /* r punta al primo char di una parola
..1: ++r|al=*r|B[MyTable+a]<=3#.1
c=r|#.3
..2: ++c|al=*c
..3: B[MyTable+a]==Space#.2
a==':'#.3a|##.7 /* trovata label
..3a: r-=i
r+=5|r<k#.4
..e: a=-1|stc|##.z
..4: ^LetterCount=r
k=r|k-=5| <?#.e | b=c
DCopy()|j+=a
B*j=':'| ++j
B*j=' '| ++j /*| B*j=0
B*j=' '| ++j| B*j=0
i=b|b^=b|Next_ch1()|b==13!#.6
B*j=13|++j,i|B*j=0|bl=*i|b==10!#.4a
..5: B*j=10|++j,i|B*j=0|D[s+Result]|=1| #.6a
..6: b==10#.5
..4a: b==0!#.5a| D[s+Result]|=128|#.6a
..5a: D[s+Result]|=512 /* fine istruzione per label
..6a: D[s+Result]|=2|a=1
clc|#.z
..7: a^=a
..z:
retLetterCount, Result
/* combine cambia j
combine:
k=a | a^=a /* k=risultato macro
c=[s+2052]|j=[s+2056]|c+=j
..0: al=*k
a=='õ'!#.2 /* 1..64
++k|al=*k|a==0#.e|a>64#.e|++k
r=&[s+80]|r=[r+a*4]|r==0#.e
..1: al=*r|a==0#.0|*j=al |j>=c#.e
++r |j+=1 |jnc .1| #.e
..2: *j=al|j>=c#.e|a==0#.3
++k|j+=1|jnc .0
..e: a=1|B*j=0|stc|#.z
..3: clc
..z:
ret
/* i=origin
/* ritorna in b l'ultimo carattere
/* e in i la posizione del prossimo carattere
/* non usa altri registri che b ed i
/* quindi per uso informativo usare come in
Next_ch:
<< NowPC=44, PrecPC=56
++i
First_ch:
..1: bl=*i|B[MyTable+b]!=Space#.2
i+=1|jnc .1|#.z
..2: a=^NowPC|^PrecPC=a|^NowPC=i|clc
..z:
retNowPC, PrecPC
/* i=origin
/* ritorna in b l'ultimo carattere
/* e in i la posizione del prossimo carattere
/* non usa altri registri che b ed i
/* quindi per uso informativo usare come in
Next_ch1:
<< NowPC=48, PrecPC=60
++i
First_ch1:
..1: bl=*i|B[MyTable+b]!=Space#.2
i+=1|jnc .1|#.z
..2: a=^NowPC|^PrecPC=a|^NowPC=i|clc
..z:
retNowPC, PrecPC
/* il chiamante deve ++j quando trova che la parola è finita
ScriviParola:
<< B1Limit=72, B2Limit=68, DaiNumeroP=76, PointerArray=80
<< NowPC=44, PrecPC=56, InWord=60, InAsterisco=36
<< InParentesiTonde=64, InParentesiQ=40, AD=28
..0: b=='"'!#.4
..1: B[i+1]==bl#.2|B[i+2]==bl#.2|B[i+3]==bl#.2|B[i+4]==bl#.2|B[i+5]==bl#.2
a=^PrecPC|a==0#.0a|B*a==','!#.1a
..0a: D[s+InParentesiTonde]#.3
D[s+InAsterisco]#.3|D[s+InParentesiQ]#.3|#.2
..1a: B*a=='d'!#.3|B[a+1]!='b'#.3
r^=r|rl=[a+2]|B[MyTable+r]!=Space#.3 /* qui copia stringa
..2: r=j|CopyString()| jc .e|##.6
..3: r=j|CopyPseudoString()| jc .e| ##.6
..4: b==39#.1 /* e' simbolo '
/* qui r e' la prima lettera della stringa
/* o pseudo stringa scritta: serve per scrivere B2
b=='*'!#.4a| D[s+InParentesiQ]#.3a | D[s+InParentesiTonde]#.3a
D[s+InAsterisco]==1!#.3b
..3a: |r=j|B*j=bl|++i,j|##.6
..3b: ^InAsterisco=1|r=j
/* B*j=' '|j>=[s+B1Limit]#.e|++j
B*j='['|j>=[s+B1Limit]#.e|++i,j|##.6
..e: a=1|stc|##.z
..4a:
..4b: b=='^'!#.5
r=j|a=j|a+=12|j>=[s+B1Limit]#.e
^AD==1!#.4bb
D*j=" D[e"|j+=4|D*j="sp+ "|j+=4
++i| ##.6
..4bb: D*j=" dwo"|j+=4|D*j="rd[e"|j+=4
D*j="sp+ " |j+=4|++i| ##.6
..5: B[MyTable+b]>3!#.5a /* scrive *tutto* anche i punti in B1
/* solo le parole alfanumeriche possono
/* utilizzare FindMacroWord()
r=j
bl=='['!#.3c|a=^PrecPC|B*a=='B','W','D','Q','T'#.3c
B*j=' '|j>=[s+B1Limit]#.e|++j
B*j=' '|j>=[s+B1Limit]#.e|++j
..3c: *j=bl|j>=[s+B1Limit]#.e|++i,j|##.6
..5a: ^4=i
FindMacroWord(i)
/* r lunghezza della parola puntata da i
/* a risultato della stringa in entrata
/* c lunghezza del parametro precedente
/* uso b
i+=r /* i e' aggiornato, r e' libero
bl=*a|bl=='"', "'"#.4d
r=^PrecPC|r==^4#.5b /* sembra che r==^4 significa
B*r==','#.4d /* la prima parola trattata
..4c: B[MyTable+b]<=3!#.5b /* controlla due alfanumeriche
r==0#.5b|bl=*r
B[MyTable+b]<=3!#.5b
..4d: B*j=' '|r=j|j>=[s+B1Limit]#.e|++j
#.5c
..5b: r=j
..5c: b=&[j+c]|b>=[s+B1Limit]#.e
b^=b
<k,i,r| k=c|i=a|DCopy()|>k,i,r /* cambia solo c,a
j+=a /* aggiorna j
..6: D[s+InWord]!=0!#.8
..7: a^=a|##.z
/* Qui deve essere InWord==0
..ee: ##.e
..8: D[s+InWord]=1
B*k='õ'| k>=[s+B2Limit]#.ee /* 1..64 sono 64 vettori
++k|a=^DaiNumeroP|a==0#.ee|a>64#.ee
++^DaiNumeroP
*k=al|k>=[s+B2Limit]#.e|++k /* mette un puntatore a inizio parola
c=&[s+80]|c=&[c+a*4]|*c=r /* calcola da 76+4=80 poiche' l'indice
a^=a /* parte da 1
..z:
retInParentesiTonde, InParentesiQ, AD
NowPC, PrecPC, InWord
B1Limit, B2Limit, DaiNumeroP, PointerArray
/* u32 ToNasm(j:Destination, k:destinationSize, i:origin)
/* c==0 Nasm, c==1 RosAsm
/* in B*i vi e' il prossimo carattere da trattare
/* a==eax==risultato della funzione
/* se c!=0 nasm c==0 rosasm
/* a& 1!=0: raggiunta la fine della linea con \n
/* a& 2!=0: esiste la label
/* a& 4!=0 [<=>CF==1] riscontrato errore
/* a& 8!=0 commento
/* a& 16!=0 commento doppio
/* a& 32!=0 errore di parametro
/* a& 64!=0 errore di copia
/* a&128!=0 raggiunta la fine della istruzione con 0
/* a&256!=0 raggiunta la fine della istruzione con "|", ";"
/* a&512!=0 raggiunta la fine della istruzione per label
/*
/* j:Destination, k:destinationSize, vengono salvati nello stack
/* nella routine: i:origin, b:LastChar, j=B1attuale, K=B2attuale
/* in c vi e' la lunghezza della stringa scritta
/* a,r sono libere
/* 0, 4, 8, 12, 16, 20, 24, 28, 32, 36 variabili libere
/* 40, 44, 48, 52, 56, 60, 64, 68, 72, 76
/* 80, 84, ...,336 [64 puntatori]
/* 340 ... 1364 [1024 Buffer1]
/* 1368 ... 2040 [672 Buffer2]
/* label: istruzione ; commento
ToNasm:
<j,k
s-=2048 /* *s viene usato localmente ovunque anche in ScriviParola
<< PointerArray=76, DaiNumeroP=72, B1Limit=68, B2Limit=64
<< InParentesiTonde=60, InWord=56, PrecPC=52, Result=48
<< LetterCount=44, NowPC=40, InParentesiQ=36, InAsterisco=32
<< ParentesiTuttoFare=28, AD=24, NewLine=20
^Result=0 | ^LetterCount=0 |^NowPC=0
^PrecPC=0 |^AD=c | ^NewLine=0 |b^=b
IsComment()| jc .ee0|a==1#.f /* spostano j
IsLabel() | jc .ee0|a==1#.f /* il chiamante sa che e' tutta una linea
/* quindi non esiste il bisogno di
continuare
j=&[s+340]|k=&[s+1368]|a=&[j+1024]|r=&[k+672]
^B1Limit=a|^B2Limit=r |^InWord=0| ^DaiNumeroP=1
^InParentesiTonde=0 |^InParentesiQ=0
^InAsterisco=0 | ^ParentesiTuttoFare=0| #.2
..ee0: c^=c
..e: a=^Result|a|=4|stc|##.z /* non sposta j errore di buffer interno
..ej: c=j|c-=[s+2052]|#.e /* sposta j
..f: c=j|c-=[s+2052] /* sposta j
a=^Result|clc|##.z
..1: Next_ch()| jc .ej /* aggorna "i" e "b"
..2: b==';'#.1a| ##.4
..1a: D[s+Result]|=256| B*i!='|'#.2a /* incontrari ; oppure |
..3: ++i
..2a: D[s+InAsterisco]==0#.3a|B*j=']'|j>=[s+B1Limit]#.ej|++j
..3a: D[s+InParentesiTonde]#.ej
D[s+InParentesiQ ]#.ej
B*j=0|B*k=0 /* i vecchi j e k
r=&[s+1368]|FindMacro(r)|combine()|jc .ej /* sposta j
/* i nuovi j e k
/* k j
c=[s+2048]|r=[s+2052]|c+=r
^NewLine!#.3ab
..3aa: B*j=13|j>=c#.ej|++j
B*j=10|j>=c#.ej|++j|B*j=0
--^NewLine#.3aa
..3ab: ^Result&1#.3b
B*i!=';'!#.4b /* sposta j
B*i=='/'#.4b
^AD==2!#.3b /* aggiunto RosAsm
B*j=' '|j>=c#.ej|++j
B*j='|'|j>=c#.ej|++j /* per \n
#.4c
..3b: |a=j|a+=2|a>=c#.ej
|B*j=13|++j|B*j=10|++j|B*j=0| #.4c
..4b: |B*j=' '|j>=c#.ej|++j
..4c: c=j|c-=r| <?#.ej /* c= i caratteri scritti
##.f
..4: b==10 !#.5| D[s+Result]|=1 | ##.3
..5: b==13 !#.6| B[i+1]!=10#.6
++i|bl=*i|#.4
..ee: ##.ej /* "a|=b" "|=#.9"
..6: b==0!#.5a | D[s+Result]|=128 | ##.2a
..5a: b=='|'!#.7| D[s+InParentesiTonde]#.7
B[i+1]=='='#.6a
..5b: ++^AD|##.1a
..6a: B[i+2]=='#'#.5b
..7: b=='/'!#.6b
B[i+1]=='*'!#.6b| ##.2a
..6b: b=='\'!#.4n|B[i+1]==10,13#.4d|#.4n
..4d: B[i]=' '| ++^NewLine
B[i+1]==13!#.4e|B[i+1]=' '|#.4f
..4e: B[i+1]==10!#.4f|B[i+1]=' '
..4f: B[i+2]==13!#.4g|B[i+2]=' '|#.4h
..4g: B[i+2]==10!#.4h|B[i+2]=' '
..4h: LevaSpaziDa_i()| b=a
##.2
..4n: B[MyTable+b]==Punti#.7a| ##.m
..7a: b==','!#.7c
B[i+1]==10!#.7b|B[i+1]=' ' | ++^NewLine
..6c: ##.i /* NB qui cambia il vettore di "i"
..7b: B[i+1]==13!#.6c|B[i+2]!=10#.6c| ++^NewLine
B[i+1]=' '| B[i+2]=' '
..7c: D[s+InParentesiTonde]!=0!#.b1
b==','!#.a|##.i /* tratta virgola come punto
..a: b==')'!#.b| ^InParentesiTonde=0
D[s+ParentesiTuttoFare]==0#.a1
^ParentesiTuttoFare=0
..a0: *j=bl|j>=[s+B1Limit]#.ee|++j
^InWord=0|B*j=0|j>=[s+B1Limit]#.ee|++j|##.1
..a1: ##.i /* idem ')'
..b: ##.o /* ma il resto e' parola
..b1: D[s+InParentesiQ]#.b
D[s+InAsterisco]!=0!#.c|
b=='*'#.b2|b=='+'#.b2|b=='-'#.b2|#.b3
..b2: B[i+1]!='='#.c1
..b3: B*j=']'|j>=[s+B1Limit]#.ee|++j
^InAsterisco=0|##.i
..c: b=='('!#.c0| ++^InParentesiTonde
a=^PrecPC|a==0#.b4|B*a=='<'#.b4
B*a==']'#.b4
B*a=='('#.b4
r^=r|rl=*a |B[MyTable+r]<=3#.b4
^ParentesiTuttoFare=1|##.o
..c0: b=='*'!#.c2
..c1: ##.o
..b4: ##.i
..c2: b=='-'!#.d
..c3: /* B[i+1]=='='#.i
a^=a|al=[i+1]|B[MyTable+a]#.b4
al=[i-1]|B[MyTable+a]!=Space#.c1
B*j=' '|j>=[s+B1Limit]#.e0|++j
B*j= 0 |##.o
..d: b=='+'#.c3
b=='^'!#.i|B[i+1]=='='#.i
| ^InAsterisco=1| ##.o
..i: D[s+InWord]!=0!#.l /* finiesce la parola precedente
..i0: ^InWord=0
B*j=0 |j>=[s+B1Limit]#.e0|++j
..l: *k=bl|k>=[s+B2Limit]#.e0|++k| ##.1
..e0: ##.ej
..m: /* gli altri casi non punti
b=='['!#.n| ++^InParentesiQ| #.o
..n: b==']'!#.o| --^InParentesiQ|##.a0
..o: ScriviParola()| jc .e0| First_ch()| ##.2
..z:
s=&[s+2048]ParentesiTuttoFare, AD, NewLine
LetterCount, NowPC, InParentesiQ, InAsterisco InParentesiTonde, InWord,
PrecPC, Result
PointerArray, DaiNumeroP, B1Limit, B2Limit
j,kret
/* CopyUntil10Or0_jki(j,k,i)
/* Copia la stringa di i, in j di size k
/* se errore ritorna 0 altrimenti ritorna
/* 1 se incontra \n
/* 128 se incontra \0
CopyUntil10Or0_jki:
a^=a|k#.1
..e: B*j=0|a^=a|stc|#.z
..0: ++i,j
..1: al=*i|*j=al
..2: --k!#.e|a==0#.3|a!=10#.0
++i,j|--k!#.e|B*j=0
a=1|#.4 /* trovato \n
..3: a=128 /* trovato \0
..4: clc
..z:
ret
/* VaiUntil10Or0_i()
/* Copia la stringa di i, in j di size k
VaiUntil10Or0_i:
a^=a|#.1
..0: ++i
..1: al=*i
..2: a==0#.3|a!=10#.0
++i
a=1|#.z
..3: a=128
..z:
ret
/* u32 LineToNasm(u8* dest, u32 dsize, u8* origin, u32 commento)
/* come risultato ecx, caratteri scritti in j
/* edx, caratteri di avanzamento di i
/* a==eax==risultato della funzione
/* a& 1!=0 raggiunta la fine della istruzione con \n
/* a& 2==0 nessuna label nell'istruzione
/* a& 2!=0 esiste la label
/* a& 4==0 [<=>CF==0] nessun errore trovato
/* a& 4!=0 [<=>CF==1] riscontrato errore
/* a& 8!=0 commento semplice
/* a& 16!=0 commento doppio
/* a& 32!=0 errore di parametro
/* a& 64!=0 errore di copia
/* a&128!=0 raggiunta la fine della istruzione con 0
/* a&256!=0 raggiunta la fine della istruzione con "|", ";"
/* a&512!=0 raggiunta la fine della istruzione per label
/* 0k,4j,8i,12b,16ra,20P_d,24P_dsize,28P_or,32P_comm
/* j:Destination, k:destinationSize, i:origin, b:LastChar
/* section, SECTION, %define, %undef: copia tutta la linea e esce
/* usare come
/* a=1; W(1){c=fgets(o,osize,fp)
/* a=LineToNasm(d, ds, o, a);
/* fputs(fp,d);
/* if(c==EOF) break;
/* }
LineToNasm:
<b,i,j,k
j=[s+20]|k=[s+24]|i=[s+28]
b^=b|j!#.e1|k<=0?#.e1|B*j=0|a^=a|i#.1
..e1: a|=32
..e: a|=4|i-=[s+28]|j-=[s+20]|r=i|c=j
D[s+32]&16!#.eee|a|=16
..eee: stc| ##.z
..e2: a|=64| #.e
..f0: i-=[s+28]|j-=[s+20]|r=i|c=j
..f: clc | ##.z
..f2: a|=b | #.f0 /* a=2 linea con ";" a=3 ";;"
..0: ++i
..1: bl=*i|B[MyTable+b]==Space#.0
b==10!#.1b
..1a: CopyUntil10Or0_jki()|jc .e2
b=[s+32]|b&=0FFFFFC10h|a|=b
#.f0
..1b: b==13!#.1c|B[i+1]==10#.1a
..1c: B[MyTable+b]==5#.f0
b==';'!#.4| b=8
B[i+1]==';'!#.3a
/* caso ";;" trovato anche prima: D[s+32]&16!=0
..1c0: D[s+32]&16#.1d| b=16|#.2a
..1d: | b=8 |#.2a
..2: b=16
..3: B*i!=';'!#.2a
B*j=';'|--k!#.e2|++j
B*j=' '|--k!#.e2|++j
..2a: CopyUntil10Or0_jki()|jc .e2| ##.f2
/* caso ";" ora e ";;" prima oppure no
..3a: B[i+1]=='*'#.1c0
b=16|D[s+32]&16#.3|b=8|#.3
..4: D[s+32]&16#.2
..5: a=[i] |r=[i+4]
/* b e' il primo carattere effettivo
b=='s'!#.7|a!="sect"#.a|r!="ion "#.a /* viene vista come commento
..6: b=8 | CopyUntil10Or0_jki()| jc .e2| ##.f2
..7: b=='S'!#.8 |a!="SECT"#.a|r=="ION "#.6
..8: b=='%' #.6
/* j destination, i origin, b last char,
..a: c=0|ToNasm()|j+=c|k-=c|<=?#.e
a&4#.b|a&128#.a0|a&1#.a0|a&2#.a0|c#.a
/* B*i#.a
..a0: i-=[s+28]|j-=[s+20]|r=i|c=j|##.f
..b: i-=[s+28]|j-=[s+20]|r=i|c=j|##.eee
..z:
b,i,j,kret 16
/* DCmp(j,i,k)
/* compara i di len k, con j terminato da 0
/* Se 0 CF==0 allora la stringa i con
/* l'array di lunghezza fissa j sono uguali
/* altrimenti sono diversi
DCmp:
c=k|r^=r|c&=0FFFFFFFCh| =#.3 | #.1
..n: a=-1|stc|#.z
..1: a =[j+r]|a!=[i+r]#.n|r+=4
..2: r<c#.1
..3: c=k|c&=3| =#.5|c+=r
..4: al=[j+r]|al!=[i+r]#.n|++r|r<c#.4
..5: a^=a|al=*j+r|B[MyTableR+a]==0#.n
a^=a
..z:
ret
/* DCmp_old(j,i,k)
/* compara i di len k, con j terminato da 0
/* Se 0 CF==0 allora la stringa i con
/* l'array di lunghezza fissa j sono uguali
/* altrimenti sono diversi
DCmp_old:
c=k|r^=r|c&=0FFFFFFFCh| =#.3 | #.1
..n: a=-1|stc|#.z
..1: a =[j+r]|a!=[i+r]#.n|r+=4
..2: r<c#.1
..3: c=k|c&=3| =#.5|c+=r
..4: al=[j+r]|al!=[i+r]#.n|++r|r<c#.4
..5: /* B[j+r]!=0#.n
a^=a
..z:
ret
/* DCopy(j,i,k)
/* Copia la stringa di i di lunghezza [len] k, in j
/* ritorna la lunghezza della stringa
/* modifica c,a,r
DCopy:
c=k|a^=a|c&=0FFFFFFFCh| =#.3
..1: r=[i+a]|[j+a]=r|a+=4
..2: a<c#.1
..3: c=k|c&=3| =#.5|c+=a
..4: rl=[i+a]|[j+a]=rl|++a|a<c#.4
..5: B[j+a]=0 /* non necessario?
clc
..z:
ret
/* find macro per parole alfanumeriche
/* all'interno a stringhe
/* u8* FindMacroWord(u8* name)
/* ritorna c=a=0 CF=1 se errore di parametro
/* ----------------------------------------
/* ritorna a=name, c=lenUntilNotLetter(name)
/* CF=1 se non trovato nel lookup
/* r=strlen(name)
/* ----------------------------------------
/* ritorna a=def, c=strlen(def), CF=0
/* se e' trovato nel lookup
/* r=strlen(name)
/* ----------------------------------------
/* 0k,4j,8i,12b,16ra,20P_name
FindMacroWord:
<b,i,j,k
<< nx=0, nm=4, df=8, dfl=12
i=[s+20]|D[hashtab]!#.e0|i#.1
..e0: a^=a|c^=c
..e: stc|#.z
..e1: a=i|c=k|r=k|#.e
..0: a=[b+df]|c=[b+dfl]|r=k|clc|#.z
..1: HashWord(i)|k=c /* in k la lunghezza di i
c=[hashtab]|a=&[c+r*4]
b=[a] |b==0#.e1 /* non trovato
..2: j=[b+4] |j==0#.e1 /* senza stringa???
DCmp() |jnc .0 /* cmp(i:lenk, j:string)
..4: r=b|b=[r]|b#.2| #.e1
..z:
ret 4nx, nm, df, dflb,i,j,k
/* a*31=a*(32-1)=a*32-a
/* ritorna il valore di hash della parola alfanumerica
/* puntata da b. in ogni caso edx==eax alla fine della funzione
/* e in ecx vi e' la lunghezza della parola alfanumerica "name"
/* u32 HashWord(u8* name)
/* 0i,4b,8ra,12P_s
HashWord:
<b,i
b=[s+12]|a^=a|c^=c|r^=r|i=8|b#.2
..e: stc|#.z
..0: cl=*b|B[MyTable+c]>3#.3|++b|#.0
..1: ++b| --i!#.0 /* a*31=a*32-a
r=a|a<<=5|a+=c|a-=r
..2: cl=*b|B[MyTable+c]<=3#.1
..3: r=[s+12]|c=HASHSIZE|b-=r|a<<=4 /* in b e' len
r^=r|a+=b|div c|a=r|c=b /* eax==edx==valore di hash
clc /* c=strlen(name)
/* notare che in "< ss" la lunghezza tornata
..z: /* è zero infatti "<" non è alfanumerico
b,iret 4
/* 0i,4ra,8P_a
AtoI:
<i| r=[s+8]|a^=a|c^=c| r==0#.e
cl=*r |B[MyTable+c]==0#.2
..e: a=-1|stc|#.z /* 10a=(4a+a)*2
..1: ++r|cl=*r|B[MyTable+c]#.3
a&0C0000000h#.e|i=a
a<<=2|a+=i|jc .e|a+=a|jc .e
..2: c-='0'|a+=c|jnc .1| #.e
..3: clc
..z:
iret 4
/* u32 Undef(u8* name)
/* 0i,4b,8ra,12P_name
Undef:
<b,i
<< nx=0
b=[s+12]|b#.1
..e: a=1|#.z /* in r precedente [compreso puntatore di hash]
..1: Lookup(b) /* in a attuale
a==0#.e
c=[a+nx]|[r+nx]=c
FreeNodo(a)|jc .e
/* qui a==0 ed CF==0
..z:
ret 4nxb,i
/* input in eax vi sta l'indice
/* risultato in eax: posizione dell'indice
/* a*16
/* 0 1 2
/* |0,0,0,0|0,0,0,0|0,0,0,0|
/* u32* AllocNodo()
AllocNodo:
<b
c=*TheNext|b=[NodeMem]
c>=512#.e |b#.1
..e: a^=a|stc | #.z
..0: a=b | #.3
..1: c<<=4|r=8192|a=&[b+c]
c=&[b+r]|r=a /* r=a=*TheNext
..2: D[a+4]==0#.4 /* c=NodeMem+512*4*4=
a+=16|a==c#.0 /* =NodeMem+8192 Nodo limite
..3: a!=r#.2|#.e
..4: c=a|D[a+4]=1
a-=b
a>>=4|++a|a==512!#.5|a=0
..5: [TheNext]=a|a=c|clc
..z:
bret
/* u32 FreeNodo(u32* node)
/* 0,12,24,36
/* 0i,4b,8ra,12P_node
FreeNodo:
<b,i
<< nx=0, nm=4, df=8, dfl=12
b=[s+12]|b#.1
..e: a=1|stc |#.z
..1: r=[NodeMem] |b<r#.e
i=r|a=512 |a<<=4 /* k*16
i+=a |b>=i#.e
a=b| a-=r |a&0Fh#.e /* non allineato
D[b+nx]=0|D[b+nm]=0|D[b+df]=0|D[b+dfl]=0
a>>=4
[TheNext]=a
a^=a
..z:
ret 4nx, nm, df, dflb,i
/* Struttura della tavola di Hash
/* hashtable
/* 0
/* p-->|nx--->|nx=0
/* 0 |nm |nm <---nodes
/* 0 |df |df
/* 0 |dfl |dfl
/* 0
/* p-->|nx=0
/* 0 |nm
/* 0 |df
/* 0 |dfl
FreeMem:
<i,j
i=[NodeMem] |j=[hashtab]
Free_sys(i) |Free_sys(j)
D[NodeMem]=0|D[hashtab]=0
D[TheNext]=0
i=*StringPointers
i!=0!#.9|D*PointerSize<=0?#.9
j^=j
..1: a=[i+j*4]
Free_sys(a)
++j|j<*PointerSize#.1
..9: Free_sys(i)
D*PointerSize =0
D*TheNextPointer=0
D*StringPointers=0
D[MacroDefinizioniGeneraliLed]=0
D[NasmDefLed] =0
D[RosAsmDefLed]=0
i,jret
/* InstalMacro(u8* Def, u8* Sost, u32 delimtatore)
/* il delimitatore vale solo per trovare sost
/* il delimitatore per def e' lo spazio: la prima
/* parola e' presa
/* InstalMacro(b,i,0)|jc .e
/* il delimitatore e' 0 => prende sost fino a \0
/* InstalMacro(b,i,1)|jc .e
/* il delimitatore e' 1 => prende sost fino allo spazio successivo
/* 0k,4j,8i,12b,16ra,20P_Def,24P_Sost, 28P_delim +64
/* 84 88 92
InstalMacro:
<b,i,j,k
s-=64
a=*TheNextPointer|k=*StringPointers
c=a| k==0#.e
a<*PointerSize?#.3
..e: a^=a|stc|##.z
..0: ++a
a==*PointerSize!#.1|a^=a
..1: c==a#.e
..3: r=[k+a*4]|r#.0
j=a
i=^84|WordLen_i()|c<=0?#.e
b=c|i=^88
^92#.3a| LenStr_i()|c<=0?#.e|#.3b
..3a: |WordLen_i()|c<=0?#.e
..3b: b+=c|<=?#.e|b+=8|<=?#.e
Malloc_sys(b)|a==0#.e
[k+j*4]=a /* conserva il vettore nell'int_array
++j /* StringPointers
j>=*PointerSize!#.4|j^=j
..4: *TheNextPointer=j
k=b| k-=2| *s=a
j=a|i=^84|PrendiWord_jki()|jc .e
++j|--k|<=?#.e|^4=j|i=^88
^92#.5|CopyLine_jki()|jc .e|#.6
..5: |PrendiWord_jki()|jc .e
..6: a=*s|r=^4|Install(a,r)|jc .e
..z:
s=&[s+64]
b,i,j,kret 12
/* input export one, two, none
/* 0i,4r,8c,12b,16ra,20P_Str
PushExport:
<b,c,r,i
i=^20|a^=a|i#.1
..e: stc| ##.z
..0: clc| ##.z
..1: a=*i |a!="expo"#.e
r=*i+4|r&=000FFFFFFh
r!="rt "#.e
..2: FindNextWord_i()|a==0,10,13#.e
InstalMacro(i, i, 1)|jc .e
FindNextWord_i()|a==0,10,13#.0
a==','#.2|#.e
..z:
b,c,r,iret 4
/* input %define one two
/* input << a=b, c=d
/* 0i,4b,8ra,12P_Str + 1024
PushMacro:
<b,i
s-=1024
i=[s+1036]|a^=a|i#.1
..e: stc| ##.z
..1: al=B*i
a=='%'!#.2
a=*i|r=[i+4]
a!="%def"#.e| r!="ine "#.e
FindNextWordTraSPazi_i()|a==0#.e
b=i
FindNextWordTraSPazi_i()|a==0#.e
InstalMacro(b,i,0)|jc .e
..1a: ##.9
..2: a=*i|a&=00000FFFFh
a=="<<"!#.e
#.4
..3: FindNextWord_i()|a==0#.1a /* parola
a!=','#.e
..4: FindNextWord_i()|a ==0 #.e /* parola
al=B*i|B[MyTableR+a]!=0#.e
b=i
FindNextWord_i()|a!='='#.e /* =
FindNextWord_i()|a ==0 #.e /* parola
al=B*i|B[MyTableR+a]!=0#.e
a^= a|r=b|c=&[s+8]|D*s=c|D*s+=1000|#.5a
..5: ++r,c|c>=*s#.e
..5a: al=*r|*c=al|a==0#.6
B[MyTableR+a]==0#.5
B*c=0
..6: ++c|b=c|#.7a /* "b" e' il secondo s+8 e'primo
..7: ++i,c|c>=*s#.e
..7a: al=*i|*c=al|a==0#.8
B[MyTableR+a]==0#.7
B*c=0| --i /* punta un carattere prima la virgola
..8: a=&[s+8]
InstalMacro(a, b, 1)|jc .e
##.3
..9: clc
..z:
s=&[s+1024]
b,iret 4
/* 0j,4ra,8P_Str
FreeIfFindAddressInString:
<j |a^=a
j=*StringPointers
c=^8|j==0#.e
D*PointerSize>0?#.3
..e: a^=a|stc|#.z
..0: ++a|a==*PointerSize#.e
..3: r=[j+a*4]
r!=c#.0
< a|Free_sys(r)|> a
jc .e
D[j+a*4]=0
*TheNextPointer=a
..z:
jret 4
/* 0i,4b,8ra,12P_Str + 1024
/* 1036
UndefMacro:
<b,i
s-=1024
<< nx=0, nm=4, df=8
b=[s+1036]|b#.1
..e: a=1|stc|#.z /* in r precedente [compreso puntatore di hash]
..1: r=s|c=1020|c+=r|a^=a
..2: al=*b|B[MyTableR+a]#.3|a==0#.3|*r=al
++r,b|r>=c#.e|#.2
..3: B*r=0
a=s|Lookup(a) /* in a attuale
a==0#.e
c=[a+nx]|[r+nx]=c
b=[a+nm]
FreeNodo(a)|jc .e
/* qui a==0 ed CF==0
FreeIfFindAddressInString(b)|jc .e
..z:
s=&[s+1024]
ret 4nx, nm, dfb,i
/* input %undef one
/* input >> a,b, c, d
/* 0i,4b,8ra,12P_Str
PopMacro:
<b,i
i=[s+12]|a^=a|i#.1
..e: stc| ##.z
..1: al=B*i
a=='%'!#.2
a=*i|r=[i+4]| r&=000FFFFFFh
a!="%und"#.e| r!="ef "#.e
++i
FindNextWordTraSPazi_i()|a==0#.e
UndefMacro(i)|#.z
..2: a=*i|a&=00000FFFFh
a==">>"!#.e
..3: FindNextWord_i()|a==0#.e
..4: al=B*i|B[MyTableR+a]!=0#.e
UndefMacro(i)|jc .e
FindNextWord_i()|a==0#.5
a!=','#.e
#.3
..5: clc
..z:
b,iret 4
/* u32 Install(u8* name, u8* defn)
/* name e defn devono essere stringhe
/* che vengono deallocate alla fine del programma
/* se ritorna 0 [<=>CF==1] errore
/* altrimenti ok ed in eax vi e'
/* l'indirizzo del nodo istallato
/* 0j,4i,8ra,12P_name,16P_defn
Install:
<i,j
<< nx=0, nm=4, df=8, dfl=12
i=[s+12]|j=[s+16]|i==0#.e|j#.1|#.e
..0: FreeMem()
..e: a^=a|stc|##.z
..1: D[hashtab]#.a
/* HASHSIZE=4019
/* (4019+1)*4= 16080
Malloc_sys(16080)|a==0#.0
[hashtab]=a | Zero(a, 16080)
..a: D*StringPointers#.b
/* 2048 * 4 = 8192
Malloc_sys(8192)|a==0#.0
[StringPointers]=a|D[TheNextPointer]=0
D*PointerSize =2048
Zero(a, 8192)
..b: D[NodeMem]#.i
/* 512 * 4 * 4 = 8192
/* Serbatoio di 512 nodi di 4 u32
Malloc_sys(8192)|a==0#.0
[NodeMem]=a|D[TheNext]=0
Zero(a, 8192)
..i: Lookup(i)|jc .5
/* point to next:nx puntatore
/* name:nm nome
/* defn:df definizione
/* defnlen:dfl lenDefinizione
/* << nx=0, nm=4, df=8, dfl=12
/* u32* Lookup(u8* name)
/* ritorna a=0 CF==1, hashtab posizi. nodo in edx
/* strlen(name) in ecx
/* se non troavato
/* -----------------------------------------
/* altrimenti l'indirizzo del nodo trovato in eax
/* l'indirizzo del precedente in edx
/* strlen(name) in ecx
/* Nodo trovato
a==0#.e /* se Lookup ok => a==c
..2: [a+df]=j|#.4 /* Caso: Nodo Esistente
..3: ++j /* => sovrascrivi
..4: B*j#.3
j-=[a+df]|[a+dfl]=j|clc|#.z
..5: <r|AllocNodo()|>r /* r indirizzo di Hash
jc .e|c=[r]|[a+nm]=i|[a+nx]=c|[r]=a
#.2 /* a indirizzo nodo
..z:
ret 8nx, nm, df, dfli,j
/* 0i,4b,8ra,12P_w
Installl:
<b,i
b=[s+12]|i=b|#.2
..1: ++i
..2: B*i#.1
..1a: ++i
..1b: B*i==0#.1a
Install(b,i)|jnc .4
..e: a=-1|stc|#.z
..3: ++i
..4: B*i#.3
..4a: ++i
..4b: B*i==0#.4a
b=i|B*i!=0FFh#.2
a^=a|clc
..z:
b,iret 4
InstallGenerali:
clc
D[MacroDefinizioniGeneraliLed]#.z
ConvertiNumeriTavola(MacroDefinizioniGenerali)| jc .z
Installl(MacroDefinizioniGenerali) | jc .z
D[MacroDefinizioniGeneraliLed]=1
..z:
ret
InstallNasm:
clc
D[MacroDefinizioniGeneraliLed]#.0
SostituisciSbarraCon13_10(MacroDefinizioniGenerali)| jc .z
ConvertiNumeriTavola(MacroDefinizioniGenerali)| jc .z
Installl(MacroDefinizioniGenerali)| jc .z
D[MacroDefinizioniGeneraliLed]=1
..0: D[NasmDefLed]#.z
SostituisciSbarraCon13_10(NasmDef)| jc .z
ConvertiNumeriTavola(NasmDef)| jc .z
Installl(NasmDef) | jc .z
D[NasmDefLed]=1
..z:
ret
InstallRos:
clc
D[MacroDefinizioniGeneraliLed]#.0
ConvertiNumeriTavola(MacroDefinizioniGenerali)| jc .z
Installl(MacroDefinizioniGenerali) | jc .z
D[MacroDefinizioniGeneraliLed]=1
..0: D[RosAsmDefLed]#.z
ConvertiNumeriTavola(RosAsmDef)| jc .z
Installl(RosAsmDef) | jc .z
D[RosAsmDefLed]=1
..z:
ret
FreeTab:
<i,j,k
<< nx=0
i=[hashtab]|a=HASHSIZE|i==0#.z
k=&[i+a*4]
..1: r=[i]|r==0#.3
..2: j=[r+nx]|FreeNodo(r)|r=j|j#.2
..3: i+=4 |i<k#.1
D[MacroDefinizioniGeneraliLed]=0
D[NasmDefLed] =0
D[RosAsmDefLed]=0
..z:
retnxi,j,k
/* parametri i la stringa da leggere
/* j la stringa da scrivere
/* c la size di j
/*
/* il primo carattere puntato da i
/* deve essere " oppure '
/* in j scrive in i legge
/* il numero di carattere di j e' c
/* aggiorna sia i sia j, il numero di
/* caratteri avanzati si trova in a
/* modifica a,r i,j
PrendiNomeTraVirgoletteDa_i:
<c |a^=a|r^=r|c<>0|rl=*i|<?#.e
r=='"'#.1|r=="'"#.1|#.e
..ee: a=*s|a-=c|B*j=0
..e: stc|#.z
..0: ++i,j| --c!#.ee
..1: al=*i|*j=al| a==0#.3|a!=r#.0
++i,j| --c | a=*s| a-=c
..3: B*j=0| clc
..z:
cret
/* parametri i la stringa da leggere
/* j la stringa da scrivere
/* c la size di j
/*
/* il primo carattere puntato da i
/* deve essere un non spazio
/* il loop finisce se trova uno spazio
/* oppure la stringa in i finisce.
/* in j scrive in i legge
/* il numero di carattere letti in i
/* scritti in j e' eax
/* aggiorna sia i sia j, il numero di
/* caratteri avanzati si trova in a
/* modifica a,i,j
PrendiNomeTraSpaziDa_i:
<c |a^=a|c<0?#.e|#.1
..ee: a=*s|a-=c|B*j=0
..e: stc|#.z
..0: ++i,j| --c!#.ee
..1: al=*i|*j=al| a==0#.3|B[MyTable+a]!=Space#.0
..3: B*j=0
..z:
cret
/* In i vi e' il nome
/* In j vi e' dove lo si vuole scrivere
/* In c vi e' la dimensione di j
/* modifica a,r,c i,j
PrendiNomeDa_i:
LevaSpaziDa_i()
al=*i
a=='"'!#.1
..0: PrendiNomeTraVirgoletteDa_i()|#.2
..1: a=="'"#.0
PrendiNomeTraSpaziDa_i()
..2:
ret
/* a=1File, r=2File
/*
MacroNasm:
<b,i,j,k /* 400 FileLine=656..1680 size=1024
s-=2048 /* b1=128..384, b2=392..648 size=256
<< InpHandle=16, OutHandle=20, MemFile=24
<< InpFName=128, OutFName=392, FileLine=656
<< FileSize=28, MemLimit=44
i=a|b=r
InstallNasm()| jc .e
j=&[s+InpFName]|c=256
PrendiNomeDa_i()| jc .e1
i=b|j=&[s+OutFName]|c=256
PrendiNomeDa_i()| jnc .1
..e1: a=1|
..e: FreeMem()|stc| ##.z
..e2: a=2| #.e /* errore di file input
..e5: r=[s+OutHandle]|FlushCloseHandle(r)
..e4: a=[s+MemFile] |Free_sys(a)
..e3: r=[s+InpHandle]|CloseHandle(r)
a=b| #.e /* errore di file output
..1: /* Apri file di input
r=&[s+InpFName]
[s+InpHandle]=CreateFileA(r, GENERIC_READ,
0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,0)
b=3|a==INVALID_HANDLE_VALUE#.e2
b=4
r=s|GetFileSize(a, r)|a==-1#.e3|D*s#.e3
b=5|^FileSize=a| a+=64
Malloc_sys(a)|a==0#.e3|[s+MemFile]=a
r=^FileSize| ^MemLimit=a| ^MemLimit+=r
r+=32| D[a+r]=0 /* per essere sicuri che termini
r=&[s+OutFName]| b=6 /* line to nasm
[s+OutHandle]=CreateFileA(r, GENERIC_WRITE,
0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0)
a==INVALID_HANDLE_VALUE#.e4
r=^InpHandle|c=^FileSize|c+=32|i=^MemFile|a=s|b=7
ReadFile(r, i, c, a, 0)|a==0#.e5
c=*s| [s+FileSize]!=c#.e5
b=8
/* in i vi e' tutto il file di lunghezza c
r=[s+InpHandle]|CloseHandle(r)|a==0#.e5
k^=k| b=9|j=&[s+656]
..2: k=LineToNasm(j, 1024, i, k)| r==0#.9
/* ^Result=a|^Chars_i=r|^Chars_j=c
i+=r|jc .e5|i>[s+MemLimit]#.e5
r=^OutHandle|a=s
WriteFile(r, j, c, a, 0)|a==0#.e5
i<[s+MemLimit]#.2
..9: b=10
r=[s+OutHandle]|FlushCloseHandle(r)|jc .e4
r=[s+MemFile] |Free_sys(r)
FreeMem()
..z:
s=&[s+2048]FileSize, MemLimit
InpFName, OutFName, FileLine
InpHandle, OutHandle, MemFile
b,i,j,kret
/* AssegnaVettori(u32* vettori, u32 NParole, u8* str)
/* assume che vettori sia abbastanza per Nparole+1
/* nel vettore finale si scrive dove e' arrivato i
/* 28P_str, 24P_Nvettori, 20P_vettori,16Ra,b12,c8,r4,i0
AssegnaVettori:
<b,c,r,i
c=^24|i=^28|r=^20|c<<=2
a^=a|b^=b|c+=r|#.3
..2: ++i
..3: al=*i
..4: B[MyTable+a]==Space#.2
a==0#.8
++b
*r=i|r+=4|r==c#.8
..5: ++i
..6: al=*i
..7: B[MyTableR+a]==0#.5
a=='"',"'"#.5
a#.4
..8: *r=i
..z: a =b
b,c,r,iret 12
/* j:Destination, k:destinationSize, i:origin
/*
GetData_jki:
<j|s-=64
D*s=0|k<=0?#.e
#.tris0
..inizio:
D*s=1
..tris0:
LevaSpaziDa_i()
a=*i|al== 0 #.0|al==10!#.1
B*j=10|--k!#.e0|++j
..bis0: B*j=0|a=1
..biss: clc|##.z
..0: B*j=0|a=128|clc|##.z
..e0: B*j=0
..e: a^=a|stc|##.z
..1: ax==00A0Dh!#.2|k-=2|<=#.e0
W*j=ax|j+=2|i+=2|#.bis0
..2: ax==02A2Fh!#.0x /* /*
B*j=';'|--k!#.e0|++j|i+=2
..2aa: CopyUntil10Or0_jki()|jc .e0
##.biss
..0x: al==';'!#.0y
B*j=';'|--k!#.e0|++j,i
#.2aa
..0y: al=='"'!#.1d
..1a: D*s==0#.1b|PrendiWordTraVirgolette_jki()|jc .e0
##.inizio
..1b: PrendiPseudoWordTraVirgolette_jki()|jc .e0
B*j=':'|--k!#.e0|++j
B*j=' '|--k!#.e0|++j
##.inizio
..1d: al=="'"#.1a
r=*i+4
a=="time"#.2b
..2a: ##.7
..2b: rx!="s "#.2a /* 0==time 1==48 2==db 3==num 4==fine
a=&[s+8]|AssegnaVettori(a, 5, i)|a!=5#.e0
r=[s+8+(4*2)]|a=*r|a&=000FFFFFFh
al!='d'#.e0
ah&=05fh /* da minuscola a maiuscola
*j=ah |--k!#.e0|++j
k-=2|<=?#.e0
W*j="$ "|j+=2
a>>=16|B[MyTable+a]!=Space#.e0
r=[s+8+(4*3)]| B*r=='"',"'"#.3
<i|i=r|CopyMacro_jki()|>i | jc .6a| #.4
..3: al=*r|*j=al|--k!#.e0|a==0,13,10#.4
++r,j|B[MyTable+a]!=Space#.3
..4: B*j=' '|--k!#.e0|++j
B*j='#'|--k!#.e0|++j
r=[s+8+(4*1)]
<i|i=r| CopyMacro_jki()|>i | jc .6a
/*.5: al=*r|*j=al|--k!#.e0|a==0#.6
/* ++r,j|B[MyTable+a]!=Space#.5
..6: i=[s+8+(4*4)]
B*j=' '|--k!#.6a|++j
##.inizio
..6a: ##.e0
..7: a&=000FFFFFFh
a=="res"!#.7a|B[i+4]==' '!#.7a
rl=[i+3]| k-=6| <=?#.6a
rl&=05fh /* da minuscola a maiuscola
B*j = rl | ++j
D*j="$ ? " |j+=4|i+=4
B*j="#" | ++j
LevaSpaziDa_i()
PrendiWord_jki()|jc .6a
B*j=' '|--k!#.6a|++j
##.inizio
..7a: al=='d'!#.8|B[i+2]==' '!#.8
rl=[i+1]| k-=3| <=?#.6a
rl&=05fh /* da minuscola a maiuscola
B*j = rl | ++j
W*j="$ " |j+=2|i+=2
##.inizio
..8: a&=0FFh /* Numeri
B[MyTable+a]==0!#.9
..7b: PrendiWord_jki()|jc .6a
B*j=' '|--k!#.6a|++j
##.inizio
/* Alfanumerici non numeri
..9: B[MyTableR+a]==0!#.a
D*s==0!#.9a
PrendiWord_jki()|jc .9b
B*i==':'!#.8a | ++i
..8a: W*j =": "|k-=2|<=?#.9b|j+=2 /* appendi ':'
##.inizio
..9a: CopyMacro_jki()|jc .9b
##.inizio
..9b: ##.e0
..a: B[MyTable+a]==9#.7b
B*j=al|--k!#.9b|++j,i
##.inizio
..z:
s=&[s+68]
ret
/* FindCarattereFromEnd(u8* inizio, u8* fine, u32 carattere)
/* trova la parentesi quadra a partire dalla fine
/* CF==1 trovato CF==0 non trovato
/* 0ra, 4P_inizio, 8P_fine
FindCarattereFromEnd:
c=^4|r=^8|a^=a
..1: r<c#.a
al=*r
a==^12#.b
--r
B[MyTableR+a]>=16#.1
B[MyTableR+a]<9 #.1
..a: clc|#.z
..b: stc
..z:
ret 12
/* CF==1 means find
/* CF==0 means not find
/* trova nella linea attuale
/* 0i,4b,8ra,12P_Str,16P_StrToFind
Find:
<b,i|a^=a|b^=b|r=^12
c=^16|bl=*c
b==0#.5|#.3
..0: i=r
..1: ++i,c
bl=*c| b== 0#.5
B[MyTable+b]==Space#.5
bl==*i#.1
c=^16|bl=*c
..2: ++r
..3: al=*r
a==b#.0|a==10,13#.4|a#.2
..4: clc|#.6
..5: stc
..6:
b,iret 8
FindData_i:
s-=32
^0="DATA"|^4=0
a=s|Find(i,a)|jc .z
^0="data"|^4=0
a=s|Find(i,a)|jc .z
^0="bss" |^4=0
a=s|Find(i,a)|jc .z
^0="BSS" |^4=0 /* BSS e' anche data
a=s|Find(i,a)
..z:
s=&[s+32]
ret
FindCode_i:
s-=32
^0="CODE"|^4=0
a=s|Find(i,a)|jc .z
^0="code"|^4=0
a=s|Find(i,a)|jc .z
^0="text"|^4=0
a=s|Find(i,a)|jc .z
^0="TEXT"|^4=0
a=s|Find(i,a)
..z:
s=&[s+32]
ret
/* u32 LineToRosAsm(u8* dest, u32 dsize, u8* origin, u32 commento)
/* come risultato ecx, caratteri scritti in j
/* edx, caratteri di avanzamento di i
/* a==eax==risultato della funzione
/* a& 1!=0 raggiunta la fine della istruzione con \n
/* a& 2!=0 esiste la label
/* a& 4==0 [<=>CF==0] nessun errore trovato
/* a& 4!=0 [<=>CF==1] riscontrato errore
/* a& 8!=0 commento semplice
/* a& 16!=0 commento doppio
/* a& 32!=0 errore di parametro
/* a& 64!=0 errore di copia
/* a& 128!=0 raggiunta la fine della istruzione con 0
/* a& 256!=0 raggiunta la fine della istruzione con "|", ";"
/* a& 512!=0 raggiunta la fine della istruzione per label
/* a&1024!=0 data
/* a&2048!=0 linea dello stesso tipo di dati
/* a&4096!=0 Stampa "["
/* 0k,4j,8i,12b,16ra,20P_d,24P_dsize,28P_or,32P_comm
/* j:Destination, k:destinationSize, i:origin, b:LastChar
LineToRosAsm:
<b,i,j,k
j=[s+20]|k=[s+24]|i=[s+28]
b^=b|j!#.e1|k<=7?#.e1|B*j=0|a^=a|i#.1
..e1: r=[s+32]
r&=0FFFFFC10h /* levo \n ed \0
/* levo 1,2,4,32,64,128,256,512
a|=32|a|=r
..e: B*j=0|a|=4|i-=[s+28]|j-=[s+20]|r=i|c=j
..eee: stc| ##.z
..e2: r=[s+32] | r&=0FFFFFC10h
a|=64| a|=r | #.e
..f0: B*j=0|i-=[s+28]|j-=[s+20]|r=i|c=j
..f: clc | ##.z
..f1: r=[s+32]| r&=0FFFFFC10h |a|=r| #.f0
..f2: a=b | #.f0 /* a=2 linea con ";" a=3 ";;"
..0: ++i
..1: bl=*i|B[MyTable+b]==Space#.0
b==10!#.1b
..1a: CopyUntil10Or0_jki()|jc .e2
#.f1
..1b: b==13!#.1c|B[i+1]==10#.1a
..1c: B[MyTable+b]==5!#.1k
D[s+32]&1024!#.f1
a=[s+32]
a&=0FFFFFC10h
a&=0FFFFFBFFh
a|=128
B*j=']'|++j|--k!#.e
..1d: ##.f0
..1k: b==';'!#.4|b=[s+32]|b&=0FFFFFC10h|b|=8
B[i+1]==';'!#.3a
/* caso ";;" trovato anche prima: D[s+32]&16!=0
D[s+32]&16#.22
..2: b|=16|#.3
..22: b&=0FFFFFFEFh
..3: CopyUntil10Or0_jki()|jc .e2|b|=a| ##.f2
/* caso ";" ora e ";;" prima oppure no
..3a: D[s+32]&16#.3|b|=8|#.3
..4: D[s+32]&16!#.5
b=[s+32]|b&=0FFFFFC10h|#.2
..5: b=='/'!#.1o|B[i+1]=='*'!#.1o
b=[s+32]|b&=0FFFFFC10h|b|=8
B*j=';'|++j|--k|i+=2|#.3
..1o: D[s+32]&2048!#.3f
b=[s+32]|b&=0FFFFFC10h|b|=8
CopyUntil10Or0_jki()|jc .e2|b|=a
a=[s+20]|FindCarattereFromEnd(a,j,']')|jnc .3b
b&=0FFFFF7FFh /* trova la parentesi quadra not(2048)
..3b: ##.f2
..3c: ##.7
..3d: ##.a
..3f: a=[i] |r=[i+4]
/* b e' il primo carattere effettivo
b=='s'!#.3c|a!="sect"#.3d|r!="ion "#.3d /* viene vista come commento
..6: b=[s+32]| b&=0FFFFFC10h| b|=8 /* commento
FindData_i()|jnc .6d
b&1024!#.3g|b&4096#.3g
B*j=']'|++j|--k /* fine del segmento precedente
..3g: b|=1024 /* aggiungo data
..6a: VaiUntil10Or0_i()|b|=a
a&1!#.3h
B*j=13|++j|B*j=10 |++j|k-=2
..3h: b&1024!#.6c| b&8!#.6c
b|=4096 /* quando arriva ai dati deve
/* stampare '['
..6c: ##.f2
..6d: FindCode_i()|jnc .6a
b&1024!#.5b |b&4096#.5b|B*j=']'|++j|--k
..5b: b&=0FFFFFBFFh|#.6a /* levo data
..6f: ##.e2
..7: b=='S'!#.8 |a!="SECT"#.a|r=="ION "#.6
..8: b=='%'!#.a |a=="%def"!#.8b|r=="ine "!#.8b
..8a: b=[s+32]| b&=0FFFFFC10h
PushMacro(i)|##.6a /* definizione di macro
..8b: |a=="%und"!#.6a|rx=="ef"!#.6a
..8c: b=[s+32]| b&=0FFFFFC10h
PopMacro(i)|##.6a
..des_e: ##.e
..des_e2: ##.e2
/* j destination, i origin, b last char,
..a: ax=="<<"#.8a|ax==">>"#.8c
r&=000FFFFFFh
a=="expo"!#.7a|r=="rt "!#.7a
b=[s+32]| b&=0FFFFFC10h
PushExport(i)| ##.6a
..7a: a=="glob"!#.1x|r=="al "!#.1x
..1q: b=[s+32]|b&=0FFFFFC10h|b|=8
VaiUntil10Or0_i()|b|=a
a&1!#.1r
B*j=13|++j|B*j=10|++j|k-=2
..1r: ##.f2
..1x: a=="exte"!#.1z|r=="rn "#.1q
..1z: D[s+32]&1024!#.8d /* settore "data"
b=[s+32]| b&=0FFFFFC10h
b|=8 /* commento
HaLaLineaQualcheParola_i()|jc .a0
CopyUntil10Or0_jki()|jc .des_e2|b|=a
a&128!#.a01|B*j=']'|++j|--k!#.des_e
b&=0FFFFFBFFh /* fine stringa
..a01: ##.f2 /* quando finisce il file
..a0: b&4096!#.a1
B*j='['|++j|--k!#.des_e
b&=0FFFFEFFFh /* toglie 4096
..a1: GetData_jki()|b|=a
..6g: ##.f2
..8d: al=='['!#.8e
IsNextWordLabel_i()|jnc .8e
b=[s+32]|b&=0FFFFFC10h
CopyUntil10Or0_jki()|jc .6f|b|=a
a=[s+20]|FindCarattereFromEnd(a,j,']')|jc .6g
b|=2048 |##.f2
..8e: c=1|ToNasm()|j+=c|k-=c|<=?#.des_e
<c,j|j-=c|c=^0|FromNasmToRos()|>c,j
a&4#.b|a&128#.a9|a&1#.a9
c#.8e /*B*i#.8e
..a9: ##.f0
..b: ##.e
..z:
b,i,j,kret 16
/*
/* FromNasmToRos(j,a)
/* in "j" vi e' l'inizio della stringa in "a" la sua fine
/* Non cambia la lunghezza di j
/* trasforma j->" stringa " stringa
/* in-place
/* da Nasm a Ros
/* mov [eax], ebx
/* < a272, b268, c264, i260, j256
FromNasmToRos:
<a,b,c,i,j
s-=256
a&8#.0|a&16#.0|#.0b
..0: clc|##.z
..e: stc|##.z
/* mov D[esp],90 -> mov D$esp , 90
/* | || | |
/* mov [esp],eax -> mov D$esp , eax /* r==1
/* | | | |
/* mov eax, [esp] -> mov eax, D$esp /* r==2
/* | | | |
/* call [eax]
/* | | |
/* call D$eax
/* | ||| |
..0a: j=[s+b*4-4]|++j|j>=^264#.0
..0b: a=s
AssegnaVettoriIstruzione(a, 60, j)|jc .e
b=a|r^=r|a^=a|b==0#.0
b==1!#.0c|i=[s+r*4]|B*i==';',13,10,0#.0
..0c: b==1,2#.0a
b==3!#.1a|i=[s+(4*1)]|al=*i|a!='$'#.0a
B[i-1]='D' |#.0a /* call dword
b!=4#.0a
..1a: ++r|r==3#.0a /* r==1,2
..1b: i=[s+r*4]
al=*i
..2: a=='$'!#.1a
r==2#.3
c=[s+r*4+4]
..2a: <r|Isreg(c)|>r|a==0#.0a
c^=c|cl=["ZBW D Q T"+a]
B[i-1]=cl
##.0a
..3: c=[s+r*4-4]|#.2a
..z:
s=&[s+256]
a,b,c,i,jret
/* CF==1 Find
/* CF==0 not Find
IsExport_k:
pushad
#.1
..notfind: clc| ##.z
..find: stc| ##.z
..1: FindMacroWord(k)|jc .notfind
r!=c#.notfind
i=a|j=k|k=c
DCmp()|jnc .find /* trovato
#.notfind
..z:
popad
ret
/* AssegnaVettoriIstruzione(u32* vettori, u32 NMaxParole, u8* str)
/* assume che NMaxParole siano abbastanza per trattare l'istruzione
/* nel vettore finale si scrive dove e' arrivato i
/* 36P_str, 32P_Nvettori, 28P_vettori,24Ra,b20,c16,r12,i8,j4, k0
AssegnaVettoriIstruzione:
<b,c,r,i,j,k
r=^28|c=^32|i=^36|c<<=2
a^=a|b^=b|c+=r|#.3
..e: a=b| stc| ##.z
..1: ##.9
..2: ++i
..3: al=*i
..4: B[MyTableR+a]==Space#.2
a=='|',0,10,';'#.1
a==',' #.2
a=='.'!#.4a|B*i='@'
B[i+1]=='.'!#.4a|B[i+1]='@'
..4a: ++b
*r=i|r+=4|r==c#.e
a=='['!#.4m
a=']'|B*i='$'
..4h: j=a
..4i: ++i|al=*i|a==0,10#.9
a!=j#.4i
a==']'!#.2
B*i=' '
##.2
..4m: a=='(',"'", '"'#.4h
k=i
..5: ++i
..6: al=*i
..7: B[MyTableR+a]==0#.5
a==':'!#.8|r-=4|--b|++i
IsExport_k()|jnc .8
B*i=':'|++i
..8: a#.4
..9: *r=i|a=&[b+1]|clc
..z:
b,c,r,i,j,kret 12
/* a=1File, r=2File
MacroRosAsm:
<b,i,j,k /* 400 FileLine=656..1680 size=1024
s-=2048 /* b1=128..384, b2=392..648 size=256
<< InpHandle=16, OutHandle=20, MemFile=24
<< InpFName=128, OutFName=392, FileLine=656
<< FileSize=28, MemLimit=44
i=a|b=r
InstallRos()| jc .e
j=&[s+InpFName]|c=256
PrendiNomeDa_i()| jc .e1
i=b|j=&[s+OutFName]|c=256
PrendiNomeDa_i()| jnc .1
..e1: a=1|
..e: FreeMem()|stc| ##.z
..e2: a=2| #.e /* errore di file input
..e5: r=[s+OutHandle]|FlushCloseHandle(r)
..e4: a=[s+MemFile] |Free_sys(a)
..e3: r=[s+InpHandle]|CloseHandle(r)
a=b| #.e /* errore di file output
..1: /* Apri file di input
r=&[s+InpFName]
[s+InpHandle]=CreateFileA(r, GENERIC_READ,
0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,0)
b=3|a==INVALID_HANDLE_VALUE#.e2
b=4
r=s|GetFileSize(a, r)|a==-1#.e3|D*s#.e3
b=5|^FileSize=a| a+=64
Malloc_sys(a)|a==0#.e3|[s+MemFile]=a
r=^FileSize| ^MemLimit=a| ^MemLimit+=r
r+=32| D[a+r]=0 /* per essere sicuri che termini
r=&[s+OutFName]| b=6 /* line to nasm
[s+OutHandle]=CreateFileA(r, GENERIC_WRITE,
0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0)
a==INVALID_HANDLE_VALUE#.e4
r=^InpHandle|c=^FileSize|c+=32|i=^MemFile|a=s|b=7
ReadFile(r, i, c, a, 0)|a==0#.e5
c=*s| [s+FileSize]!=c#.e5
b=8
/* in i vi e' tutto il file di lunghezza c
r=[s+InpHandle]|CloseHandle(r)|a==0#.e5
k^=k| b=9|j=&[s+656]
..2: k=LineToRosAsm(j, 1024, i, k) /* | r==0#.9
i+=r|jc .e5|i>[s+MemLimit]#.e5
r=^OutHandle|a=s
WriteFile(r, j, c, a, 0)|a==0#.e5
B*j#.2
/* i<[s+MemLimit]#.2
..9: b=10
r=[s+OutHandle]|FlushCloseHandle(r)|jc .e4
r=[s+MemFile] |Free_sys(r)
FreeMem()
..z:
s=&[s+2048]FileSize, MemLimit
InpFName, OutFName, FileLine
InpHandle, OutHandle, MemFile
b,i,j,kret
/*------------------------------
GetStdIo:
#.1
..e: a=-1|stc|##.z
..1: *stderr=GetStdHandle(STD_ERROR_HANDLE )|a==-1#.e
*stdin =GetStdHandle(STD_INPUT_HANDLE )|a==-1#.e
*stdout=GetStdHandle(STD_OUTPUT_HANDLE)|a==-1#.e
a==*stdin#.e
r=*stdout| GetConsoleScreenBufferInfo(r, BufInfo)
a==0#.2|r=BufInfo|r+=2|a^=a|ax=*r|a==0#.3
--a|jz .2|*consoley=a /* consoley non e' corretto[-1]
r-=2|ax=*r|a==0#.3|*consolex=a
..2: a^=a
..3: clc
..z:
ret
CloseStdIo:
r=*stderr|FlushCloseHandle(r)
r=*stdin |r==-1#.1|CloseHandle(r)
..1: r=*stdout|FlushCloseHandle(r)
D*stderr=-1| D*stdin=-1
D*stdout=-1
a^=a
..z:
ret
/*0j,4i,8ra,12P_Handle
FlushCloseHandle:
<i,j |i=^12|i!=-1#.1
..e: a^=a|stc|#.z /* bene a!=0
..1: FlushFileBuffers(i)|j=a
CloseHandle(i)|a==0#.e
j==0#.e
clc
..z:
i,jret 4
/* 0j,4i,8b,12ra,16P_hexValue +256
HexPrint:
<b,i,j
s-=256
b=^272|j^=j|a^=a|c=28
B[s+j]='0'|++j
B[s+j]='x'|++j
i=0F0000000h
..0: r=i|r&=b|r>>=cl
al=["0123456789ABCDEF" + r]
[s+j]=al|++j|i>>=4|c-=4|>=?#.0
B[s+j]=0
i=*stderr|a=s|SPuts(i, a)
s=&[s+256]
b,i,jret 4
/*u32 SPuts(u32 Handle, u32 String)
/* scrive in Handle la stringa String
/* 0j,4ra,8P_Handle,12P_Str + 8
/* 16 , 20
SPuts:
<j
s-=8
a=^20|c^=c |r=a
D[s+16]==-1#.e|a#.2
..e: stc|#.z
..1: ++a,c
..2: B*a#.1
j=^16|a=s
WriteFile(j,r,c,a,0)
c=a|a=*s
c==0#.e
clc
..z:
s=&[s+8]
jret 8
/* r=*stderr| PrintError(r)
/* FORMAT_MESSAGE_FROM_SYSTEM 01000h
/* 32P_FHeader,ra28,a24,b20,c16,r12,i8,j4,k0
PrintError:
<a,b,c,r,i,j,k
k=[s+32]|k==-1#.e
GetLastError()
i=a | #.1
..e0: Free_sys(j)
..e: stc | #.z
..1: Malloc_sys(1024)|a==0#.e
j=a
FormatMessageA(01000h,0,i,0,j,1020,0)
a==0#.e0
SPuts(k, j)|jc .e0
B*j=13|B[j+1]=10|W[j+2]=0
SPuts(k, j)|jc .e0
Free_sys(j)
..z:
a,b,c,r,i,j,kret 4
/* u32 SPutsLine(u32 Handle, u32 String)
/* scrive in Handle la stringa String
/* ritorna in a la lunghezza della stringa
/* scritta mentre r==1 se ha raggiunto la
/* fine della stringa
/* r=0 non ha raggiunto la fine della stringa
/* 0j,4ra,8P_Handle,12P_Str + 16
/* 24 , 28
SPutsLine:
<j
s-=16
a=^28|c^=c|r=a|D[s+8]=0|a#.2
r=1
..e: stc|#.z
..1: ++a,c
..2: B*a==10#.3|B*a#.1
D[s+8]=1| #.4
..3: ++c
..4: j=^24|a=s
WriteFile(j,r,c,a,0)
c=a|r=[s+8]|a=*s
c==0#.e
clc
..z:
s=&[s+16]
jret 8
/*0j,4j,8i,12b, 16ra, 20P_FileH
ScriviChi:
<b,i,j,j
j=^20|b=nome|i=nome1
SPutsLine(j,i)
..0: a^=a| al=*b|a==0#.1
r^=r| rl=*i|a^=r
^0=a| ++i,b
a=s|SPuts(j,a)|jnc .0
..1: SPutsLine(j,nl)
..z:
b,i,j,jret 4
/* ShowHelpConsole(u32* string)
/* 0k,4j,8i,12ra,16P_String
ShowHelpConsole:
<i,j,k
i=[s+16]|k^=k|j=*stdout
ScriviChi(j)|k+=2
..1: ++k
SPutsLine(j,i)|r#.z| a==0#.z
i+=a|k!=[consoley]#.1
k^=k
r=*stderr|a="<Premi \n> " |SPuts(r, a)
r=*stderr|FlushFileBuffers(r)
r=*stdin |SGetLine(qui, 1024, r)
#.1
..z: D[consoley]==1024#.zz
r=*stderr|a="<Premi \n> " |SPuts(r, a)
r=*stderr|FlushFileBuffers(r)
r=*stdin |SGetLine(qui, 1024, r)
..zz: a=k
i,j,kret 4
/* 0k,4j,8i,12b,16ra,20P_w
ShowMacro:
<b,i,j,k
b=[s+20]|k^=k
j=*stdout|i=b|D[stderr]==-1#.ee
j==-1#.ee| #.2
..ee: ##.e
..1: ++i
..2: B*i#.1
..1a: ++i
..1b: B*i==0#.1a
D[consoley]==1024#.1c
++k| k==18!#.1c| k=0
a="<Premi \n> " |r=*stderr|SPuts(r, a)
r=*stderr|FlushFileBuffers(r)
r=*stdin |SGetLine(qui, 1024, r)
..1c: SPutsLine(j, b)| jc .e
a=" ---> "|SPutsLine(j, a)| jc .e
SPutsLine(j, i)| jc .e
SPutsLine(j,nl)| jnc .4
..e: a=-1|stc|#.z
..3: ++i
..4: B*i#.3
..4a: ++i
..4b: B*i==0#.4a
b=i|B*i!=0FFh#.2
a^=a|clc
..z:
b,i,j,kret 4
/* ritorna la lunghezza della stringa presa
/* c==1 significa raggiunto EOF
/* c==0 significa non raggiunto EOF
/* 0k,4j,8i,12b,16ra,
/* 20PArr,24PArrSize,28PHandle + 8
/* 28 j |32 k |36 i
SGetLine:
<b,i,j,k
s-=8|j=^28|k=^32|i=^36|b=s
k<=0?#.e0|j#.1
..e0: a^=a
..e: c^=c|stc|#.z
..e1: B*j=0|j-=[s+28]|a=j|#.e
..1: k+=j
..2: j>=k#.e1
ReadFile(i,j,1,b,0)
a==0#.e1|D*s!=1#.3 /*raggiunto EOF
++j| B[j-1]!=10#.2|c^=c|#.4
..3: c=1
..4: B*j=0|j-=[s+28]|a=j|clc
..z:
s=&[s+8]
b,i,j,kret 12
/* CREATE_NEW_PROCESS_GROUP 0200h
/* NORMAL_PRIORITY_CLASS 020h 0220h
/*0k,4j,8i,12ra,16Ps + 1024
SystemA:
<i,j,k
s-=1024
i=[s+1040]|D*s=0|i#.1
..e1: a=1
..e: stc|##.z
..e2: a=*stderr|PrintError(a)
a=2|#.e
..e3: a=3|#.e
..e4: r=[ProcInfo+4]| CloseHandle(r)| a==0#.e3
r=*ProcInfo | CloseHandle(r)| a==0#.e3
a=4|#.e
..1: r=*stderr|SPuts(r,i)
r=*stderr|SPuts(r,nl)
GetStartupInfoA(StartInfo)
CreateProcessA(0,i,0,0,1, 0220h,0,0,StartInfo,ProcInfo)
a==0#.e2
i=*ProcInfo
WaitForSingleObject(i,0FFFFFFFFh)|a==-1#.e4
a=s|GetExitCodeProcess(i,a)
r=[ProcInfo+4]|CloseHandle(r)|a==0#.e3
CloseHandle(i)|a==0#.e3
a=*s
clc /* significa che la chiamate c'e' stata
..z:
s=&[s+1024]
i,j,kret 4
/* u32 PrendiArgomenti(u32** arr, u32 NArrElements)
/* ritorna il numero di argomenti presi CF==0 tutto ok
/* alla fine un puntatore permesso del vettore arr
/* punta a un array di char che descrive l'argomento
/* che risulta essere finito da ' ' spazio o tab
/* se non inizia con ' oppure "
/* altrimenti e' finito rispettivamente da ' e da "
/* altrimenti se errore es il vettore e' tutto riempito
/* o i parametri sono sbagliati: ritorna
/* il numero di argomenti ed CF==1
/* 0j,4i,8b, 12ra,16P_arr, 20P_limite
PrendiArgomenti:
<b,i,j
b=^16|D[s+20]<=0?#.e0|b#.a
..e0: a^=a
..e: stc| ##.z
..ee: a=c| #.e
..a: GetCommandLineA()|i=a /* nel puntatore 0 vi e' il primo argomento
a==0#.e0|c^=c|a^=a|r=^20|#.2 /* c=contatore; r=il limite;
..0: ++i| al=*i| a==0#.e|a!=j#.0
..1: ++i /* leva gli eventuali spazi prima
..2: al=*i|B[MyTable+a]==Space#.1
a==0#.3
[b+c*4]=i /* assegna al puntatore il primo carattere
++c| c>=r#.ee
j=a|a=='"'#.0|a==39#.0
..2a: ++i
..2b: al=*i|a==0#.3|B[MyTable+a]!=Space#.2a /* scorre la parola
#.1
..3: a=c|clc
..z:
b,i,jret 8
LevaSpaziDa_i:
a^=a
..0: al=*i|B[MyTable+a]!=Space#.1|++i|#.0
..1: ret
/* prende una parola separata da spazi
/* se i punta a qualche spazio prima la
/* parola => ritorna la prima parola incontrata
/* se i punta gia' a una parola, scarta tale
/* parola e ritorna quella dopo
FindNextWordTraSPazi_i:
a^=a|r=i
..0: al=*i|B[MyTableR+a]!=Space#.1|++i|#.0
..1: r!=i#.z /* *i non e' spazio
a==0,13,10#.z
/* se e' fine linea esci
/* scarta la parola attuale
..2: ++i|al=*i|a==0#.z|B[MyTableR+a]!=Space#.2
/* scarta gli spazi
..3: ++i|al=*i|a==0#.z|B[MyTableR+a]==Space#.3
..z:
ret
/* trova la prossima parola alfanumerica
/* o formata da punti
/* se i punta a qualche spazio prima la
/* parola => ritorna la prima parola incontrata
/* se i punta gia' a una parola, scarta tale
/* parola e ritorna quella dopo
FindNextWord_i:
a^=a|r=i
..0: al=*i|B[MyTableR+a]!=Space#.1|++i|#.0
..1: r!=i#.z /* *i non e' spazio
a==0,13,10#.z
/* se e' fine linea esci
/* scarta la parola attuale
rl=[MyTableR+a] /* La prima lettera
..2: ++i|al=*i|a==0#.z|B[MyTableR+a]==rl#.2
#.4
/* scarta gli spazi
..3: ++i|al=*i|a==0#.z
..4: B[MyTableR+a]==Space#.3
..z:
ret
/* a==128 fine di i con \0
/* a== 1 fine di i con \n
/* a== 0 trovato qualcosa di diverso
HaLaLineaQualcheParola_i:
a^=a|r=i
..0: al=*r|B[MyTableR+a]!=Space#.1|++r|#.0
a==13!#.1|++r|al=*r
..1: a==10#.4
a== 0#.5
a^=a |stc|#.z
..4: a=1 |clc|#.z
..5: a=128|clc
..z:
ret
/* ritorna in c la lunghezza della prossima parola
/* incontrata senza far muovere i
WordLenTraSpazi_i:
a^=a|c=i /* leva gli spazi
..0: al=*c|B[MyTableR+a]!=Space#.1|++c|#.0
..1: r=c /* conserva la posizione
a==0,10,13#.3 /* se e' fine linea esci
..2: ++c|al=*c|a==0#.3|B[MyTableR+a]!=Space#.2
/* scarta gli spazi
..3: c-=r
..z:
ret
/* ritorna in c la lunghezza della prossima parola
/* incontrata senza far muovere i
WordLen_i:
<b
a^=a|c=i /* leva gli spazi
..0: al=*c|B[MyTableR+a]!=Space#.1|++c|#.0
..1: r=c /* conserva la posizione
a==0#.3 /* se e' fine linea esci
bl=[MyTableR+a] /* La prima lettera
..2: ++c|al=*c|a==0#.3|B[MyTableR+a]==bl#.2
..3: c-=r
..z:
bret
LenStr_i:
a=i|#.1
..0: ++a| .1: B*a#.0
a-=i|c=a
ret
/* i+c punta alla fine della
/* prossima parola: non modifica i
/* modifica a, c[risultato], r
/* qui la parola puo' essere delimitata
/* da virgolette
FindEndNextWordTraSpazi_i:
LevaSpaziDa_i()
a^=a|r=i|c^=c|cl=*i|c==0#.2| ++r
c=='"', "'", 96#.1| #.4
..0: ++r
..1: al=*r
a==0,10,13#.2
a!=c#.0
++r
..2: c=r|c-=i|clc|#.z
..3: ++r
..4: al=*r|B[MyTable+a]==Space#.2
a==10,13#.2
a#.3|#.2
..z:
ret
/* non modifica i
/* salta, se sono in parola, l'attuale parola
/* trova la fine della prossima parola
/* vede se ci sono due punti ":"
/* ritorna CF==1 label trovata altrimenti CF==0
/* sono preservati tutti i registri anche eax
IsNextWordLabel_i:
<a,r,c |r=i|c^=c|a^=a
al=*r| a==0#.9
cl=[MyTableR+a]|c==Space#.0
..0a: ++r|al=*r|a==0#.9 /* elimina l'attuale parola
B[MyTableR+a]==cl#.0a /* nel caso l'attuale carattere nella
parola
B[MyTableR+a]==0#.2 /* parola
B[MyTableR+a]!=Space#.9
..0: ++r
..1: al=*r|B[MyTableR+a]==Space#.0
a==0#.9
B[MyTableR+a]#.9
..2: ++r
al=*r|B[MyTableR+a]==0#.2
a!=':'#.9
..8: stc|#.z
..9: clc
..z:
a,r,cret
/* i+c punta al punto '.' piu' vicino alla fine
/* della stringa puntata da i, oppure all'ultimo
/* catattere cie' \0
/* in "a" vi e' l'ultimo carattere non nullo trattato
/* o zero se errore o fine stringa
/* NB modifica i (leva gli spazi)
/* qui la parola puo' essere delimitata
/* da virgolette
FindLastPoint_i:
<b,r
LevaSpaziDa_i()
a^= a|c^=c|b^=b
cl=*i|r =i|c==0#.2|++r
c=='"', "'", 96#.1| #.4
..0: ++r /* finisce con a=0,10,13 clc
..1: al=*r|a==0,10,13#.2
a=='.'#.1a
a!=c#.0
++r|#.2
..1a: b=r|#.0
..2: b#.2a| b=r
..2a: c=b|c-=i|clc|#.z
..3: ++r
..4: al=*r|B[MyTable+a]==Space#.2
a==10,13#.2
a=='.'#.5
a#.3|#.2 /* finisce con a=0 clc
..5: b=r |#.3
..z:
b,rret
/* 0ra, 4Pspazi
Spazi_j:
c=[s+4]|k<>0|<?#.ee| =#.e|c>0?#.0
..e: B*j=0
..ee: stc|#.z
..0: B*j=' '|--k!#.e|++j|--c#.0
B*j=0
..z:
ret 4
/* parametri: i la stringa da leggere
/* j la stringa da scrivere
/* k la size di j
/* alla fine modifica sia i,j,k
/* Ritorna in ecx la lunghezza della stringa
/* scritta in j
Copy_jki:
<k |a^=a|k>0?#.1
..e: c=*s|c-=k|B*j=0|stc|#.z
..1: al=*i|*j=al|a==0#.2|--k!#.e
++i,j|#.1
..2: c=*s|c-=k|clc
..z:
s=&[s+4]
ret
/* parametri: i la stringa da leggere
/* j la stringa da scrivere
/* k la size di j
/* alla fine modifica sia i,j,k
/* Ritorna in ecx la lunghezza della stringa
/* scritta in j
CopyMacro_jki:
<c
^0=0|i==0#.e
FindMacroWord(i)|a==0#.e
k<=c#.e|*s=c
i+=r
<i,k
i=a|k=c|DCopy()
>i,k
j+=a|k-=a|#.9
..e: stc|#.z
..9: clc
..z:
cret
CopyLine_jki:
<k |a^=a|k>0?#.1
..e: c=*s|c-=k|B*j=0|stc|#.z
..1: al=*i|a==13#.1a|a==10#.1a
*j=al|a==0#.2|--k!#.e
++i,j|#.1
..1a: B*j=0
..2: c=*s|c-=k|clc
..z:
s=&[s+4]
ret
/* parametri: i la stringa da leggere
/* j la stringa da scrivere
/* k la size di j
/* alla fine modifica sia i,j,k
/* Ritorna in ecx la lunghezza della stringa
/* scritta in j
/*
/* il primo carattere puntato da i
/* deve essere " oppure '
/* modifica i,j,k,a,c,r
PrendiWordTraVirgolette_jki:
<k |a^=a|c^=c|k<>0|cl=*i|<?#.e| =#.ee
c=='"',"'",96#.1|#.e
..ee: c=*s|c-=k|B*j=0
..e: stc|#.z
..1: *j=cl
..2: --k!#.ee|++i,j
al=*i|*j=al| a==0#.3|a!=c#.2
--k | ++i,j| B*j=0
..3: c=*s| c-=k| clc
..z:
s=&[s+4]
ret
/* parametri: i la stringa da leggere
/* j la stringa da scrivere
/* k la size di j
/* alla fine modifica sia i,j,k
/* Ritorna in ecx la lunghezza della stringa
/* scritta in j
/*
/* il primo carattere puntato da i
/* deve essere " oppure '
/* modifica i,j,k,a,c,r
PrendiPseudoWordTraVirgolette_jki:
<k |a^=a|c^=c|k<>0|cl=*i|<?#.e| =#.ee
c=='"',"'",96#.1|#.e
..ee: c=*s|c-=k|B*j=0
..e: stc|#.z
..1: B*j='I'
..2: --k!#.ee|++i,j
al=*i
a=='.'#.1a0
B[MyTable+a]>2!#.1a
..1a0: B*j='I'| #.1b
..1a: *j=al
..1b: a==0#.3|a!=c#.2
++i
..3: B*j=0|c=*s| c-=k| clc
..z:
s=&[s+4]
ret
/* parametri: i la stringa da leggere
/* j la stringa da scrivere
/* k la size di j
/* alla fine modifica sia i,j,k
/* Ritorna in ecx la lunghezza della parola
/* scritta in j
/*
/* il primo carattere puntato da i
/* non deve essere spazio
/* modifica i,j,k,a,c
PrendiWordTraSpazi_jki:
<k |a^=a|k<>0|<?#.e| =#.ee
#.1
..ee: c=*s|c-=k|B*j=0
..e: stc|#.z
..0: --k!#.ee|++i,j
a==',',';'#.2
..1: al=*i|*j=al|a==0#.3
B[MyTable+a]!=Space#.0
..2: B*j=0
..3: c=*s|c-=k|clc
..z:
s=&[s+4]
ret
/* prende parola alfanumerica o di punti
/* parametri: i la stringa da leggere
/* j la stringa da scrivere
/* k la size di j
/* alla fine modifica sia i,j,k
/* Ritorna in ecx la lunghezza della parola
/* scritta in j
/*
/* il primo carattere puntato da i
/* non deve essere spazio
/* modifica i,j,k,a,c
PrendiWord_jki:
<k |a^=a|k<>0|<?#.e| =#.ee
al=*i|cl=B[MyTableR+a]|#.1
..ee: c=*s|c-=k|B*j=0
..e: stc|#.z
..0: --k!#.ee|++i,j
al=*i
..1: *j=al|a==0#.3
B[MyTableR+a]==cl#.0
..2: B*j=0
..3: c=*s|c-=k|clc
..z:
s=&[s+4]
ret
/* In i vi e' il nome
/* In j vi e' dove lo si vuole scrivere
/* In k vi e' la dimensione di j
PrendiWordSpaziVirgolette_jki:
LevaSpaziDa_i()
a^=a|al=*i
a=='"'!#.1
..0: PrendiWordTraVirgolette_jki()|#.2
..1: a=="'"#.0| a==96#.0
PrendiWordTraSpazi_jki()
..2:
ret
/* ShowHelp(u32* string)
/* 0ra, 4P_String
ShowHelp:
a=[s+4] |r=*stderr|r==-1#.z
SPuts(r, a)|jc .z
r=*stderr
SPuts(r, "<Premi\n>")|jc .z
r=*stderr|FlushFileBuffers(r)
r=*stdin| r==-1#.z
SGetLine(qui, 1024, r)
..z:
ret 4
/* u32 FormatA(u32* ArrOut,u32 ArrSize,u32* ArrIn)
/* 0k,4j,8i,12b,16ra,
/* 20PArrOut,24PArrSize,28PArrIn
FormatA:
<b,i,j,k
j=[s+20]|k=[s+24]|i=[s+28]
j==0#.e |k<=0?#.e|i#.2
..e: stc| ##.z
..1: Copy_jki()| ##.z
..2: LevaSpaziDa_i()
a==';','%',13,10,0#.1
a=D*i| r=D[i+4]
a=="sect"!#.3| r=="ion "#.1|#.4
..f: clc| ##.z
..3: a=="SECT"!#.4 | r=="ION "#.1
..4: a=="segm"!#.3a| r=="ent "#.1|#.3b
..3a: a=="SEGM"!#.3b| r=="ENT "#.1|#.3b
..3b: a=="resb"!#.3c| B[i+4]==' '#.1
..3c: a=="resw"!#.3d| B[i+4]==' '#.1
..3d: a=="resd"!#.3e| B[i+4]==' '#.1
..3e: r&=000FFFFFFh
a=="exte"!#.3f| r=="rn "#.1
..3f: a=="glob"!#.3g| r=="al "#.1
..3g: a=="time"!#.3h| rx=="s "#.1
..3h:
a&=000FFFFFFh
a=="db ","dd ","dt ", "dq "#.1
a=="dw ","do ","dy "#.1
FindEndNextWordTraSpazi_i()
jc .e| #.4b
..4a: ++r /* dopo gli spazi
..4b: al=*r|a==0#.f
B[MyTable+a]==Space#.4a
a=D*r| b=D[r+4]
a=="resb"!#.1c| B[r+4]==' '#.1
..1c: a=="resw"!#.1d| B[r+4]==' '#.1
..1d: a=="resd"!#.1e| B[r+4]==' '#.1
..1e:
b&=00000FFFFh
a=="time"!#.4c|b=="s "#.1
..4c:
a&=000FFFFFFh
a=="db ","dd ","dt ", "dq "#.1
a=="dw ","do ","dy "#.1
b=10
B[i+c-1]==':'!#.5
PrendiWordSpaziVirgolette_jki()
jc .e|a==0#.f
b-=c|>?#.5|b=1
..5: Spazi_j(b)
/* .e1: pop õ8
b=6
LevaSpaziDa_i()
a==";"#.1
PrendiWordSpaziVirgolette_jki()
jc .e|a==0#.f
b-=c |>?#.6|b=1
..6: Spazi_j(b)
..7: LevaSpaziDa_i()
a==";"!#.7a
..5a: b=32|c=j|c-=[s+20]
b-=c| >?#.6a| b=1
..6a: Spazi_j(b)| ##.1
..7a: a==0#.f
a!=","!#.8|Spazi_j(2)|jc .e
..8: PrendiWordSpaziVirgolette_jki()
jc .e|a==0#.f
B[j-1]==';'!#.9
B[j-1]=0|--j,i|#.5a
..9: #.7
..z:
b,i,j,kret 12
/* b1= 40..296 256 buffer fileIn
/* b2=300..556 256 buffer fileOut
/* b4=580..1604 1024 buffer
/* b5=1608..2632 1024 buffer
/* 0k,4j,8i,12b,16ra, 20PArr + 3072
/* 3092
Beautyfy:
<b,i,j,k
s-=3072
<< InpHandle=4, OutHandle=8
<< InpFName=40, OutFName=300
i=^3092|i#.0
..e1: a=1
..e: stc|##.z
..0: j=&[s+InpFName] |k=256
PrendiWordSpaziVirgolette_jki()| jc .e1
j=&[s+OutFName] |i=^3092|k=256
PrendiWordSpaziVirgolette_jki()| jc .e1
r=&[s+OutFName] /* c==CH_Lunghezza
j==r#.e|c=j|c-=r|<=?#.e1
a=256|a-=c|a<=12?#.e1
b=0
B[j-1]=='"'!#.1a| b='"'| #.1b
..1a: B[j-1]=="'"!#.1b| b="'"
..1b: a^=a|#.2
..ee: ##.e1
..e2: r=[s+InpHandle]|CloseHandle(r)| a=2|##.e
..1: ++r|--c
..2: al=*r|c<=0?#.3|a!='.'#.1
..3: D*r="_Btf"|r+=4|D*r=".asm"|r+=4|B*r=0
b!=0!#.4| B*r=bl| ++r| B*r=0
..4: r=&[s+InpFName]
[s+InpHandle]=CreateFileA(r, GENERIC_READ,
0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,0)
a==INVALID_HANDLE_VALUE#.ee
r=&[s+OutFName]
[s+OutHandle]=CreateFileA(r, GENERIC_WRITE,
0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0)
a==INVALID_HANDLE_VALUE#.e2
j=&[s+580]|i=^InpHandle|k=^OutHandle|b=&[s+1608]
#.5
..e3: r=[s+InpHandle]|CloseHandle(r)
r=[s+OutHandle]|CloseHandle(r)|a=3|##.e
..5: SGetLine(j,1024,i)| jc .e3|a==0#.7|*s=c
FormatA (b,1024,j)| jc .e3
..6: SPuts (k, b)| jc .e3| D*s==0#.5
..7: r=[s+InpHandle]|CloseHandle(r)| a==0#.e3
r=[s+OutHandle]|FlushCloseHandle(r)| jc .z
clc
..z:
s=&[s+3072]InpFName, OutFName
InpHandle, OutHandle
b,i,j,kret 4
/* AppendPointName(u8* res, u32 resSize, u8* array1, u8* arr2)
/* Ritorna la lunghezza della stringa
/* 0k,4j,8i,12b,16ra, 20P_res, 24P_resSize, 28P_arr1, 32P_arr2
AppendPointName:
<b,i,j,k
j=[s+20]|k=[s+24]|i=[s+28]
j==0#.e |k<=1?#.e|i#.1
..e: a^=a| stc| #.z
..1: FindLastPoint_i()|c>k#.e
<k| k=c| DCopy()| >k | jc .e
k-=a|j+=a
B*j='.'| --k!#.e| ++j| B*j=0
i=[s+32]|B*i=='.'!#.2
--j|++k| B*j=0
..2: CatStr(j, k, i)
k-=a|j+=a
i=[s+20]
B*i=='"'!#.3
k<=2?#.e
B*j='"'|++j
..3: B*j=0|j-=i|a=j
clc
..z:
b,i,j,kret 16
/* u32 [size] CatStr(u8* dest, u32 Size, u8* stringCat)
/* 0j,4ra,8P_dest,12P_size,16P_stringCat a,c,r,j
CatStr:
<j
j=[s+8]|c=[s+12]|r=[s+16]
j==0#.e|a^=a|c>1?#.2
..ee: B*j=0
..e: a^=a| stc| #.z
..1: ++j|--c!#.e
..2: B*j#.1
..3: al=*r|*j=al|a==0#.4
--c!#.ee|++r,j|#.3
..4: a=j|B*j=0|a-=[s+8]|clc
..z:
jret 12
InizioTempo:
pushad|GetTickCount()|*TempoA=a|popad|ret
StampaDelta:
pushad
s-=8
GetTickCount()|a-=*TempoA|j=a
i=*stderr|SPuts(i,";;Ok Delta Time: ")
HexPrint(j) /* a=s|B*a=' '|B[a+1]=0
SPuts(i, nl)
s+=8
popad
ret
/* 0k,4j,8i,12b,16ra, 20P_Arry1 + 2048
/* 2068
FaiObj:
<b,i,j,k
s-=2048
k=[s+2068]|j=&[s+256]|k#.1
..e: a^=a| stc| ##.z
..1: D*s=".asm"|D[s+4]=0|a=s
AppendPointName(j,760, k,a)| jc .e
InizioTempo()
pushad
i=*stderr|SPuts(i, "Macro2D\n" )
popad
a=k|r=j|MacroNasm()|jc .e
StampaDelta()
i=&[s+1024]|a="Nasmw -fobj "
B*i=0|CatStr(i,1020,a)|jc .e
r=1020| r-=a
i+=a |CatStr(i, r,j)|jc .e
i=&[s+1024]
InizioTempo()
SystemA(i)| jc .e
a#.e
StampaDelta()
a=1|clc /* per ok
..z:
s=&[s+2048]
b,i,j,kret 4
/* 0k,4j,8i,12b,16ra, 20P_Arry1 + 2048
/* 2068
FaiPe:
<b,i,j,k
s-=2048
k=[s+2068]|j=&[s+256]|k#.1
..e: a^=a| stc| ##.z
..1: FaiObj(k)| jc .e /* macro+nasm
D*s=".obj"|D[s+4]=0|a=s
AppendPointName(j,760, k,a)| jc .e
i=&[s+1024]|a="alink -oPE "
B*i=0|CatStr(i,1020,a)|jc .e
b=1020
b-=a|i+=a|CatStr(i,b,j)|jc .e
r=" win32.lib"
b-=a|i+=a|CatStr(i,b,r)|jc .e
i=&[s+1024]
InizioTempo()
SystemA(i)| jc .e /* Alink
a#.e
StampaDelta()
a=1|clc
..z:
s=&[s+2048]
b,i,j,kret 4
/* 0k,4j,8i,12b,16ra, 20P_Arry1 + 2048
/* 2068
FaiDll:
<b,i,j,k
s-=2048
k=[s+2068]|j=&[s+256]|k#.1
..e: a^=a| stc| ##.z
..1: FaiObj(k)| jc .e /* macro+nasm
D*s=".obj"|D[s+4]=0|a=s
AppendPointName(j,760, k,a)| jc .e
i=&[s+1024]|a="alink -oPE -dll "
B*i=0|CatStr(i,1020,a)|jc .e
b=1020
b-=a|i+=a|CatStr(i,b,j)|jc .e
r=" win32.lib"
b-=a|i+=a|CatStr(i,b,r)|jc .e
i=&[s+1024]
InizioTempo()
SystemA(i)| jc .e /* Alink
a#.e
StampaDelta()
a=1|clc
..z:
s=&[s+2048]
b,i,j,kret 4
/* 0k,4j,8i,12b,16ra, 20P_Arry1 + 2048
/* 2068
FaiConsole:
<b,i,j,k
s-=2048
k=[s+2068]|j=&[s+256]|k#.1
..e: a^=a| stc| ##.z
..1: FaiObj(k)| jc .e /* macro+nasm
D*s=".obj"|D[s+4]=0|a=s
AppendPointName(j,760, k,a)| jc .e
i=&[s+1024]|a="alink -oPE -subsys con "
B*i=0|CatStr(i,1020,a) |jc .e
b=1020
b-=a|i+=a|CatStr(i,b,j)|jc .e
r=" win32.lib"
b-=a|i+=a|CatStr(i,b,r)|jc .e
i=&[s+1024]
InizioTempo()
SystemA(i)| jc .e /* Alink
a#.e
StampaDelta()
a=1|clc
..z:
s=&[s+2048]
b,i,j,kret 4
InterattivoNasm:
<b,i,j,k
s-=1024
j=*stdout|i=*stdin|k^=k
j==-1#.e |i==-1#.e|D[stderr]==0#.e
InstallNasm()| jnc .1
..e: FreeMem() |stc|##.z
..1: b="Inserisci Nasm Macro > "
..2: r=*stderr|SPuts(r,b)| jc .e
a=&[s+8]|SGetLine(a, 510, i)| jc .e
a==0#.7 | *s=c
a=&[s+8]|r=&[s+512]
k=LineToNasm(r, 500, a, k)| jc .2
r=&[s+512]|SPuts(j,r)|jc .e
D*s==0#.2
..7: FreeMem()
clc
..z:
s=&[s+1024]
b,i,j,kret
ProvaFunzioni:
<b,i,j,k
s-=1024
j=*stdout|i=*stdin|k^=k
j==-1#.e |i==-1#.e|D[stderr]==0#.e
InstallRos()| jnc .1
..e: FreeMem() |stc|##.z
..1: b="Inserisci Nasm Macro > "
..2: r=*stderr|SPuts(r,b)| jc .e
a=&[s+8]|SGetLine(a, 510, i)| jc .e
a==0#.7 | *s=c
a=&[s+8]|r=&[s+512]
k=LineToRosAsm(r, 500, a, k)
c==0#.7
/* jc .2
r=&[s+512]|SPuts(j,r)|jc .e
D*s==0#.2
..7: FreeMem()
clc
..z:
s=&[s+1024]
b,i,j,kret
/* P --> little help
/* P -h[elp*] --> little help
/* P -howuse --> big help
/* P a.asm --> fomat(a.asm) -> a_Btf.asm
/* P a.m --> a.asm
/* P a.m b.m --> b.m [lo scrive in b]
/* P -Ob a.m --> a.asm
/* nasmw -fobj a.asm -> a.obj
/* P -Pe a.m --> a.asm
/* nasmw -fobj a.asm -> a.obj
/* alink -oPe a.obj win32.lib -> a.exe
/* P -Co a.m --> a.asm
/* nasmw -fobj a.asm -> a.obj
/* alink -oPe -subsys con a.obj win32.lib -> a.exe
/*------------------------------
/* "123 456", 7
/* 40,44,48, 840 sono 200 elementi
/* per memorizzare i possibili parametri
...start:
_main:
AsmMain:
<b,i,j,k
s-=2048
finit
GetStdIo()|jc .e0
a=&[s+40]|PrendiArgomenti(a, 200)|jnc .1
..e: b=*stderr|b==-1#.0
SPuts(b, "Errore di argomenti; " )
PrintError(b)
..0: CloseStdIo()
..e0: a=1|stc|##.z
..1: a==0#.e
c=a|--c| c==0#.4
c==1#.2| ##.8
..2: r=[s+c*4+40]|B*r=='-'!#.2b
D*r=="-In "!#.2c
..2a: InterattivoNasm()| ##.y
..2b: ##.6
..2c: D*r=="-In"#.2a
B[r+1]=='h'!#.e|B[r+2]==0#.4|B[r+2]==' '#.4
D[r+1]=="help"#.4|D[r+1]=="howu"#.5|##.e
..4: ShowHelpConsole(Litlehelp)| ##.y
..5: a=D[r+5]|a&=00000FFFFh|a!="se"#.e
ShowHelpConsole(helpText)
ShowMacro(MacroDefinizioniGenerali)
ShowMacro(NasmDef)| ##.y
..6: i=r|FindLastPoint_i()|B[i+c]== 0 #.7
D[i+c]!=".asm"#.7
Beautyfy(i)|jc .e| ##.y
..7: a^=a|r^=r|j=&[s+1024]|c>=1000#.e|k=c
DCopy()|D[j+a]=".asm"|B[j+a+4]=0
B*i=='"'!#.7a|B[j+a+4]='"'|B[j+a+5]=0|#.7b
..ee: ##.e
..7a: B*i=="'"!#.7b|B[j+a+4]="'"|B[j+a+5]=0
..7b: a=[s+4+40] /* I argomento
r=j /* II argomento
..7c: MacroNasm()|jc .ee| ##.y
..8: c==2#.8a |##.x
..8a: b=c /* conserva il numero di argomenti
r=[s+b*4+40] /* II argomento
a=[s+b*4+40-4] /* I argomento
D*a=="-Ob "!#.9
..8b: FaiObj(r)| jc .eee| ##.y
..9: D*a=="-ob "#.8b
D*a=="-Pe "!#.a
..9a: FaiPe(r)| jc .eee| ##.y
..a: D*a=="-pe "#.9a
D*a=="-Co "!#.b
..aa: FaiConsole(r)| jc .eee| ##.y
..b: D*a=="-co "#.aa
D*a=="-Dl "!#.b1
..b0: FaiDll(r)| jc .eee| ##.y
..b1: D*a=="-dl "#.b0
r=[s+c*4+40] /* II argomento
a=[s+c*4+40-4] /* I argomento
##.7c
..eee: b=*stderr|b==-1#.c|SPuts(b,"Errore nell'origine; ")
|PrintError(b)
..c: ##.0
..x: c==3!#.4 | a=[s+c*4+40-8] /* I argomento
r=D*a| r&=000FFFFFFh|r!="-r "#.4
a=[s+c*4+40-4] /* II argomento
r=[s+c*4+40] /* III argomento
MacroRosAsm()|jc .ee
..y: CloseStdIo()
a^=a
..z:
s=&[s+2048]
b,i,j,kret
.
- Follow-Ups:
- Re: Macro2D
- From: Herbert Kleebauer
- Re: Macro2D
- From: Rosario
- Re: Macro2D
- Prev by Date: Re: Macro2D
- Next by Date: Re: Macro2D
- Previous by thread: Re: Macro2D
- Next by thread: Re: Macro2D
- Index(es):
Relevant Pages
|
