print1.c

F:反汇编源码代码学习disasm.ZIP

# define max_col 12
# define my_ON   0
# define my_OFF  1
# define WINAPI

# include "ccx.h"
# include <ctype.h>

//
// I use function pointer to turn off printing
// so if I want to printout something then %prxntf% becomes %printf% 
// and if I don't want to print out then %prxntf% becomes %nullxx% (which does nothing)
// wow, how convenient is this, but I rather like to have something more elegant
// like -- fprintf(stdout,...) and fprintf(nullfilepointer,...)
// I don't know whether this is doable or not... sang cho -- october 23, 1997
//
extern int (*prxntf)(const char *,...);
LPVOID WINAPI TranslateFunctionName (char *);
int           Get32Address(int);

extern int imageBase;
extern int entryPoint; 
extern int opcodeTable[]; 
extern int opcode2Table[];
extern int repeatgroupTable[];
extern int modTable[];
extern int mod16Table[];
extern int sibTable[];
extern int regTable[];
extern int rmTable[];

extern char  *piNameBuff;	  // import module name buffer
extern char  *pfNameBuff;	  // import functions in the module name buffer
extern char  *peNameBuff;	  // export function name buffer
extern char  *pmNameBuff;     // menu name buffer
extern char  *pdNameBuff;	  // dialog name buffer
extern int    piNameBuffSize; // import module name buffer size
extern int    pfNameBuffSize; // import functions in the module name buffer	size
extern int    peNameBuffSize; // export function name buffer size
extern int    pmNameBuffSize; // menu name buffer size
extern int    pdNameBuffSize; // dialog name buffer	size

extern int imagebaseRVA;
extern int fsize;
extern int a_loc;
extern int i_col;
extern int i_col_save;
extern int i_psp;
extern int prefixStack[];
extern int opclass;
extern int modclass;
extern int i_opclass;
extern int i_opcode;
extern int i_mod;
extern int i_sib;
extern int i_byte;
extern int i_word;
extern int i_dword;
extern int m_byte;
extern int needspacing;
extern int byteaddress;
extern int imb;
extern int mbytes[64];
extern int m_dword;
extern LPVOID lpFile;
extern int NumberOfBytesProcessed;
extern int addressOveride;
extern int operandOveride;
extern int lastAnchor;
extern int leaveFlag;
extern int delta;

extern int nextMode;
extern int dmc;
extern int dmLabels[8];

int gotJmpRef = 0;
int specifierFlag = my_OFF;
int class=0;
int ref=0;
int tempref[8]={0,};
int temppos[8]={0,};
int reg=-1;

void   WINAPI TranslateParameters (char **, char **, char **);

char  *reg8String[] = {  "al",  "cl",  "dl",  "bl",  "ah",  "ch",  "dh",  "bh"};
char *reg16String[] = {  "ax",  "cx",  "dx",  "bx",  "sp",  "bp",  "si",  "di"};
char *reg32String[] = { "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi"};
char *reg64String[] = { "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7"};
char *SregString [] = {  "es",  "cs",  "ss",  "ds",  "fs",  "gs",  "##",  "##"};
char *mod16String[] = {"bx+si","bx+di","bp+si","bp+di","si","di",  "bp",  "bx"};

/* *********************************************************************** */
/* Original Part of grammar generated data                                 */
/* *********************************************************************** */



