/programs/develop/c--/trunk/32.c-- |
---|
0,0 → 1,1441 |
//===== « £¨ ª®¬¯¨«ï樨 |
#pragma option w32c |
#stack 0x8000 |
#argc TRUE |
//===== ®¤ª«îç ¥¬ë¥ ¬®¤ã«¨ |
#include "wapi.h--" |
#include "enums.h--" |
#include "data.h--" |
#include "opcodesc.h--" |
#include "tree.h--" |
#include "directiv.h--" |
#include "tokscan.h--" |
#include "exe.h--" |
#include "generate.h--" |
#include "parser.h--" |
//===== « ¢ ï äãªæ¨ï ¯à®£à ¬¬ë |
main() |
dword count,pari,cmdline; |
{ |
stdout=GetStdHandle(STD_OUTPUT_HANDLE); |
WRITESTR("\n32-Compiler Version 0.01\tXAC (C) 1999."); |
WRITESTR("\nBased on SPHINX C-- Compiler Peter Cellik (C) 1995.\n"); |
// §¡®à ª®¬¬ ¤®© áâப¨: 32.exe <SourceFileName> [/map] [/debug] |
pari=@PARAMCOUNT(); |
for(count=1;count<pari;count++){ //®¡à ¡®âª ª®¬ ¤®© áâப¨ |
cmdline=@PARAMSTR(count); |
CharUpperA(EAX); |
CharToOemA(cmdline,cmdline); // ८¡à §ã¥¬ ¢ ¢ OEM ª®¤à®¢ª¥ |
ESI=cmdline; |
IF(DSBYTE[ESI]=='/'){ |
ESI++; |
IF(lstrcmpA("MAP",ESI)==0)makemapfile = 1; |
ELSE IF(lstrcmpA("DEBUG",ESI)==0)dbg=1; |
ELSE{ |
WRITESTR("ERROR > Unknown command line option: '"); |
WRITESTR(cmdline); |
WRITESTR("'\n"); |
ExitProcess(e_unknowncommandline); |
} |
} |
ELSE{ // ®¯¨à㥬 ¨¬ï ¨á室®£® ä ©« ¡¥§ à áè¨à¥¨ï |
EDI=#rawfilename; |
for(;;){ |
$LODSB |
IF(AL=='.')||(AL==0)BREAK; // áâì à áè¨à¥¨¥? |
$STOSB; |
} |
AL=0; |
$STOSB; |
lstrcpyA(#inputfile,cmdline); // ®¯¨à㥬 ¨¬ï ¢å®¤®£® ä ©« á à áè¨à¥¨¥¬ |
} |
} |
IF(rawfilename[0]==0){ |
errmsg(); |
WRITESTR("No input file specified"); |
pari=1; |
} |
IF(pari < 2){ |
WRITESTR("\nUsage: 32.exe [/MAP] [/DEBUG] <Source file>"); |
WRITESTR("\n\t/MAP\t<< generate map file"); |
WRITESTR("\n\t/DEBUG\t<< generate .TDS - debug info file\n"); |
ExitProcess(e_noinputspecified); |
} |
GetMem(); // ¢ë¤¥«¥¨¥ ¯ ¬ï⨠¤«ï ª®¬¯¨«ï樨 |
TokInit(); // ¨¨æ¨ «¨§ æ¨ï ᯨ᪮¢ |
Compile(); |
IF( error == 0 )EAX=e_ok; |
ELSE EAX=e_someerrors; |
ExitProcess(EAX); |
} |
//===== ®¬¯¨«ïâ®à |
Compile() |
{ |
IF(makemapfile)StartMapfile(); |
WRITESTR("Compiling ...\n"); |
Preview(#inputfile); |
CompileAll(); |
/*if( endifcount > 0 ) |
preerror("#endif expected before end of file"); |
if( outptr%16 != 0 ) // paragraph align the end of the code seg |
outptr += 16 - outptr%16;*/ |
DoLink(); // ®à¬¨à®¢ ¨¥ link |
IF(posts > 0)DoPosts(); // ¡®¢«¥¨¥ ¢á¥å post ¤à¥á®¢ |
SeekUndefined(treestart); |
if(error==0){ |
wsprintfA(#mapstr,"\nCOMPILING FINISHED.\tErrors: %d\tLines: %u\n",error,totallines); |
WRITESTR(#mapstr); |
runfilesize = outptr-output; |
postsize += postsize%2; |
PrintMemsizes(GetStdHandle(STD_OUTPUT_HANDLE)); |
IF(WriteEXE()==0) { |
wsprintfA(#mapstr,"\nRun File Saved (%ld bytes).\n",runfilesize); |
WRITESTR(#mapstr); |
wsprintfA(#mapstr,"DLL: %d\tAPI: %d \n",DLLcount,APIcount); |
WRITESTR(#mapstr); |
} |
// if(dbg) |
// dotds(); // do turbo debugger line info |
} |
IF(makemapfile)FinishMapfile(); |
} |
// ---- ।¢ à¨â¥«ì ï ®¡à ¡®âª ä ©« |
Preview(dword filename) |
long hold; |
char trialfilename[FILENAMESIZE]; |
{ |
lstrcpyA(#trialfilename,filename); |
hold = LoadInputfile(#trialfilename); |
IF(EAX==-2)unabletoopen(#trialfilename); |
IF(hold!=0)ExitProcess(e_cannotopeninput); |
lstrcpyA(#currentfilename,#trialfilename); |
module++; |
IF(module<MAXMDL) { |
lstrcpyA(FILENAMESIZE*module+#modules,#currentfilename); |
currmod = module; |
} |
IF(makemapfile){ |
EBX=inptr; |
cha=DSBYTE[EBX]; |
wsprintfA(#mapstr,"File %s included.\n\n%c",#currentfilename,cha); |
fprint(mapfile,#mapstr); |
} |
ShowSrcLine(); |
NextChar(); |
cha2 = cha; |
inptr2=inptr; |
linenum2 = 1; |
NextTok(); |
WHILE(tok!=tk_eof){ // ®ª ¥ ª®ç¨âáï ¢å®¤®© ¡ãä¥à |
IF(tok==tk_directive){ |
GetDirAddr(#Jmp_Directives,number); |
EAX(); |
} |
ELSE IF(tok==tk_command){ |
GetDirAddr(#Jmp_Commands,number); |
EAX(); |
} |
ELSE IF(tok==tk_id)GetProc(tk_void); |
ELSE IF(tok==tk_void){ |
NextTok(); |
GetProc(tk_void); |
} |
ELSE{ |
preerror("unuseable input"); |
NextTok(); |
} |
} |
LocalFree(input); |
} |
// ---- ®¬¯¨«ïæ¨ï ®¤®© ¯à®æ¥¤ãàë ¨«¨ ®¡ê¥¨ï ¤ ëå |
CompileSrc(dword ptr) |
{ |
EAX=src; |
if(EAX){ |
inptr = EAX; |
inptr2 = EAX; |
endoffile = 0; // ç «® ¡ãä¥à |
linenum2 = modline&0xFFFF; |
currmod=modline>>16; |
lstrcpyA(#currentfilename,FILENAMESIZE*currmod+#modules); |
NextChar(); |
cha2 = cha; |
inptr2=inptr; |
IF(tok==tk_proc){ |
Proc(cpt_near); |
DoPoststrings(); |
} |
ELSE IF(tok==tk_var)GlobalVar(type); |
ELSE preerror("Bad input format\n"); |
} |
ELSE{ // post-¯¥à¥¬¥ ï ¡¥§ à §¬¥à®á⨠|
ESI=ptr; |
DSDWORD[ESI+recnumber] = postsize; |
DSDWORD[ESI+recpost] = 1; |
postsize+=TypeSize(type); |
} |
} |
// ---- ®¬¯¨«ïæ¨ï ¢á¥å ¯à®æ¥¤ãà ¨ ®¡ê¥¨© ¤ ëå |
CompileAll() |
{ |
IF(SearchTree(#tok,#type,#src,#post,"main",#number))AX=3; // Console |
ELSE IF(SearchTree(#tok,#type,#src,#post,"WinMain",#number))AX=2; // GUI |
ELSE{ |
preerror("Main not found"); |
return; |
} |
OptSubSystem=AX; |
OptEntryPointRVA=OptBaseOfCode+outptr-output; |
CompileSrc(treeptr); // ®¬¯¨«ïæ¨ï main |
WHILE(SeekToDo(treestart)){ |
ESI=treeptr; |
wsprintfA(#mapstr,"==>%3d %8lXh %8lXh %6Xh\t%s\n",DSDWORD[ESI+rectok], |
DSDWORD[ESI+rectype],DSDWORD[ESI+recnumber],DSDWORD[ESI+recpost], |
DSDWORD[ESI+recid]); |
fprint(mapfile,#mapstr); |
CompileSrc(treeptr); // ®¬¯¨«ïæ¨ï ¨á室¨ª®¢ |
} |
IF(makemapfile) |
fprint(mapfile,"Compile all sources\n"); |
} |
// ---- ¡à ¡®âª ¯ à ¬¥â஢ ¯à¨ ®¡ê¥¨¨ ¯à®æ¥¤ãàë |
DeclareParams() |
dword paramtok,paramtype; |
{ |
LL: |
IF(tok==tk_command)GetDirAddr(#Jmp_Commands,number); |
ELSE EAX=-1; |
IF(EAX==#CmdShort){ |
paramtok = tk_param; |
paramtype=tk_short; |
} |
ELSE IF(EAX==#CmdWord){ |
paramtok = tk_param; |
paramtype=tk_word; |
} |
ELSE IF(EAX==#CmdChar){ |
paramtok = tk_param; |
paramtype=tk_char; |
} |
ELSE IF(EAX==#CmdByte){ |
paramtok = tk_param; |
paramtype=tk_byte; |
} |
ELSE IF(EAX==#CmdInt){ |
paramtok = tk_param; |
paramtype=tk_int; |
} |
ELSE IF(EAX==#CmdDword){ |
paramtok = tk_param; |
paramtype=tk_dword; |
} |
ELSE{ |
datatype_expected(); |
NextTok(); |
} |
for(;;){ |
NextTok(); |
IF(tok==tk_id ){ |
paramsize += 4; |
AddLocalvar(#string,paramtok,paramtype,paramsize); |
} |
ELSE IF(tok==tk_semicolon){ |
NextTok(); |
$JMP LL |
} |
ELSE IF(tok==tk_closebracket)BREAK; |
ELSE IF(tok!=tk_comma)idexpected(); |
} |
} |
// ---- ¡à ¡®âª «®ª «ìëå ¯¥à¥¬¥ëå ¯à¨ ®¡ê¥¨¨ ¯à®æ¥¤ãàë |
DeclareLocals() |
dword size; |
dword loctok,loctype; |
{ |
LL: |
IF(tok==tk_command)GetDirAddr(#Jmp_Commands,number); |
IF(EAX==#CmdShort){ |
loctok = tk_local; |
loctype=tk_short; |
size = 2; |
} |
else IF(EAX==#CmdWord){ |
loctok = tk_local; |
loctype=tk_word; |
size = 2; |
} |
else IF(EAX==#CmdChar){ |
loctok = tk_local; |
loctype=tk_char; |
size = 1; |
} |
ELSE IF(EAX==#CmdByte){ |
loctok = tk_local; |
loctype=tk_byte; |
size = 1; |
} |
ELSE IF(EAX==#CmdInt){ |
loctok = tk_local; |
loctype=tk_int; |
size = 4; |
} |
ELSE IF(EAX==#CmdDword){ |
loctok = tk_local; |
loctype=tk_dword; |
size = 4; |
} |
ELSE IF(tok==tk_eof)||(tok==tk_openbrace)$JMP L1 |
ELSE{ |
datatype_expected(); |
NextTok(); |
goto LL; |
} |
for(;;){ |
NextTok(); |
IF(tok==tk_id){ |
AddLocalvar(#string,loctok,loctype,localsize); |
IF(tok2==tk_openblock){ |
NextTok(); |
NextTok(); |
localsize += DoConstLongMath()*size; |
EAX=localsize; |
$TEST EAX,3; |
IF(NOTZEROFLAG){ |
EAX=EAX>>2+1<<2; |
localsize=EAX; // ëà ¢¨¢ ¨¥ dword |
} |
expecting(tk_closeblock); |
} |
ELSE localsize+=4; |
} |
ELSE IF(tok==tk_semicolon){ |
NextTok(); |
$JMP LL |
} |
ELSE IF(tok==tk_openbrace)||(tok==tk_eof)BREAK; |
ELSE IF(tok!=tk_comma)idexpected(); |
} |
L1: |
IF(paramsize==0)Asm("push ebp; mov ebp,esp;"); |
wsprintfA(#mapstr,"sub esp,%d;",localsize); |
Asm(#mapstr); |
} |
// ---- ¡à ¡®âª ®¡à é¥¨ï ª 㦥 ®¯¨á ®© ¯à®æ¥¤ãॠ|
DoAnyProc() |
byte s[80]; |
{ |
wsprintfA(#s,"call %s;",#string); |
NextTok(); |
DoParams(); |
Asm(#s); |
} |
// ---- ¡à ¡®âª à ¥¥ ®¡ê¢«¥®©, ® ¯®ª ¥ ¨§¢¥á⮩ ¬¥âª¨ |
dword DoAnyUndefproc(dword expectedreturn) |
byte s[80]; |
{ |
IF( tok2 == tk_colon ){ // ¬¥âª |
number = outptr-output+OptImageBase+OptBaseOfCode; |
tok = tk_proc; |
ESI=treeptr; |
DSDWORD[ESI+rectok] = tok; |
DSDWORD[ESI+recnumber] = number; |
DSDWORD[ESI+recpost] = 0; |
NextTok(); // move past id |
NextTok(); // move past : |
RETURN(tokens); |
} |
IF( tok2 == tk_openbracket ){ |
wsprintfA(#s,"call %s;",#string); |
NextTok(); |
DoParams(); |
Asm(#s); |
RETURN(tk_dword); |
} |
undefinederror(); |
NextTok(); |
return(tk_int); |
} |
// ---- ¡à ¡®âª ®¡à é¥¨ï ª API äãªæ¨¨ |
dword doAPI() |
dword hold; |
byte s[IDLENGTH]; |
{ |
if( tok2 == tk_openbracket ){ |
hold = treeptr; |
GetVarname(#s); |
NextTok(); |
DoParams(); |
IF(posts>=MAXPOSTS){ |
preerror("maximum number of API procedure calls exceeded"); |
return(tokens); |
} |
EBX=hold; |
IF(DSDWORD[EBX+recpost]==0) { // ¥à¢ë© ¢ë§®¢ API? |
DSDWORD[EBX+recpost]=1; // ®â¬¥â¨¬ ¢ë§®¢ ¤ ®© API |
APIcount++; |
EAX=DSDWORD[EBX+rectype]; // ª § ⥫ì DLL, ¢ ª®â®à®¬ 室¨âáï API |
DSDWORD[EAX+recmodline]++; // ¢¥«¨ç¨¬ áç¥â稪 API, ¢ë§¢ ëå ¨§ DLL |
} |
OUTWORD(0x15FF); // call [dword] |
SetPost(hold,POST_API); |
OUTDWORD(0); |
IF(list){ |
fprint(mapfile,"\t//\tcall "); |
fprint(mapfile,#s); |
fprint(mapfile,"\n"); |
} |
return(tk_int); |
} |
undefinederror(); |
NextTok(); |
return(tokens); |
} |
// ---- ¡à ¡®âª ¯à®£à ¬¬®£® ¡«®ª {...} |
void DoBlock() |
{ |
expecting(tk_openbrace); |
for(;;){ |
IF(tok==tk_eof){ |
unexpectedeof(); |
BREAK; |
} |
IF(tok == tk_closebrace){ |
NextTok(); |
BREAK; |
} |
DoCommand(); |
} |
} |
// ---- ¡à ¡®âª ®¤®© ª®¬ ¤ë ¢ãâਠ¡«®ª |
DoCommand() |
{ |
LL: |
FastSearch(#string,#St_Sizes);// â® à §¬¥à ®¯¥à ¤ ? |
IF(CARRYFLAG){ // : byte,word ¨«¨ dword |
type=EAX<<1+tk_byte; |
string[0]=0; |
tok=tk_var; |
GOTO LL; |
} |
IF(tok==tk_mnemonics){ |
DoMnemonics(); |
NextTok(); |
} |
else IF(tok==tk_directive){ |
GetDirAddr(#Jmp_Directives,number); |
EAX(); |
} |
else IF(tok==tk_command){ |
GetDirAddr(#Jmp_Commands,number); |
EAX(); |
} |
else IF(tok==tk_id){ |
DoId(tk_void); |
IF(EAX!=tokens)NextSemiNext(); |
} |
else IF(tok==tk_undefproc){ |
DoAnyUndefproc(tk_void); |
IF(EAX!=tokens)NextSemiNext(); |
} |
else IF(tok==tk_proc){ |
DoAnyProc(); |
NextSemiNext(); |
} |
else IF(tok==tk_API){ |
IF(doAPI()!=tokens)NextSemiNext(); |
} |
else IF(tok==tk_var)||(tok==tk_local)||(tok==tk_param)||(tok==tk_reg)DoVar(type); |
ELSE IF(tok==tk_openblock)DoVar(tk_dword); |
ELSE IF(tok==tk_string){ |
Macros(); |
NextSemiNext(); |
} |
ELSE IF(tok==tk_locallabel)DoLocalPost(); |
ELSE IF(tok==tk_openbrace)DoBlock(); |
ELSE IF(tok==tk_comma)||(tok==tk_semicolon)NextTok(); |
ELSE IF(tok==tk_eof)unexpectedeof(); |
/* case tk_from: |
NextTok(); DoFrom(0); NextSemiNext(); break; |
case tk_extract: |
NextTok(); DoExtract(0); SemiNext(); break; |
*/ |
} |
// ---- ¡à ¡®âª ®¢ëå ¨¤¥â¨ä¨ª â®à®¢ |
dword DoId(dword expectedreturn) |
byte s[80]; |
{ |
IF(tok2 == tk_colon){ // ¬¥âª ? |
number = outptr-output+OptImageBase+OptBaseOfCode; |
tok = tk_proc; |
post = 0; |
AddToTree(#string); |
NextTok(); NextTok(); // ¯à®¯ãá⨬ ¨¤¥â¨ä¨ª â®à ¨ : |
EAX=tokens; |
} |
ELSE IF(tok2 == tk_openbracket){ // ¢ë§®¢ ¯à®æ¥¤ãàë |
wsprintfA(#s,"call %s;",#string); |
tok = tk_undefproc; |
number=0; |
post=1; |
AddToTree(#string); |
NextTok(); |
DoParams(); |
Asm(#s); |
EAX=expectedreturn; |
} |
ELSE{ |
undefinederror(); |
NextTok(); |
EAX=tk_int; |
} |
} |
// ---- ¡à ¡®âª ¯ à ¬¥â஢ ¯à¨ ¢ë§®¢¥ ¯à®æ¥¤ãàë |
DoParams() |
{ |
IF(tok==tk_openbracket){ |
inptr2--; |
DoParam(); |
NextTok(); |
} |
ELSE expecting(tk_openbracket); |
} |
// ---- ¡à ¡®âª <Var> ... |
DoVar(dword vartype) |
dword next,vtok; |
byte varName[2*IDLENGTH]; |
byte varName2[2*IDLENGTH]; |
{ |
next=1; |
vtok=GetVarname(#varName); |
NextTok(); |
IF(tok==tk_assign){ |
NextTok(); |
IF(tok2notstopper()){ |
DoExpr(#varName,vtok,vartype,"mov"); |
next=0; |
} |
ELSE GetIntoVar(#varName,vtok,vartype); |
} |
else IF(tok==tk_minusminus){ // Var--; |
wsprintfA(#mapstr,"dec %s",#varName); |
Asm(#mapstr); |
} |
else IF(tok==tk_plusplus){ // Var++; |
wsprintfA(#mapstr,"inc %s",#varName); |
Asm(#mapstr); |
} |
else IF(tok==tk_plusequals){ // Var+=Expr; |
NextTok(); |
DoExpr(#varName,tk_var,vartype,"add"); |
next=1; |
} |
else IF(tok==tk_minusequals){ // Var-=Expr; |
NextTok(); |
DoExpr(#varName,tk_var,vartype,"sub"); |
next=1; |
} |
else IF(tok==tk_andequals){ // Var&=Expr; |
NextTok(); |
DoExpr(#varName,tk_var,vartype,"and"); |
next=1; |
} |
else IF(tok==tk_xorequals){ // Var^=Expr; |
NextTok(); |
DoExpr(#varName,tk_var,vartype,"xor"); |
next=1; |
} |
else IF(tok==tk_orequals){ // Var|=Expr; |
NextTok(); |
DoExpr(#varName,tk_var,vartype,"or"); |
next=1; |
} |
else if(tok==tk_swap){ // Var><Var; |
NextTok(); |
GetVarname(#varName2); |
IF(tok==tk_reg){ |
wsprintfA(#mapstr,"xchg %s,%s",#string,#varName); |
Asm(#mapstr); |
} |
else if(tok==tk_var)&&(tok2notstopper()==0){ |
IF(vartype==tk_dword)||(vartype==tk_int){ |
wsprintfA(#mapstr,"xchg %s,eax",#varName); |
Asm(#mapstr); |
wsprintfA(#mapstr,"xchg %s,eax",#varName2); |
Asm(#mapstr); |
wsprintfA(#mapstr,"xchg %s,eax",#varName); |
} |
else IF(vartype==tk_word)||(vartype==tk_short){ |
wsprintfA(#mapstr,"xchg %s,ax",#varName); |
Asm(#mapstr); |
wsprintfA(#mapstr,"xchg %s,ax",#varName2); |
Asm(#mapstr); |
wsprintfA(#mapstr,"xchg %s,ax",#varName); |
} |
ELSE IF(vartype==tk_byte)||(vartype==tk_char){ |
wsprintfA(#mapstr,"xchg %s,al",#varName); |
Asm(#mapstr); |
wsprintfA(#mapstr,"xchg %s,al",#varName2); |
Asm(#mapstr); |
wsprintfA(#mapstr,"xchg %s,al",#varName); |
} |
Asm(#mapstr); |
} |
ELSE swaperror(); |
} |
else IF(tok==tk_llequals){ // Var<<=Expr; |
NextTok(); |
IF(tok == tk_number) wsprintfA(#mapstr,"shl %s,%d",#varName,DoConstMath()); |
ELSE{ |
Expression("cl",tk_reg,tk_byte); |
wsprintfA(#mapstr,"shl %s,cl",#varName); |
next=0; |
} |
Asm(#mapstr); |
} |
ELSE IF(tok==tk_rrequals){ // Var>>=Expr; |
NextTok(); |
IF(tok == tk_number)wsprintfA(#mapstr,"shr %s,%d",#varName,DoConstMath()); |
ELSE{ |
Expression("cl",tk_reg,tk_byte); |
wsprintfA(#mapstr,"shr %s,cl",#varName); |
next=0; |
} |
Asm(#mapstr); |
} |
ELSE operatorexpected(); |
IF(next)NextSemiNext(); |
ELSE SemiNext(); |
} |
// ---- ¡à ¡®âª ááë«®ª ¢¯¥à¥¤ |
DoPosts() |
dword addhold,i; |
{ |
i=0; |
while(i<posts){ |
ECX=i<<2; |
ESI=posttype+ECX; |
EAX=DSDWORD[ESI]; |
ESI=postloc+ECX; |
EBX=DSDWORD[ESI]; |
ESI=postnum+ECX; |
ECX=DSDWORD[ESI]; |
IF(EAX==POST_DATA){ |
IF(DSDWORD[ECX+recpost]){ |
GetDword(EBX); |
EAX=EAX+DSDWORD[ECX+recnumber]+OptImageBase+OptBaseOfCode+outptr-output; |
} |
ELSE{ |
GetDword(EBX); |
EAX+=DSDWORD[ECX+recnumber]; |
} |
SetDword(EBX,EAX); |
} |
ELSE IF(EAX==POST_CALL){ |
EAX=DSDWORD[ECX+recnumber]-OptImageBase-OptBaseOfCode-EBX; // áç¥â ®â®á¨â¥«ì®£® ᬥ饨ï EAX-=addvalue; |
EAX+=output; |
SetDword(EBX,EAX-4); |
} |
ELSE IF(EAX==POST_LOC){ |
EAX=ECX; EAX-=OptImageBase; |
EAX-=OptBaseOfCode; EAX-=EBX; // áç¥â ®â®á¨â¥«ì®£® ᬥ饨ï EAX-=addvalue; |
EAX+=output; SetDword(EBX,EAX-4); |
} |
ELSE IF(EAX==POST_API){ |
addhold = OptImageBase + DSDWORD[ECX+recmodline]; |
SetDword(EBX,addhold); |
} |
ELSE preerror("Bad post type\n"); |
i++; |
} |
} |
// ---- ëáâàë© ¯®¨áª ¯® â ¡«¨æ¥ |
// OUTPUT: EAX=No.& CARRYFLAG - success |
dword FastSearch(dword probe,table) |
byte ident[IDLENGTH]; |
{ |
$PUSH ECX,ESI,EDI,EDX |
lstrcpyA(#ident,probe); |
CharUpperA(#ident); |
lstrlenA(#ident); |
EDX=EAX-1; |
$JZ HET // ident ¨§ ®¤®£® ᨬ¢®« |
EBX=0; |
BL=ident;//[0]; // ஢¥à¨¬ ¯¥à¢ë© ᨬ¢®« ¢ ident |
BL-='A'; |
$JC HET // ¥ ¡ãª¢ |
$CMP BL,'Z'-'A'; |
$JA HET // ¨ ¥ 'A'...'Z' |
EAX=0; |
EBX=EBX<<2+table; |
EDI=DSDWORD[EBX]; // §ïâì ¤à¥á § ¯¨á¨ ¨§ table |
$OR EDI,EDI; |
$JE HET // ¥â § ¯¨á¨ ¤«ï â ª®£® ident... |
TRY0: |
AH=DSBYTE[EDI]; |
EDI++; // ®¬¥à § ¯¨á¨ ¨§ table ¨ áâப㠢 table |
TRY1: |
ESI=#ident+1; |
ECX=EDX; // §ïâì ident ¤«¨ã - 1 |
$REPE $CMPSB; |
$JNE NXT // à ¢¨¬ á § ¯¨áìî ¢ table |
$JCXZ YES1 // ®¢¯ «¨ ¯® ¤«¨¥ probe |
NXT: |
EDI--; |
LOOK: |
AL=DSBYTE[EDI]; |
EDI++; |
$OR AL,AL; |
$JE TRY0 // ஢¥à¨¬ á«¥¤ãîéãî § ¯¨áì |
$CMP AL,'/'; |
$JE NEAR TRY1 // ஢¥à¨¬ ALIAS |
$CMP AL,_END; |
$JE NEAR HET // ®¥æ â ¡«¨æë - ¢ë室 |
GOTO LOOK; |
HET: |
$CLC; |
GOTO EX; // ident ¥ ©¤¥ ¢ table |
YES1: |
$CMP DSBYTE[EDI],0; |
$JZ YES; |
$CMP DSBYTE[EDI],_END; |
$JZ YES; |
$CMP DSBYTE[EDI],'/'; |
$JZ YES; |
GOTO NXT; |
YES: |
AL=AH; |
AH=0; |
$STC // ident ©¤¥ ¢ table |
EX: |
$POP EDX,EDI,ESI,ECX; |
} |
// ---- 뢮¤ áâ â¨á⨪¨ ¯® ª®¬¯¨«ï樨 |
FinishMapfile() |
{ |
fprint(mapfile,"\n"); |
DisplayTree(); |
fprint(mapfile,"Component Sizes:\n"); |
PrintMemsizes(mapfile); |
wsprintfA(#mapstr,"Run file size: %ld bytes\n",runfilesize); |
fprint(mapfile,#mapstr); |
wsprintfA(#mapstr,"\nEND OF MAP FILE FOR %s.%s\n\n",#rawfilename,"EXE"); |
fprint(mapfile,#mapstr); |
_lclose(mapfile); |
mapfile=0; |
list=0; |
} |
// ---- 뢮¤ ¢ ä ©« |
fprint(dword handle,str) |
{ |
_lwrite(handle,str,lstrlenA(str)); |
} |
// ---- 뤥«¥¨¥ ¯ ¬ï⨠¤«ï ª®¬¯¨«ï樨. ਠ¥ã¤ ç¥ ¢ë室 ¨§ ª®¬¯¨«ïâ®à |
GetMem() |
{ |
output=LocalAlloc(0x40,MAXDATA); |
IF(EAX==NULL)outofmemory2(); |
LocalUnlock(output); |
outptr=output; |
startptr=output; |
postloc=LocalAlloc(0x40,MAXPOSTS*4); |
IF(EAX==NULL)outofmemory2(); |
postnum=LocalAlloc(0x40,MAXPOSTS*4); |
IF(EAX==NULL)outofmemory2(); |
posttype=LocalAlloc(0x40,MAXPOSTS); |
IF(EAX==NULL)outofmemory2(); |
dbginfo=LocalAlloc(0x40,MAXDBGS*dbg_size); |
IF(EAX==NULL)outofmemory2(); |
dbgs=dbginfo; |
} |
// ---- ⥨¥ ¤¢®©®£® á«®¢ |
dword GetDword(dword ptr) |
{ |
ESI><ptr; |
$LODSD; |
ESI><ptr; |
} |
// ---- ¨æ¨ « § æ¨ï ᯨ᪠|
// «ï keylist = {"ZAK",0,"AAD",0,"ABC",0,"BAR",0,"AAA",0,"ZZ",0,"BAC",_END}; |
// áä®à¬¨àã¥âáï áâàãªâãà ¢ ¯ ¬ï⨠᫥¤ãî饣® ¢ ¤ : |
// table |
// +-----+ |
// | 'A' | ---> db 4,'AA',1,'AD',2,'BC',_END |
// +-----+ |
// | 'B' | ---> db 6,'AC',3,'AR",_END |
// +-----+ |
// | ... | |
// +-----+ |
// | 'Z' | ---> db 0,'AK',5,'Z',_END |
// +-----+ |
InitList(dword keylist,table) |
dword ptr; |
{ |
ptr=LocalAlloc(0x40,SORTSIZE*256); |
IF(EAX==NULL)outofmemory2(); |
EDI><EAX; //ptr; |
ESI=keylist; |
ECX=0; |
BL=0; |
// ¥á¥¨¥ áâப ¨§ keylist ¢ ptr |
for(;;){ |
for(;;){ |
$PUSH EDI; |
IF(DSBYTE[ESI]!='-')BREAK; |
ESI+=2; |
BL++; |
$POP EDI; |
} |
AL=BL; |
$STOSB // ®åà ¨¬ ¯®à浪®¢ë© ®¬¥à áâப¨ |
for(;;){ |
$LODSB // ª®¯¨à㥬 áâப㠢 ptr |
IF(AL<' ')BREAK; |
$STOSB; |
} |
IF(AL==_END)BREAK; |
$STOSB; |
$POP EDI; |
BL++; |
EDI+=SORTSIZE; |
ECX++; |
} |
ESI=ptr; |
$PUSH ECX // ®¯¨à®¢ ¨¥ ¢ ptr § ª®ç¥®. ®åà ¨¬ ª®«-¢® áâப |
ECX--; |
IF(NOTZEROFLAG){// ᥣ® ®¤ áâப ? - á®àâ¨à®¢ª ¥ 㦠|
// ®àâ¨à®¢ª áâப ¢ ptr |
loop(ECX){ |
$PUSH ESI,ECX; |
EDI=ESI+SORTSIZE; |
loop(ECX){ |
$PUSH ECX,ESI,EDI; |
ECX=SORTSIZE; |
ESI++; |
EDI++; |
$REPE $CMPSB; |
$POP EDI,ESI; |
IF(NOTCARRYFLAG){ // ¯à®¢¥à¨â ãá«®¢¨¥ ????????????à ¢¥¨¥ ¤¢ãå áâப |
EAX=ESI; |
EDX=EDI; |
EDI=#Buffer16; |
ECX=SORTSIZE/4; // 諨 ¬¥ìèãî áâபã |
$REP $MOVSD; |
ESI=EDX; |
EDI=EAX; |
ECX=SORTSIZE/4; // -¯®¬¥ï¥¬ ¬¥áâ ¬¨ |
$REP $MOVSD; |
ESI=#Buffer16; |
EDI=EDX; |
ECX=SORTSIZE/4; |
$REP $MOVSD; |
ESI=EAX; |
EDI=EDX; |
} |
EDI+=SORTSIZE; |
$POP ECX; |
} |
$POP ECX,ESI; |
ESI+=SORTSIZE; |
} |
} |
// ®àâ¨à®¢ª ¢¢¥¤¥ëå áâப ¢ ¡ãä¥à¥ ptr § ª®ç¥ |
EDI=table; |
ECX=26; |
EAX=0; |
$REP $STOSD; // ¡ã«¥ ¥ table |
$POP ECX; |
ESI=ptr; |
EDI=ESI; |
$PUSH ESI; |
GOTO L42; // ®à¬ à㥬 â ¡«¨æã |
loop(ECX){ |
$PUSH ESI; |
IF(AH!=DSBYTE[ESI+1]){ |
EDI--; |
AL=_END; |
$STOSB // ⬥⨬ ª®¥æ â ¡«¨æë ¤«ï ¤ ®£® ᨬ¢®« ¢ AH |
L42: |
AH=DSBYTE[ESI+1]; |
EBX=0; |
BL=AH; |
BL-='A'; |
EBX=EBX<<2+table; //¤ «ìè¥ ¨¤¥â ªà å |
DSDWORD[EBX]=EDI; // ¯¨áì 㪠§ â¥«ï ¢ table |
} |
$MOVSB // ¯®¬¨¬ ¯®à浪®¢ë© ®¬¥à áâப¨ |
ESI++; // யã᪠¯¥à¢®£® ᨬ¢®« - ® 㦥 ¨§¢¥á⥠|
do{ |
$LODSB; |
$STOSB; |
}while(AL!=0); // ®¯¨à㥬 áâப㠢 table |
$POP ESI; |
ESI+=SORTSIZE; |
} // த®«¦¨¬ ¤«ï á«¥¤ãî饩 áâப¨ |
EDI--; |
AL=_END; |
$STOSB // table áä®à¬¨à®¢ . ⬥⨬ ª®¥æ |
} |
// ---- ஢¥àª æ¨äàã |
dword IsNumber(dword ch) |
{ |
IF(ch<'0')||(ch>'9')EAX=0; |
ELSE EAX=1; |
} |
// ---- ⥨¥ ¢å®¤®£® ä ©« ¢ ¡ãä¥à |
long LoadInputfile(dword infile) |
dword fhandle, size; |
{ |
fhandle=_lopen(infile,0); |
IF(EAX==-1){ |
GetLastError(); |
return(-2); |
} |
EAX=GetFileSize(EAX,0); |
IF(EAX==-1){ |
unabletoopen(infile); |
_lclose(fhandle); |
return(-1); |
} |
size=EAX; |
input=LocalAlloc(0x40,EAX+2); // ¯®«¥ ï ã«ï¬¨ |
IF(EAX==NULL){ |
preerror("Not enough memory for input buffer"); |
_lclose(fhandle); |
RETURN(-1); |
} |
EAX=_lread(fhandle,input,size); |
IF(EAX!=size){ |
preerror("File Read error"); |
_lclose(fhandle); |
RETURN(-1); |
} |
_lclose(fhandle); |
inptr = input; |
inptr2 = input; |
endoffile = 0; // ç «¥ ä ©« |
return(0); |
} |
// ---- ¡à ¡®âª ¬ ªà®á |
Macros() |
byte holdcha; |
byte s[STRLEN],s2[STRLEN]; |
{ |
IF(makemapfile){ |
fprint(mapfile,#string); |
fprint(mapfile,"\n"); |
} |
holdcha=cha2; |
$PUSH linenum2,inptr2,number,tok2,tok,input,inptr,currmod, |
linenumber,endoffile,displaytokerrors; |
lstrcpyA(#s,#string); |
lstrcpyA(#s2,#string2); |
input=#s; |
inptr=input; |
inptr2=input; |
endoffile=0; // ç «¥ ä ©« |
NextChar(); |
cha2=cha; |
inptr2=inptr; |
linenum2 = 1; |
NextTok(); |
for(;;){ |
IF(tok==tk_eof)BREAK; |
DoCommand(); |
} |
lstrcpyA(#string,#s); |
lstrcpyA(#string2,#s2); |
$POP displaytokerrors,endoffile,linenumber,currmod,inptr,input,tok,tok2, |
number,inptr2,linenum2; |
cha2=holdcha; |
} |
// ---- ç¨á⪠ᯨ᪠«®ª «ìëå ¯¥à¥¬¥ëå |
KillLocals() |
dword ptr1,ptr2; |
{ |
ptr2=locallist; |
WHILE( ptr2 != NULL ){ |
ptr1=ptr2; |
IF( DSDWORD[EAX+localtok]==tk_locallabel) // ஢¥àª ¥§ ªàëâë¥ ¬¥âª¨ |
localunresolved(EAX+localid); |
EAX=ptr2; |
ptr2=DSDWORD[EAX+localnext]; |
GlobalFree(ptr1); |
} |
locallist = NULL; |
paramsize = 0; |
localsize = 0; |
} |
// ---- ¢¥à襨¥ ⥫ ¯à®æ¥¤ãàë |
LeaveProc() |
{ |
IF(localsize > 0)Asm("leave"); |
ELSE{ |
IF(paramsize > 0)Asm("pop ebp"); |
} |
IF( current_proc_type == cpt_far ){ |
IF(paramsize == 0)EAX="retf"; |
ELSE{ |
wsprintfA(#mapstr,"retf %d;",paramsize); |
EAX=#mapstr; |
} |
} |
ELSE{ |
IF(paramsize == 0)EAX="ret"; |
ELSE{ |
wsprintfA(#mapstr,"ret %d;",paramsize); |
EAX=#mapstr; |
} |
} |
Asm(EAX); |
} |
// ---- ⥨¥ ®ç¥à¥¤®£® ᨬ¢®« ¨§ ¢å®¤®£® ¡ãä¥à |
NextChar() |
{ |
ESI><inptr; |
// EAX=0; |
$LODSB |
cha=AL; |
inptr><ESI; // ¯®¬¨¬ ⥪ãéãî ¯®§ æ¨î ¢ ¡ãä¥à¥ |
IF(AL==0)||(AL==26)endoffile = 1; |
IF(AL == 13){ // CR |
linenumber++; // ¡ à㦥 ª®¥æ áâப¨ |
totallines++; |
ShowSrcLine(); |
NextChar(); |
} |
} |
// ---- ®«ã票¥ ®ç¥à¥¤®£® token |
void NextTok() |
{ |
inptr = inptr2; |
linenumber = linenum2; |
cha = cha2; |
displaytokerrors = 1; |
TokScan(#tok,#type,#src,#post,#string,#number); |
IF(linenumber!=linenum2){ // ®¢ ï áâப ? |
IF(dbg){ // ॡã¥âáï ®â« ¤ª ? |
$PUSH ESI |
ESI=dbgs*dbg_size+dbginfo; |
EAX=currmod; |
$CMP EAX,DSDWORD[ESI+dbg_mod]; |
$JNE DIFF // ॡã¥âáï § ¯®¬¨âì ¨ä®à¬ æ¨î ¯® ®¢®© áâப¥ |
EAX=linenumber; |
$CMP EAX,DSDWORD[ESI+dbg_line] |
$JNE DIFF // ॡã¥âáï § ¯®¬¨âì ¨ä®à¬ æ¨î ¯® ®¢®© áâப¥ |
DSDWORD[ESI+dbg_line]=linenumber; // ¯®¬¨¬ ®¬¥à áâப¨ |
GOTO ALL; |
DIFF: |
dbgs++; |
ESI+=dbg_size; |
DSDWORD[ESI+dbg_mod]=currmod; |
DSDWORD[ESI+dbg_line]=linenumber; |
DSDWORD[ESI+dbg_loc]=outptr; |
ALL: |
$POP ESI |
} |
} |
inptr2 = inptr; |
linenum2 = linenumber; |
cha2 = cha; |
displaytokerrors = 0; // ¥§ ¢ë¢®¤ á®®¡é¥¨© ®¡ ®è¨¡ª å |
TokScan(#tok2,#type2,#src2,#post2,#string2,#number2); |
linenumber = linenum2; |
} |
// ---- «¥¤ãî騩 token § ªàëâë© ; |
NextSemiNext () |
{ |
NextTok(); |
SemiNext(); |
} |
// ---- ªàë¢ î騩 ; ¨ token § ¨¬ |
SemiNext () |
{ |
IF(tok != tk_semicolon)expected(';'); |
NextTok(); |
} |
// ---- ¯¨áì ¡ ©â ¢ CODE |
OP() |
{ |
EDI><outptr; |
$STOSB; |
outptr><EDI; |
} |
// ---- ¯¨áì á«®¢ ¢ CODE |
OUTWORD() |
{ |
EDI><outptr; |
$STOSW; |
outptr><EDI; |
} |
// ---- ¯¨áì ¤¢®©®£® á«®¢ ¢ CODE |
OUTDWORD() |
{ |
EDI><outptr; |
$STOSD; |
outptr><EDI; |
} |
// ---- 뢮¤ à §¬¥à®¢ CODE&DATA |
PrintMemsizes(dword handle) |
{ |
wsprintfA(#mapstr,"Code:%u bytes,\tPost: %u bytes\n",outptr-output,postsize); |
fprint(handle,#mapstr); |
} |
// ---- ¡à ¡®âª ¯à®æ¥¤ãà |
Proc(dword proc_type) |
{ |
current_proc_type = proc_type; |
tok = tk_proc; |
number = outptr-output+OptImageBase+OptBaseOfCode; |
ESI=treeptr; |
DSDWORD[ESI+rectok] = tok; |
DSDWORD[ESI+recnumber] = number; |
DSDWORD[ESI+recpost] = 0; |
NextTok(); |
expecting(tk_openbracket); |
IF(tok!=tk_closebracket)DeclareParams(); |
NextTok(); |
IF(paramsize > 0)Asm("push ebp;mov ebp,esp"); |
IF( tok != tk_openbrace )DeclareLocals(); |
DoBlock(); // ¡à ¡®âª ⥫ ¯à®æ¥¤ãàë { ... } |
LeaveProc(); |
KillLocals(); |
} |
// ---- ¯¨áì ¤¢®©®£® á«®¢ ¯® ¤à¥áã |
SetDword(dword ptr, value) |
{ |
EDI><ptr; |
EAX><value; |
$STOSD; |
EDI><ptr; |
EAX><value; |
} |
// ---- 뢮¤ áâப¨ ¨á室®£® ⥪áâ |
ShowSrcLine() |
byte str[STRLEN]; |
{ |
IF(list){ |
ESI><inptr; |
$PUSH EDI,ESI; |
ESI++; |
EDI=#str; |
for(;;){ |
$LODSB; |
IF(AL==13)||(AL==0)BREAK; |
$STOSB; |
} |
AL=0; |
$STOSB |
$POP ESI,EDI; |
ESI><inptr; |
IF(displaytokerrors){ |
fprint(mapfile,#str); |
fprint(mapfile,"\n"); |
} |
// AL=cha; |
} |
} |
// ---- ®§¤ ¨¥ ä ©« áâ â¨á⨪¨ |
StartMapfile() |
byte mapfilename[80]; |
{ |
wsprintfA(#mapfilename,"%s.MAP",#rawfilename); |
mapfile=_lcreat(#mapfilename,0x1000); |
IF(EAX==0){ |
errmsg(); |
WRITESTR("Unable to create map file"); |
WRITESTR(#mapfilename); |
ExitProcess(e_cannotopenmapfile); |
} |
wsprintfA(#mapstr,"MAP FILE FOR %s.%s\n\n",#rawfilename,"EXE"); |
fprint(mapfile,#mapstr); |
} |
// ---- ¨æ¨ «¨§ æ¨ï ᯨ᪮¢ १¥à¢ëå á«®¢ |
TokInit() |
{ |
InitList(#Mnemonics,#St_Mnemonics); |
InitList(#Registers,#St_Registers); |
InitList(#Directives,#St_Directives); |
InitList(#Sizes,#St_Sizes); |
} |
// ---- ®§¢à é ¥â à §¬¥à ¤«ï § ¤ ®£® ⨯ ¤ ëå |
dword TypeSize(dword vartype) |
char holdstr[60]; |
{ |
IF(vartype==tk_void) RETURN(0); |
IF(vartype==tk_char)||(vartype==tk_byte) RETURN(1); |
IF(vartype==tk_short)||(vartype==tk_word) RETURN(2); |
IF(vartype==tk_dword)||(vartype==tk_int) RETURN(4); |
wsprintfA(#holdstr,"vartype=%d in TypeSize()",vartype); |
internalerror(holdstr); |
return(-1); |
} |
// ---- யã᪠¯à®¡¥«®¢ ¨ â ¡ã«ï権 |
WhiteSpaces() |
{ |
for(;;){ |
AL=cha; |
IF(AL!=32)&&(AL!=10)&&(AL!=9)BREAK; |
NXT: |
NextChar(); |
} |
IF(AL == 13){ // CR |
linenumber++; // ¡ à㦥 ª®¥æ áâப¨ |
totallines++; |
ShowSrcLine(); |
GOTO NXT; |
} |
} |
// ---- 뢮¤ stdout |
WRITESTR() |
{ |
fprint(stdout,EAX); |
} |
//===== ¡à ¡®âª ®è¨¡®ª |
// ---- |
datatype_expected() |
{ |
preerror("byte, word, short, char, dword or int expected"); |
} |
// ---- |
errmsg() |
{ |
WRITESTR("\nERROR> "); |
} |
// ---- |
expected(dword ch) |
byte hstr[80]; |
{ |
wsprintfA(#hstr,"'%c' expected",ch); |
preerror(#hstr); |
} |
// ---- |
expectederror(dword str) |
byte hstr[80]; |
{ |
IF(displaytokerrors){ |
wsprintfA(#hstr,"'%s' expected",str); |
preerror(#hstr); |
} |
} |
// ---- ஢¥àª ⥪ã饣® token § ¤ ë© â¨¯ |
expecting(dword want) |
{ |
if(want!=tok){ |
IF(want==tk_closebracket) expected(')'); |
else IF(want==tk_openbracket) expected('('); |
ELSE IF(want==tk_semicolon) expected(';'); |
ELSE IF(want==tk_colon) expected(':'); |
ELSE IF(want==tk_openblock) expected('['); |
ELSE IF(want==tk_closeblock) expected(']'); |
ELSE IF(want==tk_openbrace) expected('{'); |
ELSE IF(want==tk_closebrace) expected('}'); |
ELSE IF(want==tk_comma) expected(','); |
ELSE preerror("expecting a different token"); |
} |
NextTok(); |
} |
// ---- |
/*idalreadydefined() |
byte holdstr[80]; |
{ |
wsprintfA(#holdstr,"identifier %s already defined",#string); |
preerror(#holdstr); |
NextTok(); |
} */ |
// ---- |
idexpected() |
{ |
preerror("undefined 'identifier' expected"); |
} |
// ---- ãâà¥ïï ®è¨¡ª ª®¬¯¨«ïâ®à |
internalerror(dword str) |
{ |
error++; |
wsprintfA(#mapstr,"%s(%d)#%d> *** SERIOUS COMPILER INTERNAL ERROR ***\n>%s.\n", |
#currentfilename,linenumber,error,str); |
WRITESTR(#mapstr); |
wsprintfA(#mapstr,"STRING:%s\n",#string); |
WRITESTR(#mapstr); |
wsprintfA(#mapstr,"TOK:%d\tPOST:%d\tnumber:%ld\n",tok,post,number); |
WRITESTR(#mapstr); |
wsprintfA(#mapstr,"STRING2:%s\n",#string2); |
WRITESTR(#mapstr); |
wsprintfA(#mapstr,"TOK2:%d\tPOST2:%d\tnumber2:%ld\n",tok2,post2,number2); |
WRITESTR(#mapstr); |
WRITESTR("Oh no.\n"); |
IF(makemapfile)CloseHandle(mapfile); |
ExitProcess(e_internalerror); |
} |
// ---- |
localunresolved(dword str) |
byte holdstr[80]; |
{ |
wsprintfA(#holdstr,"local jump label '%s' unresolved",str); |
preerror(#holdstr); |
} |
// ---- |
maxwordpostserror () |
{ |
preerror("maximum number of word post location references exceeded"); |
} |
// ---- |
/*notyet() |
{ |
preerror("specified syntax not handled in this version!!!"); |
} */ |
// ---- |
numexpected() |
{ |
preerror("'number' expected"); |
} |
// ---- |
operatorexpected () |
{ |
preerror("operator identifier expected"); |
} |
// ---- |
outofmemory() |
{ |
preerror("Compiler out of memory"); |
IF( makemapfile )CloseHandle(mapfile); |
ExitProcess(e_outofmemory); |
} |
// ---- |
outofmemory2() |
{ |
errmsg(); |
WRITESTR("Not enough memory for the compiler's buffers.\n"); |
ExitProcess(e_outofmemory ); |
} |
// ---- 訡ª ¢ ⥪ã饩 áâப¥: ¯®ª § ®¬¥à áâப¨ ¨ ¨¬¥¨ ä ©« |
preerror(dword str) |
{ |
IF(error < maxerrors){ |
error++; |
wsprintfA(#mapstr,"%s (%d)#%d> %s.\n",#currentfilename,linenumber,error,str); |
WRITESTR(#mapstr); |
IF(makemapfile)fprint(mapfile,#mapstr); |
} |
ELSE toomanyerrors(); |
} |
// ---- |
/*regnameerror() |
{ |
preerror("register name cannot be used as an identifier"); |
NextTok(); |
} */ |
// ---- ॡã¥âáï áâப |
stringexpected() |
{ |
preerror("'string' expected"); |
} |
// ---- ¥¤®¯ãáâ¨¬ë© ®¯¥à ¤ ¤«ï swap |
swaperror () |
{ |
preerror("invalid or incompatable swap item"); |
} |
// ---- ।¥«ì®¥ ç¨á«® ®è¨¡®ª - ¢ë室 |
toomanyerrors() |
{ |
IF( makemapfile )CloseHandle(mapfile); |
ExitProcess( e_toomanyerrors ); |
} |
// ---- |
unabletoopen(dword str) |
byte hstr[80]; |
{ |
wsprintfA(#hstr,"unable to open file '%s'",str); |
preerror(#hstr); |
} |
// ---- |
undefinederror() |
byte holdstr[80]; |
{ |
wsprintfA(#holdstr,"'%s' undefined",#string); |
preerror(holdstr); |
} |
// ---- |
unexpectedeof() |
{ |
preerror("unexpected END OF FILE"); |
} |
// ---- |
warning(dword str) |
{ |
wsprintfA(#mapstr,"%s (%d)Warning> %s.\n",#currentfilename,linenumber,str); |
WRITESTR(#mapstr); |
IF(makemapfile)fprint(mapfile,#mapstr); |
} |
/* |
void TestProc() |
char buf[20]; |
{ |
$pushad |
wsprintfA(#buf,"%08X\n",SSDWORD[EBP+4]); |
WRITESTR(#buf); |
$popad |
} */ |
/programs/develop/c--/trunk/data.h-- |
---|
0,0 → 1,157 |
//===== «®¡ «ìë¥ ¯¥à¥¬¥ë¥ |
// ---- ä®à¬ æ¨ï ¯® tokens |
dword tok=0; |
dword type=0; |
dword src=0; |
dword post=0; |
dword number=0; |
byte string[STRLEN]=0; |
dword tok2=0; |
dword type2=0; |
dword src2=0; |
dword post2=0; |
dword number2=0; |
dword modline=0; |
byte string2[STRLEN]=0; |
// ---- ãä¥à ã¯à ¢«ïî騥 ä« £¨ |
dword currmod=0; // ®¬¥à ⥪ã饣® ä ©« |
dword displaytokerrors=1;// « £ ¢ë¢®¤ á®®¡é¥ © ®¡ ®è ¡ª¥ |
dword error=0; // ®¤¥à¦¨â ®¬¥à ⥪ã饩 ®è¨¡ª |
dword maxerrors = 16; // ।¥« ¯® ª®«¨ç¥áâ¢ã ®è¨¡®ª |
dword makemapfile=0; // « £ £¥¥à æ ¨ MAP-ä ©« |
dword dbg=0; // « £ £¥¥à æ ¨ TDS-ä ©« ¤«ï TD32 |
dword dbginfo=0; // ª § â¥«ì ¡ãä¥à dbg ¨ä®à¬ 樥© (á¬.®¯¨á ¨¥ ¢ enum dbg_...) |
dword dbgs=0; // ¥ªã騩 㪠§ â¥«ì ¢ dbginfo |
dword input=0; // ª § ⥫ì ç «® ¤¨ ¬¨ç¥áª®£® ¡ãä¥à á ¢å®¤ë¬ ä ©«®¬ |
dword inptr=0; // ª § ⥫ì ⥪ãé ᨬ¢®« ¢ ¡ãä¥à¥ input |
dword inptr2=0; // ®¯¨ï inptr |
dword endoffile=0; // « £ ª®æ ä ©« |
dword totallines=1; // ¡é¥¥ ª®«¨ç¥á⢮ ®âª®¬¯¨«¨à®¢ ëå áâப |
dword linenumber=0; // ®¬¥à ⥪ã饩 áâப¨ |
dword linenum2=0; // ®¬¥à á«¥¤ãî饩 áâப¨ |
dword list=0; // « £ ¢ë¤ ç¨ «¨á⨣ |
dword label=0; // ª¢®§®© ®¬¥à ¤«ï «®ª «ìëå ¬¥â®ª |
dword mapfile=0; // Handle ¤«ï MAP ä ©« |
dword module=0; // ç¥â稪 ®âª®¬¯¨«¨à®¢ ëå ¬®¤ã«¥© |
dword outptr=0; // ¤¥ªá ¢ output |
dword output=0; // ª § â¥«ì ¡ãä¥à á ª®¤®¬ |
dword localsize=0; // §¬¥à á⥪ ¯®¤ «®ª «ì묨 ¯¥à¥¬¥ë¬¨ |
dword posttype=0; // ª § ⥫ì ⨯ POST |
dword postloc=0; // ª § â¥«ì ¯®«®¦¥¨¥ ¢ output |
dword postnum=0; // ª § â¥«ì § 票¥ ¯® postloc |
dword posts=0; // ®¬¥à ⥪ã饩 § ¯¨á¨ ¢ posttype, postloc ¨ postnum |
dword postsize=0; // 㬬 àë© à §¬¥à ¢á¥å post-¯¥à¥¬¥ëå |
dword poststrptr=MAXDATA-1; // ¤¥ªá ¤«ï ¢ë¢®¤ post-áâப |
dword procedure_start=0;// ¤à¥á ç « ¯à®æ¥¤ãàë |
dword runfilesize=0; |
dword startptr=0; // ª § ⥫ì main() |
dword treestart=0; // ª § ⥫ì ç «® ᯨ᪠¨¤¥â¨ä¨ª â®à®¢ |
dword treeptr=0; // ª § ⥫ì ⥪ãéã § ¯¨áì ¢ ᯨ᪥ ¨¤¥â ª â®à®¢ |
dword locallist = NULL; // ª § ⥫ì ç «® ᯨ᪠«®ª «ìëå ¯¥à¥¬¥ëå |
dword localptr=NULL; // ª § ⥫ì ⥪ãéãî § ¯¨áì ¢ ᯨ᪥ «®ª «ìëå |
dword DLLcount=0; // ç¥â稪 ¨¬¯®àâ¨à®¢ ëå DLL |
dword APIcount=0; // ç¥â稪 ¨á¯®«ì§ã¥¬ëå API |
dword importFlag=0; // « £ ¨¬¯®àâ ¨§ DLL |
dword DLLlist[MAXDLLS]; |
byte currentfilename[FILENAMESIZE] = 0; |
byte inputfile[FILENAMESIZE]=0; |
byte rawfilename[FILENAMESIZE]=0; |
byte mapstr[120]=0; |
// ---- DOS&PE headers |
word exeheader[34]={ |
0x5A4D,0x40,1,0,2,0,0xFFFF,0, |
0,0,0,0,0x40,0,0,0, |
0xC88C,0xD88E,0x0FBA,0xB400,0xCD09,0xB821,0x4C00,0x21CD, |
0x6957,0x336E,0x2032,0x6E6F,0x796C,0x2421,0x40,0, |
0x4550,0}; |
// PE Header |
//unsigned dword PEsign = 0x4550; |
word PEmachine=0x14C; // target machine = Intel 386 |
word PEnSections=1; // XAC - only .text!!! number of sections in Sections table |
word PEDate=0; |
word PEtime=0; |
dword PEpSymbolTable=0; // Offset within COFF file of the symbol table |
dword PEnSymbols=0; // number of entries in the symbol table |
word PEOptHeaderSize=0xE0; // Size of optional header |
word PECharacteristics=0x30E; //0x30E 32-bit+... |
// Optional header (only in EX image) |
word OptMagic=0x10B; // normal executable |
byte OptLmajor=2; // Linker major version number |
byte OptLminor=0x37; // Linker minor version number |
dword OptCodeSize=0; // Size of the code section |
dword OptInitDataSize=0; // Size of the initialized data section |
dword OptUninitDataSize=0;// Size of the uninitialized data section (BSS) |
dword OptEntryPointRVA=0x1000;// Address of entry point, relative to image base |
dword OptBaseOfCode=0x1000;// Address realtive to image base |
dword OptBaseOfData=0;//Address realtive to image base |
dword OptImageBase=0x00400000;// Preferred address of first byte of image |
dword OptSectionAlignment=0x1000; |
dword OptFileAlignment=0x200; |
word OptOSmajor=1; |
word OptOSminor=0; |
dword OptUserVersion=0; |
word OptSubSysMajor=4; |
word OptSubSysMinor=0; |
dword OptReserved=0; |
dword OptImageSize=0x0; // Size of image, including all headers |
dword OptHeaderSize=0x200; //DOSheader+PEheader+ObjectTable |
dword OptFileChecksum=0; // Image file checksum |
word OptSubSystem=3; // 2-GUI; 3-console |
word OptDLLflag=0; |
dword OptStackReserveSize=0x100000; |
dword OptStackCommitSixe=0x1000; |
dword OptHeapReserveSize=0x100000; |
dword OptHeapCommitSize=0x1000; |
dword OptLoaderSize=0; |
dword OptNumOfDataDirectories=16; |
// Optional header Data Directories |
dword OptExportTableAdr=0; |
dword OptExportTableSize=0; |
dword OptImportTableAdr=0; |
dword OptImportTableSize=0; |
dword OptResourceTableAdr=0; |
dword OptResourceTablesize=0; |
dword OptExceptionTableAdr=0; |
dword OptExceptionTableSize=0; |
dword OptSecurityTableAdr=0; |
dword OptSecurityTableSize=0; |
dword OptBaseRelocationTableAdr=0; |
dword OptBaseRelocationTableSize=0; |
dword OptDebugAdr=0; |
dword OptDebugSize=0; |
dword OptCopyrightAdr=0; |
dword OptCopyrightSize=0; |
dword OptGlobalPtrAdr=0; |
dword OptGlobalPtrSize=0; |
dword OptTLStableAdr=0; |
dword OptTLStablesize=0; |
dword OptLoadConfigTableAdr=0; |
dword OptLoadConfigTableSize=0; |
dword OptReserved2[10]={0,0,0,0,0,0,0,0,0,0}; |
// Sections Table |
// TEXT section header |
byte TxtSectionName[8]=".text"; |
dword TxtVirtualSize=0; |
dword TxtRVAoffset=0x1000; |
dword TxtSizeOfRawData=0; |
dword TxtPointerToRawData=0x200; |
dword TxtPointerToRelocs=0; |
dword TxtPointerToLinenumbers=0; |
word TxtNumberOfRelocs=0; |
word TxtNumberOfLinenumbers=0; |
dword TxtSectionFlags=0xE00000E0; // can be executed + contain executable code |
// ---- ¥¨¨æ àã¥¬ë¥ ¤ ë¥ |
dword stdout; // Handle to stdout |
byte cha,cha2; |
dword numberofids; |
dword current_proc_type; // ¨¯ ⥪ã饩 ¯à®æ¥¤ãàë (cpt_near, cpt_far) |
dword returntype; // ¨¯ ¢®§¢à é ¥¬®£® § 票ï (void, byte, word, ...) |
dword paramsize; |
dword relation; |
dword startlabel,endlabel; |
byte modules[MAXMDL*FILENAMESIZE]; |
dword St_Mnemonics[26]; |
dword St_Registers[26]; |
dword St_Directives[26]; |
dword St_Sizes[26]; |
byte Buffer16[64]; // ãä¥à ¤«ï á®àâ¨à®¢ª áâப |
/programs/develop/c--/trunk/directiv.h-- |
---|
0,0 → 1,986 |
byte Directives={ |
"IF","ELSE","ENDIF", // á«®¢ ï ª®¬¯¨«ïæ¨ï |
"INCLUDE","DEFINE", // ª«î票¥ ä ©« /¯à¥¤¥«¥¨¥ ª®áâ âë |
"IMPORT", // ¬¯®àâ ¨§ DLL ¯® ¨¬¥¨ API |
"IMPORTN", // ¬¯®àâ ¨§ DLL ¯® ®¬¥àã API |
"MAP", // ¥¥à æ¨ï MAP-ä ©« |
"DEBUG", // ¥¥à æ¨ï ®â« ¤®ç®© ¨ä®à¬ 樨 |
"LIST", // ë¤ ç ASM-«¨á⨣ |
"DLL", // ¥¥à æ¨ï DLL-ä ©« |
"DB","DW","DD", // ¨¯ë ¯¥à¥¬¥ëå |
"BYTE","CHAR","WORD","SHORT","DWORD","INT", |
"ENUM", // 㬥஢ ë¥ ª®áâ âë |
"STRUC", // ¯à¥¤¥«¥¨¥ áâàãªâãàë |
"CYCLE","RETURN", |
"WHILE","DO","INLINE", |
"CONTINUE","BREAK", |
"DOCASE","CASE","DEFAULT", |
"CARRYFLAG","EXTRACT","FROM", |
"NOTCARRYFLAG","NOTOVERFLOW","OVERFLOW", |
"ZEROFLAG","NOTZEROFLAG",_END}; |
// ----- «ï tokens, ®¡à ¡ âë¢ ¥¬ëå ç¥à¥§ â ¡«¨æã ¯¥à¥ª«îç ⥫¥© |
EMPTY() |
{ |
WRITESTR(#string); |
WRITESTR("-ToDo\n"); |
NextTok(); |
} |
// ---- ®§¢à é ¥â ¤à¥á ¨§ Jmp_.... |
dword GetDirAddr(dword table,num) |
{ |
EAX=num<<2+table; |
EAX=DSDWORD[EAX]; |
} |
// ----- ¨à¥ªâ¨¢ #define |
DirDefine() |
byte holdid[IDLENGTH]; |
dword next; |
{ |
next=1; |
NextTok(); |
if(tok==tk_id){ |
lstrcpyA(#holdid,#string); // ¬ï ª®áâ âë |
NextTok(); |
IF(tok==tk_eof) unexpectedeof(); |
ELSE IF(tok==tk_number){ |
AddConstToTree(#holdid,DoConstLongMath()); next = 0; |
} |
ELSE IF(tok==tk_minus){ |
IF(tok2==tk_number) { |
AddConstToTree(#holdid,DoConstLongMath()); |
next = 0; |
} |
} |
ELSE IF(tok==tk_undefproc){ |
tok = tk_id; AddToTree(#holdid); |
} |
ELSE AddToTree(#holdid); |
} |
ELSE idexpected(); |
IF(next)NextTok(); |
} |
// -- #enum |
DirEnum() |
dword counter; |
byte holdid[IDLENGTH]; |
{ |
counter=0; |
NextTok(); |
IF(tok!=tk_openbrace)expected('{'); |
for(;;){ |
NextTok(); |
IF(tok==tk_id){ |
lstrcpyA(#holdid,#string); |
IF( tok2 == tk_assign ){ |
NextTok(); NextTok(); |
IF(tok==tk_number)counter=DoConstLongMath(); |
ELSE numexpected(); |
} |
AddConstToTree(#holdid,counter); |
counter++; |
CONTINUE; |
} |
IF(tok==tk_comma)CONTINUE; |
IF(tok==tk_semicolon)BREAK; |
} |
NextTok(); |
} |
// ¨à¥ªâ¨¢ #import |
DirImport() |
{ |
NextTok(); |
IF(tok==tk_string)GetImport(1); // import ¯® ¨¬¥¨ API-äãªæ¨© |
ELSE stringexpected(); |
NextTok(); |
} |
// ¨à¥ªâ¨¢ #importN |
DirImportN() |
{ |
NextTok(); |
IF(tok==tk_string)GetImport(0); // import ¯® ¨¬¥¨ API-äãªæ¨© |
ELSE stringexpected(); |
NextTok(); |
} |
// ---- ¬¯®àâ ¨§ DLL |
GetImport(dword byName) |
dword dll; |
dword dllpos,base,export,fptr,i,nexports,nsect,delta; |
byte path[80],name[120]; |
dword tok0,type0,src0,post0; |
dword number0; |
dword ord; |
dword pname1,pname2,j; |
{ |
pname1 = 0; ord=0; importFlag=1; |
IF(DLLcount>=MAXDLLS)outofmemory2(); |
IF(SearchTree(#tok0,#type0,#src0,#post0,#string,#number0))return; // DLL 㦥 ¨¬¯®àâ¨à®¢ |
wsprintfA(#name,"%s",#string); |
dll=_lopen(#name,0); |
IF(dll== -1){ |
GetSystemDirectoryA(#path,80); |
wsprintfA(#name,"%s\\%s",#path,#string); |
dll=_lopen(#name,0); |
IF(dll==-1) { |
unabletoopen(#string); |
return; |
} |
} |
nsect=0; |
_llseek(dll,0x3c,0); _lread(dll,#fptr,4); |
_llseek(dll,fptr+120,0); _lread(dll,#export,4); // Get export address |
IF(export==0) { |
wsprintfA(#mapstr,"ERROR: No export directory in file %s.\n",#string); |
preerror(#mapstr); return; |
} |
_llseek(dll,fptr+6,0); _lread(dll,#nsect,2); // Number of sections |
delta=export; |
i=1; |
while(i<=nsect){ |
EAX=i; EAX--; EAX=EAX*40; EAX+=260; EAX+=fptr; // fptr+260+40*(i-1) |
_llseek(dll,EAX,0); _lread(dll,#base,4); // RVA of section |
IF(base<=export){ |
EAX=export-base; |
IF(EAX<delta){ |
delta=export-base; |
EAX=i; EAX--; EAX=EAX*40; EAX+=268; EAX+=fptr; // fptr+268+40*(i-1) |
_llseek(dll,EAX,0); _lread(dll,#dllpos,4); |
} |
} |
i++; |
} |
dllpos = dllpos + delta; // filepos for export directory table |
delta = dllpos - export; |
_llseek(dll,dllpos+24,0); _lread(dll,#nexports,4); // number of entries for export |
_llseek(dll,dllpos+32,0); _lread(dll,#base,4); // address of export name pointer table |
_llseek(dll,dllpos+36,0); _lread(dll,#fptr,4);// address of Ordinal Table |
base=base+delta; fptr=fptr+delta; |
tok0=tok; number0=number;src0=src;type0=type;post0=post; |
tok=tk_DLL; number=nexports;src=NULL; type=byName; post=0; modline=0; |
AddToTree(#string); |
EBX=DLLcount; EBX<<=2; |
DLLlist[EBX] = treeptr; // save ptr in tree |
tok=tk_API; type=treeptr; |
i=0; |
while(nexports-1>i){ |
EAX=i; EAX<<=1; EAX+=fptr; // fptr+2*i |
_llseek(dll,EAX,0); _lread(dll,#ord,2);// Ordinal number |
EAX=i; EAX<<=2; EAX+=base; // base+4*i |
_llseek(dll,EAX,0); _lread(dll,#pname1,8); // address of name |
_llseek(dll,pname1+delta,0); _lread(dll,#string,pname2-pname1);// address of Ordinal Table |
number=ord+1; // ¯à¨ § £à㧪¥ ¨á¯®«ì§ã¥âáï ®¬¥à 1 ¡®«ìè¥ íªá¯®àâ¨à㥬®£® ¨§ DLL |
AddToTree(#string); |
// SHOW(#string);SHOW("\n"); |
i++; |
} |
EAX=i; EAX<<=1; EAX+=fptr; // fptr+2*i |
_llseek(dll,EAX,0); _lread(dll,#ord,2); // Ordinal number |
j=0; |
for(;;){ |
_llseek(dll,pname2+delta+j,0); EAX=j; |
_lread(dll,#string[EAX],1); EAX=j; |
IF(string[EAX]==0)BREAK; |
j++; |
} |
number=ord+1; |
AddToTree(#string); |
tok=tok0; number=number0;src=src0;type=type0;post=post0; |
_lclose(dll); |
DLLcount++; importFlag=0; |
} |
// ----- ¨à¥ªâ¨¢ #include |
DirInclude() |
byte s[STRLEN],s2[STRLEN]; |
{ |
NextTok(); |
if(tok==tk_string) { |
AL=cha2; |
$PUSH EAX,linenum2,inptr2,number,tok2,tok,input,inptr,endoffile, |
displaytokerrors,currmod; |
lstrcpyA(#s,#string); lstrcpyA(#s2,#string2); |
Preview(#s); |
lstrcpyA(#string,#s); lstrcpyA(#string2,#s2); |
$POP currmod,displaytokerrors,endoffile,inptr,input,tok,tok2,number,inptr2, |
linenum2,EAX; |
cha2=AL; |
NextTok(); |
} |
ELSE stringexpected(); |
} |
// ----- ¨à¥ªâ¨¢ list |
DirList() |
{ |
IF(mapfile==0){ |
makemapfile=1; |
StartMapfile(); |
} |
list^=1; // ¥à¥ª«î票¥ ¢ë¢®¤ «¨á⨣ |
NextTok(); |
} |
// ----- ¨à¥ªâ¨¢ map |
DirMap() |
{ |
makemapfile = 1; StartMapfile(); |
NextTok(); |
} |
// ---- ¡à ¡®âª £«®¡ «ì®© ¯¥à¥¬¥®© ¨«¨ ¯à®æ¥¤ãàë á ⨯®¬ |
GetProc(dword vartype) |
dword src0,beg,count; |
byte var_name[IDLENGTH]; |
{ |
lstrcpyA(#var_name,#string); // ¬ï ¯à®æ¥¤ãàë |
beg=inptr2; // ®â¬¥â¨¬ ç «® ®¯¨á ¨ï |
count=0; EAX=0; // ¨é¥¬ ç «® ¡«®ª ¯à®æ¥¤ãàë |
modline=currmod<<16+linenum2; |
for(;;){ |
ESI><inptr2; |
$LODSB; |
ESI><inptr2; |
cha2=AL; |
IF(AL==0){ |
unexpectedeof(); |
return; |
} |
IF(AL==13){ // CR |
linenum2++; // ¡ à㦥 ª®¥æ áâப¨ |
totallines++; |
CONTINUE; |
} |
IF(AL=='{'){ // ᯨ᮪ ¨¨æ¨ «¨§ 樨 |
count++; |
BREAK; |
} |
} |
for(;;){ |
ESI><inptr2; |
$LODSB; |
ESI><inptr2; |
cha2=AL; |
IF(AL==0){ |
unexpectedeof(); |
break; |
} |
IF(AL==13){ // CR |
linenum2++; // ¡ à㦥 ª®¥æ áâப¨ |
totallines++; |
} |
else if(AL=='}'){ // ¡«®ª § ªàëâ |
count--; |
IF(count==0){ // ª®¥æ ¯à®æ¥¤ãàë |
ESI><inptr2; |
$LODSB; |
ESI><inptr2; |
cha2=AL; // § ¬ëª îé ï } |
src0=LocalAlloc(0x40,inptr2-beg+2); // ª®¯¨à㥬 ¨áå.⥪áâ |
EAX=src0; |
DSBYTE[EAX]='('; |
lstrcpynA(src0+1,beg,inptr2-beg); |
tok=tk_proc; |
type=vartype; |
src=src0; |
number=0; |
post=1; |
AddToTree(#var_name); |
BREAK; |
} |
} |
ELSE IF(AL=='{'){ // ᯨ᮪ ¨¨æ¨ «¨§ 樨 |
count++; |
} |
} |
NextTok(); |
} |
// ---- ¡à ¡®âª £«®¡ «ì®© ¯¥à¥¬¥®© ¨«¨ ¯à®æ¥¤ãàë á ⨯®¬ |
GetVar(dword vartype) |
dword src0,beg,end,count,size; |
byte var_name[IDLENGTH]; |
{ |
beg=inptr; |
modline=0; // ®â¬¥â¨¬ ç «® ®¯¨á ¨ï |
NextTok(); |
IF(tok2==tk_openbracket){ // ¡ê¥¨¥ äãªæ¨¨: type FunctionName(...) |
GetProc(vartype); |
return; |
} |
for(;;){ // ¡ê¥¨¥ ¯¥à¥¬¥®© |
IF(tok==tk_semicolon){ // ®¥æ ®¯à¥¤¥«¥¨ï ¯¥à¥¬¥®© |
tok=tk_var; |
type=vartype; |
src=src0; |
number=0; |
post=1; |
AddToTree(#var_name); |
break; |
} |
IF(tok==tk_comma){ // ᯨ᮪ ¯¥à¥¬¥ëå |
tok=tk_var; |
type=vartype; |
src=src0; |
number=0; |
post=1; |
AddToTree(#var_name); |
NextTok(); |
} |
else IF(tok==tk_id){ // tk_id |
src0=NULL; |
beg=inptr2; |
size=0; |
lstrcpyA(#var_name,#string); // ¬ï ¯¥à¥¬¥®© |
number=0; |
tok=tk_var; |
type=vartype; |
post=1; |
NextTok(); |
} |
else if(tok==tk_assign)||(tok==tk_openblock){ |
inptr2--; |
count=0; |
EAX=0; |
for(;;){ |
ESI><inptr2; |
$LODSB; |
ESI><inptr2; |
cha2=AL; |
IF(AL==0){ |
unexpectedeof(); |
break; |
} |
IF(AL=='"'){ |
ESI><inptr2; |
do{ |
$LODSB; |
}while(AL!='"'); |
ESI><inptr2; |
cha2=AL; |
} |
else IF(AL==',')||(AL==';'){ |
IF(count==0){ |
end=inptr2; |
src0 = LocalAlloc(0x40,end-beg+2); |
IF(size){ |
EAX=src0; |
DSBYTE[EAX]='['; |
lstrcpynA(src0+1,beg,end-beg); |
} |
ELSE lstrcpynA(src0,beg,end-beg); |
modline=currmod<<16+linenumber; |
BREAK; |
} |
} |
ELSE IF(AL=='}'){ // ᯨ᮪ § ª®ç¥ |
count--; |
} |
ELSE IF(AL=='{'){ // ᯨ᮪ ¨¨æ¨ «¨§ 樨 |
count++; |
} |
IF(AL==']'){ // à §¬¥à®áâì |
size++; |
} |
} |
NextTok(); |
} |
} |
NextTok(); |
} |
// ---- ¡ê¥¨¥ ⨯ ¤ ëå |
CmdByte() |
{ |
GetVar(tk_byte); |
} |
CmdChar() |
{ |
GetVar(tk_char); |
} |
CmdWord() |
{ |
GetVar(tk_word); |
} |
CmdShort() |
{ |
GetVar(tk_short); |
} |
CmdDword() |
{ |
GetVar(tk_dword); |
} |
CmdInt() |
{ |
GetVar(tk_int); |
} |
// ---- break; |
CmdBreak() |
{ |
wsprintfA(#mapstr,"jmp @L%d",endlabel); |
Asm(#mapstr); |
NextSemiNext(); |
} |
// ---- case(Cond) ... |
CmdCase() |
dword loclabel; |
{ |
NextTok(); |
expecting(tk_openbracket); |
loclabel=label; |
label++; |
relation=0; |
if(tok==tk_command){ |
GetDirAddr(#Jmp_Commands,number); |
IF(EAX==#CmdCarryFlag)wsprintfA(#mapstr,"jnc @L%d",loclabel); |
else IF(EAX==#CmdNotCarryFlag)wsprintfA(#mapstr,"jc @L%d",loclabel); |
ELSE IF(EAX==#CmdZeroFlag)wsprintfA(#mapstr,"jnz @L%d",loclabel); |
ELSE IF(EAX==#CmdNotZeroFlag)wsprintfA(#mapstr,"jz @L%d",loclabel); |
ELSE IF(EAX==#CmdOverflow)wsprintfA(#mapstr,"jno @L%d",loclabel); |
ELSE IF(EAX==#CmdNotOverflow)wsprintfA(#mapstr,"jo @L%d",loclabel); |
NextTok(); |
} |
ELSE{ |
IF(Expression("eax",tk_reg,tk_dword))wsprintfA(loclabel,"test eax,eax;jnz @L%d",#mapstr); |
ELSE wsprintfA(#mapstr,"test eax,eax;jz @L%d",loclabel); |
} |
Asm(#mapstr); |
expecting(tk_closebracket); |
DoCommand(); |
wsprintfA(#mapstr,"jmp @L%d",endlabel); |
Asm(#mapstr); |
wsprintfA(#mapstr,"@L%d:",loclabel); |
Asm(#mapstr); |
} |
// ---- continue; |
CmdContinue() |
{ |
wsprintfA(#mapstr,"jmp @L%d",startlabel); |
Asm(#mapstr); NextSemiNext(); |
} |
// ---- cycle(Var) ... |
CmdCycle() |
byte varName[2*IDLENGTH]; |
{ |
NextTok(); |
expecting(tk_openbracket); |
$PUSH startlabel,endlabel; |
startlabel=label; |
label++; |
endlabel=label; |
label++; |
relation=0; |
wsprintfA(#mapstr,"@L%d:",startlabel); |
Asm(#mapstr); |
GetVarname(#varName); |
NextTok(); |
expecting(tk_closebracket); |
DoCommand(); |
IF(varName[0]==0){ // ç¥â稪 横« ®âáãâáâ¢ã¥â - ¡¥áª®¥çë© æ¨ª« |
wsprintfA(#mapstr,"jmp @L%d",startlabel); |
} |
ELSE{ |
wsprintfA(#mapstr,"dec %s;jnz @L%d",#varName,startlabel); |
} |
Asm(#mapstr); |
wsprintfA(#mapstr,"@L%d:",endlabel); |
Asm(#mapstr); |
$POP endlabel,startlabel; |
} |
// ---- « £¨ ãá«®¢¨© ¢ if |
CmdCarryFlag() |
{ |
CmdNotCarryFlag: |
CmdZeroFlag: |
CmdNotZeroFlag: |
CmdOverflow: |
CmdNotOverflow: |
} |
// ---- ... else ... |
CmdElse() |
{ |
} |
// ---- ¡ê¥¨¥ 㬥஢ ëå ª®áâ â |
CmdEnum() |
dword counter; |
byte holdid[IDLENGTH]; |
{ |
counter=0; |
NextTok(); |
expecting(tk_openbrace); |
for(;;){ |
IF(tok==tk_eof)unexpectedeof(); |
ELSE IF(tok==tk_comma)NextTok(); |
ELSE IF(tok==tk_closebrace)BREAK; |
ELSE IF(tok==tk_id){ |
lstrcpyA(#holdid,#string); |
IF(tok2==tk_assign ){ |
NextTok(); |
NextTok(); |
IF(tok==tk_number)counter=DoConstLongMath(); |
ELSE numexpected(); |
} |
AddConstToTree(#holdid,counter); |
counter++; |
NextTok(); |
} |
ELSE{ |
idexpected(); |
NextTok(); |
} |
} |
expecting(tk_closebrace); |
SemiNext(); |
} |
// ---- while(Cond) ... |
CmdWhile() |
{ |
NextTok(); |
expecting(tk_openbracket); |
$PUSH startlabel,endlabel; |
startlabel=label; |
label++; |
endlabel=label; |
label++; |
relation=0; |
wsprintfA(#mapstr,"@L%d:",startlabel); |
Asm(#mapstr); |
if(tok==tk_command){ |
GetDirAddr(#Jmp_Commands,number); |
IF(EAX==#CmdCarryFlag)wsprintfA(#mapstr,"jnc @L%d",endlabel); |
else IF(EAX==#CmdNotCarryFlag)wsprintfA(#mapstr,"jc @L%d",endlabel); |
else IF(EAX==#CmdZeroFlag)wsprintfA(#mapstr,"jnz @L%d",endlabel); |
ELSE IF(EAX==#CmdNotZeroFlag)wsprintfA(#mapstr,"jz @L%d",endlabel); |
ELSE IF(EAX==#CmdOverflow)wsprintfA(#mapstr,"jno @L%d",endlabel); |
ELSE IF(EAX==#CmdNotOverflow)wsprintfA(#mapstr,"jo @L%d",endlabel); |
NextTok(); |
} |
ELSE{ |
IF(Expression("eax",tk_reg,tk_dword))wsprintfA(#mapstr,"test eax,eax;jnz @L%d",endlabel); |
ELSE wsprintfA(#mapstr,"test eax,eax;jz @L%d",endlabel); |
} |
Asm(#mapstr); |
expecting(tk_closebracket); |
DoCommand(); |
wsprintfA(#mapstr,"jmp @L%d",startlabel); |
Asm(#mapstr); |
wsprintfA(#mapstr,"@L%d:",endlabel); |
Asm(#mapstr); |
$POP endlabel,startlabel; |
} |
// ---- default |
CmdDefault() |
{ |
NextTok(); |
DoCommand(); |
} |
CmdDb() |
{ |
NextTok(); |
for(;;){ |
IF(tok==tk_number)OP(byte DoConstLongMath()); |
ELSE IF(tok==tk_string ){ |
ECX=number; |
EDX=#string; |
loop(ECX){ |
OP(byte DSBYTE[EDX]); |
EDX++; |
} |
NextTok(); |
} |
ELSE IF(tok==tk_comma)NextTok(); |
ELSE IF(tok==tk_semicolon)BREAK; |
ELSE{ |
numexpected(); |
NextTok(); |
} |
} |
} |
CmdDd() |
{ |
NextTok(); |
for(;;){ |
IF(tok==tk_number)OUTDWORD(DoConstDwordMath()); |
ELSE IF(tok==tk_comma)NextTok(); |
ELSE IF(tok==tk_semicolon)BREAK; |
ELSE{ |
numexpected(); |
NextTok(); |
} |
} |
} |
CmdDw() |
{ |
NextTok(); |
for(;;){ |
IF(tok==tk_number)OUTWORD(DoConstDwordMath()); |
ELSE IF(tok==tk_comma)NextTok(); |
ELSE IF(tok==tk_semicolon)BREAK; |
ELSE{ |
numexpected(); |
NextTok(); |
} |
} |
} |
// ---- do ... while(Cond) |
CmdDo() |
{ |
NextTok(); |
$PUSH startlabel,endlabel; |
startlabel=label; |
label++; |
endlabel=label; |
label++; |
relation=0; |
wsprintfA(#mapstr,"@L%d:",startlabel); |
Asm(#mapstr); |
DoCommand(); |
if(tok==tk_command){ |
if(GetDirAddr(#Jmp_Commands,number)==#CmdWhile){ |
NextTok(); |
expecting(tk_openbracket); |
if(tok==tk_command){ |
GetDirAddr(#Jmp_Commands,number); |
IF(EAX==#CmdCarryFlag)wsprintfA(#mapstr,"jc @L%d",startlabel); |
else IF(EAX==#CmdNotCarryFlag)wsprintfA(#mapstr,"jnc @L%d",startlabel); |
else IF(EAX==#CmdZeroFlag)wsprintfA(#mapstr,"jz @L%d",startlabel); |
ELSE IF(EAX==#CmdNotZeroFlag)wsprintfA(#mapstr,"jnz @L%d",startlabel); |
ELSE IF(EAX==#CmdOverflow)wsprintfA(#mapstr,"jo @L%d",startlabel); |
ELSE IF(EAX==#CmdNotOverflow)wsprintfA(#mapstr,"jno @L%d",startlabel); |
NextTok(); |
} |
ELSE{ |
IF(Expression("eax",tk_reg,tk_dword))wsprintfA(#mapstr,"test eax,eax;jz @L%d",startlabel); |
ELSE wsprintfA(#mapstr,"test eax,eax;jnz @L%d",startlabel); |
} |
Asm(#mapstr); |
expecting(tk_closebracket); |
} |
ELSE{ |
ER: |
preerror("'while' expected following 'do'"); |
} |
} |
ELSE GOTO ER; |
wsprintfA(#mapstr,"@L%d:",endlabel); |
Asm(#mapstr); |
$POP endlabel,startlabel; |
} |
// ---- docase ... |
CmdDoCase() |
{ |
NextTok(); |
$PUSH startlabel,endlabel; |
startlabel=label; |
label++; |
endlabel=label; |
label++; |
wsprintfA(#mapstr,"@L%d:",startlabel); |
Asm(#mapstr); |
DoCommand(); |
wsprintfA(#mapstr,"@L%d:",endlabel); |
Asm(#mapstr); |
$POP endlabel,startlabel; |
} |
// ---- if(Cond) ... |
CmdIf() |
dword loclabel; |
{ |
NextTok(); |
expecting(tk_openbracket); |
loclabel=label; |
label++; |
relation=0; |
if(tok==tk_command){ |
GetDirAddr(#Jmp_Commands,number); |
IF(EAX==#CmdCarryFlag)wsprintfA(#mapstr,"jnc @L%d",loclabel); |
else IF(EAX==#CmdNotCarryFlag)wsprintfA(#mapstr,"jc @L%d",loclabel); |
ELSE IF(EAX==#CmdZeroFlag)wsprintfA(#mapstr,"jnz @L%d",loclabel); |
ELSE IF(EAX==#CmdNotZeroFlag)wsprintfA(#mapstr,"jz @L%d",loclabel); |
ELSE IF(EAX==#CmdOverflow)wsprintfA(#mapstr,"jno @L%d",loclabel); |
ELSE IF(EAX==#CmdNotOverflow)wsprintfA(#mapstr,"jo @L%d",loclabel); |
NextTok(); |
} |
ELSE{ |
IF(Expression("eax",tk_reg,tk_dword))wsprintfA(#mapstr,"test eax,eax;jnz @L%d",loclabel); |
ELSE wsprintfA(#mapstr,"test eax,eax;jz @L%d",loclabel); |
} |
Asm(#mapstr); |
expecting(tk_closebracket); |
DoCommand(); |
IF(tok==tk_command){ |
IF(GetDirAddr(#Jmp_Commands,number)==#CmdElse){ |
wsprintfA(#mapstr,"jmp @L%d;\n@L%d:",label,loclabel); |
Asm(#mapstr); |
loclabel=label; |
label++; |
NextTok(); |
DoCommand(); |
} |
} |
wsprintfA(#mapstr,"@L%d:",loclabel); |
Asm(#mapstr); |
} |
// ---- return(Expr) |
CmdReturn() |
{ |
NextTok(); |
IF(tok==tk_openbracket){ |
NextTok(); |
IF(tok!=tk_closebracket){ |
IF(returntype!=tk_void)Expression("eax",tk_reg,returntype); |
} |
expecting(tk_closebracket); |
} |
LeaveProc(); |
SemiNext(); |
} |
// ---- ¡ê¥¨¥ £«®¡ «ì®© ¯¥à¥¬¥®© |
GlobalVar(dword vartype) // both initialized and unitialized combined |
dword size,elements,ptr; |
long i,count; |
{ |
ptr=treeptr; |
elements=1; |
size = TypeSize(vartype); |
NextTok(); |
for(;;){ |
IF(tok==tk_eof)goto G04; //break; |
ELSE IF(tok==tk_semicolon)NextTok(); |
else IF(tok==tk_assign)NextTok(); |
else IF(tok==tk_plus)NextTok(); |
else IF(tok==tk_openblock){ // type VarName[...] |
NextTok(); |
elements = DoConstLongMath(); |
expecting(tk_closeblock); |
} |
else if(tok==tk_number){ // type VarName=initvalue |
ESI=ptr; // ⪮à४â¨à㥬 à ¥¥ ᤥ« ãî § ¯¨áì |
DSDWORD[ESI+recnumber] = outptr-output+OptImageBase+OptBaseOfCode; |
DSDWORD[ESI+recpost] = 0; |
G01: |
IF(vartype==tk_byte)i=DoConstDwordMath(); |
ELSE IF(vartype==tk_word)i=DoConstDwordMath(); |
ELSE IF(vartype==tk_dword)i=DoConstDwordMath(); |
ELSE i=DoConstLongMath(); |
count=elements; |
loop(count){ |
IF(size==1)OP(byte i); |
ELSE IF(size==2)OUTWORD(i); |
ELSE IF(size==4)OUTDWORD(i); |
} |
} |
else IF(tok==tk_minus){ |
NextTok(); |
number=-number; |
goto G01; |
} |
else IF(tok==tk_string){ |
ESI=ptr; // ⪮à४â¨à㥬 à ¥¥ ᤥ« ãî § ¯¨áì |
DSDWORD[ESI+recnumber] = outptr-output+OptImageBase+OptBaseOfCode; |
DSDWORD[ESI+recpost] = 0; |
count = 1; |
do{ |
i=number; |
EDX=#string; |
loop(i){ |
OP(byte DSBYTE[EDX]); |
EDX++; |
count++; |
} |
NextTok(); |
}while(tok==tk_string); |
OP(byte 0);// count++; |
i=elements; |
i-=count; |
IF(i>0)loop(i)OP(byte 0); |
} |
else IF(tok==tk_from){ |
NextTok(); |
SHOW("count = DoFrom(1);\n"); |
i=size*elements; |
i-=count; |
loop(i)OP(byte 0); |
NextTok(); |
} |
else IF(tok==tk_extract){ |
NextTok(); |
SHOW("count = DoExtract(1);\n"); |
i=size*elements; |
i-=count; |
loop(i)OP(byte 0); |
} |
else if(tok==tk_openbrace){ // varname={...}; |
ESI=ptr; // ⪮à४â¨à㥬 à ¥¥ ᤥ« ãî § ¯¨áì |
DSDWORD[ESI+recnumber] = outptr-output+OptImageBase+OptBaseOfCode; |
DSDWORD[ESI+recpost] = 0; |
count = 0; |
NextTok(); |
for(;;){ |
IF(tok==tk_closebrace)break; |
ELSE IF(tok==tk_comma)NextTok(); |
else IF(tok==tk_plus)NextTok(); |
else IF(tok==tk_string){ |
i=number; |
EDX=#string; |
loop(i){ |
OP(DSBYTE[EDX]); |
EDX++; |
count++; |
} |
IF(tok2!=tk_plus){ |
OP(byte 0); |
count++; |
} |
NextTok(); |
} |
else IF(tok==tk_postnumber){ |
SetPost(treeptr,POST_DATA); |
OUTDWORD(number); |
NextTok(); |
} |
else IF(tok==tk_number){ |
G02: |
IF(vartype==tk_byte)OP(byte DoConstDwordMath()); |
ELSE IF(vartype==tk_word)OUTWORD(DoConstDwordMath()); |
ELSE IF(vartype==tk_char)OP(byte DoConstLongMath()); |
ELSE IF(vartype==tk_short) OUTWORD(DoConstLongMath()); |
ELSE IF(vartype==tk_dword) OUTDWORD(DoConstDwordMath()); |
ELSE IF(vartype==tk_int) OUTDWORD(DoConstLongMath()); |
count++; |
} |
ELSE IF(tok==tk_minus){ |
NextTok(); |
number=-number; |
goto G02; |
} |
ELSE{ |
numexpected(); |
NextTok(); |
} |
} |
count=elements-count; |
IF(count>0){ |
loop(count){ |
IF(size==1)OP(byte 0); |
ELSE IF(size==2)OUTWORD(0); |
ELSE IF(size==4)OUTDWORD(0); |
} |
} |
} |
ELSE{ |
G04: |
ESI=ptr; |
DSDWORD[ESI+recnumber] = postsize; |
DSDWORD[ESI+recpost] = 1; |
postsize = elements * size + postsize; |
BREAK; |
} |
} |
} |
//===== ¡«¨æ ¯¥à¥ª«îç ⥫¥© ¤¨à¥ªâ¨¢ |
dword Jmp_Directives={ |
// "if","else","endif", // á«®¢ ï ª®¬¯¨«ïæ¨ï |
#EMPTY,#EMPTY,#EMPTY, |
// "include","define", // ª«î票¥ ä « |
#DirInclude,#DirDefine, |
// "import", // ¬¯®àâ ¨§ DLL |
#DirImport, |
// "importN", // ¬¯®àâ ¨§ DLL |
#DirImportN, |
// "map", // ¥¥à æ¨ï MAP-ä ©« |
#DirMap, |
// "debug", // ¥¥à æ¨ï ®â« ¤®ç®© ¨ä®à¬ 樨 |
#EMPTY, |
// "list", // ë¤ ç ASM-«¨á⨣ |
#DirList, |
// "dll", // ¥¥à æ¨ï DLL-ä ©« |
#EMPTY, |
// "db","dw","dd", // ¨¯ë ¯¥à¥¬¥ëå |
#EMPTY,#EMPTY,#EMPTY, |
// "byte","char","word","short","dword","int", |
#EMPTY,#EMPTY,#EMPTY,#EMPTY,#EMPTY,#EMPTY, |
// "enum", // 㬥஢ ë¥ ª®áâ âë |
#DirEnum, |
// "struc", // ¯à¥¤¥«¥¨¥ áâàãªâãàë |
#EMPTY, |
// "cycle","return", |
#EMPTY,#EMPTY, |
// "while","do","inline", |
#EMPTY,#EMPTY,#EMPTY, |
// "continue","break", |
#EMPTY,#EMPTY, |
// "docase","case","default", |
#EMPTY,#EMPTY,#EMPTY, |
// "CARRYFLAG","extract","from", |
#EMPTY,#EMPTY,#EMPTY, |
// "NOTCARRYFLAG","NOTOVERFLOW","OVERFLOW", |
#EMPTY,#EMPTY,#EMPTY, |
// "ZEROFLAG","NOTZEROFLAG" |
#EMPTY,#EMPTY |
}; |
//===== ¡«¨æ ¯¥à¥ª«îç ⥫¥© ª®¬ ¤ |
dword Jmp_Commands={ |
// "if","else","endif", // á«®¢ ï ª®¬¯¨«ïæ¨ï |
#CmdIf,#CmdElse,#EMPTY, |
// "include","define", // ª«î票¥ ä « |
#EMPTY,#EMPTY, |
// "import","importN", // ¬¯®àâ ¨§ DLL |
#EMPTY,#EMPTY, |
// "map", // ¥¥à æ¨ï MAP-ä ©« |
#EMPTY, |
// "debug", // ¥¥à æ¨ï ®â« ¤®ç® ¨ä®à¬ 樨 |
#EMPTY, |
// "list", // ë¤ ç ASM-« á⨣ |
#EMPTY, |
// "dll", // ¥¥à æ¨ï DLL-ä ©« |
#EMPTY, |
// "db","dw","dd", // ¨¯ë ¯¥à¥¬¥ëå |
#CmdDb,#CmdDw,#CmdDd, |
// "byte","char","word","short","dword","int", |
#CmdByte,#CmdChar,#CmdWord,#CmdShort,#CmdDword,#CmdInt, |
// "enum", // 㬥஢ ë¥ ª®áâ âë |
#CmdEnum, |
// "struc", // ¯à¥¤¥«¥¨¥ áâàãªâãàë |
#EMPTY, |
// "cycle","return", |
#CmdCycle,#CmdReturn, |
// "while","do","inline", |
#CmdWhile,#CmdDo,#EMPTY, |
// "continue","break", |
#CmdContinue,#CmdBreak, |
// "docase","case","default", |
#CmdDoCase,#CmdCase,#CmdDefault, |
// "CARRYFLAG","extract","from", |
#CmdCarryFlag,#EMPTY,#EMPTY, |
// "NOTCARRYFLAG","NOTOVERFLOW","OVERFLOW", |
#CmdNotCarryFlag,#CmdNotOverflow,#CmdOverflow, |
// "ZEROFLAG","NOTZEROFLAG" |
#CmdZeroFlag,#CmdNotZeroFlag |
}; |
/programs/develop/c--/trunk/enums.h-- |
---|
0,0 → 1,111 |
//===== «®¡ «ìë¥ ª®áâ âë |
#define SHOW "WRITESTR" |
// ---- |
#define STD_INPUT_HANDLE -10 |
#define STD_OUTPUT_HANDLE -11 |
#define STD_ERROR_HANDLE -12 |
#define CREATE_NEW 1 |
#define CREATE_ALWAYS 2 |
#define OPEN_EXISTING 3 |
#define OPEN_ALWAYS 4 |
#define TRUNCATE_EXISTING 5 |
// ---- |
#define GENERIC_READ 0x80000000 |
#define GENERIC_WRITE 0x40000000 |
#define GENERIC_EXECUTE 0x20000000 |
#define GENERIC_ALL 0x10000000 |
// ---- ®áâ âë ª®¬¯¨«ïâ®à |
#define _END 0x1B |
#define FILENAMESIZE 80 |
#define IDLENGTH 65 // «¨ ¨¬¥¨ ¨¤¥â¨ä¨ª â®à , ¢ª«îç ï NULL-â¥à¬¨ â®à |
#define MAXDATA 512000 // §¬¥à ¡ãä¥à®¢ ¯®¤ ª®¤ ¨ ¤ ë¥ |
#define MAXDBGS 50000 // §¬¥à ¡ãä¥à®¢ ¯®¤ ®â« ¤®çã ¨ä®à¬ æ¨î |
#define MAXDLLS 100 |
#define MAXINPUT 512000 // ªá¨¬ «ìë à §¬¥à ¢å®¤®£® ä ©« |
#define MAXMDL 100 // ªá¨¬ «ì®¥ ç¨á«® includes |
#define MAXPOSTS 150000 // §¬¥à ¡ãä¥à®¢ ¯®¤ POST ®¡à ¡®âªã |
#define NULL 0 |
#define SORTSIZE 20 |
#define STRLEN 1000 // «¨ ¡ãä¥à ¯®¤ token |
// ------------------------------------------ |
//===== 㬥஢ ë¥ ª®áâ âë |
// ---- ®¤ë ¢®§¢à â |
enum{ e_ok, e_outofmemory, e_cannotopeninput, e_toomanyerrors, |
e_internalerror, e_noinputspecified, e_unknowncommandline, |
e_extract, e_cannotopenmapfile, e_someerrors }; |
// ---- ®¤ë tokens tk_xxxx |
enum{ |
tk_eof,tk_number,tk_string,tk_var, |
tk_id, |
tk_db,tk_dw,tk_dd,tk_dq, // ¨¯ë ¯¥à¥¬¥ëå |
tk_byte,tk_char,tk_word,tk_short, |
tk_dword,tk_int, |
tk_enum, // 㬥஢ ë¥ ª®áâ âë |
tk_struc, // ¯à¥¤¥«¥¨¥ áâàãªâãàë |
tk_if,tk_else,tk_endif, // á«®¢ ï ª®¬¯¨«ïæ¨ï |
tk_include,tk_define, // ª«î票¥ ä « //¯à¥¤¥«¥¨¥ ª®áâ âë |
tk_import, // ¬¯®àâ ¨§ DLL |
tk_map, // ¥¥à æ¨ï MAP-ä ©« |
tk_debug, // ¥¥à æ¨ï ®â« ¤®ç®© ¨ä®à¬ 樨 |
tk_list, // ë¤ ç ASM-«¨á⨣ |
tk_dll, // ¥¥à æ¨ï DLL-ä ©« |
tk_loop,tk_return,tk_do, |
tk_while,tk_void, |
tk_continue,tk_break, |
tk_docase,tk_case,tk_default, |
tk_carryflag,tk_extract,tk_FALSE,tk_from, |
tk_notcarryflag,tk_notoverflow,tk_overflow,tk_TRUE, |
tk_zeroflag,tk_notzeroflag, |
tk_assign,tk_swap, |
tk_minus,tk_plus, |
tk_minusminus,tk_plusplus,tk_mult,tk_div,tk_mod, |
tk_multminus,tk_divminus,tk_modminus,tk_rr,tk_ll, |
tk_rrminus, |
tk_llminus, |
tk_minusequals,tk_plusequals,tk_rrequals,tk_llequals, |
tk_or,tk_and,tk_xor,tk_not, |
tk_orminus, |
tk_andminus,tk_xorminus, |
tk_orequals,tk_andequals,tk_xorequals, |
tk_equalto, |
tk_notequal,tk_greater,tk_greaterequal,tk_less, |
tk_lessequal, |
tk_oror,tk_andand,tk_openbrace,tk_closebrace, |
tk_openbracket,tk_closebracket,tk_openblock,tk_closeblock, |
tk_colon,tk_semicolon,tk_comma,tk_period, |
tk_dollar,tk_question,tk_tilda, |
tk_reg,tk_controlreg,tk_debugreg,tk_testreg,tk_seg, |
tk_undefproc,tk_proc, |
tk_postnumber, |
tk_local,tk_locallabel,tk_param,tk_locnumber, |
tk_DLL,tk_API,tk_directive,tk_command,tk_mnemonics, |
tokens |
}; |
// ---- ®¤¨à®¢ª ⨯ ¯à®æ¥¤ãà |
enum{ cpt_near, cpt_far }; |
// ---- ®¤¨à®¢ª POST § ¯¨á¥© |
enum { POST_CALL=1, POST_API, POST_DATA, POST_LOC, POST_STR }; |
// ---- ¯¨á ¨¥ áâàãªâãàë ¢ dbginfo: dbg_... |
enum{ dbg_mod=0, // ®¬¥à ¬®¤ã«ï |
dbg_line=4, // ®¬¥à áâப ¢ ¬®¤ã«¥ |
dbg_loc=8, // ®§¨æ¨ï ¢ EXE-ä ©«¥ |
dbg_size=12}; // à §¬¥à áâàãªâãàë |
// ---- ¯¨á ¨¥ áâàãªâãàë idrec |
enum{ left=0, // ª § ⥫ì idrec |
right=4, // ª § ⥫ì idrec |
recid=8, // ¬ï ¨¤¥â¨ä¨ª â®à |
newid=recid+4, // ª § â¥«ì «¨ á ¤«ï recid |
rectok=newid+4, // ®¬¥à token |
rectype=rectok+4, // ¨¯ token: void, byte, char, word, ... |
recsrc=rectype+4, // áå®¤ë© â¥ªáâ |
recpost=recsrc+4, // « £ POST ¯¥à¥¬¥®© |
recnumber=recpost+4, // 票¥ ¨«¨ offset ¢ recsrc |
recmodline=recnumber+4,// ®¬¥à ¬®¤ã«ï ¨ áâப¨ |
recsize=recnumber+4};// à §¬¥à áâàãªâãàë |
// ---- ¯¨á ¨¥ áâàãªâãàë localrec |
enum{ localnext=0, // ª § ⥫ì á«¥¤ãîéãî localrec |
localid=4, // ¬ï «®ª «ì® ¯¥à¥¬¥®© |
localtok=localid+IDLENGTH,// 票¥ token |
localtype=localtok+4, // ⨯ ¯¥à¥¬¥®© |
localnumber=localtype+4, // ®§¨æ¨ï ¢ á⥪¥ |
local_size=localnumber+4}; // §¬¥à áâàãªâãàë |
/programs/develop/c--/trunk/examples/docase.c- |
---|
0,0 → 1,17 |
#map |
#debug |
#list |
main() // execution always starts at main () |
{ |
docase{ |
EBX+=80; |
case(ECX==10) |
//#list |
EBX=10; |
case(EBX<5){ |
ECX=5; continue;} |
default |
EDX+=8; |
} |
EAX=9; |
} |
/programs/develop/c--/trunk/examples/docase.map |
---|
0,0 → 1,71 |
MAP FILE FOR DOCASE.EXE |
{ |
docase{ |
EBX+=80; |
// @L0: |
// add EBX,80 |
case(ECX==10) |
// mov eax,ECX |
// cmp eax,0xa |
// sete al |
// movzx eax,al |
//#list |
// test eax,eax;jz @L2 |
EBX=10; |
// mov EBX,10 |
case(EBX<5){ |
// jmp @L1 |
// @L2: |
// mov eax,EBX |
// cmp eax,0x5 |
// setl al |
// movzx eax,al |
// test eax,eax;jz @L3 |
ECX=5; continue;} |
// mov ECX,5 |
// jmp @L0 |
default |
EDX+=8; |
// jmp @L1 |
// @L3: |
// add EDX,8 |
} |
EAX=9; |
// @L1: |
// mov EAX,9 |
} |
// ret |
Compile all sources |
ALL GLOBAL IDENTIFIERS LIST: |
tok type number post IDENTIFIER |
104 1Fh 401000h 0h main |
File:DOCASE.C-, line=4: |
() // execution always starts at main () |
{ |
docase{ |
EBX+=80; |
case(ECX==10) |
//#list |
EBX=10; |
case(EBX<5){ |
ECX=5; continue;} |
default |
EDX+=8; |
} |
EAX=9; |
} |
1 Unique Global Identifiers. |
GLOBAL CONSTANT IDENTIFIER LIST: |
0 Unique Global Constant Value Identifiers. |
Component Sizes: |
Code:128 bytes, Post: 0 bytes |
Run file size: 128 bytes |
END OF MAP FILE FOR DOCASE.EXE |
/programs/develop/c--/trunk/examples |
---|
Property changes: |
Added: tsvn:logminsize |
+5 |
\ No newline at end of property |
/programs/develop/c--/trunk/exe.h-- |
---|
0,0 → 1,145 |
// ---- ®à¬¨à®¢ ¨¥ IMPORT ᥪ樨 |
void DoLink() |
dword i,j,DirTable,AddrTable,dllName,apiName,byName,hold; |
dword dll,api; |
{ |
OptImportTableAdr=outptr-output; |
DirTable=outptr; |
if(APIcount==0){ |
OUTDWORD(outptr -output + OptBaseOfCode + 4); |
OUTDWORD(0x80000001); |
OUTDWORD(0); |
OUTDWORD(DirTable-output+40+OptBaseOfCode); |
OUTDWORD(outptr-output + OptBaseOfCode - 12); |
DirTable=outptr; |
outptr = outptr + 20; |
OUTDWORD('resu'); |
OUTDWORD('d.23'); |
OUTDWORD('ll'); |
// OUTDWORD(0x72657375); OUTDWORD(0x642E3233); OUTDWORD(0x6C6C); |
apiName=outptr; |
} |
else { |
EAX=DLLcount+1*20; |
outptr+=EAX; // ç «® LookupTables |
i=0; |
while(i<DLLcount){ // à®á¬®âà ᯨ᪠DLL |
EAX=i<<2; |
dll=DLLlist[EAX]; |
EBX=dll; // á뫪 DLL ¢ ᯨ᪥ ¨¤¥â¨ä¨ª â®à®¢ |
byName = DSDWORD[EBX+rectype]; // ¬¯®àâ ¯® ¨¬¥¨? |
if(DSDWORD[EBX+recmodline]){ // 뫨 ¢ë§®¢ë API ¨§ ¤ ®© DLL? |
dllName=outptr; |
ESI=DSDWORD[EBX+recid]; // ª § â¥«ì ¨¬ï DLL |
do{ |
$LODSB; |
OP(byte AL); |
}while(AL!=0); // ®åà ¨¬ ¨¬ï DLL |
AddrTable = outptr; //䨪á¨à㥬 ç «® AddrTable ¤«ï ¤ ®£® DLL |
apiName=DSDWORD[EBX+recmodline]+1<<2+AddrTable; |
j=0; |
while(j<posts){ // 饬 ¢ post |
EBX=j<<2+posttype; |
if(DSDWORD[EBX]==POST_API){ |
EBX=j<<2+postnum; |
api=DSDWORD[EBX]; |
ECX=api; |
if(DSDWORD[ECX+rectype]==dll){ // § ®¡à ¡ âë¢ ¥¬®£® DLL? |
if(DSDWORD[ECX+recmodline]==0){ // é¥ ¥ ¢¥á¥ ¢ Lookup |
DSDWORD[ECX+recmodline]=outptr-output+OptBaseOfCode; |
IF(byName){ |
OUTDWORD(apiName - output + OptBaseOfCode - 2); |
hold=outptr; |
outptr=apiName; |
EAX=DSDWORD[ECX+newid]; |
IF(EAX!=0){ // áâì «¨ á? |
IF(lstrcmpA(DSDWORD[ECX+recid],EAX)!=0){ |
ESI=api; |
ESI=DSDWORD[ESI+newid]; |
GOTO L1; |
} |
} |
ESI=DSDWORD[ECX+recid]; |
L1: |
do{ |
$LODSB; |
OP(byte AL); |
}while(AL!=0); // ®åà ¨¬ ¨¬ï API |
apiName=outptr; |
outptr=hold; |
} |
ELSE{ |
EAX=DSDWORD[ECX+recnumber]|0x80000000; // ord number |
OUTDWORD(EAX); |
} |
} |
} |
} |
j++; |
} // end search in post |
OUTDWORD(0); |
outptr=hold; |
outptr=DirTable; |
OUTDWORD(AddrTable-output+OptBaseOfCode); |
OUTDWORD(0); |
OUTDWORD(0); |
OUTDWORD(dllName-output+OptBaseOfCode); |
OUTDWORD(AddrTable-output+OptBaseOfCode); |
DirTable=outptr; |
outptr=apiName; |
} |
i++; |
} // end search in DLLlist |
} |
outptr=DirTable; |
OUTDWORD(0); |
OUTDWORD(0); |
OUTDWORD(0); |
OUTDWORD(0); |
OUTDWORD(0); |
outptr=apiName; |
OptImportTableSize=outptr-output-OptImportTableAdr; |
OptImportTableAdr=OptImportTableAdr+OptBaseOfCode; |
} |
// ---- ®à¬¨à®¢ ¨¥ EXE |
dword WriteEXE() |
dword diskout; // Handle ¢ë室®£® ä ©« |
byte exefile[FILENAMESIZE]; |
{ |
wsprintfA(#exefile,"%s.EXE",#rawfilename); |
SHOW(#exefile); |
diskout=_lcreat(#exefile,0); |
IF(EAX==0){ |
wsprintfA(#mapstr,"ERROR, unable to create output file %s.\n",#exefile); |
WRITESTR(#mapstr); |
return(-1); |
} |
OptCodeSize=outptr-startptr+1; |
OptImageSize=OptCodeSize/OptSectionAlignment; |
OptImageSize+=2; |
OptImageSize=OptImageSize*OptSectionAlignment; |
OptImageSize+=0x80000; |
TxtVirtualSize=OptCodeSize+0x80000; |
TxtSizeOfRawData=OptCodeSize/OptFileAlignment; |
TxtSizeOfRawData++; |
TxtSizeOfRawData=TxtSizeOfRawData*OptFileAlignment; |
_lwrite(diskout,#exeheader,0x160); |
WriteZero(diskout, 0xA0); |
IF(outptr-output)_lwrite(diskout,output,outptr-output); |
EAX=OptCodeSize%OptFileAlignment; |
EAX><EBX; |
EAX=OptFileAlignment-EBX; |
EAX++; |
WriteZero(diskout, EAX); |
_lclose(diskout); |
return(0); |
} |
// ---- |
WriteZero(dword handle,size) |
byte c; |
{ |
c=0; |
loop(size)_lwrite(handle,#c,1); |
} |
/programs/develop/c--/trunk/generate.h-- |
---|
0,0 → 1,1718 |
dword ACTUALMNEMDESC; // ª § â¥«ì ®¯¨á ¨¥ ⥪ã饩 ¬¥¬®¨ª¨ |
byte ACTUALMNEMONIC; // ®¤ ⥪ã饩 ¬¥¬®¨ª¨ |
byte OPERANDSIZE; // §¬¥à ®¯¥à ¤ (B,W,D,BW,WB,DW) |
byte OPDESC[3]; // ¨¯ë ®¯¥à ¤®¢ (R,E,D,CC,SR,TR,DR,CR) |
byte OPDATA[3]; // ä®à¬ æ¨ï ¯® ®¯¥à ¤ã (RG,CO,EA) |
dword OPCONST[3]; // 票¥ ª®áâ âë ¢ ®¯¥à ¤¥ |
byte OPCONSTFLAG[3]; // «¨ç¨¥ ª®áâ âë ¢ ®¯¥à ¤¥ |
byte OPCONSTSIZE[3]; // §¬¥à®áâì ª®áâ âë ¢ ®¯¥à ¤¥ |
byte OPPOST[3]; |
dword OPPOSTREF[3]; |
byte PFLAG; // 票¥ P-ä« £ (®¬¥à ª« áá ). |
byte RANDFLAG; // TRUE: RAND: âॡã¥âáï ¯à¥ä¨ªá 0x66 |
byte ADDRFLAG; // TRUE: ADDR: âॡã¥âáï ¯à¥ä¨ªá 0x67 |
byte WBIT; // ¨â WORD ¢ OPCODE |
byte DBIT; // ¨â DIRECTION ¢ OPCODE |
byte OPLENGTH; // ®«¨ç¥á⢮ ®¯¥à ¤®¢ ¢ ⥪ã饩 ¨áâàãªæ¨¨ |
byte EA_M; // ©â XRM |
byte EA_X; |
byte EA_R; // R NIBBLE IN XRM BYTE. |
byte EA_S; //SEGMENT REGISTER |
byte EA_R2; //BASE REGISTER |
byte EA_I; //INDEX REGISTER |
byte EADESC[2]; //CONTAINS INFORMATION ABOUT AN PARSED EFFECTIVE ADRESS. |
byte EALENGTH; // ®«¨ç¥á⢮ ॣ¨áâ஢ ¢ EA |
byte EA_SIBFLAG; // « £ «¨ç¨ï Sib ¢ 32-¡¨â®¬ EA |
byte EA_SCALING; // ¤¥ªá ¢ Sib |
dword EA_SCALE; // 票¥ ¤«ï Scale ¢ Sib |
dword EADescInd; // ¤¥ªá ¢ EADESC |
byte SEGREGISTER; // SEGMENT OVERRIDE PREFIX NEEDED OR 0. |
byte SYSRNUM; // CONTROL/DEBUG/TASKREG INDEX |
byte SYSRTYPE; // SYSTEM REGISTER TYPE (CR,CR4,DR,TR) |
byte SYSRCODE; // ENCODED REGISTER TYPE |
byte OVERRIDE; //SEGMENT OVERRIDE PREFIX NEEDED OR 0. |
dword opDescInd; |
dword prevTok; |
// ----- áᥬ¡«¨à®¢ ¨¥ áâப¨ |
Asm(dword str) |
byte holdcha; |
byte source[256],s[STRLEN],s2[STRLEN]; |
{ |
lstrcpyA(#source,str); |
IF(list){ |
fprint(mapfile,"\t//\t"); |
fprint(mapfile,str); |
fprint(mapfile,"\n"); |
} |
holdcha=cha2; //§ ¯®¬¨âì ¯®§¨æ¨î à §¡®à |
$PUSH linenum2,inptr2,number,tok2,tok,input,inptr,currmod,linenumber, |
endoffile,displaytokerrors,type; |
lstrcpyA(#s,#string); |
lstrcpyA(#s2,#string2); |
input=#source; //à §¡¨à ¥¬ ®¢ãî áâபã |
inptr = input; |
inptr2=input; |
endoffile=0; // ç «¥ ä ©« |
NextChar(); |
cha2 = cha; |
inptr2=inptr; |
linenum2 = 1; |
for(;;){ |
NextTok(); |
IF(tok==tk_mnemonics)DoMnemonics(); |
ELSE IF(tok==tk_eof)BREAK; |
ELSE IF(tok==tk_locallabel)DoLocalPost(); |
ELSE IF(tok!=tk_semicolon)preerror("ASM: Bad input format\n"); |
} |
lstrcpyA(#string,#s); //¢®áâ ®¢¨âì |
lstrcpyA(#string2,#s2); |
$POP type,displaytokerrors,endoffile,linenumber,currmod,inptr,input, |
tok,tok2,number,inptr2,linenum2; |
cha2=holdcha; |
} |
DoLocalPost() |
dword i; |
{ |
tok = tk_number; |
number = outptr-output+OptImageBase+OptBaseOfCode; |
ESI=localptr; |
DSDWORD[ESI+localtok] = tok; |
DSDWORD[ESI+localnumber] = number; |
i=0; |
WHILE(i<posts){ |
ECX=i<<2+postnum; |
EAX=DSDWORD[ECX]; |
IF(EAX==localptr){ |
DSDWORD[ECX]=number; |
EBX=i<<2+posttype; |
DSDWORD[EBX]=POST_LOC; |
} |
i++; |
} |
NextTok(); |
NextTok(); |
} |
// ---- áâ ®¢ª áá뫪¨ ¯®ª ¥®¡ê¥ë© ¨¤¥â¨ä¨ª â®à |
SetPost(dword ref,ptype) |
{ |
IF(posts >= MAXPOSTS)maxwordpostserror(); |
EBX=posts<<2+postloc; |
DSDWORD[EBX] = outptr; |
EBX=posts<<2+postnum; |
DSDWORD[EBX] = ref; |
EBX=posts<<2+posttype; |
DSDWORD[EBX] = ptype; |
posts++; |
} |
// ---- யã᪠¤® á«¥¤ãî饩 § ¯¨á¨ ¢ è ¡«®¥ ¨áâàãªæ¨¨ |
SCDEND() |
{ |
$LODSB |
IF(AL!=0){ |
$CMP AL,_END |
$JNE SCDEND |
illegaloperand(); |
$POP EAX; // ë室 ¨§ MapOperands |
} |
} |
GETSCALING() |
{ |
NextTok(); // ®«ã稬 § 票¥ ¬ áèâ ¡®£® ª®íää¨æ¨¥â |
IF(tok==tk_number){ |
DoScale: |
EA_SCALE=number; // Scale |
EA_SIBFLAG=1; // ⬥⨬ «¨ç¨¥ Sib ¢ 32-¡¨â®¬ EA |
} |
ELSE preerror("ASM: Illegal scaling value\n"); |
} |
// ---- ®¨áª ¢ è ¡«®¥ ¯®¤å®¤ï饩 ª ®¯¥à ¤ã § ¯¨á¨ (¤«ï ®¤®®¯¥à ¤®© ¨áâàãªæ¨¨) |
GETOL1() |
{ |
if(DSBYTE[ESI]!=0){ // áâàãªæ¨ï JMP - ¥ ¯à®¢¥à塞 ᮢ¯ ¤¥¨¥ à §¬¥à®¢ |
G4: |
$LODSB |
AH=AL&NOLBITS; // ᪫î稬 ç¨á«® ®¯¥à ¤®¢ |
if(NOTZEROFLAG){// â® ¢á¥-â ª¨ JMP... |
DL=AL&OPBITS; // ᪠¤«ï ⨯ ®¯¥à ¤ |
IF(DL!=SOO){ // ¯®«¥ à §¬¥à ®¯¥à ¤ ᮤ¥à¦¨âáï ¨ä®à¬ æ¨ï ® ⨯¥ ®¯¥à ¤ ? |
AL&=OLBITS; // 뤥«¨¬ ª®«¨ç¥á⢮ ®¯¥à ¤®¢ |
IF(AL!=OL1){ // ¡«® ¤«ï ¨áâàãªæ¨¨ á ®¤¨¬ ®¯¥à ¤®¬? |
G3: |
do{ |
$LODSB // à®á¬®âਬ á«¥¤ãîéãî § ¯¨áì è ¡«® |
IF(AL==0)GOTO G4; // ®¥æ § ¯¨á¨? |
}while(AL!=_END); // â® ª®¥æ è ¡«® ? |
illegaloperand(); // ¥â ¯®¤å®¤ï饩 § ¯¨á¨ ¤«ï â ª®© ¬¥¬®¨ª¨ |
$POP EAX; |
$RET // ë室 ¨§ MapOperands |
} |
// ¡à ¡®âª § ¯¨á¨ è ¡«® |
G2: |
AL=AH&TRANSBITS; // 뤥«¨¬ à §¬¥à ®¯¥à ¤ |
$CMP AL,_D |
$JBE G5 // ¯¥à ¤ ¬.¡. à §¬¥à : byte, word, dword |
$CMP AL,_OW |
$JNE J0 |
OPERANDSIZE=_W; |
GOTO G40; |
J0: |
$CMP AL,_OD; |
$JNE J1 |
OPERANDSIZE=_D; |
GOTO G40; |
J1: |
$CMP AL,NB |
$JB G90 // ¯¥à ¤ ¬.¡. à §¬¥à WB,DW OR BW. |
AL-=NB; // ¥à¥áç¨â ¥¬ ¤«ï 䨪á¨à®¢ ëå à §¬¥à®¢: NB->B,OW->W, AF->D |
G90: |
$CMP AL,OPERANDSIZE // §¬¥à ®¯¥à ¤ ¨ à §¬¥à ¨§ è ¡«® ᮢ¯ «¨? |
$JNE G3 // ¥â - ᬮâਬ á«¥¤ãîéãî § ¯¨áì ¢ è ¡«®¥ |
GOTO G40; // §¬¥àë ᮢ¯ «¨ - ¯à®¤®«¦¨¬ |
G5: |
$CMP AL,OPERANDSIZE // §¬¥à ®¯¥à ¤ ¨ à §¬¥à ¨§ è ¡«® ᮢ¯ «¨? |
$JA G3 // ¥â - ᬮâਬ á«¥¤ãîéãî § ¯¨áì ¢ è ¡«®¥ |
EBX=0; // WBIT/RANDFLAG=0 |
DL=AL; |
AL=OPERANDSIZE; |
IF(DL==_B)&&(AL!=_B)BL++; |
// $CMP DL,_B // è ¡«®¥ byte? |
// $JNE G20 |
// $CMP AL,_B // ¯¥à ¤ byte? |
// $JE G20 |
// BL++; // W-¡¨â=TRUE |
//G20: |
$CMP AL,_W // è ¡«®¥ word? |
$JNE G30 |
$JA G30 |
BH++; // ¯¥à ¤ ®¡ï§ â¥«ì® ¤.¡. word - âॡã¥âáï ¯à¥ä¨ªá RAND |
G30: |
WBIT=BL; |
RANDFLAG=BH; // ¯®¬¨¬ ¨ä®à¬ æ¨î ® ¯à¥ä¨ªá¥ ¨ W-¡¨â¥ |
G40: |
AH&=NTRANSBITS; // áâ ¢¨¬ SOO ¡¨âë |
} |
} |
} |
AL=AH; // ®§¢à ⨬ SOO ¯®«¥ |
} |
// ---- §¡®àª è ¡«® ¤«ï ¤¢ã宯¥à ¤®© ¨áâàãªæ¨¨ |
GETOL2() |
{ |
G7: |
$LODSB // ®«ã稬 ¡ ©â ¨§ è ¡«® |
AH=AL; |
AL&=OLBITS; // 뤥«¨¬ ç¨á«® ®¯¥à ¤®¢ |
$CMP AL,OL2 // ¨á«® ®¯¥à ¤®¢ = 2? |
$JE G8 // - 祬 ¯à®¢¥àªã |
G9: |
$LODSB // ®¨áª á«¥¤ãî饩 § ¯¨á¨ ¢ è ¡«®¥ |
$OR AL,AL // ®¥æ § ¯¨á¨? |
$JZ G7 // - ¯à®¢¥à¨¬ ®¢ãî § ¯¨áì |
$CMP AL,_END // ®¥æ è ¡«® ? |
$JNE G9 // ¬®âਠ¤ «ìè¥ ¨ ç¥ - ®è¨¡ª |
toomuchoperands(); |
$POP EAX; |
$RET // ë室 ¨§ MapOperands |
G8: |
AH&=NOLBITS; // ᪫î稬 ç¨á«® ®¯¥à ¤®¢ |
AL=AH; |
AL&=TRANSBITS; // 뤥«¨¬ à §¬¥à ®¯¥à ¤ |
$CMP AL,_D |
$JBE G100 // ¯¥à ¤ ¬.¡. à §¬¥à : byte, word, dword |
G94: |
$CMP AL,NB |
$JB J0 //G95 // ¯¥à ¤ ¬.¡. à §¬¥à WB,DW OR BW. |
AL-=NB; // ¥à¥áç¨â ¥¬ ¤«ï 䨪á¨à®¢ ëå à §¬¥à®¢: NB->B,OW->W, AF->D |
G95: |
$CMP AL,OPERANDSIZE // §¬¥à ®¯¥à ¤ ¨ à §¬¥à ¨§ è ¡«® ᮢ¯ «¨? |
$JNE G9 // §¬¥àë ¥ ᮢ¯ «¨ - ¨é¥¬ á«¥¤ãîéãî § ¯¨áì |
$JMP G11 // §¬¥àë ᮢ¯ «¨ - ¯à®¤®«¦¨¬ |
J0: |
$CMP OPDESC[0],CO |
$JNE J1 |
$CMP AL,WB; |
$JNE J1 |
OPCONSTSIZE[0]=_W; |
OPCONSTSIZE[1]=_B; |
GOTO G11; |
J1: |
$CMP AL,_DW; |
$JNE J2; |
RANDFLAG=0; |
OPCONSTSIZE[0]=_D;// OPCONSTSIZE[1]=_W; |
GOTO G11; |
J2: |
$CMP AL,BW; |
$JNE G95 |
OPCONSTSIZE[0]=_B; |
OPCONSTSIZE[1]=_W; |
GOTO G11; |
G100: |
$CMP OPERANDSIZE,_D |
$JA NEAR G9 // §¬¥à ®¯¥à ¤ > dword - á«¥¤ãîéãî § ¯¨áì |
$CMP OPERANDSIZE,AL |
$JB NEAR G9 // §¬¥àë ¥ ᮢ¯ «¨ - ¨é¥¬ á«¥¤ãîéãî § ¯¨áì |
EBX=0; |
DL=AL; |
AL=OPERANDSIZE; |
$CMP DL,_B // §¬¥à ¢ è ¡«®¥ = byte? |
$JNE G50 |
$CMP AL,_B // §¬¥à ®¯¥à ¤ = byte? |
$JE G50 |
BL++; // W-¡¨â=TRUE |
G50: |
$CMP AL,_W // è ¡«®¥ word? |
$JNE G60 |
$JA G60 |
BH++; // ¯¥à ¤ ®¡ï§ â¥«ì® ¤.¡. word - âॡã¥âáï ¯à¥ä¨ªá RAND |
G60: |
WBIT=BL; |
RANDFLAG=BH; |
G11: |
AH&=NTRANSBITS; |
AL=AH; // ®§¢à ⨬ SOO ¯®«¥ |
} |
// ---- §¡®àª è ¡«® ¤«ï âà¥å®¯¥à ¤®© ¨áâàãªæ¨¨ |
GETOL3() |
{ |
G12: |
$LODSB |
AH=AL; |
AL&=OLBITS; |
$CMP AL,OL3 |
$JE G13 |
G14: |
$LODSB //TRY NEXT ENTRY. |
$OR AL,AL |
$JZ G12 |
$CMP AL,_END |
$JNE G14 |
toomuchoperands(); |
$POP EAX; |
$RET // ë室 ¨§ MapOperands |
G13: |
AH&=NOLBITS; |
$CMP OPERANDSIZE,_D //DWORD ? |
$JE G15 |
$CMP OPERANDSIZE,_W //WORD ? |
$JE G16 |
preerror("ASM: This instruction required a WORD/DWORD operand\n"); |
$RET |
G16: |
RANDFLAG=1; |
G15: |
AL=AH&0xE0; |
} |
// ---- |
CREATE_EA() |
{ |
EA_M=AL&7; |
EA_X=3; |
} |
// ---- |
CREATE_R() |
{ |
EA_R=AL&7; |
} |
// ---- ¥¥àà æ¨ï ModRM ¨ Sib |
GETMODRMBYTE() |
{ |
DL=EALENGTH; // ®«¨ç¥á⢮ ॣ¨áâ஢ ¢ EA |
$OR DL,DL // ¥â ॣ¨áâ஢ ¢ EA? |
$JE NEAR C11 // |
$TEST EADESC,_W+_D*8 |
$JE NEAR E1 // 8-¡¨âë¥ à¥£¨áâàë ¥«ì§ï ¯à¨¬¥ âì ¢ ¤à¥á¥ |
$TEST EADESC,_W*8 // 16-¡¨âë© à¥£¨áâà? |
$JNE NEAR E4 // 16-¡¨â ï ¤à¥á æ¨ï ¥ à §à¥è¥ |
GETEADISPX(); |
$CMP DH,2 |
$JNZ X00 |
EAX=opDescInd; |
OPCONSTSIZE[EAX]=_D; // ¡ï§ â¥«ì® 32-¡¨âë© disp |
X00: |
DL--; // 1 ॣ¨áâà? |
$JNE N1 // ¥â... |
AL=EADESC&7; |
$CMP EA_SIBFLAG,1 // « £ «¨ç¨ï Sib ¢ 32-¡¨â®¬ EA |
$JNE L2 // ¥â Sib |
EA_R2=5; // ¨ªá¨à㥬 ¡ §®¢ë© ॣ¨áâà |
EA_M=4; |
EA_I=AL; |
EDX=opDescInd; |
$CMP OPCONSTFLAG[EDX],1 // ᯮ«ì§ã¥¬ disp? |
$JE L1 |
EAX=0; |
OPCONSTFLAG[EDX]=1; |
EDX<<=2; |
OPCONST[EDX]=EAX; // disp=0 ¢ EA |
L1: |
EDX=opDescInd; |
OPCONSTSIZE[EDX]=_D; |
EA_X=0; //EA_X=AL; |
$RET |
L2: |
EA_M=AL; |
$RET |
N1: |
EA_M=4; //2 REGISTERS USED. |
EA_SIBFLAG=1; |
AL=EADESC[1]>>3; |
$CMP AL,_W |
$JE E5 //ERROR: INDEX REGISTER ISN'T OF SIZE DWORD |
AL=EADESC; |
AH=EADESC[1]; |
EAX&=0x707; |
$CMP AH,5 //CAN'T USE BP AS INDEX. |
$JE E6 |
EA_R2=AL; |
EA_I=AH; |
$RET |
E1: |
preerror("ASM: You can't use byte registers in addresses\n"); |
$RET |
E4: |
preerror("ASM: 16-bit addressing mode not allowed\n"); |
$RET |
E5: |
preerror("ASM: You must use a 32-bit registers for scaling\n"); |
$RET |
E6: |
preerror("ASM: You can't use EBP as an index\n"); |
$RET |
C11: |
EA_X=0; |
EA_M=5; |
ECX=opDescInd; |
AL=OPCONSTSIZE[ECX]; |
IF(AL==_B)OPCONSTSIZE[ECX]=_D; |
ELSE IF(AL==_W)ADDRFLAG=1; |
} |
// ---- |
GETEADISPX() |
{ //CREATE X NIBBLE OF DISPLACEMENT SIZE. |
DH=0; |
$PUSH ECX |
ECX=opDescInd; |
IF(OPCONSTFLAG[ECX]==1){ |
AL=OPCONSTSIZE[ECX]; |
DH=2; //(D)WORD DISPLACEMENT |
IF(AL==_B)DH--; //SBYTE DISPLACEMENT |
} |
EA_X=DH; |
$POP ECX |
} |
// ---- ¨æ¨ «¨§ æ¨ï ¡ãä¥à áᥬ¡«¥à |
INIT_LINE() |
{ |
ECX=#opDescInd-#OPERANDSIZE; |
AL=0; |
EDI=#OPERANDSIZE; |
$REP $STOSB; |
AL=255; |
OPERANDSIZE=AL; |
SEGREGISTER=AL; |
} |
// ---- ¯¨áì ¯¥à¥®¯à¥¤¥«¥¨ï ᥣ¬¥â |
WRITEOVERRIDE() |
{ |
EBX=OVERRIDE; |
IF(BL!=0){ |
AL=OVERRIDETAB[EBX]-rES; |
OP(); |
} |
} |
// ---- ¯¨áì ¯à¥ä¨ªá à §¬¥à®á⨠®¯¥à ¤ |
WRITERAND() |
{ |
$PUSH EAX |
IF(RANDFLAG==1){ |
AL=0x66; |
OP(); |
} |
$POP EAX |
} |
// ---- ¯¨áì ª®áâ âë: CL=TYPE; EDI 㪠§ â¥«ì § 票¥ |
WRITECONST() |
{ |
IF(CL==_B)CL=1; |
ELSE IF(CL==_W)CL=2; |
ELSE IF(CL==_D)CL=4; |
ELSE CL++; |
loop(ECX){ |
AL=DSBYTE[EDI]; |
EDI++; |
OP(); |
} |
} |
// ---- ¡à ¡®âª Override |
GETOVERRIDE() |
{ |
IF(tok==tk_seg)&&(tok2==tk_colon){ |
IF(OVERRIDE==0){ |
OVERRIDE=number; |
$STC // ù ᥣ¬¥â®£® ॣ¨áâà |
} |
ELSE preerror("ASM: Double segment override"); |
NextTok(); |
NextTok(); // யã᪠¥¬ : |
} |
} |
// ---- ëç¨á«¥¨¥ à §¬¥à ®¯¥à ¤ : _B,_W,_D,WB,_DW & RAND-FLAG. AL=SIZE |
DEF_OPSIZE() |
{ |
AH=OPERANDSIZE; |
IF(AH==255){ |
OPERANDSIZE=AL; // ¤¨ ®¯¥à ¤ |
return; |
} |
IF(AH==AL)return; // §¬¥àë ᮢ¯ ¤ îâ |
IF(AX==0X100){ // RW,RB ? |
RANDFLAG=1;// OPERANDSIZE=WB; |
return; |
} |
IF(AX==0X200){ // RD,RB ? |
IF(ACTUALMNEMDESC==#PCOMMANDS3_){ |
// OPERANDSIZE=_D; |
return; |
} |
OPERANDSIZE=WB; |
return; |
} |
IF(AX==0X201){ //RD,RW |
RANDFLAG=1; |
OPERANDSIZE=_DW; |
} |
} |
// ---- ¯¨áì ¯à¥ä¨ªá ¤à¥á 樨 |
WRITEADDR() |
{ |
$PUSH EAX |
IF(ADDRFLAG==1){ |
AL=0x67; |
OP(); |
} |
$POP EAX |
} |
// ---- ¯à¥¤¥«¥¨¥ à §¬¥à®á⨠ª®áâ âë |
DefConstSize() |
{ // ¯à¥¤¥«¨¬ à §¬¥à®áâì ª®áâ âë |
EBX=opDescInd; |
DL=_D; |
IF(OPPOST[EBX]==0){ |
EBX=opDescInd<<2; |
EAX=OPCONST[EBX]; |
DL=_B; // byte |
IF(long EAX>=-128){ // -128 |
$CMP EAX,0XFF // 255 |
$JNG W2 |
} |
DL++; // _W - word |
IF(long EAX>=-32768){ |
$CMP EAX,0XFFFF // 65535 |
$JNG W2 |
} |
DL++; // _D - dword |
} |
W2: |
EBX=opDescInd; |
OPCONSTSIZE[EBX]=DL; |
OPCONSTFLAG[EBX]=1; |
} |
// ---- ¡à ¡®âª ¬¥¬®¨ª¨ áᥬ¡«¥à |
DoMnemonics() |
{ |
opDescInd=0; |
EADescInd=0; |
INIT_LINE(); // ç¨á⪠¡ãä¥à®¢ |
IF(number<24){ |
IF(number<8)EBX=#PCOMMANDS1; |
ELSE IF(number<12){ |
number-=8; |
EBX=#PCOMMANDS2; |
} |
ELSE IF(number<20){ |
number-=12; |
EBX=#PCOMMANDS3; |
} |
ELSE{ |
number-=20; |
EBX=#PCOMMANDS4; |
} |
number+=DSBYTE[EBX]; |
PFLAG=number; |
EBX++; |
} |
ELSE{ |
number-=24; |
EBX=number<<2; |
EBX=TAB_MNEMONICS[EBX]; |
IF(EBX>=#T_DAA)&&(EBX<#T_NOT){ // ஢¥à¨¬ «¨ç¨¥ ¨áâàãªæ¨¨ ¡¥§ ®¯¥à ¤®¢ |
ACTUALMNEMDESC=EBX; |
IF(tok2==tk_semicolon)NextTok(); |
ESI=ACTUALMNEMDESC; |
$JMP CreateCode;// ¥¥à æ¨ï ª®¤ ¤«ï ¨áâàãªæ¨¨ ¡¥§ ®¯¥à ¤®¢ |
} |
} |
ACTUALMNEMDESC=EBX; // ¯®¬¨¬ 㪠§ ⥫ì ⥪ã騩 è ¡«® ¬¥¬®¨ª¨ |
for(;;){ // ¨ª« «¨§ ®¯¥à ¤®¢ |
prevTok=tok; |
NextTok(); // «¥¤ãî騩 ®¯¥à ¤ |
FastSearch(#string,#St_Sizes);// â® à §¬¥à ®¯¥à ¤ ? |
IF(CARRYFLAG){ // : byte,word ¨«¨ dword |
OPERANDSIZE=AL; // ¯®¬¨¬ _B,_W,_D |
continue; |
} |
GETOVERRIDE(); // ¡à ¡®âª ª®áâàãªæ¨¨ SEG: |
ContLine: // ®çª ¤«ï ¯à®¤®«¦¥¨ï ®¡à ¡®âª¨ ⥪ã饣® |
IF(tok==tk_eof)||(tok==tk_semicolon){ |
EBX=opDescInd; |
IF(OPDESC[EBX]==E){ // ¡à ¡®âª ¢ EA? |
DefConstSize(); |
GETMODRMBYTE(); // EOL - GENERATE MODRM OPCODE BYTE. |
} |
IF(prevTok!=tk_mnemonics){ // 뫨 ®¯¥à ¤ë |
OPLENGTH++; |
IF(OPERANDSIZE==255){ |
OPERANDSIZE=_D; // à¨ã¤¨â¥«ì® ãáâ ®¢¨¬ dword |
} |
} |
$JMP MapOperands |
} |
else IF(tok==tk_comma){ |
IF(opDescInd==3){ |
toomuchoperands(); |
break; |
} |
EBX=opDescInd; |
IF(OPDESC[EBX]==E){ // ¡à ¡®âª ¢ EA? |
DefConstSize(); |
GETMODRMBYTE(); // EOL - GENERATE MODRM OPCODE BYTE. |
} |
opDescInd++; |
OPLENGTH++; |
} |
else IF(tok==tk_openblock){ |
EBX=opDescInd; |
OPDESC[EBX]=E; // ⬥⨬, çâ® à ¡®â ¥¬ á EA ®¯¥à ¤®¬ |
} |
else IF(tok==tk_closeblock){ // ] |
DefConstSize(); |
GETMODRMBYTE(); // EOL - GENERATE MODRM OPCODE BYTE. |
} |
else IF(tok==tk_minus){ |
IF(tok2 == tk_number){ |
NextTok(); |
number = -number; |
$JMP ContLine; // த®«¦¨¬ docase ¡¥§ ¢ë¡®àª¨ á«¥¤.token |
} |
} |
else IF(tok==tk_plus) continue; |
else IF(tok==tk_mult){ // * |
GETSCALING(); // ª § ¬ áè ¡ ¢ Sib |
} |
else if(tok==tk_reg){ // ¡à ¡®âª ॣ¨áâà |
G0: |
EBX=opDescInd; |
IF(OPDESC[EBX]==E){ // ¡à ¡®âª ¢ EA? |
IF(type==tk_byte){ |
preerror("ASM: No byte register in address\n"); |
return; |
} |
IF(EALENGTH<2){ // ®«¨ç¥á⢮ ॣ¨áâ஢ ¢ EA < 2 ? |
EALENGTH++; // ⬥⨬, çâ® ¥áâì ¥é¥ ®¤¨ ॣ¨áâà ¢ EA |
EBX=EADescInd; |
EADESC[EBX]=number; // ¯®¬¨¬ ù ॣ¨áâà |
EADescInd++; |
} |
ELSE{ // «¨èª®¬ ¬®£® ॣ¨áâ஢ ¢ EA |
preerror("ASM: too much registers in combination\n"); |
return; |
} |
} |
ELSE{ |
OPDATA[EBX]=number; // ù ॣ¨áâà |
OPDESC[EBX]=R; |
AH=number&7; |
EA_R=AH; |
IF(opDescInd!=2){ |
AL>>=3; |
DEF_OPSIZE(); |
} |
} |
} |
else IF(tok==tk_number) { // ¡à ¡®âª ª®áâ âë |
IF(tok2==tk_mult){ |
DoScale(); |
NextTok(); |
continue; |
} |
NUM: |
EBX=opDescInd<<2; |
OPCONST[EBX]+=number; // ¯®¬¨¬ ª®áâ âã |
DefConstSize(); // ¯à¥¤¥«¨¬ à §¬¥à®áâì ª®áâ âë |
IF(OPDESC[EBX]!=E) // ®áâ â ¢ EA? |
OPDESC[EBX]=CO; |
} |
else IF(tok==tk_postnumber){ |
EBX=opDescInd; |
OPPOST[EBX]=POST_DATA; |
EBX<<=2; |
OPPOSTREF[EBX]=treeptr; |
ESI=treeptr; |
DSDWORD[ESI+recpost]++; |
GOTO NUM; |
} |
else IF(tok==tk_proc){ |
IF(post){ |
EBX=opDescInd; |
OPPOST[EBX]=POST_CALL; |
EBX<<=2; |
OPPOSTREF[EBX]=treeptr; |
ESI=treeptr; |
DSDWORD[ESI+recpost]++; |
} |
$JMP NUM |
} |
else IF(tok==tk_locallabel){ |
EBX=opDescInd<<2; |
OPPOSTREF[EBX]=localptr; |
I2: |
EBX=opDescInd; |
$CMP ACTUALMNEMDESC,#T_JCXZ; |
$JB I1 |
$CMP ACTUALMNEMDESC,#T_CALLFAR; |
$JA I1 |
OPPOST[EBX]=POST_CALL; |
$JMP NUM |
I1: |
OPPOST[EBX]=POST_DATA; |
AL=_D; |
DEF_OPSIZE(); |
$JMP PARSE_EA1 |
} |
else IF(tok==tk_undefproc){ |
I0: |
EBX=opDescInd<<2; |
OPPOSTREF[EBX]=treeptr; |
GOTO I2; |
} |
else IF(tok==tk_id){ |
tok = tk_undefproc; |
post = 1; |
number=0; |
AddToTree(#string); |
GOTO I0; |
} |
else IF(tok==tk_var){ // ¨æ¨ «¨§ æ¨ï EA á ª®áâ ⮩: EA+disp |
AL=type-tk_byte>>1; // AL=à §¬¥à ¤à¥á㥬®£® ®¯¥à ¤ (_B,_W,_D) |
DEF_OPSIZE(); |
EBX=opDescInd; |
IF(post){ |
EBX<<=2; |
OPPOSTREF[EBX]=treeptr; |
EBX=opDescInd; |
OPPOST[EBX]=POST_DATA; |
ESI=treeptr; |
DSDWORD[ESI+recpost]++; |
} |
PARSE_EA1: |
OPDESC[EBX]=E; |
OPCONSTFLAG[EBX]=1; // ⬥⨬, çâ® à ¡®â ¥¬ á EA ®¯¥à ¤®¬ |
EBX<<=2; |
OPCONST[EBX]+=number; // ¯®¬¨¬ ¤à¥á |
} |
else IF(tok==tk_seg){ |
EBX=opDescInd; |
OPDATA[EBX]=number-rES; // ù ᥣ¬¥â®£® ॣ¨áâà |
SEGREGISTER=AL; |
AL<<=3; // ®§¤ âì ª®¤ ¤«ï XSM ¯®«ï |
EA_S=AL; |
OPDESC[EBX]=_SR; |
AL=_W; |
DEF_OPSIZE(); |
} |
else IF(tok==tk_param)||(tok==tk_local){ |
PARSE_PAR: |
AL=type-tk_byte>>1; |
DEF_OPSIZE(); |
EBX=opDescInd; |
OPDESC[EBX]=E; |
EBX<<=2; // ⬥⨬, çâ® à ¡®â ¥¬ á EA ®¯¥à ¤®¬ |
OPCONST[EBX]+=number; // ¯®¬¨¬ ¤à¥á |
OPCONSTFLAG[EBX]=1; |
number=rEBP; |
$JMP G0; |
} |
else IF(tok==tk_controlreg){ |
EBX=opDescInd; |
OPDESC[EBX]=SYSR; |
SYSRNUM=number; |
IF(AL==4)SYSRTYPE=_CR4; |
ELSE{ |
SYSRTYPE=_CR; |
SYSRCODE=0; |
} |
} |
ELSE IF(tok==tk_debugreg){ |
EBX=opDescInd; |
OPDESC[EBX]=SYSR; |
SYSRNUM=number; |
SYSRTYPE=_DR; |
SYSRCODE=1; |
} |
ELSE IF(tok==tk_testreg){ |
EBX=opDescInd; |
OPDESC[EBX]=SYSR; |
SYSRNUM=number; |
SYSRTYPE=_TR; |
SYSRCODE=4; |
} |
ELSE preerror("ASM: Syntax error\n"); |
} |
} |
CreateScale() |
{ |
IF(ADDRFLAG)return; |
if(EA_SIBFLAG){ // « £ «¨ç¨ï Sib ¢ 32-¡¨â®¬ EA |
IF(EA_SCALE==0){ // âáãâáâ¢ã¥â |
EA_SCALING=0; |
} |
else IF(EA_SCALE==1)EA_SCALING=0; |
else IF(EA_SCALE==2)EA_SCALING=0x40; |
ELSE IF(EA_SCALE==4)EA_SCALING=0x80; |
ELSE IF(EA_SCALE==8)EA_SCALING=0xC0; |
ELSE{ |
EA_SCALING=0; |
IF(EA_SCALE>255)OP(byte 0x69); |
ELSE OP(byte 0x6B); |
AL=EA_I<<3|EA_I|0xC0; |
OP(byte AL); |
IF(EA_SCALE>255)OUTDWORD(EA_SCALE); |
ELSE OP(byte EA_SCALE); |
} |
} |
} |
// ---- ¥¥à æ¨ï ª®¤ . ESI=ptr § ¯¨áì ® ®¯¨á ¨¥ ¬¥¬®¨ª¨ (§ ¯¨áì ⨯ T_...) |
CreateCode() |
{ |
WRITEOVERRIDE(); |
CreateScale(); |
IF(ADDRFLAG==1){ //ADDR: PREFIX ? |
OP(byte 0x67); |
} |
IF(RANDFLAG==1){ //RAND: PREFIX ? |
OP(byte 0x66); |
} |
EDI=ESI; |
IF(ACTUALMNEMDESC==#T_TEST)DBIT=0; //DON'T ADD ANYTHING IF TESTING |
$SHL DBIT,1 //SHIFT D-BIT TO THE RIGHT POSITION. |
NEXT_DESC_BYTE: // ¡à ¡®âª ¡ ©â ¨§ ¤¥áªà¨¯â®à ¬¥¬®¨ª¨ |
EBX=0; |
BL=DSBYTE[EDI]; |
EDI++; |
NB3: |
$CMP BL,X7M |
$JA NC3 |
$CMP BL,X0M |
$JB N24 |
AH=BL-X0M; |
AL=EA_X<<3|AH<<3|EA_M; |
OP(); |
GOTO NEXT_DESC_BYTE; |
N24: |
EBX<<=2; |
EBX+=#Dsc_Jump; |
$JMP NEAR DSDWORD[EBX] |
NC3: |
$CMP BL,_END |
$JNE E42 |
$JMP CreateConstants // ®¥æ è ¡«® ¤«ï ¬¥¬®¨ª¨ |
E42: |
preerror("Descriptor damaged\n"); |
return; |
// OpCode - 1 ¡ ©â |
Dsc_O: |
AL=DSBYTE[EDI]+WBIT+DBIT; |
EDI++; |
OP(); |
GOTO NEXT_DESC_BYTE; |
// OpCode - 1 á«®¢® |
Dsc_OW: |
AL=DSBYTE[EDI]; |
EDI++; |
OP(); |
AL=DSBYTE[EDI]+WBIT+DBIT; |
EDI++; |
OP(); |
$JMP NEXT_DESC_BYTE |
// OpCode - 1 ¡ ©â ¨ á«¥¤ãî騩 ¡ ©â, § ¤ ë© 8-à¨ç®© áâப®© |
Dsc_OS: |
AL=DSBYTE[EDI]; |
EDI++; |
OP(); |
// OpCode - 8-à¨ç ï áâப á ª®¤®¬ |
Dsc_S: |
S01: |
CL=3; |
EAX=0; |
loop(CL){ |
AL=DSBYTE[EDI]; |
EDI++; |
IF(AL=='X'){ //X CHAR |
AL=EA_X; |
} |
ELSE IF(AL=='R')AL=EA_R; |
ELSE IF(AL=='M')AL=EA_M; |
ELSE IF(AL=='S')AL=SEGREGISTER; |
ELSE IF(AL=='N')AL=SYSRNUM; |
ELSE IF(AL=='P')AL=PFLAG; |
ELSE AL-='0'; |
AH=AH<<3|AL; |
} |
AL=AH+DBIT+WBIT; |
N15: |
OP(); |
$JMP NEXT_DESC_BYTE |
// OpCode - ModRM ¡ ©â |
Dsc_XRM: |
AL=EA_X<<3|EA_R<<3|EA_M; // ®«ãç¨âì ॣ¨áâà ¨§ ®¯¨á ¨ï ¬¥¬®¨ª¨ |
GOTO N15; |
// OpCode - ModRM á P-ä« £®¬ ( à¨ä¬¥â¨ç¥áª¨¥ ¨áâàãªæ¨¨) |
Dsc_XPM: |
AL=EA_X<<3|PFLAG<<3|EA_M; |
GOTO N15; |
// OpCode - ModRM á ᥣ¬¥âë¬ à¥£¨áâ஬ |
Dsc_XSM: |
AL=EA_X<<3|SEGREGISTER<<3|EA_M; |
GOTO N15; |
// JMP NEXT_DESC_BYTE |
} |
// ---- §¡®à § ª®ç¥ -> £¥¥à æ¨î ª®¤ ¯® è ¡«®ã |
MapOperands() |
{ |
// AL=0; WBIT=AL; DBIT=AL; |
opDescInd=0; |
ESI=ACTUALMNEMDESC; // ª § â¥«ì ¨ä®à¬ æ¨î ¯® £¥¥à 樨 |
AL=OPLENGTH; // ®«¨ç¥á⢮ ®¯¥à ¤®¢ |
ECX=#OPDESC; // ª § â¥«ì ¨ä®à¬ æ¨î ®¡ ®¯¥à ¤ å |
ECX=DSDWORD[ECX]; |
IF(ESI!=#T_MOV){ // áâàãªæ¨ï MOV? |
IF(AL!=0){ |
$CMP AL,1 |
$JE NEAR ONEOP // áâàãªæ¨ï á ®¤¨¬ ®¯¥à ¤®¬ |
$CMP AL,2 |
$JE NEAR TWOOPS // áâàãªæ¨ï á ¤¢ã¬ï ®¯¥à ¤ ¬¨ |
$CMP AL,3 |
$JE NEAR THREEOPS // áâàãªæ¨ï á âà¥¬ï ®¯¥à ¤ ¬¨ |
toomuchoperands(); |
return; |
} |
// ---- áâàãªæ¨ï ¡¥§ ®¯¥à ¤®¢ |
do{ |
$LODSB |
IF(AL==0)goto CreateCode; // ¥¥à æ¨ï ª®¤ |
}while(AL!=_END); |
preerror("ASM: Operand required\n"); |
return; |
// ---- ¥¥à æ¨ï MOV ¨áâàãªæ¨¨ |
} |
$PUSH EAX,ECX |
WRITEOVERRIDE(); |
CreateScale(); |
$POP ECX,EAX |
IF(AL!=2){ // 2 OPERANDS IN INSTRUCTION? |
preerror("ASM: Two operands required\n"); |
return; |
L2: |
preerror("ASM: Not same size\n"); |
return; |
} |
L1: |
BL=0; |
AL=OPERANDSIZE; |
IF(AL!=_D){ |
$CMP AL,_W |
$JA L2 |
$JNE N4 |
RANDFLAG=1; |
} |
BL=1; |
N4: |
WBIT=BL; //STORE W-BIT |
DL=0; //CLEAR D-BIT |
WRITEADDR(); |
EBX=0; |
BL=CL; |
EBX=EBX<<2+#Jmp_Mov; |
$JMP NEAR DSDWORD[EBX] |
Mov_ERR: |
preerror("ASM: a constant can't be used as a destination\n"); |
return; |
Mov_R: |
EBX=0; |
BL=CH; |
EBX=EBX<<2+#Jmp_Mov_R; |
$JMP NEAR DSDWORD[EBX] |
Mov_E: |
EBX=0; |
BL=CH; |
EBX=EBX<<2+#Jmp_Mov_E; |
$JMP NEAR DSDWORD[EBX] |
Mov_R2R: |
WRITERAND(); |
AL=OPDATA[1]; |
AH=OPDATA[0]; |
DL=DBIT; |
$PUSH EAX |
AL=0o210+WBIT; |
$SHL DL,1 |
AL+=DL; //D-BIT |
OP(); |
$POP EAX |
AL=AL&7<<3; |
AH&=7; |
AL=AL|AH|0o300; |
OP(); |
$JMP CreateConstants |
Mov_R2E: |
AL=OPDATA&7; //AL/AX/EAX ? |
$OR AL,AL |
$JNE N1 |
$CMP EA_M,6 //AR,[DW] POSSIBLE? |
$JNE N1 //NO, ONLY AR,[EA] |
$CMP ADDRFLAG,0 //32BIT-EA ? |
$JE N1 //NO, TRY ANOTHER... |
WRITERAND(); |
AL=0o240+WBIT; //INSTRUCTION FOUND. |
OP(); |
$JMP CreateConstants |
Mov_E2R: |
D1: |
AL=OPDATA[1]&7; //[DW],AR POSSIBLE? |
$OR AL,AL |
$JNE Y1 |
$CMP ADDRFLAG,0 //32BIT EA ? |
$JNE Y1 //YES, RAVE ON... |
$CMP EA_M,6 |
$JNE Y1 |
WRITERAND(); |
AL=0o242+WBIT; //INSTRUCTION FOUND. |
OP(); |
$JMP CreateConstants |
N1: |
DL=2; //SET D-BIT |
Y1: |
DL+=0o210; |
WRITERAND(); |
AL=DL; |
DL=0; |
AL+=WBIT; |
OP(); |
AL=EA_X<<3|EA_R<<3|EA_M; |
OP(); |
$JMP CreateConstants |
E1: |
preerror("ASM: Not same size\n"); |
return; |
//EA,CONSTANT ? |
Mov_E2C: |
OPCONSTSIZE[1]=OPERANDSIZE; |
$CMP AL,_D |
$JA E1 |
$JE X1 |
$CMP AL,_W |
$JNE X1 |
AL=0x66; |
OP(); |
X1: |
AL=0o306+WBIT; |
OP(); |
AL=EA_X<<6|EA_M; |
OP(); |
$JMP CreateConstants |
Mov_R2C: |
OPCONSTSIZE[1]=OPERANDSIZE; |
$CMP OPERANDSIZE,_B |
$JNE N2 |
AL=OPDATA&7|0o260; |
OP(); |
$JMP CreateConstants |
N2: |
$CMP OPERANDSIZE,_D //BYTE, WORD OR DWORD? |
$JA NEAR E1 // Not same size |
IF(OPERANDSIZE==_W){ |
AL=0x66; |
OP(); |
} |
AL=OPDATA&7|0o270; |
OP(); |
$JMP CreateConstants |
E21: |
preerror("ASM: Word required\n"); |
return; //SEGMENT REGISTER IS ALWAYS WORD. |
Mov_S: |
AL=0; |
$CMP CX,_SR*256+E // mov EA,segreg |
$JE O1 |
$CMP CX,_SR*256+R // mov segreg,reg |
$JE O2 |
$CMP CX,R*256+_SR // mov reg,segreg |
$JE O3 |
$CMP CX,E*256+_SR // mov segreg,EA |
$JNE NEAR N12 |
AL=2; //SET D-BIT |
O1: |
$CMP OPERANDSIZE,_W |
$JNE E21 |
AL+=0o214; |
OP(); |
AL=EA_X<<6|EA_S|EA_M; |
OP(); |
$JMP CreateConstants |
O2: |
$CMP OPERANDSIZE,_W |
$JNE E21 |
AL=0o214; |
OP(); |
AL=EA_S|0o300|EA_R; //CREATE XSM BYTE |
OP(); |
$STC |
$RET |
O3: |
$CMP OPERANDSIZE,_W |
$JNE NEAR E21 |
AL=0o216; |
OP(); |
AL=EA_S|0o300|EA_R; |
OP(); |
$STC |
$RET |
E31: |
preerror("ASM: CR1 only readable\n"); |
$RET |
E32: |
preerror("ASM: SysR must be dword\n"); |
$RET |
Mov_SYSR: |
N12: |
AH=0o40; |
$CMP CX,SYSR*256+R |
$JE O11 |
$CMP CX,R*256+SYSR |
$JNE N22 //ERROR: ILLEGAL OPERANDS |
AH=0o42; |
$CMP SYSRTYPE,_CR //CR1 REGISTER USED? |
$JNE O11 |
$CMP SYSRNUM,1 |
$JE E31 //YES, ONLY READ FROM IT. |
O11: |
AH+=SYSRCODE; |
$CMP OPERANDSIZE,_D //SYSTEM REGISTERS ARE ALWAYS DWORD. |
$JNE E32 |
AL=0o17; |
OP(); |
$CMP SYSRTYPE,_CR4 //EXCEPTION: CR4 |
$JE N22 |
AL=AH; |
OP(); |
AL=SYSRNUM<<3|0o300|EA_R; //CREATE 3NR OPCODE |
OP(); |
$STC |
$RET |
N22: |
$CMP CX,SYSR*256+R |
$JNE N32 |
AL=0x22; |
OP(); |
GOTO L11; |
N32: |
AL=0x20; |
OP(); |
L11: |
AL=0o340|EA_R; |
OP(); |
$STC |
$RET |
// ---- áâàãªæ¨ï á ®¤¨¬ ®¯¥à ¤®¬ |
ONEOP: |
EBX=CL<<2+#Jmp_Op1; |
$JMP NEAR DSDWORD[EBX] |
Op1ERR: |
preerror("ASM: only use system registers within MOV instruction\n"); |
$RET |
// RX |
L31: |
SCDEND(); |
Op1R: |
GETOL1(); //GET FIRST GENERATION INFO. |
$CMP AL,SOR //SINGLE OPERAND/REGISTER ? |
$JNE X23 |
$JMP CreateCode |
X23: |
$CMP AL,SOE //CONVERT REGISTER INTO EFFECTIVE ADDRESS? |
$JNE L31 |
C2: |
EA_X=3; |
AL=EA_R; |
EA_M=AL; |
$JMP CreateCode |
// EA |
L41: |
SCDEND(); |
Op1E: |
GETOL1(); |
$CMP AL,SOE //SINGLE OPERAND/EFFECTIVE ADDRESS ? |
$JNE X24; |
$JMP CreateCode |
X24: |
$CMP AL,SOM //SINGLE OPERAND/MEMORY POINTER ? |
$JNE L41 |
$CMP EA_X,0 |
$JNE L41 |
$CMP EA_M,6 //[WORD CONSTANT]? |
$JNE L41 |
C11: |
$JMP CreateCode |
// CO |
L51: |
SCDEND(); |
Op1C: |
GETOL1(); |
$OR AL,AL //JUMP INSTRUCTION? |
$JNE NEAR N13 |
// ¤¥áì ®¡à ¡®âª call&jmp |
ECX=OPCONST[0]-OptImageBase-OptBaseOfCode-outptr+output; // áç¥â ®â®á¨â¥«ì®£® ᬥ饨ï |
$LODSB // ®«ã稬 short ¨«¨ near |
$CMP AL,_JB // short? |
$JNE N14 |
ECX-=2; |
$CMP ECX,0xFFFFFF80 |
$JL L10 |
$CMP ECX,0x7F |
$JG L10 |
OPCONSTSIZE[0]=_B; |
H1: |
OPCONST[0]=ECX; |
$JMP CreateCode |
N14: |
EAX=0; |
$LODSB // ®¯à ¢ª à §¬¥à call ¨«¨ jmp |
ECX-=EAX; |
OPCONSTSIZE[0]=_D; |
GOTO H1; |
L10: |
$CMP ACTUALMNEMDESC,#T_JCXZ |
$JB L51 |
$CMP ACTUALMNEMDESC,#T_LOOP |
$JA NEAR L51 |
preerror("ASM: Jump range too long\n"); |
$RET |
N13: |
$CMP AL,SO3 //CONSTANT VALUE 3 ? |
$JNE N23 |
$CMP OPCONST[0],3 |
$JNE NEAR L51 |
OPCONSTFLAG[0]=0; //YES, AVOID CONSTANT GENERATION. |
$JMP CreateCode |
N23: |
$CMP AL,SOC //SINGLE OPERAND/CONSTANT? |
$JNE X25 |
OPCONSTSIZE[0]=OPERANDSIZE; |
$JMP CreateCode |
X25: |
$CMP AL,SOO_CC //SINGLE OPERAND/SIGNED BYTE ? |
$JNE NEAR L51 |
IF(OPPOST[0])$JMP L51 |
$CMP OPCONST[0],0x7F |
$JG NEAR L51 |
$CMP OPCONST[0],0xFFFFFF80 |
$JL NEAR L51 |
OPCONSTSIZE[0]=_B; |
$JMP CreateCode |
// SR |
L61: |
SCDEND(); |
Op1S: |
GETOL1(); |
$CMP AL,SOS //SINGLE OPERAND/SEGMENT REGISTER? |
$JNE L61 |
$JMP CreateCode |
// AF |
L71: |
SCDEND(); |
Op1AF: |
GETOL1(); |
$CMP AL,SOO_AF |
$JNE L71 |
$JMP CreateCode |
// ---- áâàãªæ¨ï á ¤¢ã¬ï ®¯¥à ¤ ¬¨ |
TWOOPS: |
EBX=CL<<2+#Jmp_Op2; |
$JMP NEAR DSDWORD[EBX] // ¥à¥å®¤ ¯® ⨯㠯¥à¢®£® ®¯¥à ¤ |
//Op2ERRC: |
// preerror("ASM: A constant can't be used as a destination\n"); |
// return; |
Op2ERRS: |
preerror("ASM: segment register can only be used within a MOV or PUSH\n"); |
return; |
Op2ERRSYS: |
preerror("ASM: only use system registers within MOV instruction\n"); |
return; |
Op2ERRAF: |
preerror("Absolute FAR addresses can only be used for jumps\n"); |
return; |
// ¥à¢ë© ®¯¥à ¤ ¢ 2-®¯¥à ¤®© ¨áâàãªæ¨¨ - ॣ¨áâà |
Op2R: |
EBX=0; |
BL=CH; |
EBX=EBX<<2+#Jmp_Op2R; |
$JMP NEAR DSDWORD[EBX] // ¥à¥å®¤ ¯® ⨯㠢â®à®£® ®¯¥à ¤ |
// ¥à¢ë© ®¯¥à ¤ ¢ 2-®¯¥à ¤®© ¨áâàãªæ¨¨ - EA |
Op2E: |
EBX=0; |
BL=CH; |
EBX=EBX<<2+#Jmp_Op2E; |
$JMP NEAR DSDWORD[EBX] // ¥à¥å®¤ ¯® ⨯㠢â®à®£® ®¯¥à ¤ |
// mnem EA,RX |
L81: |
SCDEND(); |
OpE2R: |
GETOL2(); // ¡à ¡®âª § ¯¨á¨ ¨§ è ¡«® |
$CMP AL,DER //EA & R + D-BIT ? |
$JE C21 |
X26: |
$CMP AL,ERO //'ERO' ORDER ? |
$JE C21 |
$CMP AL,EAO //EA, ? |
$JNE L81 // ¯à®¯ã᪠§ ¯¨á¨ ¢ è ¡«®¥ |
$CMP OPDATA[1],rCL //CL REGISTER USED?? |
$JNE L81 // ¯à®¯ã᪠§ ¯¨á¨ ¢ è ¡«®¥ |
$CMP DSBYTE[ESI+1],rCL //CL IN GENERATION INFO? |
$JNE L81 // ¯à®¯ã᪠§ ¯¨á¨ ¢ è ¡«®¥ |
// CMP OPERANDSIZE,_B //YES, CHECK SIZE. |
// JNE L81 // ¯à®¯ã᪠§ ¯¨á¨ ¢ è ¡«®¥ |
ESI++; |
ESI++; |
C21: |
$JMP CreateCode |
L91: |
SCDEND(); |
OpR2E: |
GETOL2(); |
$CMP AL,DER //DER ? |
$JNE N43 |
DBIT=1; //(DIRECTION BIT) |
$JMP CreateCode |
N43: |
$CMP AL,REO //REO ? |
$JNE L91; |
$JMP CreateCode |
//RX,RX ? |
W2: |
ESI++; |
GOTO W1; |
LA1: |
SCDEND(); |
OpR2R: |
$CMP DSBYTE[ESI],_B+OL2+EAO // ¡ ©â+2®¯+EAold? |
$JE W2 //EAO FOUND, R+R COMBINATION NOT PERMITTED. |
GETOL2(); // ¡à ¡®âª § ¯¨á¨ è ¡«® |
$CMP AL,DER // EA,reg ¨«¨ reg,EA á D/W-¡¨â®¬? |
$JNE N53 |
LB2: |
AL=OPDATA[0]; // ८¡à §ã¥¬ ॣ¨áâà ¢ EA |
CREATE_EA(); |
AL=OPDATA[1]; // â®à®© ®¯¥à ¤ |
CREATE_R(); |
$JMP CreateCode |
N53: |
$CMP AL,ERO |
$JE LB2 |
$CMP AL,REO |
$JNE N63 |
AL=OPDATA[1]; //RX,EP |
CREATE_EA(); |
AL=OPDATA[0]; |
CREATE_R(); |
$JMP CreateCode |
N63: |
$CMP AL,EAO |
$JNE LA1 // ¯à®¯ã᪠§ ¯¨á¨ ¢ è ¡«®¥ |
W1: |
ECX=2; //COMPARE 2 OPERANDS. |
opDescInd=0; |
LX2: |
$LODSB // ¯®«¥ ¨§ § ¯¨á¨ è ¡«® |
$CMP AL,255 //1ST OPERAND OK. |
$JE L022 |
$CMP AL,AR //AL/AX/EAX? |
$JE OL2X_AR |
$CMP AL,rDX //DX? |
$JE OL2X_DX |
$CMP AL,rCL |
$JE OL2X_CL |
GOTO LA1; // ¯à®¯ã᪠§ ¯¨á¨ ¢ è ¡«®¥ |
OL2X_AR: |
EBX=opDescInd; |
AH=OPDATA[EBX]&7; // ¯¥à ¤ ¨§ ¬¥¬®¨ª¨ |
$JNZ NEAR LA1 // ¯à®¯ã᪠§ ¯¨á¨ ¢ è ¡«®¥ |
L022: |
opDescInd++; |
$LOOP LX2 |
GOTO L23; |
OL2X_DX: |
EBX=opDescInd; |
$CMP OPDATA[EBX],0o12 |
$JNE NEAR LA1 // ¯à®¯ã᪠§ ¯¨á¨ ¢ è ¡«®¥ |
opDescInd++; |
$LOOP LX2 |
GOTO L23; |
OL2X_CL: |
EBX=opDescInd; |
$CMP OPDATA[EBX],rCL //CL |
$JNE NEAR LC1 |
opDescInd++; |
$LOOP LX2 |
$TEST OPDATA[0],8+16 //1ST REGISTER WORD/DWORD? |
$JZ L23 |
WBIT=1; //YES, SET W-BIT. |
L23: |
AL=OPDATA[0]; |
CREATE_EA(); |
$JMP CreateCode |
//EA,CONSTANT ? //EA,CONST? |
LB1: |
SCDEND(); |
OpE2C: |
GETOL2(); |
opDescInd=1; |
$CMP AL,ECO |
$JNE N73 |
OPCONSTSIZE[1]=OPERANDSIZE; |
$JMP CreateCode |
N73: |
$CMP AL,EAO |
$JNE N83 |
$CMP OPERANDSIZE,_B |
$JNE N83 |
$CMP DSBYTE[ESI],_1 |
$JNE N83 |
$CMP OPCONST[4],1 |
$JNE N83 |
OPCONSTFLAG[1]=0; |
ESI++; |
$JMP CreateCode |
N83: |
$CMP AL,ECCO //EA/SIGNED BYTE ? |
$JNE LB1 |
$CMP OPCONST[4],0xFFFFFF80 |
$JL LB1 |
$CMP OPCONST[4],0x7F |
$JG NEAR LB1 |
OPERANDSIZE=_B; //OMIT A SINGLE BYTE ON GENERATION. |
$JMP CreateCode |
// mnem reg,const |
LC1: |
SCDEND(); |
OpR2C: |
GETOL2(); |
opDescInd=1; |
$CMP AL,RCO; |
$JNE Q1 |
A0: |
OPCONSTSIZE[1]=OPERANDSIZE; |
$JMP CreateCode // reg,const |
Q1: |
$CMP AL,ECO; |
$JNE L110 |
A1: |
AL=EA_R; |
CREATE_EA(); |
GOTO A0; |
L110: |
$CMP AL,EAO; |
$JE N93 |
$CMP AL,ECCO; |
$JNE LC1 //SIGNED BYTE CONST ? |
$CMP OPCONST[4],0xFFFFFF80; |
$JL LC1 |
$CMP OPCONST[4],0x7F; |
$JG LC1 |
OPERANDSIZE=_B; |
OPCONSTSIZE[1]=_B; |
GOTO A1; //CONVERT REGISTER TO EFFECTIVE ADDRESS AND GENERATE OPCODE. |
N93: |
ECX=2; //COMPARE 2 OPERAND. |
B2: |
$LODSB; |
$CMP AL,255; |
$JE L122 |
$CMP AL,AR; |
$JE OL2_AR //AL/AX/EAX? |
$CMP AL,CO; |
$JE OL2_CO //CONSTANT? |
$CMP AL,rDX; |
$JE OL2_DX //DX? |
$CMP AL,_1; |
$JE OL2_1 //CONSTANT VALUE 1? |
$JMP LC1 |
OL2_AR: |
AH=OPDATA[0]&7; |
$JNZ NEAR LC1 |
L122: |
$LOOP B2; |
$JMP CreateCode |
OL2_CO: |
$CMP OPDESC[1],CO; |
$JNE NEAR LC1 |
OPCONSTSIZE[1]=OPERANDSIZE; |
GOTO L122; |
OL2_DX: |
$CMP OPDATA[0],0o12; |
$JE L122; |
$JMP LC1 |
OL2_1: |
$CMP OPCONSTSIZE[1],_B; |
$JNE NEAR LC1 |
$CMP OPCONST[4],1; |
$JNE NEAR LC1 |
OPCONSTFLAG[1]=0; |
$JMP A1 |
LD1: |
SCDEND(); |
// ¥à¢ë© ®¯¥à ¤ ¢ 2-®¯¥à ¤®© ¨áâàãªæ¨¨ - ª®áâ â |
Op2C: |
GETOL2(); |
$CMP AL,EAO |
$JNE LD1 |
ECX=2; //COMPARE 2 OPERANDS. |
opDescInd=0; |
B12: |
$LODSB |
$CMP AL,255 |
$JE L222 |
$CMP AL,AR //AL/AX/EAX |
$JE XOL2_AR |
$CMP AL,CO |
$JE XOL2_CO |
$CMP AL,rDX //DX |
$JE XOL2_DX |
$CMP AL,_1 |
$JE XOL2_1 |
GOTO LD1; |
XOL2_AR: |
EBX=opDescInd; |
AH=OPDATA[EBX]&7; |
$JNZ N21 |
L222: |
opDescInd++; |
$LOOP B12 |
$JMP CreateCode |
N21: |
GOTO LD1; |
XOL2_CO: |
EBX=opDescInd; |
$CMP OPDESC[EBX],CO |
$JNE LD1 |
opDescInd++; |
$LOOP B12 |
$JMP CreateCode |
XOL2_DX: |
EBX=opDescInd; |
$CMP OPDATA[EBX],0o12 |
$JNE NEAR LD1 |
opDescInd++; |
$LOOP B12 |
$JMP CreateCode |
XOL2_1: |
EDX=opDescInd; |
$CMP OPCONSTSIZE[EDX],_B |
$JNE NEAR LD1 |
EDX<<=2; |
$CMP OPCONST[EDX],1 |
$JNE NEAR LD1 |
EDX=opDescInd; |
OPCONSTFLAG[EDX]=0; |
AL=EA_R; |
CREATE_EA(); |
$JMP CreateCode |
// à¥å®¯¥à ¤ ï ¨áâàãªæ¨ï |
LE1: |
SCDEND(); |
THREEOPS: |
D11: |
GETOL3(); |
$CMP AL,ERO |
$JNE N42 |
$CMP CX,R*256+E |
$JE O21 |
$CMP CX,R*256+R |
$JNE LE1 |
AL=OPDATA[0]; |
CREATE_EA(); |
AL=OPDATA[1]; |
CREATE_R(); |
GOTO O21; |
N42: |
$CMP AL,REO |
$JNE N52 //ERROR: INVALID OPERANDS. |
$CMP CX,E*256+R |
$JE O21 |
$CMP CX,R*256+R |
$JNE LE1 |
AL=OPDATA[1]; |
CREATE_EA(); |
AL=OPDATA[0]; |
CREATE_R(); |
O21: |
BL=AH&TRANSBITS; |
$CMP OPCONSTFLAG[2],1 |
$JNE NEAR NA3 |
$CMP BL,CC3 |
$JNE N52 |
$CMP OPCONST[8],0xFFFFFF80 |
$JL NEAR LE1 |
$CMP OPCONST[8],0x7F |
$JG NEAR LE1 |
OPCONSTSIZE[2]=_B; |
$JMP CreateCode |
N52: |
$CMP BL,CB3 |
$JNE N62 |
$CMP OPCONST[8],0xFF |
$JA NEAR LE1 |
OPCONSTSIZE[2]=_B; |
$JMP CreateCode |
N62: |
$CMP BL,CW3 |
$JNE NA3 |
$CMP OPCONST[8],0xFFFFFFFF |
$JA NEAR LE1 |
$CMP RANDFLAG,1 |
$JNE NA2 |
OPCONSTSIZE[2]=_W; |
$JMP CreateCode |
NA2: |
OPCONSTSIZE[2]=_D; |
NA_2: |
$JMP CreateCode |
NA3: |
$CMP BL,CL3 |
$JNE NEAR LE1 |
$CMP OPDESC[2],R |
$JNE NEAR LE1 |
$CMP OPDATA[2],rCL |
$JE NA_2 |
illegaloperand(); |
} |
CreateConstants() |
{ |
$CMP EA_SIBFLAG,1 // « £ «¨ç¨ï Sib ¢ 32-¡¨â®¬ EA |
$JNE L3 // Sib ®âáãâáâ¢ã¥â |
$CMP ADDRFLAG,1 |
$JE L3 //NO, NORMAL XRM |
// ¯¨áì SIB - ¡ ©â |
AL=EA_I<<3|EA_R2|EA_SCALING; |
OP(); |
L3: |
$CMP OPCONSTFLAG[0],1 |
$JNE NEAR N1 |
IF(OPPOST[0])SetPost(OPPOSTREF[0],OPPOST[0]); |
ECX=OPCONSTSIZE[0]; |
EDI=#OPCONST; // 票¥ disp ¢ EA |
WRITECONST(); |
N1: |
$CMP OPCONSTFLAG[1],1 |
$JNE NEAR N41 |
ECX=OPCONSTSIZE[1]; |
$CMP CL,AF //ABSOLUTE FAR ? |
$JNE D21 |
EDI=#OPCONST+4; //YES, CREATE ADDRESS. |
CL=_W; //(32 BIT) |
$CMP ADDRFLAG,1 |
$JNE D2 |
ECX=_D; //(48 BIT) |
D2: |
WRITECONST(); |
EDX+=output; |
EBX=EDX>>4; |
$AND EDX,15 |
$PUSH EBX,EDX |
$POP EDX //??? |
EAX=opDescInd; |
DSDWORD[EAX]=EDX; |
ECX=_W; |
/* AFSEG ¨£¤¥ ¥ ®¯à¥¤¥«¥, ¤® ¡ã¤¥â à §¡¨à âìáï |
EDI=#AFSEG; //(SEGMENT/SELECTOR) */ |
WRITECONST(); |
$STC |
$RET |
D21: |
IF(OPPOST[1])SetPost(OPPOSTREF[4],OPPOST[1]); |
EDI=#OPCONST+4; |
WRITECONST(); |
N41: |
IF(OPCONSTFLAG[2]==1){ |
ECX=OPCONSTSIZE[2]; |
EDI=#OPCONST+8; |
WRITECONST(); |
} |
} |
// ---- |
illegaloperand() |
{ |
preerror("ASM: Illegal operand\n"); |
} |
// ---- |
toomuchoperands() |
{ |
preerror("ASM: Illegal number of operands\n"); |
} |
// JUMP TABLES |
dword Jmp_Mov={#Mov_R,#Mov_E,#Mov_ERR,#Mov_S, |
#Mov_SYSR,#Mov_SYSR,#Mov_SYSR,#Mov_SYSR,#Mov_SYSR,#Mov_SYSR}; |
dword Jmp_Mov_R={#Mov_R2R,#Mov_R2E,#Mov_R2C,#Mov_S, |
#Mov_SYSR,#Mov_SYSR,#Mov_SYSR,#Mov_SYSR,#Mov_SYSR,#Mov_SYSR}; |
dword Jmp_Mov_E={#Mov_E2R,#Mov_ERR,#Mov_E2C,#Mov_S, |
#Mov_ERR,#Mov_ERR,#Mov_ERR,#Mov_ERR,#Mov_ERR,#Mov_ERR}; |
dword Jmp_Op1={#Op1R,#Op1E,#Op1C,#Op1S, |
#Op1ERR,#Op1ERR,#Op1ERR,#Op1ERR,#Op1ERR,#Op1AF}; |
dword Jmp_Op2={#Op2R,#Op2E,#Op2C,#Op2ERRS, |
#Op2ERRSYS,#Op2ERRSYS,#Op2ERRSYS,#Op2ERRSYS,#Op2ERRSYS,#Op2ERRAF}; |
dword Jmp_Op2R={#OpR2R,#OpR2E,#OpR2C,#Op2ERRS, |
#Op2ERRSYS,#Op2ERRSYS,#Op2ERRSYS,#Op2ERRSYS,#Op2ERRSYS,#Op2ERRAF}; |
dword Jmp_Op2E={#OpE2R,0,#OpE2C,#Op2ERRS, |
#Op2ERRSYS,#Op2ERRSYS,#Op2ERRSYS,#Op2ERRSYS,#Op2ERRSYS,#Op2ERRAF}; |
//dword TC_JMP={#T_JMPSHORT,#T_JMPNEAR,#T_JMPFAR}; |
//dword TC_CALL={0,#T_CALL,#T_CALLFAR}; |
//dword TC_J={#T_J,#T_JN,1}; |
dword Dsc_Jump={#CreateConstants,#Dsc_O,#Dsc_OW,#Dsc_OS,#Dsc_S,#Dsc_XRM,#Dsc_XPM,#Dsc_XSM}; |
/programs/develop/c--/trunk/opcodesc.h-- |
---|
0,0 → 1,591 |
//CODE GENERATION DESCRIPTORS |
// ========================= |
// >>> DESCRIPTION CODES <<< |
// ========================= |
//T_<MNEMONIC>: |
// DB <TRANSFER SIZE|# OF OPERANDS|ALLOWED OPERANDS> |
// [DB <OPERAND CODES>] |
// [DB <PROCESSOR VERSION>] |
// DB <TYPE OF OPCODE DESCRIPTION> |
// DB <OPCODE DESCRIPTOR> |
// DB 0 |
//OR DB _END //IF THERE'RE NO MORE INFO ABOUT THIS MNEMONIC |
// OPERATION SIZE CODES |
enum { _B, //OPERATION MAY BE OF SIZE BYTE,WORD OR DWORD SEIN. THE OPCODE'S |
// W BIT INDICATES IF IT'S A BYTE OR WORD OPERATION. |
// FOR DWORD OPERATIONS, THE W BIT MUST BE TRUE (WORD OPERATION) |
// AND THE RAND:PREFIX MUST BE GENERATED. |
_W, //OPERATION SIZE MAY BE WORD OR DWORD. |
_D, //OPERATION MAY ONLY BE DWORD. |
WB, //1. OPERAND WORD, 2. OPERAND BYTE |
_DW, //1. OPERAND DWORD, 2. OPERAND WORD |
BW, //1. OPERAND BYTE, 2. OPERAND WORD |
NB, //ONLY BYTE SIZE. |
_OW, //ONLY WORD SIZE. |
_OD, // Only DWORD size |
AF}; //ONLY ABSOLUTE FAR 32/48 BIT ADDRESS |
#define _JB 1 //OPERAND IS A JUMP - DESTINATION +/-128 |
#define _JW 2 //OPERAND IS A JUMP - DESTINATION +/-32678 |
// 0-2 = OPERATION SIZE CODE |
// 3-4 = # OF OPERANDS NEEDED. |
// # OF OPERANDS |
#define OL0 0 |
#define OL1 0o10 |
#define OL2 0o20 |
#define OL3 0o30 |
#define OLBITS 0o30 //MASKS FOR # OF OPERANDS. |
#define NOLBITS 0o347 |
#define TRANSBITS 0o7 //MASKS FOR OPERATION SIZE CODES. |
#define NTRANSBITS 0o370 |
// IF OL1, USE THIS OPERAND TYPES: |
#define SOJ 0b00000000 //JUMP |
#define SOE 0b00100000 //EA |
#define SOR 0b01000000 //REG |
#define SOC 0b01100000 //CONST |
#define SO3 0b10000000 //_3 |
#define SOS 0b10100000 //SREG |
#define SOM 0b11000000 //EA-MEMORY-POINTER |
#define SOO 0b11100000 //THERE IS INFORMATION USING THE OPERAND SIZE CODE BITS. |
#define SOO_FS 0o340 //FS-REGISTER |
#define SOO_GS 0o341 //GS-REGISTER |
#define SOO_AF 0o342 //ABSOLUTE ADRESS |
#define SOO_CC 0o343 //SIGNED BYTE |
#define OPBITS 0b11100000 |
// IF OL2, USE THOSE INSTEAD: |
// 00000000B //DIRECT DESCRIPTOR |
//AR,CO |
#define ERO 0b00100000 //FIXED EA,REG ORDER |
#define REO 0b01000000 //FIXED REG,EA ORDER |
#define DER 0b01100000 //EA,REG OR REG,EA DEFINED BY A D-BIT |
#define ECO 0b10000000 //EA,CONSTANT// SIZE DEFINED BY W-BIT |
#define ECCO 0b10100000 //EA,CC |
#define RCO 0b11000000 //REG,CONSTANT// SIZE DEFINED BY W-BIT |
#define EAO 0b11100000 //EA,? // SECOND OPERAND DESCRIBED BY OLD DESCIPTORS |
//?=_1,rCL,CO |
// OPERAND TYPE CODES |
enum { R, //GENERAL REGISTER |
E, //EFFEKTIVE ADRESS |
CO, //CONSTANT |
_SR, //SEGMENT REGISTER |
SYSR, //SYSTEM REGISTER |
_DR, //DEBUG REGISTER |
_TR, //TASK REGISTER |
_CR, //CONTROL REGISTER |
_CR4, // |
_AF, //ABSOLUTE 32/48 BIT FAR ADDRESS |
AR=11, //AX/AL REGISTER, INDICATED BY OPERATION SIZE |
_1}; //CONSTANT VALUE 1 |
// IF OL3, USE THIS: |
// INSTRUCTION WITH THREE OPERANDS ARE ALWAYS OF SIZE WORD. |
// THE FOLLOWING CODES DESCRIBE THE 3RD OPERAND. |
enum { CB3, //BYTE CONSTANT |
CW3, //WORD CONSTANT |
CC3, //SBYTE CONSTANT |
CL3}; //CL REGISTER |
// OPCODE DESCRIPTORS |
enum{ O=1, //OPCODE IS A BYTE |
OW, //OPCODE IS A WORD |
OS, //OPCODE IS A BYTE PLUS A SECOND BYTE THAT IS DESCRIBED BY AN |
//OCTAL STRING. |
S, //OCTAL STRING FOLLOWS FOR OPCODE |
XRM, //MODRM BYTE |
XPM, //MODRM MIT P-FLAG (GRUPPE VON ARITHMETIC INSTRUCTIONS) |
XSM, //MODRM MIT SEGMENTREGISTER |
X0M,X1M,X2M,X3M,X4M,X5M,X6M,X7M //MODRM WITH CONSTANT R DIGIT |
}; |
byte OVERRIDETAB={0o46,0o56,0o66,0o76,0o144,0o145}; |
// ---- ®¤¨à®¢ª ॣ¨áâ஢ |
enum{ rAL ,rCL ,rDL ,rBL ,rAH ,rCH ,rDH ,rBH, // 0-7 byte regs |
rAX ,rCX ,rDX ,rBX ,rSP ,rBP ,rSI ,rDI, // 8-15 16-bit word regs |
rEAX,rECX,rEDX,rEBX,rESP,rEBP,rESI,rEDI,// 16-23 32-bit regs |
rCR0,rCR1,rCR2,rCR3,rCR4,rCR5,rCR6,rCR7,// 24-31 control regs |
rDR0,rDR1,rDR2,rDR3,rDR4,rDR5,rDR6,rDR7,// 32-39 debug regs |
rTR0,rTR1,rTR2,rTR3,rTR4,rTR5,rTR6,rTR7,// 40-47 test regs |
rES,rCS,rSS,rDS, rFS,rGS}; // 48-53 seg regs |
byte Registers={ |
"AL","CL","DL","BL","AH","CH","DH","BH", |
"AX","CX","DX","BX","SP","BP","SI","DI", |
"EAX","ECX","EDX","EBX","ESP","EBP","ESI","EDI", |
"CR0","CR1","CR2","CR3","CR4","CR5","CR6","CR7", |
"DR0","DR1","DR2","DR3","DR4","DR5","DR6","DR7", |
"TR0","TR1","TR2","TR3","TR4","TR5","TR6","TR7", |
"ES","CS","SS","DS","FS","GS",_END}; |
byte Sizes={"BYTE","WORD","DWORD",_END}; |
// ---- ¯¨á ¨ï ¬¥¬®¨ª |
byte PCOMMANDS1={ |
0, //P FLAG STARTS AT 0 |
_B+OL2+EAO,AR,CO,S,"0P4", |
_B+OL2+DER,S,'0','P','0',XRM,0, |
_W+OL2+ECCO,O,0o203,XPM,0, |
_B+OL2+ECO,O,0o200,XPM,_END}; |
byte PCOMMANDS2={ |
4, //P FLAG STARTS AT 4 |
_B+OL1+SOE,O,0xF6,XPM,_END}; |
byte PCOMMANDS3= 0; //P FLAG STARTS AT 0 |
byte PCOMMANDS3_={ |
_B+OL2+EAO,-1,_1,O,0xD0,XPM,0, |
_B+OL2+EAO,-1,rCL,O,0xD2,XPM,0, |
_B+OL2+ECCO,O,0xC0,XPM,_END}; |
byte PCOMMANDS4={ |
4, //P FLAG STARTS AT 4 |
_W+OL2+ERO,OS,0xF,'2','P','3',XRM,0, |
WB+OL2+ECO,OW,0xF,0o272,XPM,_END}; |
// ¤®¡ ©â®¢ë¥ ¨áâàãªæ¨¨ |
byte T_DAA={ O,0o47,_END}; |
byte T_DAS={ O,0o57,_END}; |
byte T_AAA={ O,0o67,_END}; |
byte T_AAD={ OW,0o325,0o12,_END}; |
byte T_AAM={ OW,0o324,0o12,_END}; |
byte T_AAS={ O,0o77,_END}; |
byte T_CWDE={ O,0o230,_END}; |
byte T_CBW={ OW,0x66,0o230,_END}; |
byte T_CDQ={ O,0o231,_END}; |
byte T_CWD={ OW,0x66,0o231,_END}; |
byte T_XLATB={ O,0o327,_END}; |
byte T_NOP={ O,0o220,_END}; |
byte T_WAIT={ O,0o233,_END}; |
byte T_LOCK={ O,0o360,_END}; |
byte T_HLT={ O,0o364,_END}; |
byte T_INTO={ O,0o316,_END}; |
byte T_IRET={ O,0o317,_END}; |
byte T_POPFD={ O,0o235,_END}; |
byte T_POPF={ OW,0x66,0o235,_END}; |
byte T_PUSHFD={ O,0o234,_END}; |
byte T_PUSHF={ OW,0x66,0o234,_END}; //PUSHF / (#) PUSHFD |
byte T_SAHF={ O,0o236,_END}; |
byte T_LAHF={ O,0o237,_END}; |
byte T_CMC={ O,0o365,_END}; |
byte T_CLC={ O,0o370,_END}; |
byte T_STC={ O,0o371,_END}; |
byte T_CLI={ O,0o372,_END}; |
byte T_STI={ O,0o373,_END}; |
byte T_CLD={ O,0o374,_END}; |
byte T_STD={ O,0o375,_END}; |
byte T_PUSHAD={ O,0o140,_END}; |
byte T_PUSHA={ OW,0x66,0o140,_END}; |
byte T_POPAD={ O,0o141,_END}; |
byte T_POPA={ OW,0x66,0o141,_END}; |
byte T_INSB={ O,0o154,_END}; |
byte T_INSW={ OW,0x66,0o155,_END}; |
byte T_INSD={ O,0o155,_END}; |
byte T_OUTSB={ O,0o156,_END}; |
byte T_OUTSW={ OW,0x66,0o157,_END}; |
byte T_OUTSD={ O,0o157,_END}; |
byte T_MOVSB={ O,0o244,_END}; |
byte T_MOVSW={ OW,0x66,0o245,_END}; |
byte T_MOVSD={ O,0o245,_END}; |
byte T_CMPSB={ O,0o246,_END}; |
byte T_CMPSW={ OW,0x66,0o247,_END}; |
byte T_CMPSD={ O,0o247,_END}; |
byte T_STOSB={ O,0o252,_END}; |
byte T_STOSW={ OW,0x66,0o253,_END}; |
byte T_STOSD={ O,0o253,_END}; |
byte T_LODSB={ O,0o254,_END}; |
byte T_LODSW={ OW,0x66,0o255,_END}; |
byte T_LODSD={ O,0o255,_END}; |
byte T_SCASB={ O,0o256,_END}; |
byte T_SCASW={ OW,0x66,0o257,_END}; |
byte T_SCASD={ O,0o257,_END}; |
byte T_REP={ O,0o362,_END}; |
byte T_REPE={ O,0o363,_END}; |
byte T_RAND={ O,0o146,_END}; //RAND: |
byte T_ADDR={ O,0o147,_END}; //ADDR: |
byte T_LEAVE={ O,0o311,_END}; |
byte T_CLTS={ OW,0xF,6,_END}; |
byte T_INVD={ OW,0xF,0o10,_END}; |
byte T_WBINVD={ OW,0xF,0o11,_END}; |
byte T_WRMSR={ OW,0xF,0x30,_END}; //WRMSR WRITE EDXEAX TO MODEL SPECIFIC REG #ECX |
byte T_CPUID={ OW,0xF,0xA2,_END}; //CPUID IF EAX=1 SET EDXEAX TO CPU IDENTIFICATION VALUES |
byte T_RDMSR={ OW,0xF,0x32,_END}; //RDMSR READ MODEL SPECIFIC REG #ECX TO EDXEAX |
byte T_RDTSC={ OW,0xF,0x31,_END}; //RDTSC READ TIME STAMP COUNTER TO EDXEAX |
byte T_RSM={ OW,0xF,0xAA,_END}; //RSM RESUME FROM SYSTEM MANAGEMENT MODE |
//===== INTEL PENTIUM PRO INSTRUCTIONS |
byte T_RDPMC={ OW,0xF,0x33,_END}; //READ PERFORMANCE MONITORING COUNTERS |
byte T_UD2={ OW,0xF,0xB,_END}; //UNDEFINED INSTRUCTION EXCEPTION |
byte T_EMMX={ OW,0xF,0x77,_END}; //EMPTY MMX STATE |
byte T_SALC={ O,0xD6,_END}; |
byte T_ICEBP={ O,0xF1,_END}; |
byte T_PSHIMW={ OW,0xF,0x71,_END}; |
byte T_PSHIMD={ OW,0xF,0x72,_END}; |
byte T_PSHIMQ={ OW,0xF,0x73,_END}; |
byte T_NOT={ _B+OL1+SOE,O,0xF6,X2M,_END}; |
byte T_NEG={ _B+OL1+SOE,O,0xF6,X3M,_END}; |
byte T_INC={ _W+OL1+SOR,S,"10R", |
_B+OL1+SOE,O,0xFE,X0M,_END}; |
byte T_DEC={ _W+OL1+SOR,S,"11R", |
_B+OL1+SOE,O,0xFE,X1M,_END}; |
byte T_TEST={ _B+OL2+ERO,O,0o204,XRM,0, //ALPHA:WAS 204O |
_B+OL2+REO,O,0o204,XRM,0, //" |
_B+OL2+EAO,AR,CO,O,0o250,0, |
_B+OL2+ECO,O,0xF6,X0M,_END}; |
// EXTENDED 386 INTEGER MULTIPLICATION |
byte T_IMUL={ _B+OL1+SOE,O,0xF6,X5M,0, //IMUL EB |
_B+OL2+ECO,O,0xC0,X1M,0, |
_B+OL2+EAO,-1,_1,O,0xD0,X1M,0, |
_B+OL2+EAO,-1,rCL,O,0xD2,X1M,0, |
_W+OL1+REO,OW,0xF,0o257,XRM,0, //IMUL RW, EW |
OL3+REO+CC3,O,0o153,XRM,0, //IMUL RW, EW, DC |
OL3+REO+CW3,O,0o151,XRM,_END}; //IMUL RW, EW, DW |
byte T_SHLD={ OL3+ERO+CB3,OW,0xF,0o244,XRM,0, |
OL3+ERO+CL3,OW,0xF,0o245,XRM,_END}; |
byte T_SHRD={ OL3+ERO+CB3,OW,0xF,0o254,XRM,0, |
OL3+ERO+CL3,OW,0xF,0o255,XRM,_END}; |
byte T_MOVSX={ WB+OL2+REO,OW,0xF,0o276,XRM,0, |
_DW+OL2+REO,OW,0xF,0o277,XRM,_END}; |
byte T_MOVZX={ WB+OL2+REO,OW,0xF,0o266,XRM,0, |
_DW+OL2+REO,OW,0xF,0o267,XRM,_END}; |
byte T_BSWAP={ _D+OL1+SOR,OS,0xF,"31R",_END}; |
byte T_BSF={ _W+OL2+REO,OW,0xF,0o274,XRM,_END}; |
byte T_BSR={ _W+OL2+REO,OW,0xF,0o275,XRM,_END}; |
byte T_CMPXCHG={_B+OL2+ERO,OW,0xF,0xB0,XRM,_END}; |
byte T_CMPXCHG486={_B+OL2+ERO,OW,0xF,0xA7,XRM,_END}; |
byte T_CMPXCHG8B={_B+OL2+ERO,OW,0xF,0xC7,XRM,_END}; |
byte T_XADD={ _B+OL2+ERO,OW,0xF,0xC0,XRM,_END}; |
byte T_XCHG={ _W+OL2+EAO,-1,AR,S,"22M", //ALPHA:WAS "22R" BUT GENERATED NOP |
_W+OL2+EAO,AR,-1,S,"22R", |
_B+OL2+REO,O,0o206,XRM,0, |
_B+OL2+ERO,O,0o206,XRM,_END}; |
byte T_MOV=0; //DUMMY BYTE |
byte T_LEA={ _D+OL2+REO,O,0o215,XRM,_END}; //LEA RW, EN (X != 3) |
byte T_LSS={ _D+OL2+REO,OW,0xF,0o262,XRM,_END};//LSS RW, EF (X != 3) |
byte T_LFS={ _D+OL2+REO,OW,0xF,0o264,XRM,_END};//LFS RW, EF (X != 3) |
byte T_LGS={ _D+OL2+REO,OW,0xF,0o265,XRM,_END};//LGS RW, EF (X != 3) |
byte T_LES={ _D+OL2+REO,O,0o304,XRM,_END}; //LES RW, EF (X != 3) |
byte T_LDS={ _D+OL2+REO,O,0o305,XRM,_END}; //LDS RW, EF (X != 3) |
byte T_SET0={ NB+OL1+SOE,OW,0xF,0o220,X0M,_END}; |
byte T_SET1={ NB+OL1+SOE,OW,0xF,0o221,X0M,_END}; |
byte T_SET2={ NB+OL1+SOE,OW,0xF,0o222,X0M,_END}; |
byte T_SET3={ NB+OL1+SOE,OW,0xF,0o223,X0M,_END}; |
byte T_SET4={ NB+OL1+SOE,OW,0xF,0o224,X0M,_END}; |
byte T_SET5={ NB+OL1+SOE,OW,0xF,0o225,X0M,_END}; |
byte T_SET6={ NB+OL1+SOE,OW,0xF,0o226,X0M,_END}; |
byte T_SET7={ NB+OL1+SOE,OW,0xF,0o227,X0M,_END}; |
byte T_SET8={ NB+OL1+SOE,OW,0xF,0o230,X0M,_END}; |
byte T_SET9={ NB+OL1+SOE,OW,0xF,0o231,X0M,_END}; |
byte T_SETA={ NB+OL1+SOE,OW,0xF,0o232,X0M,_END}; |
byte T_SETB={ NB+OL1+SOE,OW,0xF,0o233,X0M,_END}; |
byte T_SETC={ NB+OL1+SOE,OW,0xF,0o234,X0M,_END}; |
byte T_SETD={ NB+OL1+SOE,OW,0xF,0o235,X0M,_END}; |
byte T_SETE={ NB+OL1+SOE,OW,0xF,0o236,X0M,_END}; |
byte T_SETF={ NB+OL1+SOE,OW,0xF,0o237,X0M,_END}; |
// |
byte T_JCXZ={ OL1,_JB,O,0o343,_END}; |
byte T_LOOPNZ={ OL1,_JB,O,0o340,_END}; |
byte T_LOOPZ={ OL1,_JB,O,0o341,_END}; |
byte T_LOOP={ OL1,_JB,O,0o342,_END}; |
byte T_J0={ OL1,_JB,O,0o160,0, |
OL1,_JW,6,OW,0o17,0o200,_END}; |
byte T_J1={ OL1,_JB,O,0o161,0, |
OL1,_JW,6,OW,0o17,0o201,_END}; |
byte T_J2={ OL1,_JB,O,0o162,0, |
OL1,_JW,6,OW,0o17,0o202,_END}; |
byte T_J3={ OL1,_JB,O,0o163,0, |
OL1,_JW,6,OW,0o17,0o203,_END}; |
byte T_J4={ OL1,_JB,O,0o164,0, |
OL1,_JW,6,OW,0o17,0o204,_END}; |
byte T_J5={ OL1,_JB,O,0o165,0, |
OL1,_JW,6,OW,0o17,0o205,_END}; |
byte T_J6={ OL1,_JB,O,0o166,0, |
OL1,_JW,6,OW,0o17,0o206,_END}; |
byte T_J7={ OL1,_JB,O,0o167,0, |
OL1,_JW,6,OW,0o17,0o207,_END}; |
byte T_J8={ OL1,_JB,O,0o170,0, |
OL1,_JW,6,OW,0o17,0o210,_END}; |
byte T_J9={ OL1,_JB,O,0o171,0, |
OL1,_JW,6,OW,0o17,0o211,_END}; |
byte T_JA={ OL1,_JB,O,0o172,0, |
OL1,_JW,6,OW,0o17,0o212,_END}; |
byte T_JB={ OL1,_JB,O,0o173,0, |
OL1,_JW,6,OW,0o17,0o213,_END}; |
byte T_JC={ OL1,_JB,O,0o174,0, |
OL1,_JW,6,OW,0o17,0o214,_END}; |
byte T_JD={ OL1,_JB,O,0o175,0, |
OL1,_JW,6,OW,0o17,0o215,_END}; |
byte T_JE={ OL1,_JB,O,0o176,0, |
OL1,_JW,6,OW,0o17,0o216,_END}; |
byte T_JF={ OL1,_JB,O,0o177,0, |
OL1,_JW,6,OW,0o17,0o217,_END}; |
byte T_JMP={ OL1,_JB,O,0o353,0, //JMP SHORT CB |
OL1,_JW,5,O,0o351,0, //JMP NEAR CW |
_OW+OL1+SOE,O,0o377,X4M,0}; // JMP NEAR EN |
byte T_JMPFAR={ _D+OL1+SOE,O,0o377,X5M,0, // JMP FAR EF |
OL1+SOO_AF,O,0o352,_END}; //JMP FAR AF |
byte T_JMPSHORT={ |
OL1,_JB,O,0o353,_END}; //JMP SHORT CB |
byte T_JMPNEAR={OL1,_JW,5,O,0o351,0, //JMP NEAR CW |
_OW+OL1+SOE,O,0o377,X4M,_END}; // JMP NEAR EN |
byte T_CALL={ OL1,_JW,5,O,0o350,0, //CALL CW |
_OW+OL1+SOE,O,0o377,X2M,0}; //CALL EN |
byte T_CALLFAR={ |
OL1+SOO_AF,O,0o232,0, //CALL AF |
_D+OL1+SOE,O,0o377,X3M,_END}; //CALL FAR EF |
byte T_RETF={ 0,O,0o313,0, //RETF/RET FAR |
_OW+OL1+SOC,O,0o312,_END}; //RETF DW/RET FAR DW |
byte T_ENTER={ WB+OL2+EAO,CO,CO,O,0o310,_END}; |
byte T_BOUND={ _W+OL2+REO,O,0o142,XRM,_END}; //BOUND RW, ED |
/*byte T_INT={ NB+OL1+SO3,O,0o314,0, // !!! No interrupts in Win32 |
NB+OL1+SOC,O,0o315,_END};*/ |
byte T_IN={ NB+OL2+EAO,AR,CO,O,0o344,0, //IN AL, DB |
WB+OL2+EAO,AR,CO,O,0o345,0, //IN AX,CO |
_B+OL2+EAO,AR,rDX,O,0o354,0, //IN AL,DX |
_OW+OL2+EAO,AR,rDX,O,0o355,_END}; //IN AX, DX |
byte T_OUT={ NB+OL2+EAO,CO,AR,O,0o346,0, //OUT DB, AL |
BW+OL2+EAO,CO,AR,O,0o347,0, //OUT DB, AX |
WB+OL2+EAO,rDX,AR,O,0o356,0, //OUT DX, AL |
_OW+OL2+EAO,rDX,AR,O,0o357,_END}; //OUT DX, AX |
byte T_PUSH={ OL1+SOO_CC,O,0o152,0, |
_D+OL1+SOR,S,"12R", |
_D+OL1+SOE,O,0o377,X6M,0, |
_D+OL1+SOC,O,0o150,0, |
OL1+SOO_FS,OW,0xF,0o240,0, |
OL1+SOO_GS,OW,0xF,0o250,0, |
_OW+OL1+SOS,S,"0S6", //WIEDER ANS ENDE PACKEN |
_END}; |
byte T_RET={ _OW+OL1+SOC,O,0o302,0, //RET DW |
O,0o303,0,_END}; //RET |
byte T_POP={ _D+OL1+SOR,S,"13R", |
_D+OL1+SOE,O,0o217,X0M,0, |
OL1+SOO_FS,OW,0xF,0o241,0, |
OL1+SOO_GS,OW,0xF,0o251,0, |
_OW+OL1+SOS,S,"0S7",_END}; |
byte T_ARPL={ _W+OL2+ERO,O,0o143,XRM,_END}; //ARPL ES, RW |
byte T_SLDT={ _OW+OL1+SOE,OW,0xF,0,X0M,_END}; //SLDT EW |
byte T_STR={ _OW+OL1+SOE,OW,0xF,0,X1M,_END}; //STR EW |
byte T_LLDT={ _OW+OL1+SOE,OW,0xF,0,X2M,_END}; //LLDT EW |
byte T_LTR={ _OW+OL1+SOE,OW,0xF,0,X3M,_END}; //LTR EW |
byte T_VERR={ _OW+OL1+SOE,OW,0xF,0,X4M,_END}; //VERR EW |
byte T_VERW={ _OW+OL1+SOE,OW,0xF,0,X5M,_END}; //VERW EW |
byte T_LAR={ _OW+OL1+REO,OW,0xF,2,XRM,_END}; //LAR RW, EW |
byte T_LSL={ _OW+OL1+REO,OW,0xF,3,XRM,_END}; //LSL RW, EW |
byte T_SGDT={ _OW+OL1+SOM,OW,0xF,1,X0M,_END}; //SGDT EP |
byte T_SIDT={ _OW+OL1+SOM,OW,0xF,1,X1M,_END}; //SIDT EP |
byte T_LGDT={ _OW+OL1+SOM,OW,0xF,1,X2M,_END}; //LGDT EP |
byte T_LIDT={ _OW+OL1+SOM,OW,0xF,1,X3M,_END}; //LIDT EP |
byte T_SMSW={ _OW+OL1+SOE,OW,0xF,1,X4M,_END}; //SMSW EW |
byte T_LMSW={ _OW+OL1+SOE,OW,0xF,1,X6M,_END}; //LMSW EW |
//===== X486 INSTRUCTIONS |
byte T_INVLPD={ _OW+OL1+SOM,OW,0xF,0o20,X7M,_END}; //INVLPG EA |
//===== INTEL PENTIUM INSTRUCTIONS |
byte T_CMPX8={ _OW+OL1+SOE,OW,0xF,0xC7,X1M,_END}; //CMPX8 EW 5 IF EDXEAX=MQ THEN MQ:=ECXEBX, ELSE EAXEDX:=MQ |
byte T_CMOV={ _W+OL2,REO,OW,0xF,0x40,XRM,_END}; |
//===== MMX INSTRUCTIONS |
byte T_EMMS={ _END}; |
byte T_UMOV={ _B+OL2,DER,OW,0xF,0x10,XRM,_END}; |
#define _Q 1 |
#define MMXE 1 |
#define MMXP 1 |
#define MMXPI 1 |
#define MMXPE 1 |
#define MMXEP 1 |
byte T_PUNPCKLBW={ _D+OL2,MMXE,OW,0xF,0x60,_END}; |
byte T_PUNPCKLWD={ _D+OL2,MMXE,OW,0xF,0x61,_END}; |
byte T_PUNPCKLDQ={ _D+OL2,MMXE,OW,0xF,0x62,_END}; |
byte T_PACKSSWB={ _Q+OL2,MMXE,OW,0xF,0x63,_END}; |
byte T_PCMPGTB={ _Q+OL2,MMXE,OW,0xF,0x64,_END}; |
byte T_PCMPGTW={ _Q+OL2,MMXE,OW,0xF,0x65,_END}; |
byte T_PCMPGTD={ _Q+OL2,MMXE,OW,0xF,0x66,_END}; |
byte T_PACKUSWB={ _Q+OL2,MMXE,OW,0xF,0x67,_END}; |
byte T_PCMPEQB={ _Q+OL2,MMXE,OW,0xF,0x74,_END}; |
byte T_PCMPEQW={ _Q+OL2,MMXE,OW,0xF,0x75,_END}; |
byte T_PCMPEQD={ _Q+OL2,MMXE,OW,0xF,0x76,_END}; |
byte T_PSRLW={ _Q+OL2,MMXE,OW,0xF,0xD1,_END}; |
byte T_PSRLD={ _Q+OL2,MMXE,OW,0xF,0xD2,_END}; |
byte T_PSRLQ={ _Q+OL2,MMXE,OW,0xF,0xD3,_END}; |
byte T_PMULLW={ _Q+OL2,MMXE,OW,0xF,0xD5,_END}; |
byte T_PSRAW={ _Q+OL2,MMXE,OW,0xF,0xE1,_END}; |
byte T_PSRAD={ _Q+OL2,MMXE,OW,0xF,0xE2,_END}; |
byte T_PMULHW={ _Q+OL2,MMXE,OW,0xF,0xE5,_END}; |
byte T_PSLLW={ _Q+OL2,MMXE,OW,0xF,0xF1,_END}; |
byte T_PSLLD={ _Q+OL2,MMXE,OW,0xF,0xF2,_END}; |
byte T_PSLLQ={ _Q+OL2,MMXE,OW,0xF,0xF3,_END}; |
byte T_PMADDWD={ _Q+OL2,MMXE,OW,0xF,0xF5,_END}; |
byte T_PUNPCKHBW={ _Q+OL2,MMXE,OW,0xF,0x68,_END}; |
byte T_PUNPCKHWD={ _Q+OL2,MMXE,OW,0xF,0x69,_END}; |
byte T_PUNPCKHDQ={ _Q+OL2,MMXE,OW,0xF,0x6A,_END}; |
byte T_PACKSSDW={ _Q+OL2,MMXE,OW,0xF, 0x6B,_END}; |
byte T_MOVD={ _D+OL2,MMXPE,OW,0xF,0x6E,0, |
_Q+OL2,MMXEP,OW,0xF,0x7E,_END}; |
byte T_MOVQ={ _Q+OL2,MMXE,OW,0xF,0x6F,0, |
_Q+OL2,MMXE,OW,0xF,0x7F,_END}; |
byte T_PSUBUSB={ _Q+OL2,MMXE,OW,0xF,0xD8,_END}; |
byte T_PSUBUSW={ _Q+OL2,MMXE,OW,0xF,0xD9,_END}; |
byte T_PAND={ _Q+OL2,MMXE,OW,0xF,0xDB,_END}; |
byte T_PADDUSB={ _Q+OL2,MMXE,OW,0xF,0xDC,_END}; |
byte T_PADDUSW={ _Q+OL2,MMXE,OW,0xF,0xDD,_END}; |
byte T_PANDN={ _Q+OL2,MMXE,OW,0xF,0xDF,_END}; |
byte T_PSUBSB={ _Q+OL2,MMXE,OW,0xF,0xE8,_END}; |
byte T_PSUBSW={ _D+OL2,MMXE,OW,0xF,0xE9,_END}; |
byte T_POR={ _Q+OL2,MMXE,OW,0xF,0xEB,_END}; |
byte T_PADDSB={ _Q+OL2,MMXE,OW,0xF,0xEC,_END}; |
byte T_PADDSW={ _Q+OL2,MMXE,OW,0xF,0xED,_END}; |
byte T_PXOR={ _Q+OL2,MMXE,OW,0xF,0xEF,_END}; |
byte T_PSUBB={ _Q+OL2,MMXE,OW,0xF,0xF8,_END}; |
byte T_PSUBW={ _Q+OL2,MMXE,OW,0xF,0xF9,_END}; |
byte T_PSUBD={ _Q+OL2,MMXE,OW,0xF,0xFA,_END}; |
byte T_PADDB={ _Q+OL2,MMXE,OW,0xF,0xFC,_END}; |
byte T_PADDW={ _Q+OL2,MMXE,OW,0xF,0xFD,_END}; |
byte T_PADDD={ _Q+OL2,MMXE,OW,0xF,0xFE,_END}; |
byte T_PSRL={ _Q+OL2,MMXPI,OW,0xF,_END}; |
byte T_PSRA={ _Q+OL2,MMXPI,OW,0xF,_END}; |
byte T_PSLL={ _Q+OL2,MMXE,OW,0xF,_END}; |
byte Mnemonics={ |
// FIRST OF ALL THE COMMANDS WITH A P-FLAG. THIS"LL MAKE THINGS EASIER FOR |
// COMPARISON IN THE PARSE ENGINE |
//P1=0-7 |
"ADD","OR","ADC","SBB/BC","AND","SUB","XOR","CMP", |
//P2=4-7 |
"MUL","-","DIV","IDIV", |
// IMUL ENTFERNT |
//P3=0-5/7 |
"ROL","ROR","RCL","RCR","SHL/AL","SHR","-","SAR", |
//P4=4-7 |
"BT","BTS","BTR","BTC", |
// USUAL COMMANDS |
"NOT","NEG","INC","DEC","TEST", "IMUL","SHLD","SHRD", |
"DAA","DAS","AAA","AAS","AAM","AAD", |
"MOVSX","MOVZX","CBW","CWDE","CWD","CDQ", |
"BSWAP","XLAT/LATB","BSF","BSR", |
"CMPXCHG","CMPXCHG486","CMPXCHG8B","XADD", |
"NOP","WAIT","LOCK","HLT", //"INT", |
"INTO","IRET", |
"POPF","POPFD","PUSHF","PUSHFD","SAHF","LAHF", |
"CMC","CLC","STC","CLI","STI","CLD","STD", |
"PUSH","PUSHA","PUSHAD","POP","POPA","POPAD", |
"XCHG","MOV","LEA","LSS","LFS","LGS","LES","LDS", |
"ADDR","RAND", |
"IN","OUT","INSB","INSW","INSD","OUTSB","OUTSW","OUTSD", |
"MOVSB","MOVSW","MOVSD","CMPSB","CMPSW","CMPSD", |
"STOSB","STOSW","STOSD","LODSB","LODSW","LODSD", |
"SCASB","SCASW","SCASD","REP/EPNE/EPNZ","REPE/EPZ", |
"JCXZ/ECXZ","LOOP","LOOPZ/OOPE","LOOPNZ/OOPNE", |
"JO","JNO","JC/B/NAE","JNC/AE/NB", |
"JE/Z","JNE/NZ","JBE/NA","JA/NBE", |
"JS","JNS","JP/PE","JNP/PO","JL/NGE","JGE/NL", |
"JLE/NG","JG/NLE", |
"SETO","SETNO","SETC/ETB/ETNAE","SETNC/ETAE/ETNB", |
"SETE/ETZ","SETNE/ETNZ","SETBE/ETNA","SETA/ETNBE", |
"SETS","SETNS","SETP/ETPE","SETNP/ETPO","SETL/ETNGE","SETGE/ETNL", |
"SETLE/ETNG","SETG/ETNLE", |
"JMPS","JMPN","JMPF","JMP", |
"CALL","CALLF","RET","RETF", |
"ENTER","LEAVE","BOUND","ARPL", |
"SLDT","STR","LLDT","LTR","VERR","VERW","LAR","LSL", |
"SGDT","SIDT","LGDT","LIDT","SMSW","LMSW","CLTS", |
"INVD","WBINVD","INVLPD", |
//INTEL PENTIUM COMMANDS |
"WRMSR","CMPX8/MPXCHG8B","CPUID","RDMSR","RDTSC","RSM", |
//INTEL PENTIUM PRO INSTRUCTIONS |
"RDPMC","UD2","EMMX","SETALC", |
//MMX INSTRUCTIONS |
"MOVD","MOVQ", //MOVE MMX REG |
"PACKUS/PACKUSWB", //PACK MMX REG WITH UNSIGNED SATURATION |
"PACKSSWB","PACKSSDW", //PACK MMX REG WITH SIGNED SATURATION |
"PUNPCKHBW","PUNPCKHWD", |
"PUNPCKHDQ", //UNPACK HIGH ORDER |
"PUNPCKLBW","PUNPCKLWD", |
"PUNPCKLDQ", //UNPACK LOW ORDER |
"PADDB","PADDW","PADDD", //ADD MMX REG WITH WRAP-AROUND |
"PADDSB","PADDSW", //" WITH SIGNED SATURATION |
"PADDUSB","PADDUSW", //" WITH UNSIGNED SATURATION |
"PSUBB","PSUBW","PSUBD", //SUBTRACT MMX REG |
"PSUBSB","PSUBSW","PSUBUSB","PSUBUSW", |
"PMULH/PMULHW","PMULL/PMULLW","PMADD/PMADDWD", |
"PSLLW","PSLLD","PSLLQ","PSRLW","PSRLD","PSRLQ", |
"PSRAW","PSRAD","PCMPEQB","PCMPEQW","PCMPEQD", |
"PCMPGTB","PCMPGTW","PCMPGTD","PAND","PANDN","POR","PXOR","EMMS",_END}; |
dword TAB_MNEMONICS={ |
#T_NOT,#T_NEG,#T_INC,#T_DEC,#T_TEST, |
#T_IMUL,#T_SHLD,#T_SHRD, |
#T_DAA,#T_DAS,#T_AAA,#T_AAS,#T_AAM,#T_AAD, |
#T_MOVSX,#T_MOVZX,#T_CBW,#T_CWDE,#T_CWD,#T_CDQ, |
#T_BSWAP,#T_XLATB, |
#T_BSF,#T_BSR,#T_CMPXCHG,#T_CMPXCHG486,#T_CMPXCHG8B,#T_XADD, |
#T_NOP,#T_WAIT,#T_LOCK,#T_HLT, |
// #T_INT, |
#T_INTO,#T_IRET, |
#T_POPF,#T_POPFD,#T_PUSHF,#T_PUSHFD, |
#T_SAHF,#T_LAHF, |
#T_CMC,#T_CLC,#T_STC,#T_CLI,#T_STI,#T_CLD,#T_STD, |
#T_PUSH,#T_PUSHA,#T_PUSHAD, |
#T_POP,#T_POPA,#T_POPAD, |
#T_XCHG,#T_MOV, |
#T_LEA,#T_LSS,#T_LFS,#T_LGS,#T_LES,#T_LDS, |
#T_ADDR,#T_RAND, |
#T_IN,#T_OUT, |
#T_INSB,#T_INSW,#T_INSD, |
#T_OUTSB,#T_OUTSW,#T_OUTSD, |
#T_MOVSB,#T_MOVSW,#T_MOVSD, |
#T_CMPSB,#T_CMPSW,#T_CMPSD, |
#T_STOSB,#T_STOSW,#T_STOSD, |
#T_LODSB,#T_LODSW,#T_LODSD, |
#T_SCASB,#T_SCASW,#T_SCASD, |
#T_REP, |
#T_REPE, |
#T_JCXZ,#T_LOOP,#T_LOOPZ,#T_LOOPNZ, |
#T_J0,#T_J1,#T_J2,#T_J3, |
#T_J4,#T_J5,#T_J6,#T_J7, |
#T_J8,#T_J9,#T_JA,#T_JB, |
#T_JC,#T_JD,#T_JE,#T_JF, |
#T_SET0,#T_SET1,#T_SET2,#T_SET3, |
#T_SET4,#T_SET5,#T_SET6,#T_SET7, |
#T_SET8,#T_SET9,#T_SETA,#T_SETB, |
#T_SETC,#T_SETD,#T_SETE,#T_SETF, |
#T_JMPSHORT,#T_JMPNEAR,#T_JMPFAR,#T_JMP, |
#T_CALL,#T_CALLFAR, |
#T_RET,#T_RETF, |
#T_ENTER,#T_LEAVE, |
#T_BOUND,#T_ARPL, |
#T_SLDT,#T_STR,#T_LLDT,#T_LTR,#T_VERR,#T_VERW, |
#T_LAR,#T_LSL, |
#T_SGDT,#T_SIDT,#T_LGDT,#T_LIDT, |
#T_SMSW,#T_LMSW,#T_CLTS, |
#T_INVD,#T_WBINVD,#T_INVLPD, |
//INTEL PENTIUM INSTRUCTIONS |
#T_WRMSR,#T_CMPX8,#T_CPUID,#T_RDMSR,#T_RDTSC,#T_RSM, |
//INTEL PENTIUM PRO INSTRUCTIONS |
#T_RDPMC,#T_UD2,#T_EMMX,#T_SALC, |
//MMX INSTRUCTIONS |
#T_MOVD,#T_MOVQ, //MOVE MMX REG |
#T_PACKUSWB, //PACK MMX REG WITH UNSIGNED SATURATION |
#T_PACKSSWB,#T_PACKSSDW, //PACK MMX REG WITH SIGNED SATURATION |
#T_PUNPCKHBW,#T_PUNPCKHWD,#T_PUNPCKHDQ, //UNPACK HIGH ORDER |
#T_PUNPCKLBW,#T_PUNPCKLWD,#T_PUNPCKLDQ, //UNPACK LOW ORDER |
#T_PADDB,#T_PADDW,#T_PADDD, //ADD MMX REG WITH WRAP-AROUND |
#T_PADDSB,#T_PADDSW, //" WITH SIGNED SATURATION |
#T_PADDUSB,#T_PADDUSW, //" WITH UNSIGNED SATURATION |
#T_PSUBB,#T_PSUBW,#T_PSUBD, //SUBTRACT MMX REG |
#T_PSUBSB,#T_PSUBSW, |
#T_PSUBUSB,#T_PSUBUSW, |
#T_PMULHW, |
#T_PMULLW, |
#T_PMADDWD, |
#T_PSLLW,#T_PSLLD,#T_PSLLQ, |
#T_PSRLW,#T_PSRLD,#T_PSRLQ, |
#T_PSRAW,#T_PSRAD, |
#T_PCMPEQB,#T_PCMPEQW,#T_PCMPEQD, |
#T_PCMPGTB,#T_PCMPGTW,#T_PCMPGTD, |
#T_PAND, |
#T_PANDN, |
#T_POR, |
#T_PXOR, |
#T_EMMS}; |
/programs/develop/c--/trunk/parser.h-- |
---|
0,0 → 1,630 |
// ---- ¥¥à æ¨ï ¢ëà ¦¥¨ï |
DoExpr(dword var,vtok,vtype,mnem) |
byte varName[2*IDLENGTH]; |
{ |
IF(tok2notstopper()){ |
IF(vtok==tk_var)Expression("eax",tk_reg,tk_dword); |
ELSE{ |
Expression(var,vtok,vtype); |
return; |
} |
} |
else{ // ¤¨ ®¯¥à ¤ |
tok=GetVarname(#varName); |
IF(tok==tk_reg)wsprintfA(#mapstr,"%s %s,%s",mnem,var,#varName); |
else IF(tok==tk_var){ |
IF(vtok==tk_var)Expression("eax",tk_reg,tk_dword); |
ELSE wsprintfA(#mapstr,"%s %s,%s",mnem,var,#varName); |
} |
else IF(tok==tk_number)wsprintfA(#mapstr,"%s %s,%d",mnem,var,DoConstMath()); |
ELSE IF(tok==tk_postnumber)wsprintfA(#mapstr,"%s %s#%s",mnem,var,#varName); |
ELSE IF(tok==tk_locnumber){ |
wsprintfA(#mapstr,"lea ebx,%s",#varName); |
wsprintfA(#mapstr,"%s %s,ebx",mnem,var); |
return; |
} |
Asm(#mapstr); |
RETURN; |
} |
IF(vtype==tk_byte)||(vtype==tk_char)wsprintfA(#mapstr,"%s %s,al",mnem,var); |
ELSE IF(vtype==tk_word)||(vtype==tk_short)wsprintfA(#mapstr,"%s %s,ax",mnem,var); |
ELSE IF(vtype==tk_dword)||(vtype==tk_int)wsprintfA(#mapstr,"%s %s,eax",mnem,var); |
Asm(#mapstr); |
} |
// ---- §¡®àª ¨ âà á«ïæ¨ï ¢ëà ¦¥¨© |
dword Expression(dword dest,dtok,dtype) |
byte s[IDLENGTH]; |
{ |
GetInto(dest,dtok,dtype); |
for(;;){ |
Term(#s,dtype); |
IF(tok==tk_plus){ |
Term(#s,dtype); |
wsprintfA(#mapstr,"add %s,%s",dest,#s); |
Asm(#mapstr); |
} |
else IF(tok==tk_minus){ |
Term(#s,dtype); |
wsprintfA(#mapstr,"sub %s,%s",dest,#s); |
Asm(#mapstr); |
} |
else IF(tok==tk_or){ |
Term(#s,dtype); |
wsprintfA(#mapstr,"or %s,%s",dest,#s); |
Asm(#mapstr); |
} |
else IF(tok==tk_xor){ |
Term(#s,dtype); |
wsprintfA(#mapstr,"xor %s,%s",dest,#s); |
Asm(#mapstr); |
} |
else IF(tok==tk_assign)||(tok==tk_equalto){ |
Term(#s,dtype); |
wsprintfA(#mapstr,"cmp %s,%s",dest,#s); |
Asm(#mapstr); |
Asm("sete al"); |
SE: |
wsprintfA(#mapstr,"movzx %s,al",dest); |
Asm(#mapstr); |
} |
else IF(tok==tk_notequal){ |
Term(#s,dtype); |
wsprintfA(#mapstr,"cmp %s,%s",dest,#s); |
Asm(#mapstr); |
Asm("setne al"); |
GOTO SE; |
} |
else IF(tok==tk_greater){ |
Term(#s,dtype); |
wsprintfA(#mapstr,"cmp %s,%s",dest,#s); |
Asm(#mapstr); |
Asm("setg al"); |
$JMP SE; |
} |
else IF(tok==tk_greaterequal){ |
Term(#s,dtype); |
wsprintfA(#mapstr,"cmp %s,%s",dest,#s); |
Asm(#mapstr); |
Asm("setge al"); |
$JMP SE; |
} |
else IF(tok==tk_less){ |
Term(#s,dtype); |
wsprintfA(#mapstr,"cmp %s,%s",dest,#s); |
Asm(#mapstr); |
Asm("setl al"); |
$JMP SE; |
} |
ELSE IF(tok==tk_lessequal){ |
Term(#s,dtype); |
wsprintfA(#mapstr,"cmp %s,%s",dest,#s); |
Asm(#mapstr); |
Asm("setle al"); |
$JMP SE; |
} |
ELSE BREAK; |
} |
return(relation); |
} |
// ---- ⥨¥ ®ç¥à¥¤®£® í«¥¬¥â ¢ëà ¦¥¨ï |
Factor(dword f,ftype) |
{ |
NextTok(); |
IF(tok==tk_openbracket){ |
NextTok(); |
PushEAX(); |
Expression("eax",tk_reg,ftype); |
Asm("pop ebx; xchg eax,ebx"); |
wsprintfA(f,"%s","ebx"); |
} |
else IF(tok==tk_number)wsprintfA(f,"%#x",DoConstMath()); |
else IF(tok==tk_postnumber)wsprintfA(f,"#%s",#string); |
else IF(tok==tk_proc){ |
PushEAX(); |
DoAnyProc(); |
Asm("pop ebx; xchg eax,ebx"); |
wsprintfA(f,"%s","ebx"); |
} |
ELSE IF(tok==tk_API){ |
PushEAX(); |
doAPI(); |
Asm("pop ebx; xchg eax,ebx"); |
wsprintfA(f,"%s","ebx"); |
} |
ELSE IF(tok==tk_var)||(tok==tk_param)||(tok==tk_local)||(tok==tk_openblock)|| |
(tok==tk_reg)GetVarname(f); |
} |
// ---- |
GetInto(dword dest,dtok,dtype) |
dword tk; |
{ |
tk=0; |
DOCASE: |
IF(tok==tk_minus){ |
F_0: |
tk=tok; |
NextTok(); |
GOTO DOCASE; |
} |
else IF(tok==tk_not){ |
relation^=1; |
GOTO F_0; |
} |
else IF(tok==tk_openbracket){ |
NextTok(); |
Expression(dest,dtok,dtype); |
} |
else IF(tok==tk_number){ |
IF(tk)wsprintfA(#mapstr,"mov %s,-%#x",dest,DoConstMath()); |
ELSE wsprintfA(#mapstr,"mov %s,%#x",dest,DoConstMath()); |
Asm(#mapstr); |
tk=0; |
} |
else IF(tok==tk_postnumber){ |
wsprintfA(#mapstr,"mov %s,#%s",dest,#string); |
Asm(#mapstr); |
} |
else IF(tok==tk_locnumber){ |
wsprintfA(#mapstr,"lea ebx,%s",#string); |
Asm(#mapstr); |
wsprintfA(#mapstr,"mov %s,ebx",dest); |
Asm(#mapstr); |
} |
ELSE IF(tok==tk_proc)DoAnyProc(); |
ELSE IF(tok==tk_API)doAPI(); |
ELSE IF(tok==tk_var)||(tok==tk_local)||(tok==tk_param)||(tok==tk_reg)|| |
(tok==tk_openblock)GetIntoVar(dest,dtok,dtype); |
ELSE preerror("Wrong expression member"); |
// wsprintfA(#string,dest,"mov %s,%s",#mapstr); |
// ESP+=16; Asm(#mapstr); |
IF(tk==tk_minus){ |
wsprintfA(#mapstr,"neg %s",dest); |
Asm(#mapstr); |
} |
IF(tk==tk_not){ |
wsprintfA(#mapstr,"not %s",dest); |
Asm(#mapstr); |
} |
} |
// ---- |
GetIntoVar(dword dName,dTok,dType) |
byte varName[2*IDLENGTH]; |
dword vtype,vtok; |
{ |
if(dTok==tk_reg){ |
if(tok==tk_reg){ // Reg = Reg |
IF(dType==tk_dword){// Reg32=Reg |
IF(type==tk_dword){ |
wsprintfA(#mapstr,"mov %s,%s",dName,#string); |
Asm(#mapstr); |
} |
ELSE IF(type==tk_word)||(type==tk_byte){ |
RDW: |
wsprintfA(#mapstr,"movzx %s,%s",dName,#string); |
Asm(#mapstr); |
} |
} |
else IF(dType==tk_word){ // Reg=Reg |
IF(type==tk_dword){ |
GERR: |
warning("Not same size\n"); |
} |
ELSE IF(type==tk_word){ |
wsprintfA(#mapstr,"mov %s,%s",dName,#string); |
Asm(#mapstr); |
} |
ELSE IF(type==tk_byte)GOTO RDW; |
} |
ELSE IF(dType==tk_byte){ // Reg=Reg |
IF(type==tk_dword)||(type==tk_word)GOTO GERR; |
IF(type==tk_byte){ |
wsprintfA(#mapstr,"mov %s,%s",dName,#string); |
Asm(#mapstr); |
} |
} |
} |
else if(tok==tk_var)||(tok==tk_param)||(tok==tk_local)||(tok==tk_openblock){ // Reg = Var |
vtype=type; vtok=GetVarname(#varName); |
IF(vtype==tk_dword)||(vtype==tk_int)||(dType==vtype){ |
wsprintfA(#mapstr,"mov %s,%s",dName,#varName); |
} |
ELSE IF(vtype==tk_word)||(vtype==tk_byte){ |
wsprintfA(#mapstr,"movzx %s,%s",dName,#varName); |
} |
ELSE IF(vtype==tk_short)||(vtype==tk_char){ |
wsprintfA(#mapstr,"movsx %s,%s",dName,#varName); |
} |
Asm(#mapstr); |
} |
else IF(tok==tk_number){ // Reg = Const |
wsprintfA(#mapstr,"mov %s,%d",dName,DoConstMath()); |
Asm(#mapstr); |
} |
else IF(tok==tk_postnumber){ // Reg = #Var |
GetVarname(#varName); |
wsprintfA(#mapstr,"mov %s,#%s",dName,#varName); |
Asm(#mapstr); |
} |
ELSE IF(tok==tk_locnumber){ // Reg = #locVar |
vtype=type; vtok=GetVarname(#varName); |
wsprintfA(#mapstr,"lea %s,%s",dName,#varName); |
Asm(#mapstr); |
} |
} |
else if(dTok==tk_var){ |
if(tok==tk_reg){ // Var = Reg; |
IF(type==tk_dword){ |
wsprintfA(#mapstr,"mov dword %s,%s",dName,#string); |
Asm(#mapstr); |
} |
ELSE IF(type==tk_word){ |
wsprintfA(#mapstr,"mov word %s,%s",dName,#string); |
Asm(#mapstr); |
} |
ELSE IF(type==tk_byte){ |
wsprintfA(#mapstr,"mov byte %s,%s",dName,#string); |
Asm(#mapstr); |
} |
} |
else if(tok==tk_var){ // Var = Var; |
vtype=type; |
vtok=GetVarname(#varName); |
IF(dType==tk_byte)||(dType==tk_char){ |
wsprintfA(#mapstr,"mov al,%s",#varName); |
Asm(#mapstr); |
wsprintfA(#mapstr,"mov %s,al",dName); |
Asm(#mapstr); |
} |
else if(dType==tk_word)||(dType==tk_short){ |
IF(vtype==tk_byte){ |
wsprintfA(#mapstr,"movzx ax,%s",#varName); |
Asm(#mapstr); |
} |
else IF(vtype==tk_char){ |
wsprintfA(#mapstr,"movsx ax,%s",#varName); |
Asm(#mapstr); |
} |
ELSE IF(vtype==tk_word)||(vtype==tk_short){ |
wsprintfA(#mapstr,"mov ax,%s",#varName); |
Asm(#mapstr); |
} |
ELSE IF(vtype==tk_dword)||(vtype==tk_int){ |
wsprintfA(#mapstr,"mov ax,word %s",#varName); |
Asm(#mapstr); |
} |
wsprintfA(#mapstr,"mov %s,ax",dName); |
Asm(#mapstr); |
} |
else if(dType==tk_dword)||(dType==tk_int){ |
IF(vtype==tk_byte)||(vtype==tk_word){ |
wsprintfA(#mapstr,"movzx eax,%s",#varName); |
Asm(#mapstr); |
} |
ELSE IF(vtype==tk_char)||(vtype==tk_short){ |
wsprintfA(#mapstr,"movsx eax,%s",#varName); |
Asm(#mapstr); |
} |
ELSE IF(vtype==tk_dword)||(vtype==tk_int){ |
wsprintfA(#mapstr,"mov eax,%s",#varName); |
Asm(#mapstr); |
} |
wsprintfA(#mapstr,"mov %s,eax",dName); |
Asm(#mapstr); |
} |
} |
else IF(tok==tk_number){ // Var = Const; |
wsprintfA(#mapstr,"mov %s,%d",dName,DoConstMath()); |
Asm(#mapstr); |
} |
else IF(tok==tk_postnumber){ // Var = #Var; |
vtype=type; vtok=GetVarname(#varName); |
wsprintfA(#mapstr,"mov %s,#%s",dName,#varName); |
Asm(#mapstr); |
} |
ELSE IF(tok==tk_locnumber){ // Var = #locVar; |
vtype=type; vtok=GetVarname(#varName); |
wsprintfA(#mapstr,"lea ebx,%s",#varName); |
Asm(#mapstr); |
wsprintfA(#mapstr,"mov %s,ebx",dName); |
Asm(#mapstr); |
} |
} |
} |
// ---- ⥨¥ ¯¥à¥¬¥®©: VarName[reg+reg*Scale+disp] |
dword GetVarname(dword varName) |
dword vtok; |
{ |
IF(tok==tk_openblock)GOTO G0; |
lstrcpyA(varName,#string); |
vtok=tok; |
IF(vtok==tk_local)vtok=tk_var; |
ELSE IF(vtok==tk_param)vtok=tk_var; |
if(tok2==tk_openblock){ |
NextTok(); |
G0: |
vtok=tk_var; |
lstrcatA(varName,"["); |
for(;;){ |
NextTok(); |
IF(tok==tk_reg)lstrcatA(varName,#string); |
else IF(tok==tk_plus)lstrcatA(varName,"+"); |
else IF(tok==tk_mult)lstrcatA(varName,"*"); |
ELSE IF(tok==tk_number){ |
wsprintfA(#mapstr,"%d",DoConstMath()); |
lstrcatA(varName,#mapstr); |
} |
ELSE IF(tok==tk_postnumber){ |
lstrcatA(varName,"#"); |
lstrcatA(varName,#string); |
} |
ELSE IF(tok==tk_closeblock){ |
lstrcatA(varName,"]"); |
BREAK; |
} |
ELSE preerror("Illegal index expression in []"); |
} |
} |
return(vtok); |
} |
// ---- |
Term(dword t,ttype) |
{ |
for(;;){ |
Factor(t,ttype); |
IF(tok==tk_mult){ |
Factor(t,ttype); |
IF(tok==tk_number){ |
wsprintfA(#mapstr,"mov ebx,%d",DoConstMath()); |
Asm(#mapstr); |
wsprintfA(#mapstr,"mul %s","ebx"); |
} |
ELSE wsprintfA(#mapstr,"mul %s",t); |
Asm(#mapstr); |
} |
else IF(tok==tk_div){ |
Factor(t,ttype); |
IF(tok==tk_number){ |
wsprintfA(#mapstr,"mov ebx,%d",DoConstMath()); |
Asm(#mapstr); |
wsprintfA(#mapstr,"div %s","ebx"); |
} |
ELSE wsprintfA(#mapstr,"div %s",t); |
Asm(#mapstr); |
} |
else IF(tok==tk_mod){ |
Factor(t,ttype); |
IF(tok==tk_number){ |
wsprintfA(#mapstr,"mov ebx,%d",DoConstMath()); |
Asm(#mapstr); |
wsprintfA(#mapstr,"div %s","ebx"); |
} |
ELSE wsprintfA(#mapstr,"div %s",t); |
Asm(#mapstr); |
Asm("xchg eax,edx"); |
} |
ELSE IF(tok==tk_and){ |
Factor(t,ttype); |
IF(tok==tk_number)wsprintfA(#mapstr,"and ebx,%d",DoConstMath()); |
ELSE wsprintfA(#mapstr,"and eax,%s",t); |
Asm(#mapstr); |
} |
ELSE IF(tok==tk_not)Asm("not eax"); |
ELSE BREAK; |
} |
} |
// ---- ®åà ¥¨¥ EAX ¢ á⥪¥ |
PushEAX() |
{ |
Asm("push eax"); |
} |
// ---- ®åà ¥¨¥ EAX ¢ á⥪¥ |
/*PopEAX() |
{ |
Asm("pop eax"); |
} */ |
// ---- ¡à ¡®âª áâப¨-¯ à ¬¥âà : proc("string") |
dword AddPoststring() |
dword returnvalue; |
{ |
IF(posts >= MAXPOSTS){ |
preerror("cannot add post string, post queue full"); |
ExitProcess(-1); |
} |
EBX=posts<<2+posttype; |
DSDWORD[EBX] = POST_STR; |
EBX=posts<<2+postloc; |
DSDWORD[EBX] = outptr; |
posts++; |
returnvalue = MAXDATA-1-poststrptr; |
ESI=#string; |
EBX><poststrptr; |
do{ |
$LODSB; |
EDI=output+EBX; |
DSBYTE[EDI]=AL; |
EBX--; |
}while(AL!=0); |
EBX><poststrptr; |
EAX=returnvalue; |
} |
// ---- ¡à ¡®âª post-áâப ¨ ááë«®ª ¨å |
DoPoststrings() |
dword addvalue,addhold,i; |
{ |
IF(poststrptr==MAXDATA-1)return; |
addvalue = OptImageBase + OptBaseOfCode+outptr-output ; |
EDI><outptr; |
EBX=MAXDATA-1; |
D0: |
ESI=output+EBX; |
AL=DSBYTE[ESI]; |
$STOSB |
EBX--; |
$CMP EBX,poststrptr; |
$JA D0; |
EDI><outptr; |
i=0; |
while(i<posts){ |
EBX=i<<2+posttype; |
if(DSDWORD[EBX]==POST_STR){ |
EBX=i<<2+postloc; |
addhold = GetDword(DSDWORD[EBX])+addvalue; |
SetDword(DSDWORD[EBX],addhold); |
posts--; |
EBX=i<<2+postloc; |
ECX=posts<<2+postloc; |
DSDWORD[EBX]=DSDWORD[ECX]; |
EBX=i<<2+posttype; |
ECX=posts<<2+posttype; |
DSDWORD[EBX]=DSDWORD[ECX]; |
EBX=i<<2+postnum; |
ECX=posts<<2+postnum; |
DSDWORD[EBX]=DSDWORD[ECX]; |
i--; |
} |
i++; |
} |
poststrptr = MAXDATA-1; |
} |
// ---- ⥨¥ ®¤®£® ¯ à ¬¥âà ¯à¨ ¢ë§®¢¥ ¯à®æ¥¤ãàë |
GetParam(dword p) |
dword count; // áç¥â稪 ᪮¡®ª ¢ ¯ à ¬¥âॠ|
{ |
count=0; |
for(;;){ |
EAX=0; |
ESI><inptr2; |
$LODSB; |
ESI><inptr2; |
cha2=AL; |
EDI><p; |
$STOSB EDI><p; |
IF(AL==0)BREAK; |
IF(AL==')'){ |
IF(count==0){ |
EDI><p; |
AL=0; |
EDI--; |
$STOSB; |
EDI><p; |
BREAK; |
} |
count--; |
} |
ELSE IF(AL==','){ |
IF(count==0){ |
EDI><p; |
EDI--; |
AL=0; |
$STOSB; |
EDI><p; |
DoParam(); |
BREAK; |
} |
} |
ELSE IF(AL=='(')count++; |
} |
} |
// ---- ¡à ¡®âª ®¤®£® ¯ à ¬¥âà ¯à¨ ¢ë§®¢¥ ¯à®æ¥¤ãàë |
DoParam() |
dword vtok; |
byte p[250]; // ¬¥áâ® ¯®¤ ª®¯¨î ¯ à ¬¥âà |
byte holdcha; |
byte s[STRLEN],s2[STRLEN]; |
byte varName[2*IDLENGTH]; |
{ |
GetParam(#p); |
holdcha=cha2; |
$PUSH linenum2,inptr2,number,tok2,tok,input,inptr,currmod,linenumber, |
endoffile,displaytokerrors; |
lstrcpyA(#s,#string); lstrcpyA(#s2,#string2); |
input=#p; |
inptr = input; |
inptr2 = input; |
endoffile = 0; // ç «¥ ä ©« |
NextChar(); |
cha2 = cha; |
inptr2=inptr; |
linenum2 = 1; |
NextTok(); |
for(;;){ |
IF(tok==tk_eof)||(tok==tk_closebracket)break; |
IF(tok==tk_comma)NextTok(); |
else IF(tok==tk_string){ |
OP(byte 0x68); |
OUTDWORD(AddPoststring()); |
IF(list){ |
wsprintfA(#mapstr,"\t//\tpush #\"%s\"\n",#string); |
fprint(mapfile,#mapstr); |
} |
NextTok(); |
} |
else IF(tok2isopperand()){ |
Expression("eax",tk_reg,tk_dword); |
PushEAX(); |
} |
else{ // ¥ ¢ëà ¦¥¨¥ |
IF(tok==tk_number){ |
wsprintfA(#mapstr,"push %#x",DoConstMath()); |
Asm(#mapstr); |
NextTok(); |
} |
else IF(tok==tk_postnumber){ |
wsprintfA(#mapstr,"push #%s",#string); |
Asm(#mapstr); |
NextTok(); |
} |
else if(tok==tk_reg){ |
IF(type==tk_dword){ |
wsprintfA(#mapstr,"push %s",#string); |
Asm(#mapstr); |
NextTok(); |
} |
ELSE IF(type==tk_word){ |
wsprintfA(#mapstr,"movsx e%s,%s;push e%s",#string,#string,#string); |
Asm(#mapstr); |
NextTok(); |
} |
ELSE IF(tok==tk_byte){ |
wsprintfA(#mapstr,"movsx e%cx,%s;push e%cx",string[0],#string,string[0]); |
Asm(#mapstr); |
NextTok(); |
} |
} |
else IF(tok==tk_var)||(tok==tk_local)||(tok==tk_param){ |
vtok=GetVarname(#varName); |
IF(type==tk_dword){ |
D0: wsprintfA(#mapstr,"push %s",#varName); |
Asm(#mapstr); |
NextTok(); |
} |
ELSE GOTO D1; |
IF(type==tk_int){ //???? |
vtok=GetVarname(#varName); |
GOTO D0; |
} |
} |
ELSE{ |
D1: Expression("eax",tk_reg,tk_dword); |
PushEAX(); |
} |
} |
} |
lstrcpyA(#string,#s); |
lstrcpyA(#string2,#s2); |
$POP displaytokerrors,endoffile,linenumber,currmod,inptr,input,tok,tok2; |
$POP number,inptr2,linenum2; |
cha2=holdcha; |
} |
/programs/develop/c--/trunk/readme_ru.txt |
---|
0,0 → 1,529 |
"®¢¥àè¨â¥ ¢ë ¬ ááã ®âªàë⨩, |
¨®£¤ ¥ ¦¥« ï ⮣®..." |
¥ ¯®¬î ¢â®à , ® ¯¥« |
¤à¥© ¨à®®¢. |
।¨á«®¢¨¥. |
¤¥ï ¯¨á âì ª®¬¯¨«ïâ®à ¤«ï Win32 த¨« áì ¯à¨ ¬®¥¬ ¯¥à¢®¬ |
§ ª®¬á⢥ á ª®¬¯¨«ïâ®à®¬ Sphinx C-- ¨â¥à ¥««¨ª (Peter Cellik) |
¢ 1996 £®¤ã, ® ॠ«¨§®¢ âì ¥¥ 㤠«®áì «¨èì ¥¤ ¢®, ª®£¤ |
¯®ï¢¨« áì ¢®§¬®¦®áâì ç¥à¥§ â¥à¥â ©â¨ ¨áå®¤ë¥ â¥ªáâë ¤«ï C--, |
¯®áª®«ìªã ç¨ âì á ã«ï ¦¥« ¨ï ¥ ¡ë«®. |
â ª, ª®à®âª® ® £« ¢®¬. ᮢ®© ¯à¨æ¨¯ ¯®áâ஥¨ï ¯à¨«®¦¥¨© |
¤«ï 32-à §à冷© á¨á⥬ë, ¯à¥¤« £ ¥¬ë© ¢ à §«¨çëå ª®¬¯¨«ïâ®à å, |
§ ª«îç ¥âáï ¢ à §¤¥«¥¨¨ ª®¤ ¥áª®«ìª® ᥪ権: .text, .data, |
.idata, .reloc, .rsrc ¨ â.¤., ª®â®àë¥ áâà®ïâáï ¨§ á ¬¨å ¨á室ëå |
⥪á⮢ ¨ à §«¨çëå ä ©«®¢ ®¯¨á ¨© ¨ à¥áãàᮢ áâ ¤¨¨ ᡮન |
¯à®£à ¬¬®©-«¨ª®¢é¨ª®¬ (link). ® áã⨠¤¥« ®áâ « áì áâ à ï á奬 |
¯®áâ஥¨ï: compiler + linker -> exe-file. ஬¥ ⮣®, ¡®«ì让 ¡®à |
à §«¨çëå ¡¨¡«¨®â¥ª... ª®â®àë¥ ª ⮬㠦¥ áãé¥á⢥® ¬¥ïîâáï ®â |
¢¥àᨨ ª ¢¥àᨨ, ç⮠ᮢᥬ ¥ à ¤ã¥â. ¥á«¨ ¢ë ¯¥à¥å®¤¨â¥ ®¢ãî, |
¡®«¥¥ ¯à®¤¢¨ãâãî ¢¥àá¨î ª®¬¯¨«ïâ®à , â® ¥â ¨ª ª®© £ à ⨨, çâ® |
¢ë ᬮ¦¥â¥ ¥¬ ¯¥à¥ª®¬¯¨«¨à®¢ âì ᢮¨ áâ àë¥ ¯à®£à ¬¬ë - ¯à¨¬¥à®¬ |
á«ã¦¨â DDK ®â MicroSoft. |
Sphinx C-- ¨§ ç «ì® ¡ë« § ¤ã¬ ¨ ॠ«¨§®¢ ¤«ï ᮧ¤ ¨ï |
ª®¬¯ ªâëå ¯® à §¬¥àã COM-ä ©«®¢ ¨ ¯®í⮬㠢¯®«¥ ¯®¤å®¤¨â ¤«ï |
£¥¥à 樨 32-à §àï¤ëå ¯à¨«®¦¥¨ï ¢ ¬®¤¥«¨ ¯«®áª®© (flat) ¯ ¬ïâ¨. |
®¬¨¬® í⮣® ¡®«ì訬 ¯«îᮬ ï¥âáï ¨¤¥ï ®âªàë⮣® ª®¤ ¤«ï ¢á¥å |
¢ë§ë¢ ¥¬ëå ¢ ¯à®£à ¬¬¥ ¡¨¡«¨®â¥çëå äãªæ¨©, ॠ«¨§®¢ ï ¯®á।á⢮¬ |
*.h-- ä ©«®¢. |
é¥ ®¤ ¨¤¥ï ¨§ ª®¬¯¨«ïâ®à Sphinx C--, § á«ã¦¨¢ îé ï ¢¨¬ ¨ï, - íâ® |
¤¨ ¬¨ç¥áª¨¥ ¯à®æ¥¤ãàë, â.¥. ¯à®æ¥¤ãàë, ª®â®àë¥ ¬®£ãâ ¡ëâì ¯®¬¥é¥ë ¢ ⥫® |
ª®¬¯¨«¨à㥬®© ¯à®£à ¬¬ë ⮫쪮 ⮣¤ , ª®£¤ ª ¨¬ ¥áâì ®¡à 饨¥. ª¨¬ |
®¡à §®¬, ¢ ¯à®æ¥áᥠ¯¨á ¨ï ¯à®£à ¬¬ë á ¨á¯®«ì§®¢ ¨¥¬ ¤¨ ¬¨ç¥áª¨å |
¯à®æ¥¤ãà £ à â¨àã¥âáï ¢ª«î票¥ ¢ ⥫® ¯à®£à ¬¬ë ⮫쪮 ⮣® ª®¤ , |
ª®â®àë© ¤¥©áâ¢¨â¥«ì® ¥®¡å®¤¨¬. |
¯à®æ¥áá¥ à ¡®âë ¯® ¯¥à¥¢®¤ã ª®¬¯¨«ïâ®à Sphinx C-- ¯« âä®à¬ã Win32 |
¯à®¨§¢¥¤¥ë ¢¥áì¬ áãé¥áâ¢¥ë¥ ¨§¬¥¥¨ï ª ª ¢ á ¬®¬ ª®¬¯¨«ïâ®à¥, â ª ¨ ¢ |
¨¤¥ïå, ª®â®àëå ® ॠ«¨§®¢ . ¥ ¡ã¤ã §¤¥áì ¢ë¤¥«ïâì ¢á¥ ®â«¨ç¨ï |
áâ®ï饣® ª®¬¯¨«ïâ®à ®â ¥£® ¯à த¨â¥«ï ¯® ⮩ ¯à®á⮩ ¯à¨ç¨¥, çâ® â¥, ªâ® |
á ¨¬ § ª®¬, ¨å ᬮ£ãâ 㢨¤¥âì á ¬¨, ⥬, ªâ® ¥ ¨¬¥« ¤¥« á --, ¥â 㦤ë |
¢¨ª âì ¢ í⨠¤¥â «¨. |
⬥çã, ®¤ ª®, çâ® ¯à¨æ¨¯ £¥¥à 樨 ª®¤ , ¨á¯®«ì§®¢ ¢è¨©áï ¢ --, § ¬¥¥ |
¯à¨æ¨¯, ¨á¯®«ì§ã¥¬ë© ¢ ¬ ªà® áᥬ¡«¥à¥ TMA ¢¥ «®§¥ (TMA macro assembler |
Sven Klose), á ¯à®¢¥¤¥¨¥¬ ¥£® ¤ ¯â 樨 ª 㦤 ¬ --. |
१ã«ìâ ⥠¯®ï¢¨«áï ¤ ë© ª®¬¯¨«ïâ®à, 楫ìî ª®â®à®£® ï¥âáï § ¯®«¥¨¥ |
¨è¨ ¬¥¦¤ã ï§ëª®¬ áᥬ¡«¥à ¨ ï§ëª®¬ . |
¯¨á ¨¥ ï§ëª . |
¤¥â¨ä¨ª â®àë. |
¤¥â¨ä¨ª â®àë ¤®«¦ë ç¨ âìáï á ¡ãª¢ë ¨«¨ § ª ¯®¤ç¥àª¨¢ ¨ï, ¥á«¨ |
ïîâáï £«®¡ «ì묨, ¨«¨ ¦¥ ¤®«¦ë ç¨ âìáï á ᨬ¢®« @, ¥á«¨ ®¨ «®ª «ìë¥. |
«¥¥ ¬®¦¥â ¨¤â¨ «î¡ ï ª®¬¡¨ æ¨ï æ¨äà, ¡ãª¢ ¨«¨ § ª®¢ ¯®¤ç¥àª¨¢ ¨ï ¤«¨®© |
¥ ¡®«¥¥ 63 ᨬ¢®«®¢. ãª¢ë ¬®£ãâ ¡ëâì ª ª ¨§ « â¨áª®£®, â ª ¨ ¨§ 樮 «ì®£® |
«ä ¢¨â . ¥áª®«ìª® ¯à¨¬¥à®¢: |
GoHome |
_1234 |
ਬ¥à¤¥â¨ä¨ª â®à |
@LocalLabel2 |
ᥠ¨¤¥â¨ä¨ª â®àë, ªà®¬¥ § १¥à¢¨à®¢ ëå, ïîâáï çã¢á⢨⥫ì묨 ª |
ॣ¨áâàã, â.¥. ¨¤¥â¨ä¨ª â®àë: ToDo ¨ Todo ª®¬¯¨«ïâ®à ¢®á¯à¨¬¥â ª ª à §ë¥. |
१¥à¢¨à®¢ ë¥ ¨¤¥â¨ä¨ª â®àë |
¨¦¥ ¯à¨¢®¤¨âáï ᯨ᮪ § १¥à¢¨à®¢ ëå ¨¤¥â¨ä¨ª â®à®¢ ï§ëª , ª®â®àë¥ |
¥ ¬®£ãâ ¡ëâì ¨á¯®«ì§®¢ ë ¯à¨ á®§¤ ¨¨ ¯à®£à ¬¬ë ¨ ç¥, ª ª íâ® ®¯à¥¤¥«¥® |
¢ ï§ëª¥: |
byte char word short dword int |
if else cycle do while return |
docase case continue break extract from |
enum struct |
carryflag overflow zeroflag |
notcarryflag notoverflow notzeroflag |
â ª¦¥ §¢ ¨ï ॣ¨áâ஢ ¨ ¬¥¬®¨ª¨ ª®¬ ¤ áᥬ¡«¥à . |
é¥ à § ¯®¤ç¥àªã, çâ® § १¥à¢¨à® ë¥ á«®¢ ¥ § ¢¨áïâ ®â ॣ¨áâà , â.¥. |
Enum ¨ eNuM ª®¬¯¨«ïâ®à ¢®á¯à¨¬¥â ¢ «î¡®¬ ¨§ ¢ ਠ⮢, ª ª ç «® ᯨ᪠|
㬥஢ ëå ª®áâ â. |
®áâ âë |
¨á«®¢ë¥ ª®áâ âë ¬®£ãâ ¡ëâì § ¤ ë ¢ ®¤®© ¨§ ç¥âëà¥å á¨á⥬ áç¨á«¥¨ï: |
¤¥áïâ¨ç®©, è¥áâ ¤æ â¨à¨ç®©, ¢®á¬¥à¨ç®© ¨«¨ ¤¢®¨ç®©. |
¥áïâ¨çë¥ ç¨á«®¢ë¥ ª®áâ âë § ¤ îâáï ®¡ëçë¬ ®¡à §®¬: 444 ¨«¨ 007. |
¥áâ ¤æ â¨à¨ç®¥ ¯à¥¤áâ ¢«¥¨¥ ª®áâ â ç¨ ¥âáï á ª®¬¡¨ 樨 0x: 0xFFF |
¨«¨ 0x088. |
®á¬¥à¨ç®¥ ¯à¥¤áâ ¢«¥¨¥ ª®áâ â ç¨ ¥âáï á ª®¬¡¨ 樨 0o: 0o777 ¨«¨ |
0o10. |
¢®¨ç®¥ ¯à¥¤áâ ¢«¥¨¥ ª®áâ â ç¨ ¥âáï á ª®¬¡¨ 樨 0b: 0b111101 ¨«¨ |
0b11101010. |
¨¬¢®«ë ¢ ª®áâ â å § ª«îç îâáï ¢ ®¤¨®çë¥ ª ¢ë窨 ('). ª ¦¥ ª ª ¨ ¢ |
ᨬ¢®«ë ¬®£ãâ § ¤ ë á ¯®¬®éìî 㪠§ ¨ï ¨å ª®¤ ¯®á«¥ ᨬ¢®« '\'. ¯¨á®ª |
ᯥæᨬ¢®«®¢: |
'\a', '\b', '\f', '\l', '\n', '\r', '\t' - ¤«ï ä®à¬ â¨à®¢ ¨ï ¢ë¢®¤ |
'\x??' ¨«¨ '\???' - ASCII-ᨬ¢®«. ®¤ ᨬ¢®« § ¤ «¨¡® ¢ 16, 10 § 票¥¬. |
î¡ë¥ ᨬ¢®«ë ¯®á«¥ '\' ¯à®áâ® ¯à¨¨¬ îâáï ª®¬¯¨«ïâ®à®¬, â ª¨¬ ®¡à §®¬ |
®¤¨®çãî ª ¢ëçªã ¬®¦® 㪠§ âì ª ª '\''. |
âப®¢ë¥ ª®áâ âë § ¤ îâáï ¯ã⥬ § ª«îç¥¨ï ¨å ¢ ¤¢®©ë¥ ª ¢ë窨 ("). |
ãâਠáâப®¢®© ª®áâ âë ¤®¯ã᪠¥âáï 㪠§ ¨¥ ᯥæᨬ¢®«®¢ ¢ ®¤¨®çëå |
ª ¢ëçª å. ਬ¥àë áâப®¢ëå ª®áâ â: |
"ਬ¥à áâப®¢®© ª®áâ âë\n" |
"Need '\"'word'\"' in data declaration" -> Need "word" in data declaration |
ਠ®¯à¥¤¥«¥¨¨ ç¨á«®¢ëå ¨ ᨬ¢®«ìëå ª®áâ â ¤®¯ã᪠¥âáï ¨á¯®«ì§®¢ ¨¥ |
¢ëà ¦¥¨©, ª®â®àë¥ ¢ëç¨á«ïîâáï ¢ ¯à®æ¥áᥠª®¬¯¨«ï樨. 票¥¬ ª®áâ âë |
¡ã¤¥â १ã«ìâ â ¢ëç¨á«¥¨ï ¢ëà ¦¥¨ï: |
1*2*3/2+4 ¤ áâ § 票¥ ª®áâ âë 7. |
ëç¨á«¥¨ï ¯à®¢®¤ïâáï á«¥¢ - ¯à ¢® ¡¥§ ãç¥â ¯à¨®à¨â¥â ®¯¥à 権. |
â ¤ àâë¥ â¨¯ë ¤ ëå |
¬¥¥âáï è¥áâì áâ ¤ àâëå ⨯®¢ ¤ ëå: byte, char, word, short, dword |
¨ int. â ¡«¨æ¥ ¯à¨¢¥¤¥ë à §¬¥à ¨ ¤¨ ¯ §® § 票© ¤«ï ª ¦¤®£® ⨯ : |
------------------------------------------------------------------- |
¨¯ | §¬¥à | ¨ ¯ §® § 票© |
¯¥à¥¬¥®© | ¢ ¡ ©â å | (¤¥áïâ¨ç.) | (hex) |
------------------------------------------------------------------- |
byte | 1 | 0...255 | 0...0xFF |
char | 1 | -127...127 | 0x80...0x7F |
word | 2 | 0...65535 | 0...0xFFFF |
short | 2 | -32768...32767 | 0x8000...0x7FFF |
dword | 4 | 0...4294967295 | 0...0xFFFFFFFF |
int | 4 | -2147483648... | 0x80000000 ... |
| | 2147483647 | 0x7FFFFFFF |
------------------------------------------------------------------- |
«®¡ «ìë¥ ¯¥à¥¬¥ë¥ |
¡ê¥¨¥ ¯¥à¥¬¥ëå ¨¬¥¥â ®¡ëçë© ¤«ï á¨â ªá¨á: |
<⨯> <ᯨ᮪ ¨¤¥â¨ä¨ª â®à®¢>; |
¯¨á®ª ¨¤¥â¨ä¨ª â®à®¢ á®á⮨⠨§ ®¤®£® ¨«¨ ¡®«¥¥ ¨¤¥â¨ä¨ª â®à®¢, |
à §¤¥«¥ëå § ¯ïâ묨. ᯨ᪥ â ª¦¥ ¬®£ãâ ¯à¨áãâ᢮¢ âì ®¤®¬¥àë¥ ¬ áᨢë, |
®¡êï¢«ï¥¬ë¥ ¢ ¢¨¤¥: |
<¨¤¥â¨ä¨ª â®à>[<à §¬¥à®áâì>]. |
ਬ¥àë ®¡ê¥¨© ¯¥à¥¬¥ëå: |
dword i,j; // i ¨ j ⨯ dword |
byte Tab='\t'; // ¯¥à¥¬¥ ï Tab ⨯ byte á ç «ìë¬ § 票¥¬ |
char string[]="This is a string\n"; |
int z,b[6]; // z ⨯ int ¨ ¬ áᨢ 楫ëå - b |
ëà ¦¥¨ï |
ëà ¦¥¨ï á®áâ®ïâ ¨§ «¥¢®© ¨ ¯à ¢®© ç á⥩, à §¤¥«¥ëå «¨¡® ®¯¥à 樥© |
¯à¨á¢ ¨¢ ¨ï, «¨¡® ®¯¥à 樥© áà ¢¥¨ï. ¥¢ ï ç áâì ¢ëà ¦¥¨ï ¬®¦¥â ¡ëâì |
«¨¡® ¯¥à¥¬¥®©, «¨¡® ॣ¨áâ஬. ¯à ¢®© ç á⨠¢ëà ¦¥¨ï ¬®¦¥â 室¨âìáï |
¯à®¨§¢®«ì®¥ ª®«¨ç¥á⢮ ¯¥à¥¬¥ëå, äãªæ¨©, ª®áâ â, ᪮¡®ª ¨ § ª®¢ ®¯¥à 権. |
¨¦¥ ¯à¨¢®¤¨âáï â ¡«¨æ ¢á¥å ¤®¯ãá⨬ëå ®¯¥à 権: |
------------------------------------------------------------------------- |
¯¥à æ¨ï | 票¥ | ਬ¥à |
------------------------------------------------------------------------- |
= | ¯à¨á¢®¨âì ¨«¨ | edi = 33; |
| ¯à®¢¥à¨âì à ¢¥á⢮ | while(ch = 'a') |
+ | á«®¦¨âì | eax = Count + 5; |
- | ¢ëç¥áâì | Count = eax - edi; |
* | 㬮¦¨âì | x = y * 3; |
/ | à §¤¥«¨âì | y = ecx / x; |
% | ®áâ ⮪ ¤¥«¥¨ï | y = edi / 7; |
& | «®£¨ç¥áª®¥ AND | a = B & c; |
| | «®£¨ç¥áª®¥ OR | a = B | c; |
^ | «®£¨ç¥áª®¥ XOR | a = B ^ c; |
<< | ᤢ¨£ ¡¨â ¢«¥¢® | x = y << 5; |
>> | ᤢ¨£ ¡¨â ¢¯à ¢® | x = y >> 6; |
+= | 㢥«¨ç¨âì | a += 6; // a = a + 6; |
-= | 㬥ìè¨âì | a -= 5; // a = a - 5; |
&= | ¯®¡¨âë© AND | a &= 0xF; // a = a & 0xF; |
|= | ¯®¡¨âë© OR | a |= 0o77; // a = a | 0o77; |
^= | ¯®¡¨âë© XOR | a ^= 0b1101; // a = a ^ 0b1101; |
<<= | ᤢ¨£ ¡¨â ¢«¥¢® | a <<= 7; // a = a << 7; |
>>= | ᤢ¨£ ¡¨â ¢¯à ¢® | a >>= 3; // a = a >> 3; |
>< | ®¡¬¥(swap) | x >< y; // temp=y; y=x; x=temp; |
== | ¯à®¢¥à¨âì à ¢¥á⢮ | if( x=='7' ) // ¤«ï â¥å, ª®¬ã â ª ¯à¨¢ë祥 |
> | ¡®«ìè¥ ç¥¬ | case( x > y ) |
< | ¬¥ìè¥ ç¥¬ | if( a < 0 ) |
>= | ¡®«ìè¥ ¨«¨ à ¢® | while(( b >= a ) & ( x >= ( y - 7 ))) |
<= | ¬¥ìè¥ ¨«¨ à ¢® | if( y <= ( a + b - 30 )) |
!= ¨«¨ <>| ¥ à ¢® | case( a != b) ¨«¨ ¦¥ case( a <> b) |
# | ¤à¥á ¯¥à¥¬¥®© | esi = #Count; // esi= ¤à¥á ¯¥à¥¬¥®© Count |
ãªæ¨¨ |
¡ê¥¨¥ äãªæ¨© ¨¬¥¥â ¢¨¤: |
<⨯> <¨¤¥â¨ä¨ª â®à>(<ᯨ᮪ ¯ à ¬¥â஢>) |
¯¨á®ª ¯ à ¬¥â஢ § ¤ ¥â â¨¯ë ¨ ¨¬¥ ä®à¬ «ìëå ¯ à ¬¥â஢, ¨á¯®«ì§ã¥¬ëå ¯à¨ |
¢ë§®¢¥ äãªæ¨¨. ®¬¯¨«ïâ®à ¥ ®áãé¥á⢫ï¥â ¯à®¢¥àªã ᮮ⢥âá⢨ï ᯨ᪠|
ä®à¬ «ìëå ¯ à ¬¥â஢ äãªæ¨¨ ä ªâ¨ç¥áª¨¬, ¯®í⮬ã á«¥¤ã¥â ¢¨¬ â¥«ì® á«¥¤¨âì |
§ ª®à४â®áâìî ¢ë§®¢ äãªæ¨©. |
¨¯ ¢®§¢à é ¥¬®£® ¨§ äãªæ¨¨ § ç¥¨ï ¬®¦® ¥ 㪠§ë¢ âì. í⮬ á«ãç ¥ |
¯® 㬮«ç ¨î áç¨â ¥âáï, çâ® äãªæ¨ï ¢®§¢à é ¥â § 票¥ ⨯ dword. 票¥ |
¯®¬¥é ¥âáï ¯à¨ ¢®§¢à ⥠¨§ äãªæ¨¨ ¢ ॣ¨áâà eax ¤«ï ⨯®¢ dword ¨ int, ¢ |
ॣ¨áâà ax ¤«ï ⨯®¢ word ¨ short ¨ ¢ ॣ¨áâà al ¤«ï ⨯®¢ byte ¨ char. |
ᯨ᪥ ¯ à ¬¥â஢ ¤«ï ª ¦¤®£® ¯ à ¬¥âà 㪠§ë¢ ¥âáï ¥£® ⨯. à ¬¥âàë |
®¤®£® ⨯ , ¨¤ã騥 ¯®¤àï¤, à §¤¥«ïîâáï § ¯ïâ묨. ®à¬ «ìë¥ ¯ à ¬¥âàë à §®£® |
⨯ ¢ ®¡ê¥¨¨ äãªæ¨¨ à §¤¥«ïîâáï ᨬ¢®«®¬ ;. ᫨ ⨯ ¯ à ¬¥âà ¥ § ¤ , |
â® áç¨â ¥âáï, çâ® ¯ à ¬¥âà ¨¬¥¥â ⨯ dword. ¥ § ¢¨á¨¬® ®â ⨯ ¯ à ¬¥âà ¯à¨ |
¢ë§®¢¥ äãªæ¨¨ ¤«ï ª ¦¤®£® ¯ à ¬¥âà ¢ë¤¥«ï¥âáï 4 ¡ ©â (dword). â® á¢ï§ ® |
á ⥬, çâ® ¢ Win32 á⥪ ¢á¥£¤ ¤®«¦¥ ¨¬¥âì ¢ëà ¢¨¢ ¨¥ (alignment) £à ¨æã |
¤¢®©®£® á«®¢ . |
ਬ¥àë ®¡ê¥¨ï äãªæ¨© ¨ ¨å ¢ë§®¢®¢. |
¡ê¥¨¥ ਬ¥à ¢ë§®¢ |
char ToUpper(char ch) upChar = ToUpper('i'); |
MergeStrings(dword dest,str1,str2) MergeStrings(#str,"One","+Two"); |
¯®«ã稬 str="One+Two" |
Convert(dword str; int number,base) Convert(#num, -567, 16); |
ਠ¢ë§®¢¥ äãªæ¨¨ ¯¥à¢ë© ¯ à ¬¥âà ¯®¬¥é ¥âáï ¢ á⥪ ¯®á«¥¤¨¬. ਬ¥à: |
WriteFile(handle,"Hello World!\n",14,#dWriteFileCount,0); |
¡ã¤¥â ॠ«¨§®¢ : |
push 0 |
push #dWriteFileCount |
push 14 |
push #"Hello World!" |
push handle |
call WriteFile |
ਠ¢®§¢à ⥠¨§ äãªæ¨¨ á⥪ ®ç¨é ¥âáï ®â ¯ à ¬¥â஢ ª®¬ ¤®©: ret number. |
ᥠ®¡êï¢«ï¥¬ë¥ ¢ ¯à®£à ¬¬¥ äãªæ¨¨ ïîâáï ¤¨ ¬¨ç¥áª¨¬¨. â® § ç¨â, |
çâ® ª®¤ äãªæ¨¨ ¢áâ ¢«ï¥âáï ¢ ¯à®£à ¬¬ã «¨èì ⮫쪮 ¢ á«ãç ¥ ®¡à é¥¨ï ª ¥©. |
® ¦¥ á ¬®¥ ®â®á¨âáï ¨ ª «î¡ë¬ £«®¡ «ìë¬ ¯¥à¥¬¥ë¬ ¢ ¯à®£à ¬¬¥. |
âàãªâãàë¥ ®¯¥à â®àë |
ਬ¥¥¨¥ áâàãªâãàëå ®¯¥à â®à®¢ ¢ ¯à®£à ¬¬¥ ¤¥« ¥â ¥¥ ¡®«¥¥ 㤮¡®© ¤«ï |
çâ¥¨ï ¨ «¨§ . ஬¥ ⮣®, ¯¨á âì ¥áª®«ìª® áâàãªâãàëå ®¯¥à â®à®¢ ¯à®é¥, |
祬 ¯ãâ âìáï ¢ ¯®å®¦¨å ¨¬¥ å ¡®«ì讣® ç¨á« ¬¥â®ª ¨ ¬ãç¨âìáï, ¯à¨¤ã¬ë¢ ï |
㨪 «ì®¥ ¨¬ï ¤«ï ª ¦¤®© ®¢®© ¬¥âª¨. â® ¦¥ ¢à¥¬ï ¥ § ¯à¥é ¥âáï ¨á¯®«ì§®¢ âì |
¨ ¬¥âª¨ ¢ «î¡®¬ ¬¥á⥠¯à®£à ¬¬ë. ®à®è® ¯®áâ ¢«¥ ï ¬¥âª ᯮᮡ §¤®à®¢® |
®¡«¥£ç¨âì ¯¨á ¨¥ ¨ «¨§ ¯à®£à ¬¬ë. |
¯¥à â®à if. |
®¡é¥¬ ¢¨¤¥ ãá«®¢ë© ®¯¥à â®à ¬®¦® § ¯¨á âì â ª: |
if(<ãá«®¢¨¥>) |
<£à㯯 ®¯¥à â®à®¢1> |
else |
<£à㯯 ®¯¥à â®à®¢2> |
«£®à¨â¬ ¢ë¯®«¥¨ï ãá«®¢®£® ®¯¥à â®à á®á⮨⠢ á«¥¤ãî饬: |
¯à®¢¥àï¥âáï <ãá«®¢¨¥>, ¨ ¥á«¨ ®® ¨á⨮, â® ¢ë¯®«ï¥âáï <£à㯯 ®¯¥à â®à®¢1>, |
á«¥¤ãîé ï § if, ¯®á«¥ 祣® ã¯à ¢«¥¨¥ ¯¥à¥¤ ¥âáï § ª®¥æ ãá«®¢®£® ®¯¥à â®à . |
᫨ ãá«®¢¨¥ «®¦®, â® ã¯à ¢«¥¨¥ ¯¥à¥¤ ¥âáï <£à㯯㠮¯¥à â®à®¢2>, á«¥¤ãîéãî |
§ else. ®à冷ª ¢ë¯®«¥¨ï ãá«®¢®£® ®¯¥à â®à ¢ á«ãç ¥ ®âáãâá⢨ï else |
®ç¥¢¨¤¥. ª ç¥á⢥ £àã¯¯ë ®¯¥à â®à®¢ ¬®¦¥â ¡ëâì «¨¡® ®¤¨ ®¯¥à â®à, «¨¡® ¡«®ª |
¨§ ¥áª®«ìª¨å ®¯¥à â®à®¢ ¢ {} ᪮¡ª å. ®â ¥áª®«ìª® ¯à¨¬¥à®¢: |
if(edx<=2){ |
WriteStr("Equal or less two\n"); |
return(); |
} |
else{ |
WriteStr("Greater than two\n"); |
return(0); |
} |
if((x<>0)&(y<>0)) |
return(x/y); |
¯¥à â®à cycle |
¯¥à â®à 横« cycle ¨¬¥¥â ¢¨¤: |
cycle(<áç¥â稪>) <£à㯯 ®¯¥à â®à®¢> |
¨ª« ¢ë¯®«ï¥âáï ¤® â¥å ¯®à ¯®ª § 票¥ áç¥â稪 ¥ ¡ã¤¥â à ¢® ã«î. |
஢¥àª áç¥â稪 à ¢¥á⢮ ã«î ¨ ¥£® 㬥ì襨¥ ¥¤¨¨æ㠯ந§¢®¤¨âáï |
¢ ª®æ¥ £àã¯¯ë ®¯¥à â®à®¢ 横« . ®¯ã᪠¥âáï ¢ãâਠ横« ¨á¯®«ì§®¢ âì ¨ ¬¥ïâì |
§ 票¥ áç¥â稪 . ᫨ áç¥â稪 ¥ 㪠§ , ⮠横« ¡ã¤¥â ¡¥áª®¥çë¬. ਬ¥à: |
#import "kernel32.dll" |
#import "user32.dll" |
dword Count; |
dword dWriteFileCount; |
dword handle; |
byte s[20]=0; |
main(){ |
handle=GetStdHandle(-11); |
Count=4; |
cycle(Count){ |
if(Count=2) |
Count--; |
wsprintfA(#s,"Count=%d\n",Count); ESP+=12; |
WriteFile(handle,#s,lstrlenA(#s),#dWriteFileCount,0); |
} |
} |
ਠ¢ë¯®«¥¨¨ ¡ã¤¥â ¢ë¢¥¤¥®: |
Count=4 |
Count=3 |
Count=1 |
¯¥à â®à while |
¯¥à â®à 横« while ¨¬¥¥â ¢¨¤: |
while(<ãá«®¢¨¥>) |
<£à㯯 ®¯¥à â®à®¢> |
à㯯 ®¯¥à â®à®¢ ¢ 横«¥ while ¢ë¯®«ï¥âáï ¯®ª <ãá«®¢¨¥> ®áâ ¥âáï |
¨áâ¨ë¬. ਬ¥à ¨§ ®¯¨á ¨ï ®¯¥à â®à cycle ¬®¦¥â ¡ëâì ॠ«¨§®¢ á ¯®¬®éìî |
while á«¥¤ãî騬 ®¡à §®¬: |
Count=4; |
while(Count){ |
if(Count=2) |
Count--; |
wsprintfA(#s,"Count=%d\n",Count); ESP+=12; |
WriteFile(handle,#s,lstrlenA(#s),#dWriteFileCount,0); |
Count--; |
} |
} |
¯¥à â®à do ... while |
¯¥à â®à 横« do ... while ¨¬¥¥â ¢¨¤: |
do |
<£à㯯 ®¯¥à â®à®¢> |
while(<ãá«®¢¨¥>) |
à㯯 ®¯¥à â®à®¢ ¢ 横«¥ do ... while ¢ë¯®«ï¥âáï ¯®ª <ãá«®¢¨¥> ®áâ ¥âáï |
¨áâ¨ë¬. ਬ¥à ¨§ ®¯¨á ¨ï ®¯¥à â®à cycle ¬®¦¥â ¡ëâì ॠ«¨§®¢ á ¯®¬®éìî |
do ... while á«¥¤ãî騬 ®¡à §®¬: |
Count=4; |
do{ |
if(Count=2) |
Count--; |
wsprintfA(#s,"Count=%d\n",Count); ESP+=12; |
WriteFile(handle,#s,lstrlenA(#s),#dWriteFileCount,0); |
Count--; |
} while(Count) |
} |
ᮡ¥®áâìî ®¯¥à â®à do ... while ï¥âáï â®, çâ® <£à㯯 ®¯¥à â®à®¢> |
¢ 横«¥ ¢á¥£¤ ¢ë¯®«ï¥âáï ¥ ¬¥¥¥ ®¤®£® à § . |
¯¥à â®à docase |
¯¥à â®à ¢¥â¢«¥¨ï docase ¨¬¥¥â ¢¨¤: |
docase |
<£à㯯 ®¯¥à â®à®¢ 0> |
case(<ãá«®¢¨¥1>) |
<£à㯯 ®¯¥à â®à®¢ 1> |
... |
case(<ãá«®¢¨¥N>) |
<£à㯯 ®¯¥à â®à®¢ N> |
default |
<£à㯯 ®¯¥à â®à®¢ N1> |
¯¥à â®à docase ¯®§¢®«ï¥â § ¬¥¨âì ¢«®¦¥ë¥ £àã¯¯ë ¨§ if ... else if ... |
else ... . ஬¥ ⮣® ¤ «¥¥ ¡ã¤¥â ¯®ª § ¯à¨¬¥à¥ 㨢¥àá «ì®áâì í⮣® |
®¯¥à â®à . ਬ¥à ¨§ ®¯¨á ¨ï ®¯¥à â®à cycle ¬®¦¥â ¡ëâì ॠ«¨§®¢ á ¯®¬®éìî |
docase á«¥¤ãî騬 ®¡à §®¬: |
Count=4; |
docase{ |
if(Count=2) |
Count--; |
wsprintfA(#s,"Count=%d\n",Count); ESP+=12; |
WriteFile(handle,#s,lstrlenA(#s),#dWriteFileCount,0); |
Count--; |
case(Count=0) |
break; |
default |
continue; |
} |
} |
¯¥à â®àë continue ¨ break |
⨠®¯¥à â®àë ¨á¯®«ì§ãîâáï ¢ãâਠ¢ëè¥ ®¯¨á ëå ®¯¥à â®à®¢ 横« cycle, |
while, do...while ¨ ®¯¥à â®à¥ docase ¤«ï ¯¥à¥å®¤ ç «® 横« ¨«¨ docase |
¯® ®¯¥à â®àã continue ¨ ¢ë室 § ª®¥æ ®¯¥à â®à ¯® break. ਬ¥à: |
while(cond1){<--Ô |
... | |
if(cond2) | |
continue; --+ |
... | |
if(cond3) | |
break; ---+ | |
... | | |
} ----------|-+ |
<----------+ |
¯¥à â®à enum |
§ 票¥ ®¯¥à â®à § ª«îç ¥âáï ¢ ᮧ¤ ¨¨ £à㯯 㬥஢ ëå ª®áâ â. |
ਬ¥à: |
enum { ab, ac=2, ad, ae=6}; ¯à¨ í⮬ ¡ã¤¥â: ab=0, ac=2, ad=3, ae=6. |
¯¥à â®à struc |
«ã¦¨â ¤«ï ®¯¨á ¨ï áâàãªâãà¨à®¢ ëå ¤ ëå, «®£¨ç® . |
®ª ¥ ॠ«¨§®¢ . ®¦®, ¨á¯®«ì§ãï enum, ¡¥§ ¢áïª¨å ¯à®¡«¥¬ à ¡®â âì á |
¤ 묨 «î¡®© áâàãªâãàë. ਬ¥à: |
«ï ¨á¯®«ì§®¢ ¨ï áâàãªâãàë: |
struct localrec{ |
struct localrec *next; |
char localid[IDLENGTH]; |
int localtok; |
int localnumber; |
}; |
ᮧ¤ ¤¨¬: |
// ---- âàãªâãà localrec - ®¯¨á ¨¥ «®ª «ì®© ¯¥à¥¬¥®© |
enum{ localnext=0, // ª § ⥫ì á«¥¤ãîéãî localrec |
localid=4, // ¬ï «®ª «ì®© ¯¥à¥¬¥®© |
localtok=localid+IDLENGTH, // 票¥ token |
localtype=localtok+4, // ⨯ ¯¥à¥¬¥®© |
localnumber=localtype+4, // ®§¨æ¨ï ¢ á⥪¥ |
local_size=localnumber+4}; // §¬¥à áâàãªâãàë |
⥯¥àì ¢ ¯à®£à ¬¬¥ ¬®¦® ¨á¯®«ì§®¢ âì 㬥஢ ë¥ ª®áâ âë ¤«ï ®¡à 饨ï |
ª í«¥¬¥â ¬ áâàãªâãàë localrec: |
// ---- ®¡ ¢¨âì «®ª «ìãî ¯¥à¥¬¥ãî ¢ ᯨ᮪ |
AddLocalvar(dword str,tk,ltype,num) |
dword ptr,newptr; |
{ |
newptr=LocalAlloc(0x40, local_size); |
if(newptr==NULL){ |
preerror("Compiler out of memory for local symbol linked list"); |
ExitProcess(e_outofmemory); |
} |
if(locallist==NULL) |
locallist = newptr; |
else{ |
ptr = locallist; EBX=ptr; |
docase{ |
EAX=[EBX+localnext]; |
case(EAX!=0){ |
EBX=EAX; continue; |
} |
} |
[EBX+localnext]=newptr; |
} |
EBX=newptr; lstrcpyA(EBX+localid, str); |
EBX=newptr; [EBX+localtok] = tk; [EBX+localtype] = ltype; |
[EBX+localnumber] = num; [EBX+localnext] = NULL; localptr = EBX; |
} |
¥âª¨ |
ॡ®¢ ¨ï ª ¨¬¥ ¬ ¬¥â®ª ⥠¦¥, çâ® ¨ ª ¨¤¥â¨ä¨ª â®à ¬. ᪫î票¥¬ |
ïîâáï «®ª «ìë¥ ¬¥âª¨ - ®¨ ¤®«¦ë ç¨ âìáï á ᨬ¢®« '@'. ®ª «ìë¥ |
¬¥âª¨ ¤®áâã¯ë ⮫쪮 ¢ ¯à¥¤¥« å ⮩ äãªæ¨¨, ¢ ª®â®à®© ®¨ ®¯à¥¤¥«¥ë, |
£«®¡ «ìë¥ - ¯® ¢á¥© ¯à®£à ¬¬¥. ਠᮧ¤ ¨¨ ¨¬¥ «®ª «ìëå ¬¥â®ª á«¥¤ã¥â |
ãç¨âë¢ âì, çâ® ª®¬¯¨«ïâ®à ¯à¨ ॠ«¨§ 樨 áâàãªâãàëå ®¯¥à â®à®¢ £¥¥à¨àã¥â |
¬¥âª¨ ¢¨¤ : @l<ç¨á«®>. â®¡ë ¨§¡¥¦ âì ª®««¨§¨©, á«¥¤ã¥â ¤«ï ᢮¨å ¬¥â®ª ¥ |
¯à¨¬¥ïâì â ª®£® ¢¨¤ . î¡ ï ¬¥âª § ¢¥àè ¥âáï ᨬ¢®«®¬ ¤¢®¥â®ç¨ï (:). |
ਬ¥àë ¬¥â®ª: |
NotUpperCase: // íâ® £«®¡ «ì ï ¬¥âª |
@NotUpperCase: // íâ® «®ª «ì ï ¬¥âª |
¤¥ªá æ¨ï ¬ áᨢ®¢ |
«¥¬¥âë ¬ áᨢ «î¡®£® ⨯ ¨¤¥ªá¨àãîâáï ¢ ¡ ©â®¢ëå ¥¤¨¨æ å, ¥§ ¢¨á¨¬® |
®â ⨯ ¤ ëå. â® á«¥¤ã¥â ¯®¬¨âì ¯à¨ à ¡®â¥. ¤¥ªáë ¨¬¥îâ ¢¨¤, |
¯à¨ïâë© ¢ áᥬ¡«¥à¥ ¤«ï 386 CPU: |
<¯¥à¥¬¥ ï>[<¡ §®¢ë© ॣ¨áâà>+<¬ áèâ ¡>*<¨¤¥ªáë© à¥£¨áâà>+<¨¤¥ªá>] |
®â ¥áª®«ìª® ¯à¨¬¥à®¢: |
Str[7]; // ᥤ쬮© ¡ ©â ¨§ ¬ áᨢ Str |
IntArray[4*ebx]; // ebx í«¥¬¥â ¨§ ¬ áᨢ 楫ëå - IntArray |
ByteArray[esi+8*ecx+300]; |
¯¥æ¨ «ìë¥ ãá«®¢ë¥ ¢ëà ¦¥¨ï |
¬¥¥âáï è¥áâì á¯¥æ¨ «ìëå ãá«®¢ëå ¢ëà ¦¥¨©: |
CarryFlag, NotCarryFlag, Overflow, NotOverflow, ZeroFlag, NotZeroFlag. ¨ |
á«ã¦ â ¤«ï £¥¥à 樨 ª®¤ ¯à®¢¥àïî饣® á®áâ®ï¨¥ ä« £®¢ CPU. |
®¬¬¥â ਨ |
®¬¬¥â ਨ § ¤ îâáï «®£¨ç® . |
¨à¥ªâ¨¢ë ª®¬¯¨«ïâ®à |
ᥠ¤¨à¥ªâ¨¢ë ª®¬¯¨«ïâ®à ç¨ îâáï á ᨬ¢®« '#'. ¯¨á®ª ¤¨à¥ªâ¨¢ ¨ ¨å |
§ 票¥ ¯à¨¢®¤ïâáï ¨¦¥: |
#debug // 㪠§ë¢ ¥â ª®¬¯¨«ïâ®àã ¥®¡å®¤¨¬®áâì £¥¥à 樨 |
// ®â« ¤®ç®© ¨ä®à¬ 樨 ¤«ï ª®¬¯¨«¨à㥬®© ¯à®£à ¬¬ë |
#define // ®¯à¥¤¥«¨âì ª®áâ âã ¨«¨ ¨¤¥â¨ä¨ª â®à. ਬ¥à: |
// #define MAXLINES 400 |
// #define less < |
// #define SetTrue "eax=1" |
// if(lines less MAXLINES) --> if(lines<400) |
// SetTrue; --> eax=1; |
#dll // 㪠§ë¢ ¥â ª®¬¯¨«ïâ®àã £¥¥à æ¨î DLL-ä ©« . ¡ëç® - exe. |
#include // ¯®¤ª«î票¥ ä ©« á ¨áå®¤ë¬ â¥ªá⮬. «®£¨ç® . |
#import // ¨¬¯®àâ äãªæ¨© ¨§ DLL-ä ©« ¯® ¨¬¥¨. |
#importN // ¨¬¯®àâ äãªæ¨© ¨§ DLL-ä ©« ¯® ®¬¥àã. ਬ¥à ᬮâà¨â¥ ¢ |
// ®¯¨á ¨¨ áâàãªâãàëå ®¯¥à â®à®¢ cycle, while ¨ â.¤. |
#list // 㪠§ë¢ ¥â ª®¬¯¨«ïâ®àã £¥¥à æ¨î ä ©« á «¨á⨣®¬ (.lst) |
#map // 㪠§ë¢ ¥â ª®¬¯¨«ïâ®àã £¥¥à æ¨î map-ä ©« (.map) |
áâà®¥ë© áᥬ¡«¥à |
áᥬ¡«¥à ¯®¤¤¥à¦¨¢ ¥â ¡®«ìèãî ç áâì ¨áâàãªæ¨© ¨§ ¡®à 386, 486 ¨ 586 |
¯à®æ¥áá®à®¢. ¥¬®¨ª¨ áᥬ¡«¥à ¬®£ãâ ¡ëâì ¯®¬¥é¥ë ¢ãâਠ⥫ «î¡®© äãªæ¨¨ |
¡¥§ ª ª¨å-«¨¡® ®£à ¨ç¥¨©. ਬ¥à: |
// 뤥«¥¨¥ á«®¢ ¢ Dest ¨§ áâப¨ ᨬ¢®«®¢ Source |
dword GetWord(dword Source,Dest){ |
push esi; push edi; esi=Source; edi=Dest; |
// 饬 ¯¥à¢ë© ¥¯ãá⮩ ᨬ¢®« |
@up: lodsb; cmp al,' '; jz @up; // ஡¥« |
cmp al,0; jz @down // ®¥æ áâப¨ Source |
// ®¯¨à㥬 á«®¢® ¢ Dest |
@up1: stosb; cmp al,0; jz @down; // ®¥æ áâப¨ Source |
lodsb; cmp al,' '; jnz @up1; // ¥ ¯à®¡¥« |
al=0; jmp @up1 // ⬥⨬ ª®¥æ á«®¢ |
@down: |
// «®¢® ¢ë¤¥«¥® ¨ ᪮¯¨à®¢ ® ¢ Dest |
eax=esi-Source; eax--; // ëç¨á«¨¬ ¤«¨ã á«®¢ |
pop edi; pop esi // ®ááâ ®¢¨¬ esi ¨ edi |
} |
ª«î票¥ |
¥ ¢á¥ ¨§ ¢ë襮¯¨á ®£® ॠ«¨§®¢ ®. â® ®¡ãá«®¢«¥® ¢ ¯¥à¢ãî ®ç¥à¥¤ì ⥬, |
çâ® ¤ ï ¢¥àá¨ï ï¥âáï ¯à¥¤¢ à¨â¥«ì®© ¨ ®á®¢®© ¥¥ 楫ìî ï¥âáï |
¢ë¥¨¥ ¨â¥à¥á ª®¬¯ìîâ¥à®© ®¡é¥á⢥®á⨠ª â ª®¬ã ª®¬¯¨«ïâ®àã. |
᫨ ë § ¨â¥à¥á®¢ «¨áì í⨬ ¯à®¤ãªâ®¬ ¨«¨ ã á ¢®§¨ª«¨ ª ª¨¥-«¨¡® |
¢®¯à®áë, ¨¤¥¨ ¨«¨ ¯à¥¤«®¦¥¨ï, â® ¯à®èã ® ¨å á®®¡é¨âì ¬¥ ¯® ¤à¥áã: |
halimovskiy@usa.net. |
㢠¦¥¨¥¬ . «¨¬®¢áª¨© E-mail: halimovskiy@usa.net |
/programs/develop/c--/trunk/tokscan.h-- |
---|
0,0 → 1,666 |
// ---- ८¡à §®¢ ¨¥ ⥪ã饣® ᨬ¢®« ¤«ï ª®áâãªæ¨© ⨯ : \n, \x00, â.¯. |
byte ConvertChar() |
dword hold; |
{ |
IF(cha!='\\')return(cha); |
NextChar(); // ¡à ¡®âª á«¥¤ãî饣® § \ |
IF(AL>='0')&&(AL<='9'){ |
// ¥áïâ¨ç ï ª®áâ â |
EDX=0; |
AL-='0'; |
EAX=AL; |
EDX+=EAX; |
ECX=2; |
loop(ECX){ |
EBX=EDX; |
EDX<<=1; |
EBX<<=3; |
EDX+=EBX; |
NextChar(); |
EAX=AL; |
IF(AL<'0')||(AL>'9')GOTO ERR; |
AL-='0'; |
EDX+=EAX; |
} |
return(DL); |
ERR: |
expectederror("decimal digit"); |
return(0); |
} |
IF(cha=='a')return('\a'); |
IF(cha=='b') return('\b'); |
IF(cha=='f') return('\f'); |
IF(cha=='l') return(10); |
IF(cha=='n') return(13); |
IF(cha=='p') return('_'); |
IF(cha=='r') return(13); |
IF(cha=='t') return('\t'); |
IF(cha=='v') return('\v'); |
IF(cha=='x'){ // HEX ª®áâ â |
ECX=2; |
hold=0; |
loop(ECX){ |
$PUSH ECX; |
NextChar(); |
CharUpperA(AL); |
EBX=AL; |
IF(AL>='0')&&(AL<='9')GOTO LX1; |
IF(AL<'A')&&(AL>'F')GOTO ERR1; |
LX1: |
EDX=hold; |
EDX<<=4; |
IF(BL>='A')BL-='A'-10-'0'; |
BL-='0'; |
EDX+=EBX; |
hold=EDX; |
$POP ECX; |
} |
return(hold); |
ERR1: |
$POP ECX; |
expectederror("hexdecimal digit"); |
return(0); |
} |
return(cha); |
} |
// ---- §¤¥«¨â¥«¨ |
byte Delim1={'#','\"','\'','-','+','*','/','%','|','&','!','^','=','>','<','@',0}; |
byte Delim2={':',';','(',')','{','}','[',']',',','.','$','?','~',0}; |
// ---- ¯à¥¤¥«¥¨¥ ⨯ token |
TokScan(dword tok4,type4,src4,post4,string4,number4) |
dword useme,strptr; |
dword next; |
dword dirPrefix,locPrefix;// « £¨ ®¡ à㦥¨ï #directive ¨«¨ @LocalLabel |
{ |
dirPrefix=0; |
locPrefix=0; |
SC_0: |
strptr=string4; |
next=1; |
EAX=number4; |
DSDWORD[EAX] = 0; |
EAX=type4; |
DSDWORD[EAX] = 0; |
EAX=src4; |
DSDWORD[EAX] = 0; |
EAX=post4; |
DSDWORD[EAX] = 0; |
WhiteSpaces(); |
ESI=string4; |
DSBYTE[ESI]=0; |
ECX=17; |
EDI=#Delim1; |
AL=cha; |
$REPNZ $SCASB; |
$JCXZ SC00 // ¥ ¯¥à¢ ï £à㯯 à §¤¥«¨â¥«¥ |
EDI=EDI-#Delim1-1<<2+#Jmp_Delim1; |
$JMP NEAR DSDWORD[EDI]; |
SC00: |
ECX=14; |
EDI=#Delim2; |
AL=cha; |
$REPNZ $SCASB; |
$JCXZ SC01 // ¥ ¢â®à ï £à㯯 à §¤¥«¨â¥«¥ |
EDI=EDI-#Delim2-1+#tk_delim2; |
EAX=DSBYTE[EDI]; |
EBX=tok4; |
DSDWORD[EBX]=EAX; |
$JMP ScEx |
SC01: |
IF(locPrefix){ |
EDI><strptr; |
AL='@'; |
$STOSB; |
strptr><EDI; |
} |
IF(cha==0){ // ®¥æ ¢å®¤®£® ¡ãä¥à |
EAX=tok4; |
DSDWORD[EAX]=tk_eof; |
next=0; |
} |
else if(IsCharAlphaA(cha))||(cha=='_'){ // ¤¥â¨ä¨ª â®à ç¨ ¥âáï á ¡ãª¢ë |
do{ |
do{ // ®¯¨à㥬 ¨¤¥â¨ä¨ª â®à ¢ string4 |
UP: |
EDI><strptr; |
AL=cha; |
$STOSB; |
strptr><EDI; |
NextChar(); |
}while(IsCharAlphaNumericA(cha)); |
}while(cha=='_'); |
EAX=strptr-string4; |
IF(EAX>=IDLENGTH){ |
preerror("Maximum length for an identifier exceeded"); |
strptr = string4 + IDLENGTH - 1; |
} |
EDI=strptr; |
AL=0; |
$STOSB |
EBX=tok4; |
DSDWORD[EBX]=tk_id; |
IF(locPrefix)goto FL; |
FastSearch(string4,#St_Directives); // â® § १¥à¢¨à®¢ ®¥ á«®¢®? |
IF(CARRYFLAG){ // ®¬ ¤ ®¡ à㦥 ¢ ᯨ᪥ |
EBX=number4; DSDWORD[EBX]=EAX; // ¯®¬¨¬ ¯®à浪®¢ë© ®¬¥à |
EBX=tok4; // ª ¦¥¬ ᮮ⢥âáâ¢ãî騩 token |
IF(dirPrefix)DSDWORD[EBX]=tk_directive; |
ELSE DSDWORD[EBX]=tk_command; |
dirPrefix=0; |
next=0; |
$JMP ScEx |
} |
FastSearch(string4,#St_Mnemonics); // â® ¬¥¬®¨ª ? |
IF(CARRYFLAG){ // ¥¬®¨ª áᥬ¡«¥à |
EBX=number4; |
DSDWORD[EBX]=EAX; // ¯®¬¨¬ ®¬¥à ¬¥¬®¨ª¨ |
EBX=tok4; |
DSDWORD[EBX]=tk_mnemonics; |
next=0; |
$JMP ScEx |
} |
FastSearch(string4,#St_Registers); // â® ¨¬ï ॣ¨áâà ? |
IF(CARRYFLAG){ // ¥£¨áâà |
EBX=number4; |
DSDWORD[EBX]=EAX; // ¯®¬¨¬ ®¬¥à ॣ¨áâ |
EAX>>=3; |
$CMP EAX,2; |
$JG R0 // ¯à ¢«ïî騥 ॣ¨áâàë? |
EBX=tok4; |
DSDWORD[EBX]=tk_reg; |
EBX=type4; |
EAX<<=1; |
DSDWORD[EBX] = EAX + tk_byte; |
GOTO R1; |
R0: |
EBX=tok4; |
EAX-=3; |
DSDWORD[EBX]=EAX+tk_controlreg; |
R1: |
next=0; |
$JMP ScEx |
} |
FL: |
EAX=tok4; |
EAX=DSDWORD[EAX]; |
IF(AL==tk_id){ |
SearchLocals(tok4,type4,string4,number4); // áâì ¢ ᯨ᪥ «®ª «ìëå? |
EAX=tok4; |
EAX=DSDWORD[EAX]; |
IF(AL==tk_id){ |
IF(locPrefix){ // @label |
EBX=tok4; |
DSDWORD[EBX]=tk_locallabel; |
IF(displaytokerrors)AddLocalvar(#string,tk_locallabel,0,0); |
locPrefix=0; |
GOTO FL; |
} |
SearchTree(tok4,type4,src4,post4,string4,number4); |
} |
} |
IF(dirPrefix){ // ®áâàãªæ¨ï: #ident |
dirPrefix=0; |
EBX=tok4; |
EAX=DSDWORD[EBX]; |
IF(AL==tk_id){ // áâì ¢ ᯨ᪥? |
IF(displaytokerrors){ |
EAX=post4; |
DSDWORD[EAX] = 1; // ®¡ ¢¨¬ ¢ ᯨ᮪ |
EBX=tok4; |
DSDWORD[EBX]=tk_undefproc; |
AddToTree(string4); |
} |
} |
// ¤¥â¨ä¨ª â®à ¥áâì ¢ ᯨ᪥ |
EAX=post4; |
EAX=DSDWORD[EAX]; |
EBX=tok4; |
IF(EAX){ // é¥ ¥ ®¡à ¡®â ë© ¨¤¥â¨ä¨ª â®à? |
DSDWORD[EBX] = tk_postnumber; |
} |
ELSE{ |
EAX=tok4; |
EAX=DSDWORD[EAX]; |
IF(EAX==tk_param)DSDWORD[EBX] = tk_locnumber; |
ELSE IF(EAX==tk_local)DSDWORD[EBX] = tk_locnumber; |
ELSE DSDWORD[EBX] = tk_number; |
} |
} |
next=0; |
$JMP ScEx |
} |
else if(IsNumber(cha)){ // ¤¥â¨ä¨ª â®à ç¨ ¥âáï á æ¨äàë |
EAX=tok4; |
DSDWORD[EAX]=tokens; // ®ª ¥¨§¢¥áâë© token |
if(cha=='0'){ |
NextChar(); |
IF(cha=='X')||(cha=='x'){ // hex - ç¨á«® |
EAX=tok4; |
DSDWORD[EAX]=tk_number; |
HEX: |
NextChar(); |
CharUpperA(AL); |
$CMP AL,'0'; |
$JL EHEX; |
$CMP AL,'9'; |
$JA HEXAF |
AL-='0'; |
for(;;){ |
EBX=number4; |
ECX=DSDWORD[EBX]; |
ECX<<=4; |
EAX+=ECX; |
DSDWORD[EBX]=EAX; |
GOTO HEX; |
HEXAF: |
IF(AL<'A')||(AL>'F')BREAK; |
AL-='7'; |
} |
EHEX: |
} |
ELSE IF(cha=='B')||(cha=='b'){ // binary ç¨á«® |
EAX=tok4; |
DSDWORD[EAX]=tk_number; |
for(;;){ |
NextChar(); |
IF(AL!='0')||(AL!='1')BREAK; |
AL-='0'; |
EBX=number4; |
ECX=DSDWORD[EBX]; |
ECX<<=1; |
EAX+=ECX; |
DSDWORD[EBX]=EAX; |
} |
EBIN: |
} |
ELSE IF(cha=='O')||(cha=='o'){ // octal ç¨á«® |
EAX=tok4; |
DSDWORD[EAX]=tk_number; |
for(;;){ |
NextChar(); |
IF(AL<'0')||(AL>'7')BREAK; |
AL-='0'; |
EBX=number4; |
ECX=DSDWORD[EBX]; |
ECX<<=3; |
EAX+=ECX; |
DSDWORD[EBX]=EAX; |
} |
EOCT: |
} |
} |
EAX=tok4; |
EAX=DSDWORD[EAX]; |
IF(EAX!=tk_number){ // decimal ç¨á«® |
for(;;){ |
EAX=cha; |
IF(AL<'0')||(AL>'9')BREAK; |
AL-='0'; |
EBX=number4; |
EDX=DSDWORD[EBX]; |
ECX=EDX; |
EDX<<=1; |
ECX<<=3; |
EDX+=ECX; |
EAX+=EDX; |
DSDWORD[EBX]=EAX; |
NextChar(); |
} |
EAX=tok4; |
DSDWORD[EAX]=tk_number; |
} |
next=0; |
} |
ELSE{ |
IF(displaytokerrors)preerror("tokenizer: bad character value"); |
NextChar(); |
TokScan(tok4,type4,src4,post4,string4,number4); |
next=0; |
} |
$JMP ScEx |
Jmp_Number: // #directive || #identifier |
NextChar(); |
dirPrefix=1; |
$JMP SC_0 |
Jmp_Local: // @LocalLabel |
NextChar(); |
locPrefix=1; |
$JMP SC01 |
Jmp_String: // âப ᨬ¢®«®¢ ¢ "" |
do{ |
NextChar(); |
IF(cha=='\"') // ªàë¢ îé ï ª ¢ëçª |
BREAK; |
EAX=strptr-string4; |
IF(EAX<STRLEN-1 ){ |
AL=ConvertChar(); |
EDI=strptr; |
$STOSB; |
IF(AL==13)&&(cha=='n'){ |
AL=10; |
$STOSB |
} // ®¡ ¢¨¬ char 10 ¤«ï \n |
strptr=EDI; |
} |
ELSE{ |
IF(displaytokerrors)preerror("Maximum String Length Exceeded"); |
WHILE(cha!='\"'){ // ®¨áª § ªàë¢ î饩 ª ¢ë窨 |
IF(endoffile)BREAK; |
NextChar(); |
} |
BREAK; |
} |
}while(cha==0); |
EDI=strptr; |
DSBYTE[EDI]=0; |
EDI-=string4; |
EAX=tok4; |
DSDWORD[EAX]=tk_string; |
EAX=number4; |
DSDWORD[EAX] = EDI; // ¯®¬¨¬ ¤«¨ã áâப |
IF(cha!='\"')expected('\"'); |
$JMP ScEx |
Jmp_Const: // ¨¬¢®«ì ï ª®áâ â : 'AbCD' |
NextChar(); |
EAX=tok4; |
DSDWORD[EAX]=tk_number; |
EAX=number4; |
DSDWORD[EAX] = 0; |
WHILE(cha != '\''){ |
IF(endoffile)BREAK; |
EAX=ConvertChar(); |
EBX=number4; |
ECX=DSDWORD[EBX]; |
ECX<<=8; |
EAX+=ECX; |
DSDWORD[EBX]=EAX; |
NextChar(); |
} |
IF(cha != '\''){ |
IF(displaytokerrors) |
expected(0x27/*'\''*/); |
} |
ELSE NextChar(); |
next = 0; |
$JMP ScEx |
Jmp_Minus: // - |
NextChar(); |
EBX=tok4; |
IF(cha=='=') DSDWORD[EBX]=tk_minusequals; // -= |
ELSE IF(cha=='-') DSDWORD[EBX]=tk_minusminus; // -- |
ELSE{ |
DSDWORD[EBX]=tk_minus; |
next = 0; |
} // - |
$JMP ScEx |
Jmp_Plus: // + |
NextChar(); |
EBX=tok4; |
IF(cha=='=')DSDWORD[EBX]=tk_plusequals; // += |
ELSE IF(cha=='+') DSDWORD[EBX]=tk_plusplus; // ++ |
ELSE{ |
WhiteSpaces(); |
EBX=tok4; // ¢®§¬®¦® «¨ç¨¥ ¯à®¡¥«®¢ |
IF(cha=='-')DSDWORD[EBX]=tk_minus; // ®¯â¨¬¨§ æ¨ï + - |
ELSE{ |
DSDWORD[EBX]=tk_plus; |
next = 0; |
} |
} |
$JMP ScEx |
Jmp_Mul: // * |
NextChar(); |
WhiteSpaces(); |
EBX=tok4; |
IF(cha == '-')DSDWORD[EBX] = tk_multminus; // *- |
ELSE{ |
DSDWORD[EBX] = tk_mult; |
next=0; // * |
} |
$JMP ScEx |
Jmp_Div: // / |
NextChar(); |
if(cha=='*'){ // ®¬¬¥â ਩ |
NextChar(); |
useme = 1; // useme - áç¥â稪 ¢«®¦¥ëå ª®¬¬¥â ਥ¢ |
WHILE(useme>0){ |
WhiteSpaces(); |
IF( cha == '*' ){ |
NextChar(); |
IF(cha == '/' ){ // ªàë⨥ ª®¬¬¥â à¨ï |
IF(useme > 0)useme--; // ¬¥¨è¨¬ áç¥â稪 |
NextChar(); |
} |
} |
ELSE{ |
IF( cha == '/' ){ |
NextChar(); |
IF( cha == '*' ){ // «®¦¥ë© ª®¬¬¥â ਩ |
useme++; |
NextChar(); |
} |
} |
ELSE // ¥ ®£à ¨ç¨â¥«¨ ª®¬¬¥â à¨ï |
NextChar(); |
} |
} |
IF(endoffile){ |
EAX=tok4; |
DSDWORD[EAX]=tk_eof; |
IF(useme > 0)&&(displaytokerrors)unexpectedeof(); |
} |
ELSE TokScan(tok4,type4,src4,post4,string4,number4); |
} |
ELSE IF(cha=='/'){ // ®¬¬¥â ਩ ¤® ª®æ áâப¨ // |
do{ |
NextChar(); |
IF(endoffile)BREAK; |
} while(cha!=10 ); |
IF(endoffile){ |
EAX=tok4; |
DSDWORD[EAX]=tk_eof; |
} |
ELSE{ |
WhiteSpaces(); |
TokScan(tok4,type4,src4,post4,string4,number4); |
} |
} |
ELSE{ |
WhiteSpaces(); |
IF(cha=='-'){ |
EAX=tok4; DSDWORD[EAX]=tk_divminus; // /- |
NextChar(); |
} |
ELSE{ |
EAX=tok4; |
DSDWORD[EAX]=tk_div; // / |
} |
} |
next = 0; |
$JMP ScEx |
Jmp_Mod: // % |
NextChar(); |
WhiteSpaces(); |
IF(cha == '-'){ |
EAX=tok4; |
DSDWORD[EAX] = tk_modminus; // %- |
} |
ELSE{ |
EAX=tok4; |
DSDWORD[EAX]=tk_mod; next=0; |
} |
$JMP ScEx |
Jmp_Or: // | |
NextChar(); |
IF(cha=='='){ |
EAX=tok4; |
DSDWORD[EAX]=tk_orequals; // |= |
} |
ELSE IF(cha=='|'){ |
EAX=tok4; |
DSDWORD[EAX]=tk_oror; // || |
} |
ELSE{ |
WhiteSpaces(); |
IF(cha=='-'){ |
EAX=tok4; |
DSDWORD[EAX]=tk_orminus; // |- |
} |
ELSE{ |
EAX=tok4; |
DSDWORD[EAX]=tk_or; |
next=0; // | |
} |
} |
$JMP ScEx |
Jmp_And: // & |
NextChar(); |
IF(cha=='='){ |
EAX=tok4; |
DSDWORD[EAX]=tk_andequals; // &= |
} |
ELSE IF(cha=='&'){ |
EAX=tok4; |
DSDWORD[EAX]=tk_andand; // && |
} |
ELSE{ |
WhiteSpaces(); |
IF(cha == '-'){ |
EAX=tok4; |
DSDWORD[EAX]=tk_andminus; // &- |
} |
ELSE{ |
EAX=tok4; |
DSDWORD[EAX]=tk_and; |
next=0;// & |
} |
} |
$JMP ScEx |
Jmp_Not: // ! |
NextChar(); |
IF(cha == '='){ |
EAX=tok4; |
DSDWORD[EAX]=tk_notequal; // != |
} |
ELSE{ |
EAX=tok4; |
DSDWORD[EAX]=tk_not; |
next=0; // ! |
} |
$JMP ScEx |
Jmp_Xor: // ^ |
NextChar(); |
IF(cha == '='){ |
EAX=tok4; |
DSDWORD[EAX]=tk_xorequals; // ^= |
} |
ELSE{ |
WhiteSpaces(); |
IF(cha == '-'){ |
EAX=tok4; |
DSDWORD[EAX]=tk_xorminus; // ^- |
} |
ELSE{ |
EAX=tok4; |
DSDWORD[EAX]=tk_xor; |
next=0; // ^ |
} |
} |
$JMP ScEx |
Jmp_Equal: // = |
NextChar(); |
IF(cha == '='){ |
EAX=tok4; |
DSDWORD[EAX]=tk_equalto; // == |
} |
ELSE{ |
EAX=tok4; |
DSDWORD[EAX]=tk_assign; |
next=0; // = |
} |
$JMP ScEx |
Jmp_Great: // > |
NextChar(); |
IF(cha=='>'){ |
NextChar(); |
IF( cha == '=' ){ |
EAX=tok4; |
DSDWORD[EAX]=tk_rrequals; // >>= |
} |
ELSE{ |
WhiteSpaces(); |
IF(cha == '-'){ |
EAX=tok4; |
DSDWORD[EAX]=tk_rrminus; // >>- |
} |
ELSE{ |
EAX=tok4; |
DSDWORD[EAX]=tk_rr; |
next=0;// >> |
} |
} |
} |
ELSE IF(cha=='<'){ |
EAX=tok4; |
DSDWORD[EAX]=tk_swap; // >< |
} |
ELSE IF(cha=='='){ |
EAX=tok4; |
DSDWORD[EAX]=tk_greaterequal; // >= |
} |
ELSE{ |
EAX=tok4; |
DSDWORD[EAX]=tk_greater; |
next= 0; // > |
} |
GOTO ScEx; |
Jmp_Less: // < |
NextChar(); |
IF(cha=='<'){ |
NextChar(); |
IF(cha=='='){ |
EAX=tok4; |
DSDWORD[EAX]=tk_llequals; // <<= |
} |
ELSE{ |
WhiteSpaces(); |
IF(cha == '-'){ |
EAX=tok4; |
DSDWORD[EAX]=tk_llminus; // <<- |
} |
ELSE{ |
EAX=tok4; |
DSDWORD[EAX]=tk_ll; |
next=0; |
} |
} |
} |
ELSE IF(cha=='>'){ |
EAX=tok4; |
DSDWORD[EAX]=tk_notequal; // <> |
} |
ELSE IF(cha=='='){ |
EAX=tok4; |
DSDWORD[EAX]=tk_lessequal; // <= |
} |
ELSE{ |
EAX=tok4; |
DSDWORD[EAX]=tk_less; |
next=0; // < |
} |
ScEx: |
IF(next)NextChar(); |
} |
// '#','\"','\'','-','+','*','/','%','|','&','!','^','=','>','<','@' |
dword Jmp_Delim1={#Jmp_Number,#Jmp_String,#Jmp_Const,#Jmp_Minus, |
#Jmp_Plus,#Jmp_Mul,#Jmp_Div,#Jmp_Mod,#Jmp_Or,#Jmp_And, |
#Jmp_Not,#Jmp_Xor,#Jmp_Equal,#Jmp_Great,#Jmp_Less,#Jmp_Local}; |
// ':', ';', '(', ')', |
byte tk_delim2={tk_colon,tk_semicolon,tk_openbracket,tk_closebracket, |
// '{', '}', '[', ']', ',', |
tk_openbrace,tk_closebrace,tk_openblock,tk_closeblock,tk_comma, |
//'.', '$', '?', '~' |
tk_period,tk_dollar,tk_question,tk_tilda}; |
/programs/develop/c--/trunk/tree.h-- |
---|
0,0 → 1,461 |
// ---- ¥á¥¨¥ ¯®¨¬¥®¢ ®© ª®áâ âë ¢ ᯨ᮪ |
AddConstToTree(dword keystring,constvalue) |
dword ptr,newptr; // idrec structure |
{ |
newptr=LocalAlloc(0x40,recsize); |
IF(EAX==NULL){ |
preerror("Compiler out of memory for identifier tree"); |
ExitProcess(e_outofmemory); |
} |
ptr=treestart; |
IF(EAX == NULL ) // ãá⮩ ᯨ᮪? |
treestart = newptr; |
ELSE{ |
for(;;){ |
// ®¨áª ᢮¡®¤®© áá뫪¨ |
ESI=ptr; |
EAX=lstrcmpA(DSDWORD[ESI+recid],keystring); |
ESI=ptr; |
IF(long EAX<0){ |
// ptr.left |
IF(DSDWORD[ESI+left]==0){ // 諨 ¯ãá⮩ «¥¢ë© - ¤®¡ ¢¨¬ |
DSDWORD[ESI+left]=newptr; |
BREAK; // ptr.left=newptr |
} |
ptr=DSDWORD[ESI+left]; |
} |
ELSE IF(EAX!=0){ |
// ptr.right |
IF(DSDWORD[ESI+right]==0){ // 諨 ¯ãá⮩ ¯à ¢ë© - ¤®¡ ¢¨¬ |
DSDWORD[ESI+right]=newptr; |
BREAK; |
} |
ptr=DSDWORD[ESI+right]; |
} |
ELSE internalerror("string found in tree when trying to add to it"); |
} |
} |
// ®à¬¨à㥬 ®¢ãî § ¯¨áì ¢ ᯨ᪥ |
ESI=newptr; |
DSDWORD[ESI+recid]=LocalAlloc(0x40,lstrlenA(keystring)+1); |
lstrcpyA(DSDWORD[ESI+recid],keystring); |
ESI=newptr; |
DSDWORD[ESI+newid]= NULL; |
DSDWORD[ESI+rectok]=tk_number; |
DSDWORD[ESI+recnumber]=constvalue; |
DSDWORD[ESI+recpost]=0; |
DSDWORD[ESI+left]=NULL; |
DSDWORD[ESI+right]=NULL; |
DSDWORD[ESI+recmodline] = currmod<<16+linenumber; |
} |
// ---- ®¡ ¢¨âì «®ª «ìãî ¯¥à¥¬¥ãî ¢ ᯨ᮪ |
AddLocalvar(dword str,tk,ltype,num) |
dword newptr; |
{ |
newptr=LocalAlloc(0x40,local_size); |
IF(EAX==NULL){ |
preerror("Compiler out of memory for local symbol linked list"); |
ExitProcess(e_outofmemory); |
} |
IF(locallist==NULL)locallist = newptr; |
ELSE{ |
EAX=locallist; |
EBX><EAX; //ptr; |
for(;;){ |
EAX=DSDWORD[EBX+localnext]; |
IF(EAX==0)BREAK; |
EBX><EAX; |
} |
DSDWORD[EBX+localnext]=newptr; |
} |
EBX=newptr; |
lstrcpyA(EBX+localid,str); |
EBX=newptr; |
DSDWORD[EBX+localtok] = tk; |
DSDWORD[EBX+localtype] = ltype; |
DSDWORD[EBX+localnumber] = num; |
DSDWORD[EBX+localnext] = NULL; |
localptr=EBX; |
} |
// ---- ®¡ ¢¨âì ¨¤¥â¨ä¨ª â®à ¢ ᯨ᮪ |
AddToTree(dword keystring) |
dword ptr,newptr; |
{ |
newptr=LocalAlloc(0x40,recsize); |
IF(EAX==NULL)outofmemory(); |
ptr = treestart; |
//WRITESTR(keystring);WRITESTR("\n"); |
IF(EAX==NULL)treestart = newptr; |
ELSE{ |
for(;;){ |
// ®¨áª ᢮¡®¤®© áá뫪¨ |
ESI=ptr; |
EAX=lstrcmpA(DSDWORD[ESI+recid],keystring); |
ESI=ptr; |
IF(long EAX<0){ |
// ptr.left |
IF(DSDWORD[ESI+left]==0){ // 諨 ¯ãá⮩ «¥¢ë© - ¤®¡ ¢¨¬ |
DSDWORD[ESI+left]=newptr; |
BREAK; // ptr.left=newptr |
} |
ptr=DSDWORD[ESI+left]; |
} |
ELSE IF(EAX!=0){ |
// ptr.right |
IF(DSDWORD[ESI+right]==0){ // 諨 ¯ãá⮩ ¯à ¢ë© - ¤®¡ ¢¨¬ |
DSDWORD[ESI+right]=newptr; |
BREAK; |
} |
ptr=DSDWORD[ESI+right]; |
} |
ELSE internalerror("string found in tree when trying to add to it"); |
} |
} |
ESI=newptr; |
DSDWORD[ESI+recid]=LocalAlloc(0x40,lstrlenA(keystring)+1); |
lstrcpyA(EAX,keystring); |
IF(tok == tk_string){ |
ESI=newptr; |
DSDWORD[ESI+newid] = LocalAlloc(0x40,number+1); |
IF( EAX == NULL )outofmemory(); |
ECX=number; |
EDI=EAX; |
ESI=#string; |
$REP $MOVSB |
} |
ELSE{ |
IF( lstrlenA(#string) == 0 ){ |
ESI=newptr; |
DSDWORD[ESI+newid]=NULL; |
} |
ELSE{ |
ESI=newptr; |
DSDWORD[ESI+newid]=LocalAlloc(0x40,lstrlenA(#string)+1); |
IF( EAX == NULL )outofmemory(); |
lstrcpyA(EAX,#string); |
} |
} |
ESI=newptr; |
DSDWORD[ESI+rectok] = tok; |
DSDWORD[ESI+recnumber] = number; |
DSDWORD[ESI+rectype] = type; |
DSDWORD[ESI+recsrc] = src; |
DSDWORD[ESI+recpost] = post; |
DSDWORD[ESI+left] = NULL; |
DSDWORD[ESI+right] = NULL; |
DSDWORD[ESI+recmodline] = modline; |
treeptr = newptr; |
} |
// ---- 뢮¤ ¢á¥å ¨¤¥â¨ä¨ª â®à®¢ |
void DisplayTree () |
{ // dump all identifiers to MAP file |
fprint(mapfile,"ALL GLOBAL IDENTIFIERS LIST:\n"); |
fprint(mapfile,"tok type number post\tIDENTIFIER\n"); |
numberofids = 0; |
DisplayTreeAll(treestart); |
wsprintfA(#mapstr,"\n %u Unique Global Identifiers.\n\n",numberofids); |
fprint(mapfile,#mapstr); |
fprint(mapfile,"GLOBAL CONSTANT IDENTIFIER LIST:\n"); |
numberofids = 0; |
DisplayTreeConstants(treestart); |
wsprintfA(#mapstr,"\n %u Unique Global Constant Value Identifiers.\n\n",numberofids); |
fprint(mapfile,#mapstr); |
} |
// ---- 뢮¤ ¢á¥£® ᯨ᪠¨¤¥â¨ä¨ ªâ®à®¢ |
DisplayTreeAll(dword ptr) |
{ |
if( ptr != NULL ){ |
ESI=ptr; |
DisplayTreeAll(DSDWORD[ESI+right]); |
ESI=ptr; |
if(DSDWORD[ESI+rectok]-DSDWORD[ESI+recpost]!=tk_API){ |
wsprintfA(#mapstr,"%3d %8lXh %8lXh %6Xh\t%s\n",DSDWORD[ESI+rectok], |
DSDWORD[ESI+rectype],DSDWORD[ESI+recnumber],DSDWORD[ESI+recpost], |
DSDWORD[ESI+recid]); |
fprint(mapfile,#mapstr); |
EAX=DSDWORD[ESI+newid]; |
IF(EAX!=0){ |
IF(lstrcmpA(DSDWORD[ESI+recid],EAX) != 0 ){ |
ESI=ptr; |
wsprintfA(#mapstr,"Alias=%s\n",DSDWORD[ESI+newid]); |
fprint(mapfile,#mapstr); |
} |
} |
IF(list){ |
ESI=ptr; |
EAX=DSDWORD[ESI+recsrc]; |
IF(EAX!=0){ |
EBX=DSDWORD[ESI+recmodline]>>16; |
EAX=FILENAMESIZE*EBX+#modules; |
EBX=EAX; |
wsprintfA(#mapstr,"File:%s, line=%-d:\n%s\n",EBX, |
DSDWORD[ESI+recmodline]&0xFFFF,DSDWORD[ESI+recsrc]); |
fprint(mapfile,#mapstr); |
ESI=ptr; LocalFree(DSDWORD[ESI+recsrc]); // ᢮¡®¤¨¬ ¯ ¬ïâì |
DSDWORD[ESI+recsrc]=0; |
} |
} |
numberofids++; |
} |
ESI=ptr; |
DisplayTreeAll(DSDWORD[ESI+left]); |
} |
} |
// ---- 뢮¤ ᯨ᪠£«®¡ «ìëå ª®áâ â |
DisplayTreeConstants(dword ptr) |
{ |
IF( ptr != NULL ){ |
ESI=ptr; |
DisplayTreeConstants(DSDWORD[ESI+right]); |
ESI=ptr; |
EAX=DSDWORD[ESI+rectok]; |
IF(EAX == tk_number){ |
wsprintfA(#mapstr,"#define %10ld /* %8lX hex */ %s\n", |
DSDWORD[ESI+recnumber],DSDWORD[ESI+recnumber],DSDWORD[ESI+recid]); |
fprint(mapfile,#mapstr); |
numberofids++; |
} |
ESI=ptr; |
DisplayTreeConstants(DSDWORD[ESI+left]); |
} |
} |
// ---- ëç¨á«¥¨¥ § ç¥¨ï ¡¥§§ ª®¢® ª®áâ âë |
dword DoConstDwordMath() |
dword value; |
{ |
IF(tok == tk_minus){ |
NextTok(); |
IF(tok != tk_number){ |
numexpected(); |
return(0); |
} |
number = -number; |
} |
IF(tok != tk_number){ |
numexpected(); |
return(0); |
} |
value = number; |
while(tok2isopperand()){ |
NextTok(); |
IF(tok2!=tk_number)return(value); |
switch(tok){ |
case tk_minus: value -= number2; break; |
case tk_plus: value += number2; break; |
case tk_xor: value ^= number2; break; |
case tk_and: value &= number2; break; |
case tk_or: value |= number2; break; |
case tk_mod: value = value % number2; BREAK; |
case tk_div: value = value / number2; BREAK; |
case tk_mult: value = value * number2; BREAK; |
case tk_rr: value >>= number2; BREAK; |
case tk_ll: value <<= number2; BREAK; |
case tk_xorminus: value ^= -number2; BREAK; |
case tk_andminus: value &= -number2; BREAK; |
case tk_orminus: value |= -number2; BREAK; |
/* case(tok==tk_modminus) value %= -number2; |
case(tok==tk_divminus) value /= -number2; |
case(tok==tk_multminus) value *= -number2; */ |
case tk_rrminus: value >>= -number2; BREAK; |
case tk_llminus: value <<= -number2; BREAK; |
} |
NextTok(); |
} |
return(value); |
} |
// ---- ëç¨á«¥¨¥ § ç¥¨ï § ª®¢®© ª®áâ âë |
long DoConstMath() |
long value; |
{ |
IF(tok == tk_minus){ |
NextTok(); |
IF(tok != tk_number){ |
numexpected(); |
return(0); |
} |
number = -number; |
} |
IF(tok != tk_number){ |
numexpected(); |
return(0); |
} |
value = number; |
while(tok2isopperand()){ |
NextTok(); |
IF(tok2 != tk_number) return(value); |
switch(tok){ |
case tk_minus: value -= number2; break; |
case tk_plus: value += number2; break; |
case tk_xor: value ^= number2; break; |
case tk_and: value &= number2; break; |
case tk_or: value |= number2; break; |
case tk_mod: value = value % number2; BREAK; |
case tk_div: value = value / number2; BREAK; |
case tk_mult: value = value * number2; BREAK; |
case tk_rr: value >>= number2; BREAK; |
case tk_ll: value <<= number2; BREAK; |
case tk_xorminus: value ^= -number2; BREAK; |
case tk_andminus: value &= -number2; BREAK; |
case tk_orminus: value |= -number2; BREAK; |
/* case(tok==tk_modminus) value %= -number2; |
case(tok==tk_divminus) value /= -number2; |
case(tok==tk_multminus) value *= -number2; */ |
case tk_rrminus: value >>= -number2; BREAK; |
case tk_llminus: value <<= -number2; BREAK; |
} |
NextTok(); |
} |
return(value); |
} |
// ---- ëç¨á«¥¨¥ § ç¥¨ï § ª®¢®© ª®áâ âë |
long DoConstLongMath() |
long value; |
{ |
value=DoConstMath(); |
NextTok(); |
return(value); |
} |
// ---- «¥¤ãî騩 token - ®¯¥à æ¨ï? |
dword tok2isopperand() |
{ |
EAX=tok2; |
IF(EAX==tk_plus)||(EAX==tk_minus)||(EAX==tk_mult)||(EAX==tk_div)||(EAX==tk_mod)|| |
(EAX==tk_rr)||(EAX==tk_ll)||(EAX==tk_or)||(EAX==tk_and)||(EAX==tk_xor)|| |
(EAX==tk_divminus)||(EAX==tk_modminus)||(EAX==tk_multminus)||(EAX==tk_xorminus)|| |
(EAX==tk_orminus)||(EAX==tk_andminus)||(EAX==tk_llminus)||(EAX==tk_rrminus)return(1); |
return(0); |
} |
// ---- «¥¤ãî騩 token § ªàë¢ ¥â ¢ëà ¦¥¨¥? |
dword tok2notstopper () |
{ |
EAX=tok2; |
IF(EAX==tk_semicolon)||(EAX==tk_comma)||(EAX==tk_closebracket)|| |
(EAX==tk_openblock)EAX=0; |
ELSE EAX=1; |
} |
// ---- ®¨áª ¢ ᯨ᪥ «®ª «ìëå ¯¥à¥¬¥ëå |
SearchLocals(dword tok4,type4,string4,number4) |
{ |
if( locallist != NULL ){ |
localptr = locallist; |
S00: |
ESI=EAX; //localptr; |
lstrcmpA(string4,ESI+localid); |
ESI=localptr; |
IF(EAX==0){ // ¥à¥¬¥ ï ©¤¥ |
EBX=number4; |
DSDWORD[EBX]=DSDWORD[ESI+localnumber]; |
EBX=type4; |
DSDWORD[EBX]=DSDWORD[ESI+localtype]; |
EBX=tok4; |
EAX=DSDWORD[ESI+localtok]; |
DSDWORD[EBX]=EAX; |
IF(EAX==tk_local){ |
EBX=number4; |
DSDWORD[EBX]-=localsize; |
} |
ELSE IF(EAX==tk_param){ |
EBX=number4; |
EAX=DSDWORD[EBX]+4; |
DSDWORD[EBX]=EAX; |
IF(current_proc_type==cpt_far)DSDWORD[EBX]+=4; // move over seg on stack |
} |
ELSE IF(EAX!=tk_locallabel)&&(EAX!=tk_number)internalerror("Bad *tok4 value in SearchLocals"); |
} |
ELSE{ |
IF(DSDWORD[ESI+localnext]!=NULL){ |
localptr=DSDWORD[ESI+localnext]; |
$JMP S00 |
} |
} |
} |
} |
// ---- ®¨áª ¢ ᯨ᪥ £«®¡ «ìëå ¨¤¥â¨ä¨ª â®à®¢ |
dword SearchTree(dword tok4,type4,src4,post4,string4,number4) |
dword ptr; |
long cmpresult; |
{ |
cmpresult=123; |
ptr = treestart; |
// ®¨áª ᢮¡®¤®© áá뫪¨ |
for(;;){ |
ESI=EAX; |
IF(ESI==0){ |
treeptr=NULL; |
return(0); // Not found |
} |
cmpresult = lstrcmpA(DSDWORD[ESI+recid],string4); |
ESI=ptr; |
IF(cmpresult<0)ptr=DSDWORD[ESI+left]; |
ELSE IF(cmpresult>0)ptr=DSDWORD[ESI+right]; |
ELSE BREAK; |
} |
EBX=number4; DSDWORD[EBX]=DSDWORD[ESI+recnumber]; |
EBX=type4; DSDWORD[EBX]=DSDWORD[ESI+rectype]; |
EBX=src4; DSDWORD[EBX]=DSDWORD[ESI+recsrc]; |
EBX=post4; DSDWORD[EBX]=DSDWORD[ESI+recpost]; |
EBX=tok4; EAX=DSDWORD[ESI+rectok]; DSDWORD[EBX]=EAX; |
IF(EAX==tk_string ){ |
EBX=number4; ECX=DSDWORD[EBX]; EDI=string4; |
ESI=DSDWORD[ESI+newid]; $REP $MOVSB |
} |
ELSE{ |
IF(DSDWORD[ESI+newid])lstrcpyA(string4,DSDWORD[ESI+newid]); |
} |
ESI=ptr; |
IF(lstrcmpA(DSDWORD[ESI+recid],string4)!=0) // ஢¥à¨¬: ¬¥ï«®áì «¨ ¨¬ï ¨¤¥â¨ä¨ª â®à |
SearchTree(tok4,type4,src4,post4,string4,number4); // - ¯®¢â®à¨¬ ¯®¨áª |
treeptr = ptr; |
return(1); |
} |
// ---- ®¨áª ¥®âª®¬¯¨«¨à®¢ ëå ¥é¥ ááë«®ª |
dword SeekToDo(dword ptr) |
{ |
IF(ptr!=NULL){ |
ESI=ptr; |
IF(SeekToDo(DSDWORD[ESI+right]))RETURN(1); |
ESI=ptr; EAX=DSDWORD[ESI+recpost]; |
IF(EAX>1){ |
treeptr=ptr; ESI=ptr; |
number=DSDWORD[ESI+recnumber]; |
type=DSDWORD[ESI+rectype]; modline=DSDWORD[ESI+recmodline]; |
src=DSDWORD[ESI+recsrc]; |
post=DSDWORD[ESI+recpost]; |
tok=DSDWORD[ESI+rectok]; RETURN(1); |
} |
ESI=ptr; |
IF(SeekToDo(DSDWORD[ESI+left]))RETURN(1); |
} |
return(0); |
} |
// ---- ®¨áª ¥§ ªàëâëå ááë«®ª |
SeekUndefined(dword ptr) |
{ |
IF( ptr != NULL ){ |
ESI=ptr; |
SeekUndefined(DSDWORD[ESI+right]); |
ESI=ptr; EAX=DSDWORD[ESI+rectok]; |
IF(EAX==tk_undefproc){ |
wsprintfA(#mapstr,"'%s' undefined\n",DSDWORD[ESI+recid]); |
IF( makemapfile )fprint(mapfile,#mapstr); |
WRITESTR(#mapstr); |
} |
ESI=ptr; |
SeekUndefined(DSDWORD[ESI+left]); |
} |
} |
/programs/develop/c--/trunk/wapi.h-- |
---|
0,0 → 1,36 |
extern WINAPI "user32.dll" |
{ |
cdecl long wsprintfA(); |
dword IsCharAlphaA(); |
dword IsCharAlphaNumericA(); |
dword CharUpperA(); |
dword CharToOemA(); |
} |
extern WINAPI "kernel32.dll" |
{ |
long lstrlenA(); |
long lstrcmpA(); |
dword lstrcpyA(); |
dword lstrcpynA(); |
dword lstrcatA(); |
long _lopen(); |
dword _lread(); |
dword _lwrite(); |
long _llseek(); |
long _lclose(); |
long _lcreat(); |
dword LocalAlloc(); |
dword LocalFree(); |
dword LocalUnlock(); |
dword GetSystemDirectoryA(); |
dword GlobalFree(); |
dword GetStdHandle(); |
dword GetLastError(); |
dword GetFileSize(); |
dword GetCommandLineA(); |
void ExitProcess(); |
dword CloseHandle(); |
} |
/programs/develop/c--/trunk |
---|
Property changes: |
Added: tsvn:logminsize |
+5 |
\ No newline at end of property |
/programs/develop/c-- |
---|
Property changes: |
Added: tsvn:logminsize |
+5 |
\ No newline at end of property |