Subversion Repositories Kolibri OS

Compare Revisions

No changes between revisions

Regard whitespace Rev 1845 → Rev 1846

/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