int  print_m_byte()
{
    prxntf("%02X", m_byte);
	return m_byte;
}
int  print_m_dword()
{
    if (addressOveride) prxntf("%04X",m_dword);
	else prxntf("%08X", m_dword);
	return m_dword;
}
int  print_i_byte()
{
    prxntf("%02X", i_byte);
	return i_byte;
}
int  print_i_byte32()
{
int r;
    r = ((i_byte>127)?i_byte-256:i_byte);
    if (operandOveride||addressOveride)	prxntf("%04X",r); 
	else prxntf("%08X",r);
	return r;
}
int  print_i_dword()
{
	if (operandOveride||addressOveride)	prxntf("%04X", i_dword);
    else prxntf("%08X", i_dword);
	return i_dword;
}
int  print_i_word()
{
    prxntf("%04X", i_word);
	return i_word;
}
int  print_rel8()
{
	ref = imagebaseRVA + delta + a_loc + ((i_byte>127)?i_byte-256:i_byte);
    if (addressOveride) prxntf("%04X",ref); else prxntf("%08X", ref);
	if (nextMode) 
	{   if (i_opcode == 0xEB) class = 1; else class = 2; }
	return ref;
}
int  print_rel32()
{
    ref = imagebaseRVA + delta + a_loc + i_dword;
    if (addressOveride) prxntf("%04X",ref); else prxntf("%08X", ref);
	return ref;
}
int  print_moff()
{
    prefix();
	if(addressOveride) prxntf("[%04X]",i_dword);
	else prxntf("[%08X]", i_dword);
	return i_dword;
}
int  r___(n)
int n;
{
    switch(n)
	{
	    case  8: prxntf("%s", reg8String [regTable[i_mod]]); break;
		case 16: prxntf("%s", reg16String[regTable[i_mod]]); break;
		case 32: prxntf("%s", reg32String[regTable[i_mod]]); break;
		case 64: prxntf("%s", reg64String[regTable[i_mod]]); break;
		default: fatalError=100;
	}
	return i_mod;
}
int  mm____()
{
    prxntf("%s", reg64String[regTable[i_mod]]);
	return i_mod;
}
int  rm_m32 (n)
int n;
{
    switch(n)
	{
	    case  8: prxntf("%s", reg8String [rmTable[i_mod]]); break;
		case 16: prxntf("%s", reg16String[rmTable[i_mod]]); break;
		case 32: prxntf("%s", reg32String[rmTable[i_mod]]); break;
		case 64: prxntf("%s", reg64String[rmTable[i_mod]]); break;
		default: fatalError=101;
	}
	return i_mod;
}
int  rm_m16 (n)
int n;
{
	prxntf("%s", mod16String[rmTable[i_mod]]); 
	return i_mod;
}
int  reg_s ()
{
	prxntf("%s", reg32String[regTable[i_sib]]);
	return i_sib;
}
int  base()
{
    prxntf("%s", reg32String[rmTable[i_sib]]);
	return i_sib;
}
int  scaledindex()
{
int c;
    c=modTable[i_sib];
	c=c/2;
	if (c>0) c--;
	switch(c)	 /* now c is SS of sib byte */
	{
	    case  0:               reg_s(); break;
		case  1: prxntf("2*"); reg_s(); break;
		case  2: prxntf("4*"); reg_s(); break;
		case  3: prxntf("8*"); reg_s(); break;
		default: fatalError=103;
	}
	return i_sib;
}
void specifier (n)
int n;
{ 
    if (nextMode) return;
    switch(n)
	{
	    case  8: prxntf("byte"); break;
		case 16: prxntf("word"); break;
		case 32: prxntf("dword"); break;
		case 64: prxntf("qword"); break;
		default:
	}
	prefix();
}

int  prefix()
{
	if (i_psp>0)
	{
                 if  (prefixStack[i_psp-1] ==  38)
			{    prxntf (" es:");            }
			else if  (prefixStack[i_psp-1] ==  46)
			{    prxntf (" cs:");            }
			else if  (prefixStack[i_psp-1] ==  54)
			{    prxntf (" ss:");            }
			else if  (prefixStack[i_psp-1] ==  62)
			{    prxntf (" ds:");            }
			else if  (prefixStack[i_psp-1] == 100)
			{    prxntf (" fs:");            }
			else if  (prefixStack[i_psp-1] == 101)
			{    prxntf (" gs:");            }
	}    
	if (i_psp>1)
	{
                 if  (prefixStack[i_psp-2] ==  38)
			{    prxntf (" es:");            }
			else if  (prefixStack[i_psp-2] ==  46)
			{    prxntf (" cs:");            }
			else if  (prefixStack[i_psp-2] ==  54)
			{    prxntf (" ss:");            }
			else if  (prefixStack[i_psp-2] ==  62)
			{    prxntf (" ds:");            }
			else if  (prefixStack[i_psp-2] == 100)
			{    prxntf (" fs:");            }
			else if  (prefixStack[i_psp-2] == 101)
			{    prxntf (" gs:");            }
	}
}

