print.c

win32program disassembler

//
//
// This program was written by Sang Cho, associate professor at 
//                                       the department of 
//                                       computer science and engineering
//                                       chongju university
// language used: gcc 
//
// date of second release: August 30, 1998 (alpha version)
//
//
//      you can contact me: e-mail address: [e-mail]
//                            hitel id: chokhas
//                        phone number: [phone]    [phone]
//
//            real address: Sang Cho
//                      Computer and Information Engineering
//                      ChongJu University
//                      NaeDok-Dong 36 
//                      ChongJu 360-764
//                      South Korea
//
//   Copyright (C) 1997,1998                                 by Sang Cho.
//
// Permission is granted to make and distribute verbatim copies of this
// program provided the copyright notice and this permission notice are
// preserved on all copies.
//
// File: print.c 

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

# include "disasm.h"

LPVOID WINAPI TranslateFunctionName (char *);
void   WINAPI TranslateParameters (char **, char **, char **);
DWORD  Get32Address(DWORD);
int    isGoodAddress(DWORD);
DWORD  AddressCheck(DWORD);
int    isThisSecure(DWORD);
int    referCount(DWORD);
void   showDots();
void   e64toasc();

int gotJmpRef = 0;
int specifierFlag = my_OFF;
int lclass=0;
int  ref=0;
int dref=0;
int dmark=0;
int printCol=0;
int tempref[8]={0,};
int temppos[8]={0,};
int reg=-1;

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()
{
    if (m_byte>127)     {pr2ntf("-%02X",256-m_byte);}
	else                {pr2ntf("+%02X",m_byte);}
    printCol+=3;
    return m_byte;
}
int  print_m_dword()
{
    if (addressOveride) {pr2ntf("%04X",m_dword);}
    else                {pr2ntf("%08X", m_dword);}
    if (addressOveride) printCol+=4; else printCol+=8;
    return m_dword;
}
int  print_i_byte()
{
    if (i_byte>127)     {pr2ntf("-%02X",256-i_byte);}
	else                {pr2ntf("%02X",i_byte);}
    if (i_byte>127) printCol+=3; else printCol+=2;
    return i_byte;
}
int  print_i_byte32()
{
int r;
    r = ((i_byte>127)?256-i_byte:i_byte);
    if (i_byte>127)
    {
        if (operandOveride||addressOveride) {pr2ntf("-%04X",r);}
        else                                {pr2ntf("-%08X",r);} printCol+=1;
    }
    else
    {
        if (operandOveride||addressOveride) {pr2ntf("%04X",r);} 
        else                                {pr2ntf("%08X",r);} 
    }
    if (operandOveride||addressOveride) printCol+=4; else printCol+=8;
    return r;
}
int  print_i_dword()
{
    if (operandOveride||addressOveride)     {pr2ntf("%04X", i_dword);}
    else                                    {pr2ntf("%08X", i_dword);}
    if (operandOveride||addressOveride) printCol+=4; else printCol+=8;
    return i_dword;
}
int  print_i_word()
{
    pr2ntf("%04X", i_word);
    printCol+=4;
    return i_word;
}
int  print_rel8()
{
    ref = cur_position + i_col + ((i_byte>127)?i_byte-256:i_byte);
    if (addressOveride)  {pr2ntf("%04X",ref);} 
	else                 {pr2ntf("%08X",ref);}
    {   if (i_opcode == 0xEB) lclass = 1; else lclass = 2; }
    if (addressOveride) printCol+=4; else printCol+=8;
    return ref;
}
int  print_rel32()
{
    ref = cur_position + i_col + i_dword;
    if (addressOveride)  {pr2ntf("%04X",ref);} 
	else                 {pr2ntf("%08X",ref);}
    if (addressOveride) printCol+=4; else printCol+=8;
    return ref;
}
int  print_moff()
{
    prefix();
    if(addressOveride)  {pr2ntf("[%04X]",i_dword);}
    else                {pr2ntf("[%08X]",i_dword);}
    if (addressOveride) printCol+=6; else printCol+=10;
    return i_dword;
}
int  r___(int n)
{
    switch(n)
    {
        case  8: pr2ntf("%s", reg8String [regTable[i_mod]]); break;
        case 16: pr2ntf("%s", reg16String[regTable[i_mod]]); break;
        case 32: pr2ntf("%s", reg32String[regTable[i_mod]]); break;
        case 64: pr2ntf("%s", reg64String[regTable[i_mod]]); break;
        default: fatalError=100;
    }
    return i_mod;
}
int  mm____()
{
    pr2ntf("%s", reg64String[regTable[i_mod]]);
    return i_mod;
}
int  mmm___()
{
    pr2ntf("%s", reg64String[rmTable[i_mod]]);
    return i_mod;
}
int  rm_m32 (n)
int n;
{
    switch(n)
    {
        case  8: pr2ntf("%s", reg8String [rmTable[i_mod]]); printCol+=2; break;
        case 16: pr2ntf("%s", reg16String[rmTable[i_mod]]); printCol+=2; break;
        case 32: pr2ntf("%s", reg32String[rmTable[i_mod]]); printCol+=3; break;
        case 64: pr2ntf("%s", reg64String[rmTable[i_mod]]); printCol+=3; break;
        default: fatalError=101;
    }
    return i_mod;
}
int  rm_m16 (n)
int n;
{
    pr2ntf("%s", mod16String[rmTable[i_mod]]); 
    printCol+=strlen(mod16String[rmTable[i_mod]]);
    return i_mod;
}
int  reg_s ()
{
    pr2ntf("%s", reg32String[regTable[i_sib]]);
    printCol+=strlen(reg32String[regTable[i_sib]]);
    return i_sib;
}
int  base()
{
    pr2ntf("%s", reg32String[rmTable[i_sib]]);
    printCol+=strlen(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: pr1ntf("2*"); reg_s(); printCol+=2; break;
        case  2: pr1ntf("4*"); reg_s(); printCol+=2; break;
        case  3: pr1ntf("8*"); reg_s(); printCol+=2; break;
        default: fatalError=103;
    }
    return i_sib;
}
void specifier (n)
int n;
{ 
    if (nextMode) return;
    switch(n)
    {
        case  8: pr1ntf("byte");  printCol+=4; break;
        case 16: pr1ntf("word");  printCol+=4; break;
        case 32: pr1ntf("dword"); printCol+=5; break;
        case 64: pr1ntf("qword"); printCol+=5; break;
        default:
    }
    prefix();
}

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

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

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

    rr=32;

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

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

    rr=16; 

    c=mod16Table[i_mod];
    switch(c)
    {
        case  1: specifier(n);
                 pr1ntf("["); rm_m16(rr); pr1ntf("]");         
                 printCol+=2; return -1;
        case  2: specifier(n);
                 pr1ntf("["); ref = print_m_dword(); pr1ntf("]"); 
                 printCol+=2; return ref;
        case  3: specifier(n);
                 pr1ntf("["); rm_m16(rr); 
                 print_m_byte(); pr1ntf("]");
                 printCol+=2; return -1;
        case  4: specifier(n);
                 pr1ntf("["); rm_m16(rr); 
                 pr1ntf("+"); print_m_dword(); pr1ntf("]");
                 printCol+=3; return -1;