int  r_m_  (n)
{
	if (addressOveride==0) return r_m_32(n);
	else return r_m_16(n);
}

int  r_m_32  (n)
int n;
{
int    c, rr;

	rr=32;

    c=modTable[i_mod];
	switch(c)
	{
	    case  1: specifier(n);
		         prxntf("["); ref = rm_m32(rr); prxntf("]");         
		         return -1;
		case  2: specifier(n);
				 if (sibTable[i_sib]==1)  /* sib star */ 
				 {
				     prxntf("[");
					 if (regTable[i_sib]!=4)
					 {scaledindex(); prxntf("+"); gotJmpRef=1;} 
					 ref = print_m_dword(); prxntf("]");
				 }
				 else                     /* sib non star */
				 {
				     prxntf("["); base(); prxntf("+"); 
					 ref = scaledindex(); prxntf("]");
				 }
				 return ref;
		case  3: specifier(n);
		         prxntf("["); ref = print_m_dword(); prxntf("]"); 
				 return ref;
		case  4: specifier(n);
		         prxntf("["); rm_m32(rr); 
				 prxntf("+"); print_m_byte(); prxntf("]");
				 return -1;
		case  5: specifier(n);
		         prxntf("["); base(); prxntf("+");  
				 if (regTable[i_sib]!=4)
				 {scaledindex(); prxntf("+");} 
				 print_m_byte(); prxntf("]");
				 return -1;
		case  6: specifier(n);
				 prxntf("["); rm_m32(rr); 
				 prxntf("+"); ref = print_m_dword(); prxntf("]");
				 return ref;
		case  7: specifier(n);
				 prxntf("["); base(); prxntf("+"); 
				 if (regTable[i_sib]!=4)
				 {scaledindex(); prxntf("+");}  
				 ref = print_m_dword(); prxntf("]");
				 return ref;
		case  8:
		         rm_m32(n);
				 return -1;
		default: fatalError=105;
	}
}

int  r_m_16  (n)
int n;
{
int    c, rr;

	rr=16; 

    c=mod16Table[i_mod];
	switch(c)
	{
	    case  1: specifier(n);
		         prxntf("["); ref = rm_m16(rr); prxntf("]");         
		         return -1;
		case  2: specifier(n);
		         prxntf("["); ref = print_m_dword(); prxntf("]"); 
				 return ref;
		case  3: specifier(n);
		         prxntf("["); rm_m16(rr); 
				 prxntf("+"); print_m_byte(); prxntf("]");
				 return -1;
		case  4: specifier(n);
		         prxntf("["); rm_m16(rr); 
				 prxntf("+"); print_m_dword(); prxntf("]");
				 return -1;
		case  5: 
		         rm_m32(n);
				 return -1;
		default: fatalError=105;
	}
}


int  Sreg__()
{
	prxntf("%s", SregString[regTable[i_mod]]);
	return i_mod;
}
int  m16_32()
{
	prxntf("m16:m32"); ref = r_m_ ( 0);
	return Get16_32Address(ref);
}
void m32_32()
{
	prxntf("m32:m32"); r_m_ ( 0);
}
int  m_____()
{
int    rr;

	if (operandOveride||addressOveride) rr=16; else rr=32;

	return r_m_ (rr);
}

void nmonicprint()
{
	if (opclass==1) 
	{
		switch(i_opclass)
		{
		    case  0: print0case();
			         break;
		    case  1: print1case();
			         break;
			case  2: print2case();
			         break;
			case  3: print3case();
			         break;
			case  4: print4case();
			         break; 
			case  5: print5case();
			         break;
			case  6: print6case();
			         break;
			case  7: print7case();
			         break;
			case  8: print8case();
			         break;
			case  9: print9case();
			         break;
			case 10: print10case();
			         break;
			case 11: print11case();
			         break;
			case 12: print12case();
			         break;
			case 13: print13case();   
			         break;
			case 14: print14case();
			         break;