home *** CD-ROM | disk | FTP | other *** search
/ Programming Win32 Under the API / ProgrammingWin32UnderTheApiPatVillani.iso / dsasmsrc.zip / print.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-02-22  |  129.5 KB  |  3,152 lines
  1. //
  2. //
  3. // This program was written by Sang Cho, associate professor at 
  4. //                                       the department of 
  5. //                                       computer science and engineering
  6. //                                       chongju university
  7. // language used: gcc 
  8. //
  9. // date of second release: August 30, 1998 (alpha version)
  10. //
  11. //
  12. //      you can contact me: e-mail address: sangcho@alpha94.chongju.ac.kr
  13. //                            hitel id: chokhas
  14. //                        phone number: (0431) 229-8491    +82-431-229-8491
  15. //
  16. //            real address: Sang Cho
  17. //                      Computer and Information Engineering
  18. //                      ChongJu University
  19. //                      NaeDok-Dong 36 
  20. //                      ChongJu 360-764
  21. //                      South Korea
  22. //
  23. //   Copyright (C) 1997,1998                                 by Sang Cho.
  24. //
  25. // Permission is granted to make and distribute verbatim copies of this
  26. // program provided the copyright notice and this permission notice are
  27. // preserved on all copies.
  28. //
  29. // File: print.c 
  30.  
  31. # define max_col 12
  32. # define my_ON   0
  33. # define my_OFF  1
  34. # define WINAPI
  35.  
  36. # include "disasm.h"
  37.  
  38. LPVOID WINAPI TranslateFunctionName (char *);
  39. void   WINAPI TranslateParameters (char **, char **, char **);
  40. DWORD  Get32Address(DWORD);
  41. int    isGoodAddress(DWORD);
  42. DWORD  AddressCheck(DWORD);
  43. int    isThisSecure(DWORD);
  44. int    referCount(DWORD);
  45. void   showDots();
  46. void   e64toasc();
  47.  
  48. int gotJmpRef = 0;
  49. int specifierFlag = my_OFF;
  50. int lclass=0;
  51. int  ref=0;
  52. int dref=0;
  53. int dmark=0;
  54. int printCol=0;
  55. int tempref[8]={0,};
  56. int temppos[8]={0,};
  57. int reg=-1;
  58.  
  59. char  *reg8String[] = {  "al",  "cl",  "dl",  "bl",  "ah",  "ch",  "dh",  "bh"};
  60. char *reg16String[] = {  "ax",  "cx",  "dx",  "bx",  "sp",  "bp",  "si",  "di"};
  61. char *reg32String[] = { "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi"};
  62. char *reg64String[] = { "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7"};
  63. char *SregString [] = {  "es",  "cs",  "ss",  "ds",  "fs",  "gs",  "##",  "##"};
  64. char *mod16String[] = {"bx+si","bx+di","bp+si","bp+di","si","di",  "bp",  "bx"};
  65.  
  66. /* *********************************************************************** */
  67. /* Original Part of grammar generated data                                 */
  68. /* *********************************************************************** */
  69.  
  70.  
  71.  
  72. int  print_m_byte()
  73. {
  74.     if (m_byte>127)     {pr2ntf("-%02X",256-m_byte);}
  75.     else                {pr2ntf("+%02X",m_byte);}
  76.     printCol+=3;
  77.     return m_byte;
  78. }
  79. int  print_m_dword()
  80. {
  81.     if (addressOveride) {pr2ntf("%04X",m_dword);}
  82.     else                {pr2ntf("%08X", m_dword);}
  83.     if (addressOveride) printCol+=4; else printCol+=8;
  84.     return m_dword;
  85. }
  86. int  print_i_byte()
  87. {
  88.     if (i_byte>127)     {pr2ntf("-%02X",256-i_byte);}
  89.     else                {pr2ntf("%02X",i_byte);}
  90.     if (i_byte>127) printCol+=3; else printCol+=2;
  91.     return i_byte;
  92. }
  93. int  print_i_byte32()
  94. {
  95. int r;
  96.     r = ((i_byte>127)?256-i_byte:i_byte);
  97.     if (i_byte>127)
  98.     {
  99.         if (operandOveride||addressOveride) {pr2ntf("-%04X",r);}
  100.         else                                {pr2ntf("-%08X",r);} printCol+=1;
  101.     }
  102.     else
  103.     {
  104.         if (operandOveride||addressOveride) {pr2ntf("%04X",r);} 
  105.         else                                {pr2ntf("%08X",r);} 
  106.     }
  107.     if (operandOveride||addressOveride) printCol+=4; else printCol+=8;
  108.     return r;
  109. }
  110. int  print_i_dword()
  111. {
  112.     if (operandOveride||addressOveride)     {pr2ntf("%04X", i_dword);}
  113.     else                                    {pr2ntf("%08X", i_dword);}
  114.     if (operandOveride||addressOveride) printCol+=4; else printCol+=8;
  115.     return i_dword;
  116. }
  117. int  print_i_word()
  118. {
  119.     pr2ntf("%04X", i_word);
  120.     printCol+=4;
  121.     return i_word;
  122. }
  123. int  print_rel8()
  124. {
  125.     ref = cur_position + i_col + ((i_byte>127)?i_byte-256:i_byte);
  126.     if (addressOveride)  {pr2ntf("%04X",ref);} 
  127.     else                 {pr2ntf("%08X",ref);}
  128.     {   if (i_opcode == 0xEB) lclass = 1; else lclass = 2; }
  129.     if (addressOveride) printCol+=4; else printCol+=8;
  130.     return ref;
  131. }
  132. int  print_rel32()
  133. {
  134.     ref = cur_position + i_col + i_dword;
  135.     if (addressOveride)  {pr2ntf("%04X",ref);} 
  136.     else                 {pr2ntf("%08X",ref);}
  137.     if (addressOveride) printCol+=4; else printCol+=8;
  138.     return ref;
  139. }
  140. int  print_moff()
  141. {
  142.     prefix();
  143.     if(addressOveride)  {pr2ntf("[%04X]",i_dword);}
  144.     else                {pr2ntf("[%08X]",i_dword);}
  145.     if (addressOveride) printCol+=6; else printCol+=10;
  146.     return i_dword;
  147. }
  148. int  r___(int n)
  149. {
  150.     switch(n)
  151.     {
  152.         case  8: pr2ntf("%s", reg8String [regTable[i_mod]]); break;
  153.         case 16: pr2ntf("%s", reg16String[regTable[i_mod]]); break;
  154.         case 32: pr2ntf("%s", reg32String[regTable[i_mod]]); break;
  155.         case 64: pr2ntf("%s", reg64String[regTable[i_mod]]); break;
  156.         default: fatalError=100;
  157.     }
  158.     return i_mod;
  159. }
  160. int  mm____()
  161. {
  162.     pr2ntf("%s", reg64String[regTable[i_mod]]);
  163.     return i_mod;
  164. }
  165. int  mmm___()
  166. {
  167.     pr2ntf("%s", reg64String[rmTable[i_mod]]);
  168.     return i_mod;
  169. }
  170. int  rm_m32 (n)
  171. int n;
  172. {
  173.     switch(n)
  174.     {
  175.         case  8: pr2ntf("%s", reg8String [rmTable[i_mod]]); printCol+=2; break;
  176.         case 16: pr2ntf("%s", reg16String[rmTable[i_mod]]); printCol+=2; break;
  177.         case 32: pr2ntf("%s", reg32String[rmTable[i_mod]]); printCol+=3; break;
  178.         case 64: pr2ntf("%s", reg64String[rmTable[i_mod]]); printCol+=3; break;
  179.         default: fatalError=101;
  180.     }
  181.     return i_mod;
  182. }
  183. int  rm_m16 (n)
  184. int n;
  185. {
  186.     pr2ntf("%s", mod16String[rmTable[i_mod]]); 
  187.     printCol+=strlen(mod16String[rmTable[i_mod]]);
  188.     return i_mod;
  189. }
  190. int  reg_s ()
  191. {
  192.     pr2ntf("%s", reg32String[regTable[i_sib]]);
  193.     printCol+=strlen(reg32String[regTable[i_sib]]);
  194.     return i_sib;
  195. }
  196. int  base()
  197. {
  198.     pr2ntf("%s", reg32String[rmTable[i_sib]]);
  199.     printCol+=strlen(reg32String[rmTable[i_sib]]);
  200.     return i_sib;
  201. }
  202. int  scaledindex()
  203. {
  204. int c;
  205.     c=modTable[i_sib];
  206.     c=c/2;
  207.     if (c>0) c--;
  208.     switch(c)     /* now c is SS of sib byte */
  209.     {
  210.         case  0:               reg_s();              break;
  211.         case  1: pr1ntf("2*"); reg_s(); printCol+=2; break;
  212.         case  2: pr1ntf("4*"); reg_s(); printCol+=2; break;
  213.         case  3: pr1ntf("8*"); reg_s(); printCol+=2; break;
  214.         default: fatalError=103;
  215.     }
  216.     return i_sib;
  217. }
  218. void specifier (n)
  219. int n;
  220. { 
  221.     if (nextMode) return;
  222.     switch(n)
  223.     {
  224.         case  8: pr1ntf("byte");  printCol+=4; break;
  225.         case 16: pr1ntf("word");  printCol+=4; break;
  226.         case 32: pr1ntf("dword"); printCol+=5; break;
  227.         case 64: pr1ntf("qword"); printCol+=5; break;
  228.         default:
  229.     }
  230.     prefix();
  231. }
  232.  
  233. int  prefix()
  234. {
  235.     if (i_psp>1)
  236.     {
  237.                  if  (prefixStack[i_psp-2] ==  38)
  238.             {    pr1ntf (" es:");   printCol+=4;  }
  239.             else if  (prefixStack[i_psp-2] ==  46)
  240.             {    pr1ntf (" cs:");   printCol+=4;  }
  241.             else if  (prefixStack[i_psp-2] ==  54)
  242.             {    pr1ntf (" ss:");   printCol+=4;  }
  243.             else if  (prefixStack[i_psp-2] ==  62)
  244.             {    pr1ntf (" ds:");   printCol+=4;  }
  245.             else if  (prefixStack[i_psp-2] == 100)
  246.             {    pr1ntf (" fs:");   printCol+=4;  }
  247.             else if  (prefixStack[i_psp-2] == 101)
  248.             {    pr1ntf (" gs:");   printCol+=4;  }
  249.     }
  250.     if (i_psp>0)
  251.     {
  252.                  if  (prefixStack[i_psp-1] ==  38)
  253.             {    pr1ntf (" es:");   printCol+=4;  }
  254.             else if  (prefixStack[i_psp-1] ==  46)
  255.             {    pr1ntf (" cs:");   printCol+=4;  }
  256.             else if  (prefixStack[i_psp-1] ==  54)
  257.             {    pr1ntf (" ss:");   printCol+=4;  }
  258.             else if  (prefixStack[i_psp-1] ==  62)
  259.             {    pr1ntf (" ds:");   printCol+=4;  }
  260.             else if  (prefixStack[i_psp-1] == 100)
  261.             {    pr1ntf (" fs:");   printCol+=4;  }
  262.             else if  (prefixStack[i_psp-1] == 101)
  263.             {    pr1ntf (" gs:");   printCol+=4;  }
  264.     }    
  265.     return 1;
  266. }
  267.  
  268. int  r_m_  (n)
  269. {
  270.     if (addressOveride==0) return r_m_32(n);
  271.     else return r_m_16(n);
  272. }
  273.  
  274. int  r_m_32  (int n)
  275. {
  276. int    c, rr;
  277.  
  278.     rr=32;
  279.  
  280.     c=modTable[i_mod];
  281.     switch(c)
  282.     {
  283.         case  1: specifier(n);
  284.                  pr1ntf("["); ref = rm_m32(rr); pr1ntf("]");         
  285.                  printCol+=2; return -1;
  286.         case  2: specifier(n);
  287.                  if (sibTable[i_sib]==1)  /* sib star */ 
  288.                  {
  289.                      pr1ntf("[");
  290.                      if (regTable[i_sib]!=4)
  291.                      {scaledindex(); pr1ntf("+"); gotJmpRef=1;} 
  292.                      ref = print_m_dword(); pr1ntf("]");
  293.                      printCol+=3;
  294.                  }
  295.                  else                     /* sib non star */
  296.                  {
  297.                      pr1ntf("["); base(); pr1ntf("+"); 
  298.                      ref = scaledindex(); pr1ntf("]");
  299.                      printCol+=3;
  300.                  }
  301.                  return ref;
  302.         case  3: specifier(n);
  303.                  pr1ntf("["); ref = print_m_dword(); pr1ntf("]"); 
  304.                  printCol+=2; return ref;
  305.         case  4: specifier(n);
  306.                  pr1ntf("["); rm_m32(rr); 
  307.                  print_m_byte(); pr1ntf("]");
  308.                  printCol+=2; return -1;
  309.         case  5: specifier(n);
  310.                  pr1ntf("["); base();   
  311.                  if (regTable[i_sib]!=4)
  312.                  {pr1ntf("+"); scaledindex(); printCol+=1;} 
  313.                  print_m_byte(); pr1ntf("]");
  314.                  printCol+=2; return -1;
  315.         case  6: specifier(n);
  316.                  pr1ntf("["); rm_m32(rr); 
  317.                  pr1ntf("+"); ref = print_m_dword(); pr1ntf("]");
  318.                  printCol+=3; return ref;
  319.         case  7: specifier(n);
  320.                  pr1ntf("["); base(); pr1ntf("+"); 
  321.                  if (regTable[i_sib]!=4)
  322.                  {scaledindex(); pr1ntf("+"); printCol+=1;}  
  323.                  ref = print_m_dword(); pr1ntf("]");
  324.                  printCol+=3; return ref;
  325.         case  8:
  326.                  rm_m32(n);
  327.                  return -1;
  328.         default: fatalError=105;
  329.     }
  330.     return 1;
  331. }
  332.  
  333. int  r_m_16  (n)
  334. int n;
  335. {
  336. int    c, rr;
  337.  
  338.     rr=16; 
  339.  
  340.     c=mod16Table[i_mod];
  341.     switch(c)
  342.     {
  343.         case  1: specifier(n);
  344.                  pr1ntf("["); rm_m16(rr); pr1ntf("]");         
  345.                  printCol+=2; return -1;
  346.         case  2: specifier(n);
  347.                  pr1ntf("["); ref = print_m_dword(); pr1ntf("]"); 
  348.                  printCol+=2; return ref;
  349.         case  3: specifier(n);
  350.                  pr1ntf("["); rm_m16(rr); 
  351.                  print_m_byte(); pr1ntf("]");
  352.                  printCol+=2; return -1;
  353.         case  4: specifier(n);
  354.                  pr1ntf("["); rm_m16(rr); 
  355.                  pr1ntf("+"); print_m_dword(); pr1ntf("]");
  356.                  printCol+=3; return -1;
  357.         case  5: 
  358.                  rm_m32(n);
  359.                  return -1;
  360.         default: fatalError=105;
  361.     }
  362.     return 1;
  363. }
  364.  
  365.  
  366. int  Sreg__()
  367. {
  368.     pr2ntf("%s", SregString[regTable[i_mod]]);
  369.     printCol+=strlen(SregString[regTable[i_mod]]);
  370.     return i_mod;
  371. }
  372. int  m16_32()
  373. {
  374.     pr1ntf("m16:m32"); ref = r_m_ ( 0);
  375.     printCol+=7;
  376.     return ref;
  377. }
  378. int  m32_32()
  379. {
  380.     pr1ntf("m32:m32"); ref = r_m_ ( 0);
  381.     printCol+=7;
  382.     return ref;
  383. }
  384. int  m_____()
  385. {
  386. int    rr;
  387.  
  388.     if (operandOveride||addressOveride) rr=16; else rr=32;
  389.  
  390.     return r_m_ (rr);
  391. }
  392.  
  393. void nmonicprint()
  394. {
  395.     if (opclass==1) 
  396.     {
  397.         switch(i_opclass)
  398.         {
  399.             case  0: print0case();
  400.                      break;
  401.             case  1: print1case();
  402.                      break;
  403.             case  2: print2case();
  404.                      break;
  405.             case  3: print3case();
  406.                      break;
  407.             case  4: print4case();
  408.                      break; 
  409.             case  5: print5case();
  410.                      break;
  411.             case  6: print6case();
  412.                      break;
  413.             case  7: print7case();
  414.                      break;
  415.             case  8: print8case();
  416.                      break;
  417.             case  9: print9case();
  418.                      break;
  419.             case 10: print10case();
  420.                      break;
  421.             case 11: print11case();
  422.                      break;
  423.             case 12: print12case();
  424.                      break;
  425.             case 13: print13case();   
  426.                      break;
  427.             case 14: print14case();
  428.                      break;
  429.             case 15: print15case();
  430.                      break;
  431.             case 16: print16case();
  432.                      break;
  433.             default:
  434.         }
  435.     }
  436.     else 
  437.     {   
  438.         switch(i_opclass)
  439.         {
  440.             case  0: print20case();
  441.                      break;
  442.             case  1: print21case();
  443.                      break;
  444.             case  2: print22case();
  445.                      break;
  446.             case  3: print23case();
  447.                      break;
  448.             case  4: print24case();
  449.                      break;
  450.             case  5: print25case();
  451.                      break;
  452.             default:
  453.         }
  454.     }    
  455. } /* end of nmonicprint() */
  456.  
  457.  
  458. int addressfix()
  459. {
  460.     //if (GotEof) return 0;
  461.     if (0<NumberOfBytesProcessed) a_loc = NumberOfBytesProcessed;
  462.     cur_position = getRVA(CodeOffset + a_loc + delta)+imageBase;
  463.     i_mod=0; i_dword=0; m_dword=0;
  464.     return 1;
  465. } /* end of addressprint() */
  466.  
  467. int addressprint1(int c)
  468. {
  469. static int cc=0;
  470. int        d, dd;
  471. BYTE       b;
  472.  
  473.     if (GotEof) return 0;    
  474.     //if (nextMode)     return 0;
  475.     if (c>1)  d=1; else  d=c;
  476.     if (cc>1)dd=1; else dd=cc;
  477.     
  478.     if (c!=cc && cc==2 && imb >0)
  479.     {
  480.         bodyprint21(); 
  481.         needspacing=0; imb=0;
  482.         showDots();
  483.     }
  484.  
  485.     if (d!=dd)
  486.     {
  487.         pr1ntf("\n"); needspacing=0; imb=0;
  488.         showDots();
  489.     }
  490.     else 
  491.     {
  492.         if (needspacing){ pr1ntf("\n"); needspacing=0; }
  493.     }
  494.  
  495.     
  496.     if (cur_position==entryPoint+imageBase)
  497.         {pr1ntf("\n//******************** Program Entry Point ********");}
  498.     b=getMap(cur_position); 
  499.          if (b&0x80)  printExportName();
  500.     else if (b&0x40)  printEntryMark();
  501.     else if (b==0x2F) printDataMark();
  502.     else if (b==0x2E) printDataMark();
  503.     else if (b==0x2D) printDataMark();
  504.     else if (b&0x20)  printLabelMark();
  505.  
  506.     if (c!=cc)
  507.     {
  508.         pr2ntf("\n:%08X ", (int)cur_position);
  509.     }
  510.     else 
  511.     {
  512.         if (c<2)
  513.         {pr2ntf("\n:%08X ", (int)cur_position);}
  514.         else if (imb==0)
  515.         { 
  516.             pr2ntf("\n:%08X ", (int)cur_position);
  517.             imb=0;
  518.         }
  519.     }
  520.     cc=c;
  521.     return 1;
  522. } /* end of addressprint() */
  523.  
  524. int addressprint()
  525. {
  526.     addressfix();
  527.     addressprint1(1);
  528.     return 1;
  529. }
  530.  
  531. int bodyprint(int c)
  532. {
  533.          if (c==0) bodyprint0();
  534.     else if (c==1) bodyprint1();
  535.     else if (c==2) bodyprint2();
  536.     else if (c==3) bodyprint3();
  537.     else if (c==4) bodyprint4();
  538.     else if (c==5) bodyprint5();
  539.     else if (c==6) bodyprint6();
  540.     return 1;
  541. }
  542.  
  543. int bodyprint0()
  544. {
  545. int            i,r;
  546.     
  547.     if (GotEof) return 0; 
  548.     if (finished) {finished=0; return 1;}
  549.  
  550.     r=cur_position;
  551.  
  552.     //if (nextMode==0)
  553.     for(i=i_col;i<max_col;i++)pr1ntf("  ");
  554.  
  555.     nmonicprint();
  556.  
  557.     if (nextMode)
  558.     {
  559.         pushTrace(303);
  560.         if (lclass) EnterLabel(lclass, ref, cur_position);
  561.         popTrace();
  562.         //if (dmc)   fatalError=999,dmc=0;
  563.     }
  564.     else
  565.     {
  566.         if (getMap(r)&0x10) printString();
  567.     }
  568.  
  569.     lclass = 0;
  570.     ref   = 0;
  571.     dref   = 0;
  572.     a_loc_save=a_loc;
  573.     i_col_save=i_col;
  574.     i_psp=0; 
  575.     i_col=0;
  576.     addressOveride = 0;
  577.     operandOveride = 0;
  578.     printCol = 0;
  579.  
  580.     return 1;
  581. }
  582.  
  583. int bodyprint1()
  584. {
  585. int       i, j, n;
  586.     
  587.     if (GotEof) return 0; 
  588.  
  589.     pushTrace(302);
  590.     if (nextMode>0)
  591.     EnterLabel(166, m_dword, cur_position);
  592.     else
  593.     {
  594.         for(i=i_col;i<max_col;i++)pr1ntf("  ");
  595.         pr2ntf ("DWORD %08X", m_dword); printCol = 14; 
  596.         for(i=printCol;i<26;i++)pr1ntf(" ");
  597.         n=m_dword; pr1ntf(";; "); 
  598.         j=n%256; n/=256; if(isprint(j)){pr2ntf("%c",j);}else {pr1ntf(".");}
  599.         j=n%256; n/=256; if(isprint(j)){pr2ntf("%c",j);}else {pr1ntf(".");}
  600.         j=n%256; n/=256; if(isprint(j)){pr2ntf("%c",j);}else {pr1ntf(".");} 
  601.                          if(isprint(n)){pr2ntf("%c",n);}else {pr1ntf(".");}
  602.     }
  603.     popTrace();
  604.  
  605.     lclass = 0;
  606.     ref   = 0;
  607.     dref   = 0;
  608.     a_loc_save=a_loc;
  609.     i_col_save=i_col;
  610.     i_psp=0; 
  611.     i_col=0;
  612.     operandOveride = 0;
  613.     printCol=0;
  614.     return 1;
  615. }
  616.  
  617. int bodyprint2()
  618. {
  619. static int   m=16;
  620. BYTE         b;
  621.  
  622.     if ((b=getMap(cur_position))&0x30) dmark=cur_position;
  623.    
  624.     switch(lclass)
  625.     {
  626.         case 515: m=16; break;
  627.         case 517: m=10; break;
  628.         case 518: case 528: 
  629.                   m= 8; break;
  630.         case 524: m=4;
  631.         default:  m=16;
  632.     }
  633.  
  634.     mbytes[imb++]=m_byte;
  635.     if (imb==m || (b=getMap(cur_position+1))==0x2F || b==0x1F) 
  636.         bodyprint21();
  637.     // this place is not good place to process EOF case but it is also very effective.
  638.     //  May.19.1998 sang cho
  639.     if (GotEof)
  640.     { 
  641.         bodyprint21();
  642.         addressfix();
  643.     }
  644.     return 1;
  645. }
  646.  
  647.  
  648.  
  649. int bodyprint21()
  650. {
  651. int           i, j;
  652. unsigned char c;
  653. double        d;
  654. float         f;
  655. char          s[256];
  656.     
  657.     //if (GotEof) return 0; 
  658.  
  659.     for(i=0;i<imb;i++)pr2ntf("%02X ",mbytes[i]);
  660.     for(   ;i<16; i++)pr1ntf("   "); pr1ntf("  ");
  661.  
  662.     j=lclass;
  663.     //for(i=i_col;i<max_col;i++)pr1ntf("  ");   
  664.     //    if (j==515) 
  665.     //{
  666.     //}
  667.     //else 
  668.     if (j==517) 
  669.     {
  670.         e64toasc((PWORD)toFile(dmark),s,16);
  671.         pr2ntf(";; %s",s); printCol+=26; if(d<0) printCol++; 
  672.     }
  673.     //else if (j==518) 
  674.     //{
  675.     //}
  676.     else if (j==524)
  677.     {
  678.         f=*(float *)(toFile(dmark));
  679.         if(f>=0.) {pr1ntf(";;  ");} else {pr1ntf(";; ");}
  680.         pr2ntf("%e",f);
  681.     }
  682.     else if (j==528) 
  683.     {
  684.         d=*(double *)(toFile(dmark));
  685.         if(d>=0.) {pr1ntf(";;  ");} else {pr1ntf(";; ");}
  686.         pr2ntf("%23.16e",d); printCol+=26; if(d<0) printCol++; 
  687.     }
  688.     else            
  689.     {
  690.         for(i=0;i<imb;i++)pr2ntf("%c",isprint(c=mbytes[i])?c:'.');
  691.     }
  692.     if (getMap(cur_position+1)==0x1F); else lclass=0;
  693.  
  694.     imb   = 0;
  695.     //lclass = 0;
  696.     ref   = 0;
  697.     dref   = 0;
  698.     dmark  = 0;
  699.     a_loc_save=a_loc;
  700.     i_col_save=i_col;
  701.     i_psp=0; 
  702.     i_col=0;
  703.     operandOveride = 0;
  704.     return 1;
  705. }
  706.  
  707.  
  708. int bodyprint3()
  709. {
  710.     if (GotEof) return 0; 
  711.     
  712.     imb++;
  713.     
  714.     lclass = 0;
  715.     ref   = 0;
  716.     dref   = 0;
  717.     a_loc_save=a_loc;
  718.     i_col_save=i_col;
  719.     i_psp=0; 
  720.     i_col=0;
  721.     operandOveride = 0;
  722.     return 1;
  723. }
  724.  
  725. int bodyprint4()
  726. {
  727. int  i, j, n;
  728.     
  729.     if (GotEof) return 0; 
  730.     
  731.     n=stringBuf[0];j=0;
  732.     for (i=0;i<n+1;i++)
  733.     {if(j++==16) {pr1ntf("\n          ");j=1;}pr2ntf("%02X ",stringBuf[i]);} 
  734.     for(i=j;i<max_col+4;i++)pr1ntf("   "); pr1ntf("  ");
  735.     pr2ntf (";;p %c",'"');
  736.  
  737.     n=stringBuf[0];
  738.     for (i=1;i<n+1;i++)pr2ntf("%c",stringBuf[i]);
  739.     pr2ntf("%c",'"');
  740.  
  741.     lclass = 0;
  742.     ref   = 0;
  743.     dref   = 0;
  744.     a_loc_save=a_loc;
  745.     i_col_save=i_col;
  746.     i_psp=0; 
  747.     i_col=0;
  748.     operandOveride = 0;
  749.     return 1;
  750. }
  751.  
  752. int bodyprint5()
  753. {
  754. int  i, j;
  755.  
  756.     if (GotEof) return 0; 
  757.     
  758.     i=0; j=0;
  759.     while(stringBuf[i]>-1)
  760.     {if(j++==16) {pr1ntf("\n          ");j=1;}pr2ntf("%02X ",stringBuf[i++]);}
  761.     for(i=j;i<max_col+4;i++)pr1ntf("   "); pr1ntf("  ");
  762.     pr2ntf (";;n %c",'"');
  763.     i=0;
  764.     while(isprint(stringBuf[i])) pr2ntf("%c",stringBuf[i++]);
  765.     pr2ntf("%c",'"');
  766.     
  767.     lclass = 0;
  768.     ref   = 0;
  769.     dref   = 0;
  770.     a_loc_save=a_loc;
  771.     i_col_save=i_col;
  772.     i_psp=0; 
  773.     i_col=0;
  774.     operandOveride = 0;
  775.     return 1;
  776. }
  777.  
  778. int bodyprint6()
  779. {
  780. int       i, j, n;
  781.     
  782.     if (GotEof) return 0; 
  783.  
  784.     pushTrace(392);
  785.     if (nextMode>0);
  786.     else
  787.     {
  788.         for(i=i_col;i<max_col;i++) pr1ntf("  ");
  789.         pr2ntf ("WORD %04X", m_dword); printCol = 9; 
  790.         for(i=printCol;i<26;i++) pr1ntf(" ");
  791.         n=m_dword; pr1ntf(";; "); 
  792.         j=n%256; n/=256; if(isprint(j)) {pr2ntf("%c",j);} else {pr1ntf(".");}
  793.                          if(isprint(n)) {pr2ntf("%c",n);} else {pr1ntf(".");}
  794.     }
  795.     popTrace();
  796.     
  797.     lclass = 0;
  798.     ref   = 0;
  799.     dref   = 0;
  800.     a_loc_save=a_loc;
  801.     i_col_save=i_col;
  802.     i_psp=0; 
  803.     i_col=0;
  804.     operandOveride = 0;
  805.     printCol=0;
  806.     return 1;
  807. }
  808.  
  809. int isEntry(DWORD pos)
  810. {
  811. BYTE   b=getMap(pos);
  812.  
  813.     if (isGoodAddress(pos)
  814.         &&((b&0x40)==0x40)) return 1;
  815.     else return 0;
  816. }
  817.  
  818. int GotName(int class, DWORD pos, DWORD pos1)
  819. {
  820.     int    i;
  821.     int    r;
  822.     char  *p;
  823.     _key_  k;
  824.     PKEY   pk;
  825.                                                 
  826.     r=((int)pos);
  827.     if ((int)lpFile<r&&r<(int)lpFile+fsize)
  828.     {
  829.         k.c_ref=pos; k.c_pos=-1; k.class=0;
  830.         pk = searchBtreeX(&k);
  831.         
  832.         if ((pk!=NULL)&&((int)piNameBuff<=TOINT(pk->c_pos))
  833.           &&(TOINT(pk->c_pos)<(int)piNameBuff+piNameBuffSize))
  834.         {  
  835.             pr1ntf("\n");
  836.             for(i=0;i<28;i++)pr1ntf(" ");
  837.             p=strtok((char *)(pk->c_pos),".");
  838.             if (class<10) {pr2ntf(";;jmp %s",p);} else {pr2ntf(";;call %s",p);}
  839.             pr1ntf(".");
  840.             
  841.             if (*(PBYTE)(r+2)==0x00 && *(PBYTE)(r+3)==0x80)
  842.             {
  843.                 pr2ntf("Thunk:%04X",*(short *)r);
  844.             }
  845.             else
  846.             {
  847.                 p=TranslateFunctionName((char *)r);
  848.                 pr2ntf("%s",p); 
  849.             }
  850.             return 1;
  851.         }
  852.     }
  853.     if ((int)peNameBuff<r&&r<(int)peNameBuff+peNameBuffSize)
  854.     {
  855.         pr1ntf("\n");
  856.         for(i=0;i<28;i++)pr1ntf(" ");
  857.         p=TranslateFunctionName((char *)r);
  858.         pr2ntf(";;%s",p);
  859.         return 1;
  860.     }
  861.     if (isEntry(pos1) && ref!=pos1) 
  862.     {
  863.         pr2ntf(" ;; %08X",(int)pos1);
  864.         return 1;
  865.     }
  866.     return 0;
  867. }
  868.  
  869. int printName(DWORD pos)
  870. {
  871. DWORD          r;
  872. _key_          k, k1, k2, k3;
  873. PKEY           pk;
  874. int            found;
  875.         
  876. // this is very tricky.. i need to be extremely careful. oct.31,1997sangcho
  877.         
  878.         k.c_ref=pos; k.c_pos=-1; k.class=0;
  879.         pk = searchBtree1(&k);
  880.         if(pk==NULL) return 0;
  881.  
  882.         k1=*pk;  
  883.         
  884.         k.c_ref=k1.c_pos; k.c_pos=-1; k.class=0; 
  885.         pk=searchBtreeX(&k);
  886.         if (pk!=NULL) found=1;
  887.         else found=0;
  888.         
  889.         if (found || AddressCheck(k1.c_pos))
  890.         {
  891.             r=k1.c_pos;
  892.             k.c_ref=r;  k.c_pos=-1; k.class=0;
  893.             
  894.             pk = searchBtreeX(&k);
  895.             
  896.             if (pk!=NULL)
  897.             {
  898.                 return GotName(pk->class, pk->c_pos, k1.c_pos);
  899.             }
  900.             
  901.             pk = searchBtree1(&k);
  902.       
  903.             if(pk==NULL) 
  904.             {
  905.                 if (isEntry(k1.c_pos) && ref!=k1.c_pos) 
  906.                 {
  907.                     pr2ntf(" ;; %08X",(int)(k1.c_pos));
  908.                     return 1;
  909.                 }
  910.                 return 0; 
  911.             }
  912.  
  913.             k2=*pk;
  914.             k.c_ref=k2.c_pos; k.c_pos=-1; k.class=0;
  915.             
  916.             pk = searchBtreeX(&k);
  917.             
  918.             if(pk==NULL)
  919.             {
  920.                 if (isEntry(k1.c_pos) && ref!=k1.c_pos) 
  921.                 {
  922.                     pr2ntf(" ;; %08X",(int)(k1.c_pos));
  923.                     return 1;
  924.                 }
  925.                 return 0; 
  926.             }
  927.  
  928.             k3=*pk;
  929.             return GotName(k3.class, k3.c_pos, k1.c_pos);
  930.         }
  931.        
  932.         return 1;
  933. }
  934.  
  935.  
  936. int printExportName1(DWORD ref)
  937. {
  938. int            r;
  939. _key_          k;
  940. PKEY           pk;
  941. PBYTE          p;
  942.         
  943.     k.c_ref=ref; k.c_pos=-1; k.class=0;
  944.     pk = searchBtreeX(&k);
  945.     if(pk==NULL) return 0;
  946.     r=((int)(pk->c_pos));
  947.     if ((int)peNameBuff<r&&r<(int)peNameBuff+peNameBuffSize)
  948.     {
  949.         p=TranslateFunctionName((char *)r);
  950.         pr2ntf("%s",p);
  951.     }
  952.     return 1;
  953. }
  954.  
  955. int printExportName()
  956. {
  957. BYTE          b, d;
  958.     d=getByteFile(cur_position);
  959.     if (d==0xC3) 
  960.     {
  961.         b=getMap(cur_position);
  962.         if (b&0x40) return printEntryMark();
  963.         if (b&0x20) return printLabelMark();
  964.         return 1;
  965.     }
  966.     pr1ntf("\n=========\n");
  967.     printExportName1(cur_position);
  968.     pr1ntf("\n=========");
  969.     return 1;
  970. }
  971.  
  972. int printEntryMark()
  973. {
  974.     pr1ntf("\n=========");
  975.     return 1;
  976. }
  977.  
  978. int printLabelMark()
  979. {
  980.     pr1ntf("\n---------");
  981.     return 1;
  982. }
  983.  
  984. int printDataMark()
  985. {
  986. _key_          k;
  987. PKEY           pk;
  988. int            c;
  989.  
  990.     k.c_ref=cur_position; k.c_pos=-1; k.class=0;
  991.     pk = searchBtree3(&k);
  992.     if (pk==NULL) {pr1ntf("\n---------");return 1;}
  993.     c=pk->class;  lclass=c;
  994.          if (c==514) {pr1ntf("\n#########..DWORD..");}
  995.     else if (c==515) {pr1ntf("\n#########..14/24bytes.");}
  996.     else if (c==516) {pr1ntf("\n#########..WORD...");}
  997.     else if (c==517) {pr1ntf("\n#########..80real..");}
  998.     else if (c==518) {pr1ntf("\n#########..8bytes...");}
  999.     else if (c==524) {pr1ntf("\n#########..32real.");}
  1000.     else if (c==528) {pr1ntf("\n#########..64real.");}
  1001.     else             {pr1ntf("\n#########");}
  1002.     return 1;
  1003. }
  1004.  
  1005. int printString()
  1006. {
  1007. DWORD          r;
  1008. _key_          k;
  1009. PKEY           pk;
  1010. PBYTE          p;
  1011.         
  1012.     k.c_ref=cur_position; k.c_pos=-1; k.class=0;
  1013.     pk = searchBtree1(&k);
  1014.     if(pk==NULL) return 0;
  1015.     r=pk->c_pos;
  1016.     p=toFile(r);
  1017.     pr1ntf("\n                      (StringData)");
  1018.     pr2ntf("%c",'"');
  1019.     while(isprint(*p)) {pr2ntf("%c",*p);p++;}
  1020.     if (*p==0x0D && *(p+1)==0x0A) {pr1ntf(" <cr><lf>");}
  1021.     else if (*p==0x0A) 
  1022.     { 
  1023.         pr1ntf(" <lf>");
  1024.         if (*(p+1)==0x0A) {pr1ntf(" <lf>");}    
  1025.     } 
  1026.     else if (*p==0x09)
  1027.     { 
  1028.         pr1ntf(" <t>");
  1029.         if (*(p+1)==0x09) {pr1ntf(" <t>");}
  1030.     }
  1031.     pr2ntf("%c",'"');
  1032.     return 1;
  1033. }
  1034.  
  1035. int print0case()  
  1036. {                 
  1037.     switch(i_opcode)
  1038.     {
  1039.         case 0x06:  pr1ntf("push es"); printCol+=7; break;   
  1040.         case 0x07:  pr1ntf("pop es");  printCol+=6; break;   
  1041.         case 0x0E:  pr1ntf("push cs"); printCol+=7; break;   
  1042.         case 0x16:  pr1ntf("push ss"); printCol+=7; break;     
  1043.         case 0x17:  pr1ntf("pop ss");  printCol+=6; break;    
  1044.         case 0x1E:  pr1ntf("push ds"); printCol+=7; break;     
  1045.         case 0x1F:  pr1ntf("pop ds");  printCol+=6; break;    
  1046.         case 0x27:  pr1ntf("daa");     printCol+=3; break; 
  1047.         case 0x2F:  pr1ntf("das");     printCol+=3; break;     
  1048.         case 0x37:  pr1ntf("aaa");     printCol+=3; break;     
  1049.         case 0x3F:  pr1ntf("aas");     printCol+=3; break;     
  1050.         case 0x40:  if (operandOveride){pr1ntf("inc ax"); printCol+=6;}
  1051.                     else               {pr1ntf("inc eax");printCol+=7;}
  1052.                     break;   
  1053.         case 0x41:  if (operandOveride){pr1ntf("inc cx"); printCol+=6;}
  1054.                     else               {pr1ntf("inc ecx");printCol+=7;}
  1055.                     break;   
  1056.         case 0x42:  if (operandOveride){pr1ntf("inc dx"); printCol+=6;}
  1057.                     else               {pr1ntf("inc edx");printCol+=7;}
  1058.                     break;     
  1059.         case 0x43:  if (operandOveride){pr1ntf("inc bx"); printCol+=6;}
  1060.                     else               {pr1ntf("inc ebx");printCol+=7;}
  1061.                     break;   
  1062.         case 0x44:  if (operandOveride){pr1ntf("inc sp"); printCol+=6;}
  1063.                     else               {pr1ntf("inc esp");printCol+=7;}
  1064.                     break;   
  1065.         case 0x45:  if (operandOveride){pr1ntf("inc bp"); printCol+=6;}
  1066.                     else               {pr1ntf("inc ebp");printCol+=7;}
  1067.                     break;   
  1068.         case 0x46:  if (operandOveride){pr1ntf("inc si"); printCol+=6;}
  1069.                     else               {pr1ntf("inc esi");printCol+=7;}
  1070.                     break;   
  1071.         case 0x47:  if (operandOveride){pr1ntf("inc di"); printCol+=6;}
  1072.                     else               {pr1ntf("inc edi");printCol+=7;}
  1073.                     break;  
  1074.         case 0x48:  if (operandOveride){pr1ntf("dec ax"); printCol+=6;}
  1075.                     else               {pr1ntf("dec eax");printCol+=7;}
  1076.                     break;   
  1077.         case 0x49:  if (operandOveride){pr1ntf("dec cx"); printCol+=6;}
  1078.                     else               {pr1ntf("dec ecx");printCol+=7;}
  1079.                     break;   
  1080.         case 0x4A:  if (operandOveride){pr1ntf("dec dx"); printCol+=6;}
  1081.                     else               {pr1ntf("dec edx");printCol+=7;}
  1082.                     break;     
  1083.         case 0x4B:  if (operandOveride){pr1ntf("dec bx"); printCol+=6;}
  1084.                     else               {pr1ntf("dec ebx");printCol+=7;}
  1085.                     break;   
  1086.         case 0x4C:  if (operandOveride){pr1ntf("dec sp"); printCol+=6;}
  1087.                     else               {pr1ntf("dec esp");printCol+=7;}
  1088.                     break;   
  1089.         case 0x4D:  if (operandOveride){pr1ntf("dec bp"); printCol+=6;}
  1090.                     else               {pr1ntf("dec ebp");printCol+=7;}
  1091.                     break;   
  1092.         case 0x4E:  if (operandOveride){pr1ntf("dec si"); printCol+=6;}
  1093.                     else               {pr1ntf("dec esi");printCol+=7;}
  1094.                     break;   
  1095.         case 0x4F:  if (operandOveride){pr1ntf("dec di"); printCol+=6;}
  1096.                     else               {pr1ntf("dec edi");printCol+=7;}
  1097.                     break; 
  1098.         case 0x50:  if (operandOveride){pr1ntf("push ax"); printCol+=7;}
  1099.                     else               {pr1ntf("push eax");printCol+=8;}
  1100.                     break;   
  1101.         case 0x51:  if (operandOveride){pr1ntf("push cx"); printCol+=7;}
  1102.                     else               {pr1ntf("push ecx");printCol+=8;}
  1103.                     break;   
  1104.         case 0x52:  if (operandOveride){pr1ntf("push dx"); printCol+=7;}
  1105.                     else               {pr1ntf("push edx");printCol+=8;}
  1106.                     break;     
  1107.         case 0x53:  if (operandOveride){pr1ntf("push bx"); printCol+=7;}
  1108.                     else               {pr1ntf("push ebx");printCol+=8;} 
  1109.                     break;   
  1110.         case 0x54:  if (operandOveride){pr1ntf("push sp"); printCol+=7;}
  1111.                     else               {pr1ntf("push esp");printCol+=8;}
  1112.                     break;   
  1113.         case 0x55:  if (operandOveride){pr1ntf("push bp"); printCol+=7;}
  1114.                     else               {pr1ntf("push ebp");printCol+=8;}
  1115.                     break;   
  1116.         case 0x56:  if (operandOveride){pr1ntf("push si"); printCol+=7;}
  1117.                     else               {pr1ntf("push esi");printCol+=8;}
  1118.                     break;   
  1119.         case 0x57:  if (operandOveride){pr1ntf("push di"); printCol+=7;}
  1120.                     else               {pr1ntf("push edi");printCol+=8;}
  1121.                     break;  
  1122.         case 0x58:  if (operandOveride){pr1ntf("pop ax"); printCol+=6;}
  1123.                     else               {pr1ntf("pop eax");printCol+=7;}
  1124.                     break;   
  1125.         case 0x59:  if (operandOveride){pr1ntf("pop cx"); printCol+=6;}
  1126.                     else               {pr1ntf("pop ecx");printCol+=7;}
  1127.                     break;   
  1128.         case 0x5A:  if (operandOveride){pr1ntf("pop dx"); printCol+=6;}
  1129.                     else               {pr1ntf("pop edx");printCol+=7;}
  1130.                     break;     
  1131.         case 0x5B:  if (operandOveride){pr1ntf("pop bx"); printCol+=6;}
  1132.                     else               {pr1ntf("pop ebx");printCol+=7;}
  1133.                     break;   
  1134.         case 0x5C:  if (operandOveride){pr1ntf("pop sp"); printCol+=6;}
  1135.                     else               {pr1ntf("pop esp");printCol+=7;}
  1136.                     break;   
  1137.         case 0x5D:  if (operandOveride){pr1ntf("pop bp"); printCol+=6;}
  1138.                     else               {pr1ntf("pop ebp");printCol+=7;}
  1139.                     break;   
  1140.         case 0x5E:  if (operandOveride){pr1ntf("pop si"); printCol+=6;}
  1141.                     else               {pr1ntf("pop esi");printCol+=7;}
  1142.                     break;   
  1143.         case 0x5F:  if (operandOveride){pr1ntf("pop di"); printCol+=6;}
  1144.                     else               {pr1ntf("pop edi");printCol+=7;}
  1145.                     break; 
  1146.         case 0x60:  pr1ntf("pushad");               printCol+=6;  break;  
  1147.         case 0x61:  pr1ntf("popad");                printCol+=5;  break;   
  1148.         case 0x6C:  pr1ntf("ins byte, port[dx]");   printCol+=18; break;   
  1149.         case 0x6D:  pr1ntf("ins dword, port[dx]");  printCol+=19; break;   
  1150.         case 0x6E:  pr1ntf("outs port[dx], byte");  printCol+=19; break;     
  1151.         case 0x6F:  pr1ntf("outs port[dx], dword"); printCol+=20; break;    
  1152.         case 0x90:  pr1ntf("nop");                  printCol+=3;  break;     
  1153.         case 0x91:  if (operandOveride){pr1ntf("xchg ax, cx")  ;printCol+=11;}
  1154.                     else               {pr1ntf("xchg eax, ecx");printCol+=13;}
  1155.                     break;    
  1156.         case 0x92:  if (operandOveride){pr1ntf("xchg ax, dx")  ;printCol+=11;}
  1157.                     else               {pr1ntf("xchg eax, edx");printCol+=13;}
  1158.                     break; 
  1159.         case 0x93:  if (operandOveride){pr1ntf("xchg ax, bx")  ;printCol+=11;}
  1160.                     else               {pr1ntf("xchg eax, ebx");printCol+=13;}
  1161.                     break;     
  1162.         case 0x94:  if (operandOveride){pr1ntf("xchg ax, sp")  ;printCol+=11;}
  1163.                     else               {pr1ntf("xchg eax, esp");printCol+=13;}
  1164.                     break;     
  1165.         case 0x95:  if (operandOveride){pr1ntf("xchg ax, bp")  ;printCol+=11;}
  1166.                     else               {pr1ntf("xchg eax, ebp");printCol+=13;}
  1167.                     break;     
  1168.         case 0x96:  if (operandOveride){pr1ntf("xchg ax, si")  ;printCol+=11;}
  1169.                     else               {pr1ntf("xchg eax, esi");printCol+=13;}
  1170.                     break;   
  1171.         case 0x97:  if (operandOveride){pr1ntf("xchg ax, di")  ;printCol+=11;}
  1172.                     else               {pr1ntf("xchg eax, edi");printCol+=13;}
  1173.                     break;   
  1174.         case 0x98:  pr1ntf("cbw");                  printCol+=3;  break;   
  1175.         case 0x99:  if (operandOveride) {pr1ntf("cwd");}
  1176.                     else                {pr1ntf("cdq");} printCol+=3;    
  1177.                     break;   
  1178.         case 0x9C:  pr1ntf("pushfd");               printCol+=6;  break;   
  1179.         case 0x9D:  pr1ntf("popfd");                printCol+=5;  break;   
  1180.         case 0x9E:  pr1ntf("sahf");                 printCol+=4;  break;   
  1181.         case 0x9F:  pr1ntf("lahf");                 printCol+=4;  break;   
  1182.         case 0xA4:  pr1ntf("movsb");                printCol+=5;  break;   
  1183.         case 0xA5:  if (operandOveride) {pr1ntf ("movsw");}
  1184.                     else                {pr1ntf ("movsd");} printCol+=5; 
  1185.                     break;   
  1186.         case 0xA6:  pr1ntf("cmpsb");                printCol+=5;  break;   
  1187.         case 0xA7:  if (operandOveride) {pr1ntf ("cmpsw");}
  1188.                     else                {pr1ntf ("cmpsd");} printCol+=5;
  1189.                     break;   
  1190.         case 0xAA:  pr1ntf("stosb");                printCol+=5;  break;
  1191.         case 0xAB:  if (operandOveride) {pr1ntf ("stosw");}
  1192.                     else                {pr1ntf ("stosd");} printCol+=5;
  1193.                     break;    
  1194.         case 0xAC:  pr1ntf("lodsb");                printCol+=5;  break;   
  1195.         case 0xAD:  if (operandOveride) {pr1ntf ("lodsw");}
  1196.                     else                {pr1ntf ("lodsd");} printCol+=5;
  1197.                     break;   
  1198.         case 0xAE:  pr1ntf("scasb");                printCol+=5;  break;   
  1199.         case 0xAF:  if (operandOveride) {pr1ntf ("scasw");}
  1200.                     else                {pr1ntf ("scasd");} printCol+=5;
  1201.                     break;   
  1202.         case 0xC3:  pr1ntf("ret");  needspacing=1;           printCol+=3;
  1203.                     lastAnchor=cur_position+i_col-1;
  1204.                     needJump=1;     needJumpNext=cur_position+i_col;
  1205.                     pushTrace(145);
  1206.                     if(nextMode>0) orMap(lastAnchor, 0x80);
  1207.                     popTrace();
  1208.                     break;   
  1209.         case 0xC9:  pr1ntf("leave");                printCol+=5;  break;   
  1210.         case 0xCB:  pr1ntf("ret(far)");    needspacing=1;    printCol+=8; 
  1211.                     lastAnchor=cur_position+i_col-1;
  1212.                     needJump=1;     needJumpNext=cur_position+i_col;
  1213.                     pushTrace(146);
  1214.                     if(nextMode>0) orMap(lastAnchor, 0x80);
  1215.                     popTrace();
  1216.                     //leaveFlag=cur_position+i_col;
  1217.                     break;   
  1218.         case 0xCC:  pr1ntf("int 03");               printCol+=6;  break;   
  1219.         case 0xCE:  pr1ntf("into");                 printCol+=4;  break;   
  1220.         case 0xCF:  if (operandOveride){pr1ntf ("iret"); printCol+=4;}
  1221.                     else               {pr1ntf ("iretd");printCol+=5;}
  1222.                     break;   
  1223.         case 0xD7:  pr1ntf("xlatb");                printCol+=5;  break;   
  1224.         case 0xEC:  pr1ntf("in al, port[dx]");      printCol+=15; break;   
  1225.         case 0xED:  if (operandOveride){pr1ntf ("in ax, port[dx]"); printCol+=15;}
  1226.                     else               {pr1ntf ("in eax, port[dx]");printCol+=16;}
  1227.                     break;   
  1228.         case 0xEE:  pr1ntf("out port[dx], al");     printCol+=16; break;   
  1229.         case 0xEF:  if (operandOveride){pr1ntf ("out port[dx], ax"); printCol+=16;}
  1230.                     else               {pr1ntf ("out port[dx], eax");printCol+=17;}
  1231.                     break;   
  1232.         case 0xF0:  pr1ntf("lock");                 printCol+=4;  break;   
  1233.         case 0xF4:  pr1ntf("hlt");                  printCol+=3;  break;   
  1234.         case 0xF5:  pr1ntf("cmc");                  printCol+=3;  break;   
  1235.         case 0xF8:  pr1ntf("clc");                  printCol+=3;  break;  
  1236.         case 0xF9:  pr1ntf("stc");                  printCol+=3;  break;   
  1237.         case 0xFA:  pr1ntf("cli");                  printCol+=3;  break;   
  1238.         case 0xFB:  pr1ntf("sti");                  printCol+=3;  break;   
  1239.         case 0xFC:  pr1ntf("cld");                  printCol+=3;  break;     
  1240.         case 0xFD:  pr1ntf("std");                  printCol+=3;  break;
  1241.         default:    fatalError=107;return -1;
  1242.     }
  1243.     return 0;
  1244. }
  1245.  
  1246. int print1case()
  1247. {
  1248.     switch(i_opcode)
  1249.     {
  1250.         case 0x04:  pr1ntf("add al, ");    print_i_byte(); printCol+=8; break;   
  1251.         case 0x0C:  pr1ntf("or al, ");     print_i_byte(); printCol+=7; break;   
  1252.         case 0x14:  pr1ntf("adc al, ");    print_i_byte(); printCol+=8; break;   
  1253.         case 0x1C:  pr1ntf("sbb al, ");    print_i_byte(); printCol+=8; break;     
  1254.         case 0x24:  pr1ntf("and al, ");    print_i_byte(); printCol+=8; break;    
  1255.         case 0x2C:  pr1ntf("sub al, ");    print_i_byte(); printCol+=8; break;     
  1256.         case 0x34:  pr1ntf("xor al, ");    print_i_byte(); printCol+=8; break;    
  1257.         case 0x3C:  pr1ntf("cmp al, ");    print_i_byte(); printCol+=8; break; 
  1258.         case 0x6A:  pr1ntf("push ");       print_i_byte32(); printCol+=5; break;     
  1259.         case 0x70:  pr1ntf("jo ");         print_rel8();   printCol+=3; break;     
  1260.         case 0x71:  pr1ntf("jno ");        print_rel8();   printCol+=4; break;     
  1261.         case 0x72:  pr1ntf("jc ");         print_rel8();   printCol+=3; break;   
  1262.         case 0x73:  pr1ntf("jae ");        print_rel8();   printCol+=4; break;   
  1263.         case 0x74:  pr1ntf("je ");         print_rel8();   printCol+=3; break;   
  1264.         case 0x75:  pr1ntf("jne ");        print_rel8();   printCol+=4; break;   
  1265.         case 0x76:  pr1ntf("jbe ");        print_rel8();   printCol+=4; break;   
  1266.         case 0x77:  pr1ntf("ja ");         print_rel8();   printCol+=3; break;   
  1267.         case 0x78:  pr1ntf("js ");         print_rel8();   printCol+=3; break;   
  1268.         case 0x79:  pr1ntf("jns ");        print_rel8();   printCol+=4; break;   
  1269.         case 0x7A:  pr1ntf("jpe ");        print_rel8();   printCol+=4; break;   
  1270.         case 0x7B:  pr1ntf("jpo ");        print_rel8();   printCol+=4; break;   
  1271.         case 0x7C:  pr1ntf("jl ");         print_rel8();   printCol+=3; break;   
  1272.         case 0x7D:  pr1ntf("jge ");        print_rel8();   printCol+=4; break;   
  1273.         case 0x7E:  pr1ntf("jle ");        print_rel8();   printCol+=4; break;   
  1274.         case 0x7F:  pr1ntf("jg ");         print_rel8();   printCol+=3; break;   
  1275.         case 0xA8:  pr1ntf("test al, ");   print_i_byte(); printCol+=9; break;   
  1276.         case 0xB0:  pr1ntf("mov al, ");    print_i_byte(); printCol+=8; break;   
  1277.         case 0xB1:  pr1ntf("mov cl, ");    print_i_byte(); printCol+=8; break;   
  1278.         case 0xB2:  pr1ntf("mov dl, ");    print_i_byte(); printCol+=8; break;   
  1279.         case 0xB3:  pr1ntf("mov bl, ");    print_i_byte(); printCol+=8; break;   
  1280.         case 0xB4:  pr1ntf("mov ah, ");    print_i_byte(); printCol+=8; break;   
  1281.         case 0xB5:  pr1ntf("mov ch, ");    print_i_byte(); printCol+=8; break;   
  1282.         case 0xB6:  pr1ntf("mov dh, ");    print_i_byte(); printCol+=8; break;   
  1283.         case 0xB7:  pr1ntf("mov bh, ");    print_i_byte(); printCol+=8; break;   
  1284.         case 0xCD:  pr1ntf("int ");        print_i_byte(); printCol+=4; break;   
  1285.         case 0xD4:  pr1ntf("aam ");                        printCol+=4; break;   
  1286.         case 0xD5:  pr1ntf("aad ");                        printCol+=4; break;   
  1287.         case 0xE0:  pr1ntf("loopne ");     print_rel8();   printCol+=7; break;   
  1288.         case 0xE1:  pr1ntf("loope ");      print_rel8();   printCol+=6; break;   
  1289.         case 0xE2:  pr1ntf("loop ");       print_rel8();   printCol+=5; break;   
  1290.         case 0xE3:  pr1ntf("jecxz ");      print_rel8();   printCol+=6; break;   
  1291.         case 0xE4:  pr1ntf("in al, port["); print_i_byte(); pr1ntf("]");  printCol+=13; break;   
  1292.         case 0xE5:  pr1ntf("in eax, port[");print_i_byte(); pr1ntf("]");  printCol+=14; break;   
  1293.         case 0xE6:  pr1ntf("out port["); print_i_byte(); pr1ntf("], al"); printCol+=14; break;   
  1294.         case 0xE7:  pr1ntf("out port["); print_i_byte(); pr1ntf("], eax");printCol+=15; break;
  1295.         case 0xEB:  pr1ntf("jmp ");        ref=print_rel8();                printCol+=4;
  1296.                     if (nextMode>0)
  1297.                     {
  1298.                         if (isThisSecure(ref) || referCount(ref)>2 || 
  1299.                             (opclassSave==2 && (opsave&0x80)) )  
  1300.                         {
  1301.                             lastAnchor=cur_position+i_col-1;
  1302.                             pushTrace(147);
  1303.                             orMap(lastAnchor, 0x80);
  1304.                             popTrace();
  1305.                         }
  1306.                     }
  1307.                     break;
  1308.         default:    fatalError=109;return -1;
  1309.     }
  1310.     return 0;
  1311.  
  1312. }
  1313.  
  1314. int print2case()
  1315. {
  1316.     if (i_opcode==0xC2)
  1317.     {
  1318.         pr2ntf("ret %04X", i_word);    needspacing=1; 
  1319.         needJump=1;     needJumpNext=cur_position+i_col;
  1320.     }
  1321.     else
  1322.     {
  1323.         pr2ntf("ret %04X", i_word);    needspacing=1; 
  1324.         needJump=1;     needJumpNext=cur_position+i_col;
  1325.     }
  1326.     printCol+=8;
  1327.     lastAnchor = cur_position+i_col-1;
  1328.     pushTrace(148);
  1329.     if(nextMode>0) orMap(lastAnchor, 0x80);
  1330.     popTrace();
  1331.     //leaveFlag=cur_position+i_col;
  1332.     return 0;
  1333. }
  1334.  
  1335. int print3case()
  1336. {
  1337.     pr2ntf("enter %04X, ", i_word); print_i_byte();
  1338.     printCol+=10;
  1339.     return 0;
  1340. }
  1341.  
  1342. int print4case()
  1343. {
  1344.     switch(i_opcode)
  1345.     {
  1346.         case 0x05:  if (operandOveride){pr1ntf ("add ex, "); printCol+=8;}
  1347.                     else               {pr1ntf ("add eax, ");printCol+=9;}  
  1348.                     print_i_dword();     
  1349.                     break;   
  1350.         case 0x0D:  if (operandOveride){pr1ntf ("or ax, ");  printCol+=7;}
  1351.                     else               {pr1ntf ("or eax, "); printCol+=8;}   
  1352.                     print_i_dword();     
  1353.                     break;   
  1354.         case 0x15:  if (operandOveride){pr1ntf ("adc ax, "); printCol+=8;}
  1355.                     else               {pr1ntf ("adc eax, ");printCol+=9;}  
  1356.                     print_i_dword();     
  1357.                     break;   
  1358.         case 0x1D:  if (operandOveride){pr1ntf ("sbb ax, "); printCol+=8;}
  1359.                     else               {pr1ntf ("sbb eax, ");printCol+=9;}  
  1360.                     print_i_dword();     
  1361.                     break;     
  1362.         case 0x25:  if (operandOveride){pr1ntf ("and ax, "); printCol+=8;}
  1363.                     else               {pr1ntf ("and eax, ");printCol+=9;}  
  1364.                     print_i_dword();     
  1365.                     break; 
  1366.         case 0x2D:  if (operandOveride){pr1ntf ("sub ax, "); printCol+=8;}
  1367.                     else               {pr1ntf ("sub eax, ");printCol+=9;}  
  1368.                     print_i_dword();     
  1369.                     break;      
  1370.         case 0x35:  if (operandOveride){pr1ntf ("xor ax, "); printCol+=8;}
  1371.                     else               {pr1ntf ("xor eax, ");printCol+=9;}  
  1372.                     print_i_dword();     
  1373.                     break;     
  1374.         case 0x3D:  if (operandOveride){pr1ntf ("cmp ax, "); printCol+=8;}
  1375.                     else               {pr1ntf ("cmp eax, ");printCol+=9;}  
  1376.                     print_i_dword();     
  1377.                     break;  
  1378.         case 0x68:  pr1ntf("push ");    ref=print_i_dword();     // this is OK 
  1379.         // well I really don't know it is reasonably safe to do this.
  1380.         // I think when we push some (possible) address references into stack
  1381.         // there is strong reason to do so. that's why i am doing this. i guess...
  1382.                     lclass=512;         printCol+=5; 
  1383.                     break;     
  1384.         case 0xA0:  pr1ntf("mov al, byte");    print_moff(); printCol+=12;        
  1385.                     break;     
  1386.         case 0xA1:  if (operandOveride){pr1ntf ("mov ax, word");  printCol+=12;}
  1387.                     else               {pr1ntf ("mov eax, dword");printCol+=14;}  
  1388.                     ref=print_moff();
  1389.                     if (isGoodAddress(ref)) 
  1390.                     {if (operandOveride) lclass=516; else lclass=1024;}
  1391.                     break;     
  1392.         case 0xA2:  pr1ntf("mov byte");print_moff();pr1ntf(", al");printCol+=12; 
  1393.                     break;
  1394.         case 0xA3:  if (operandOveride){pr1ntf ("mov word"); printCol+=12;}
  1395.                     else               {pr1ntf ("mov dword");printCol+=14;}
  1396.                     print_moff();
  1397.                     if (operandOveride){pr1ntf (", ax");}
  1398.                     else               {pr1ntf (", eax");}
  1399.                     break;
  1400.         case 0xA9:  if (operandOveride){pr1ntf ("test ax, "); printCol+= 9;}
  1401.                     else               {pr1ntf ("test eax, ");printCol+=10;} 
  1402.                     print_i_dword();     
  1403.                     break;   
  1404.         case 0xB8:  if (operandOveride){pr1ntf ("mov ax, "); printCol+=8;}
  1405.                     else               {pr1ntf ("mov eax, ");printCol+=9;}  
  1406.                     ref=print_i_dword();lclass=1024;     
  1407.                     break;   
  1408.         case 0xB9:  if (operandOveride){pr1ntf ("mov cx, "); printCol+=8;}
  1409.                     else               {pr1ntf ("mov ecx, ");printCol+=9;}  
  1410.                     ref=print_i_dword();lclass=1024;     
  1411.                     break;   
  1412.         case 0xBA:  if (operandOveride){pr1ntf ("mov dx, "); printCol+=8;}
  1413.                     else               {pr1ntf ("mov edx, ");printCol+=9;}  
  1414.                     ref=print_i_dword();lclass=1024;     
  1415.                     break;   
  1416.         case 0xBB:  if (operandOveride){pr1ntf ("mov bx, "); printCol+=8;}
  1417.                     else               {pr1ntf ("mov ebx, ");printCol+=9;}  
  1418.                     ref=print_i_dword();lclass=1024;     
  1419.                     break;   
  1420.         case 0xBC:  if (operandOveride){pr1ntf ("mov sp, "); printCol+=8;}
  1421.                     else               {pr1ntf( "mov esp, ");printCol+=9;}  
  1422.                     ref=print_i_dword();lclass=1024;     
  1423.                     break;   
  1424.         case 0xBD:  if (operandOveride){pr1ntf ("mov bp, "); printCol+=8;}
  1425.                     else               {pr1ntf ("mov ebp, ");printCol+=9;}  
  1426.                     ref=print_i_dword();lclass=1024;     
  1427.                     break;   
  1428.         case 0xBE:  if (operandOveride){pr1ntf ("mov si, "); printCol+=8;}
  1429.                     else               {pr1ntf ("mov esi, ");printCol+=9;}  
  1430.                     ref=print_i_dword();lclass=1024;     
  1431.                     break;   
  1432.         case 0xBF:  if (operandOveride){pr1ntf ("mov di, "); printCol+=8;}
  1433.                     else               {pr1ntf ("mov edi, ");printCol+=9;}  
  1434.                     ref=print_i_dword();lclass=1024;     
  1435.                     break;   
  1436.         case 0xE8:  pr1ntf("call "); 
  1437.                     lclass = 11;        printCol+=5;
  1438.                     ref = print_rel32();
  1439.                     needCall=1;
  1440.                     if (nextMode) {
  1441.                         if (isGoodAddress(ref))
  1442.                         {
  1443.                             needCallRef=ref;
  1444.                             needCallNext=cur_position+i_col;
  1445.                             lastAnchor=cur_position+i_col-1;
  1446.                             pushTrace(158);
  1447.                             if(nextMode>0) orMap(lastAnchor, 0x80);
  1448.                             popTrace();
  1449.                         }
  1450.                         else fatalError=-18;
  1451.                     }
  1452.                     else printName(cur_position); 
  1453.                     break;
  1454.                                         
  1455.         case 0xE9:  pr1ntf("jmp ");  ref = print_rel32();       
  1456.                     lclass =  3;      printCol+=4;
  1457.                     lastAnchor=cur_position+i_col-1;
  1458.                     needJump=1;     needJumpNext=cur_position+i_col;
  1459.                     if (nextMode>0) 
  1460.                     {
  1461.                         if (! isGoodAddress(ref)) {lclass=0; fatalError=990;}
  1462.                         else
  1463.                         {       
  1464.                             pushTrace(149);
  1465.                             orMap(lastAnchor, 0x80);
  1466.                             popTrace();
  1467.                         }
  1468.                     }
  1469.                     else printName(cur_position);
  1470.                     //leaveFlag=cur_position+i_col;
  1471.                     break;            
  1472.         default:    fatalError=111;return -1;
  1473.     }
  1474.     return 0;
  1475.  
  1476. }
  1477.  
  1478. int print5case()
  1479. {
  1480.     if (i_opcode==0x9A)
  1481.     {
  1482.         pr3ntf("call far %04X:%08X", i_word,i_dword);
  1483.         {lclass=15; ref=i_dword;}
  1484.         printCol+=22;
  1485.     }
  1486.     else
  1487.     {
  1488.         pr3ntf("jmp far %04X:%08X", i_word,i_dword);
  1489.         needJump=1;     needJumpNext=cur_position+i_col;
  1490.         {lclass=7; ref=i_dword;}
  1491.         printCol+=21;
  1492.     }
  1493.     return 0;
  1494. }
  1495.  
  1496. int print6case()  
  1497. {
  1498. int    rr;
  1499.  
  1500.     if (operandOveride) rr=16; else rr=32;
  1501.  
  1502.     switch(i_opcode)
  1503.     {
  1504.           case 0x00: pr1ntf("add ");    ref=r_m_( 8);  pr1ntf(", ");  r___( 8);  printCol+=6; 
  1505.                    if (isGoodAddress(ref)) lclass=520;
  1506.                    break; 
  1507.           case 0x01: pr1ntf("add ");    ref=r_m_(rr);  pr1ntf(", ");  r___(rr);  printCol+=6; 
  1508.                    if (isGoodAddress(ref)) 
  1509.                    {if (operandOveride) lclass=516; else lclass=514;}
  1510.                    break; 
  1511.           case 0x02: pr1ntf("add ");    r___( 8);  pr1ntf(", ");  ref=r_m_( 8);  printCol+=6; 
  1512.                    if (isGoodAddress(ref)) lclass=520;
  1513.                    break; 
  1514.           case 0x03: pr1ntf("add ");    r___(rr);  pr1ntf(", ");  ref=r_m_(rr);  printCol+=6; 
  1515.                    if (isGoodAddress(ref)) 
  1516.                    {if (operandOveride) lclass=516; else lclass=514;}
  1517.                    break; 
  1518.           case 0x08: pr1ntf("or ");     ref=r_m_( 8);  pr1ntf(", ");  r___( 8);  printCol+=5; 
  1519.                    if (isGoodAddress(ref)) lclass=520;
  1520.                    break; 
  1521.           case 0x09: pr1ntf("or ");     ref=r_m_(rr);  pr1ntf(", ");  r___(rr);  printCol+=5; 
  1522.                    if (isGoodAddress(ref)) 
  1523.                    {if (operandOveride) lclass=516; else lclass=514;}
  1524.                    break; 
  1525.           case 0x0A: pr1ntf("or ");     r___( 8);  pr1ntf(", ");  ref=r_m_( 8);  printCol+=5; 
  1526.                    if (isGoodAddress(ref)) lclass=520;
  1527.                    break; 
  1528.           case 0x0B: pr1ntf("or ");     r___(rr);  pr1ntf(", ");  ref=r_m_(rr);  printCol+=5; 
  1529.                    if (isGoodAddress(ref)) 
  1530.                    {if (operandOveride) lclass=516; else lclass=514;}
  1531.                    break; 
  1532.           case 0x10: pr1ntf("adc ");    ref=r_m_( 8);  pr1ntf(", ");  r___( 8);  printCol+=6; 
  1533.                    if (isGoodAddress(ref)) lclass=520;
  1534.                    break; 
  1535.           case 0x11: pr1ntf("adc ");    ref=r_m_(rr);  pr1ntf(", ");  r___(rr);  printCol+=6; 
  1536.                    if (isGoodAddress(ref)) 
  1537.                    {if (operandOveride) lclass=516; else lclass=514;}
  1538.                    break; 
  1539.           case 0x12: pr1ntf("adc ");    r___( 8);  pr1ntf(", ");  ref=r_m_( 8);  printCol+=6; 
  1540.                    if (isGoodAddress(ref)) lclass=520;
  1541.                    break; 
  1542.           case 0x13: pr1ntf("adc ");    r___(rr);  pr1ntf(", ");  ref=r_m_(rr);  printCol+=6; 
  1543.                    if (isGoodAddress(ref)) 
  1544.                    {if (operandOveride) lclass=516; else lclass=514;}
  1545.                    break; 
  1546.           case 0x18: pr1ntf("sbb ");    ref=r_m_( 8);  pr1ntf(", ");  r___( 8);  printCol+=6; 
  1547.                    if (isGoodAddress(ref)) lclass=520;
  1548.                    break; 
  1549.           case 0x19: pr1ntf("sbb ");    ref=r_m_(rr);  pr1ntf(", ");  r___(rr);  printCol+=6; 
  1550.                    if (isGoodAddress(ref)) 
  1551.                    {if (operandOveride) lclass=516; else lclass=514;}
  1552.                    break; 
  1553.           case 0x1A: pr1ntf("sbb ");    r___( 8);  pr1ntf(", ");  ref=r_m_( 8);  printCol+=6; 
  1554.                    if (isGoodAddress(ref)) lclass=520;
  1555.                    break; 
  1556.           case 0x1B: pr1ntf("sbb ");    r___(rr);  pr1ntf(", ");  ref=r_m_(rr);  printCol+=6; 
  1557.                    if (isGoodAddress(ref)) 
  1558.                    {if (operandOveride) lclass=516; else lclass=514;}
  1559.                    break; 
  1560.           case 0x20: pr1ntf("and ");    ref=r_m_( 8);  pr1ntf(", ");  r___( 8);  printCol+=6; 
  1561.                    if (isGoodAddress(ref)) lclass=520;
  1562.                    break; 
  1563.           case 0x21: pr1ntf("and ");    ref=r_m_(rr);  pr1ntf(", ");  r___(rr);  printCol+=6; 
  1564.                    if (isGoodAddress(ref)) 
  1565.                    {if (operandOveride) lclass=516; else lclass=514;}
  1566.                    break; 
  1567.           case 0x22: pr1ntf("and ");    r___( 8);  pr1ntf(", ");  ref=r_m_( 8);  printCol+=6; 
  1568.                    if (isGoodAddress(ref)) lclass=520;
  1569.                    break; 
  1570.           case 0x23: pr1ntf("and ");    r___(rr);  pr1ntf(", ");  ref=r_m_(rr);  printCol+=6; 
  1571.                    if (isGoodAddress(ref)) 
  1572.                    {if (operandOveride) lclass=516; else lclass=514;}
  1573.                    break; 
  1574.           case 0x28: pr1ntf("sub ");    ref=r_m_( 8);  pr1ntf(", ");  r___( 8);  printCol+=6; 
  1575.                    if (isGoodAddress(ref)) lclass=520;
  1576.                    break; 
  1577.           case 0x29: pr1ntf("sub ");    ref=r_m_(rr);  pr1ntf(", ");  r___(rr);  printCol+=6; 
  1578.                    if (isGoodAddress(ref)) 
  1579.                    {if (operandOveride) lclass=516; else lclass=514;}
  1580.                    break; 
  1581.           case 0x2A: pr1ntf("sub ");    r___( 8);  pr1ntf(", ");  ref=r_m_( 8);  printCol+=6; 
  1582.                    if (isGoodAddress(ref)) lclass=520;
  1583.                    break; 
  1584.           case 0x2B: pr1ntf("sub ");    r___(rr);  pr1ntf(", ");  ref=r_m_(rr);  printCol+=6; 
  1585.                    if (isGoodAddress(ref)) 
  1586.                    {if (operandOveride) lclass=516; else lclass=514;}
  1587.                    break; 
  1588.           case 0x30: pr1ntf("xor ");    ref=r_m_( 8);  pr1ntf(", ");  r___( 8);  printCol+=6; 
  1589.                    if (isGoodAddress(ref)) lclass=520;
  1590.                    break; 
  1591.           case 0x31: pr1ntf("xor ");    ref=r_m_(rr);  pr1ntf(", ");  r___(rr);  printCol+=6; 
  1592.                    if (isGoodAddress(ref)) 
  1593.                    {if (operandOveride) lclass=516; else lclass=514;}
  1594.                    break; 
  1595.           case 0x32: pr1ntf("xor ");    r___( 8);  pr1ntf(", ");  ref=r_m_( 8);  printCol+=6; 
  1596.                    if (isGoodAddress(ref)) lclass=520;
  1597.                    break; 
  1598.           case 0x33: pr1ntf("xor ");    r___(rr);  pr1ntf(", ");  ref=r_m_(rr);  printCol+=6; 
  1599.                    if (isGoodAddress(ref)) 
  1600.                    {if (operandOveride) lclass=516; else lclass=514;}
  1601.                    break; 
  1602.           case 0x38: pr1ntf("cmp ");    ref=r_m_( 8);  pr1ntf(", ");  r___( 8);  printCol+=6; 
  1603.                    if (isGoodAddress(ref)) lclass=520;
  1604.                    break; 
  1605.           case 0x39: pr1ntf("cmp ");    ref=r_m_(rr);  pr1ntf(", ");  r___(rr);  printCol+=6; 
  1606.                    if (isGoodAddress(ref)) 
  1607.                    {if (operandOveride) lclass=516; else lclass=514;}
  1608.                    break; 
  1609.           case 0x3A: pr1ntf("cmp ");    r___( 8);  pr1ntf(", ");  ref=r_m_( 8);  printCol+=6; 
  1610.                    if (isGoodAddress(ref)) lclass=520;
  1611.                    break; 
  1612.           case 0x3B: pr1ntf("cmp ");    r___(rr);  pr1ntf(", ");  ref=r_m_(rr);  printCol+=6; 
  1613.                    if (isGoodAddress(ref)) 
  1614.                    {if (operandOveride) lclass=516; else lclass=514;}
  1615.                    break; 
  1616.           case 0x62: pr1ntf("bound ");  r___(rr);  pr1ntf(", ");  ref=m32_32();  printCol+=8; 
  1617.                    if (isGoodAddress(ref)) lclass=518;
  1618.                    break; 
  1619.           case 0x63: pr1ntf("arpl ");   ref=r_m_(16);  pr1ntf(", ");  r___(16);  printCol+=7; 
  1620.                    if (isGoodAddress(ref)) lclass=516;
  1621.                    break; 
  1622.           case 0x84: pr1ntf("test ");   ref=r_m_( 8);  pr1ntf(", ");  r___( 8);  printCol+=7; 
  1623.                    if (isGoodAddress(ref)) lclass=520;
  1624.                    break; 
  1625.           case 0x85: pr1ntf("test ");   ref=r_m_(rr);  pr1ntf(", ");  r___(rr);  printCol+=7; 
  1626.                    if (isGoodAddress(ref)) 
  1627.                    {if (operandOveride) lclass=516; else lclass=514;}
  1628.                    break; 
  1629.           case 0x86: pr1ntf("xchg ");   ref=r_m_( 8);  pr1ntf(", ");  r___( 8);  printCol+=7; 
  1630.                    if (isGoodAddress(ref)) lclass=520;
  1631.                    break; 
  1632.           case 0x87: pr1ntf("xchg ");   ref=r_m_(rr);  pr1ntf(", ");  r___(rr);  printCol+=7; 
  1633.                    if (isGoodAddress(ref)) 
  1634.                    {if (operandOveride) lclass=516; else lclass=514;}
  1635.                    break; 
  1636.           case 0x88: pr1ntf("mov ");    ref=r_m_( 8);  pr1ntf(", ");  r___( 8);  printCol+=6; 
  1637.                    if (isGoodAddress(ref)) lclass=520;
  1638.                    break; 
  1639.           case 0x89: pr1ntf("mov ");    ref=r_m_(rr);  pr1ntf(", ");  r___(rr);  printCol+=6; 
  1640.                    if (isGoodAddress(ref)) 
  1641.                    {if (operandOveride) lclass=516; else lclass=1024;}
  1642.                    break; 
  1643.           case 0x8A: pr1ntf("mov ");    r___( 8);  pr1ntf(", ");  ref=r_m_( 8);  printCol+=6; 
  1644.                    if (isGoodAddress(ref)) lclass=520;
  1645.                    break; 
  1646.           case 0x8B: pr1ntf("mov ");    r___(rr);  pr1ntf(", ");  ref=r_m_(rr);     printCol+=6; 
  1647.                    reg=regTable[i_mod]; tempref[reg]=ref; temppos[reg]=cur_position;
  1648.                    if (isGoodAddress(ref)) 
  1649.                    {if (operandOveride) lclass=516; else lclass=1024;}
  1650.                    break; 
  1651.           case 0x8C: pr1ntf("mov ");    ref=r_m_(rr);  pr1ntf(", ");  Sreg__();  printCol+=6; 
  1652.                    if (isGoodAddress(ref)) 
  1653.                    {if (operandOveride) lclass=516; else lclass=1024;}
  1654.                    break; 
  1655.           case 0x8D: pr1ntf("lea ");    r___(rr);  pr1ntf(", ");  ref=m_____();  printCol+=6; 
  1656.                    reg=regTable[i_mod]; tempref[reg]=ref; temppos[reg]=cur_position;
  1657.                    if (isGoodAddress(ref)) 
  1658.                    {if (operandOveride) lclass=516; else lclass=514;}
  1659.                    break; 
  1660.           case 0x8E: pr1ntf("mov ");    Sreg__();  pr1ntf(", ");  ref=r_m_(16);  printCol+=6; 
  1661.                    if (isGoodAddress(ref)) lclass=516;
  1662.                    break; 
  1663.           case 0xC4: pr1ntf("les es:"); r___(rr);  pr1ntf(", ");  ref=m16_32();  printCol+=9; 
  1664.                    if (isGoodAddress(ref)) lclass=516;
  1665.                    break; 
  1666.           case 0xC5: pr1ntf("lds es:"); r___(rr);  pr1ntf(", ");  ref=m16_32();  printCol+=9; 
  1667.                    if (isGoodAddress(ref)) lclass=516;
  1668.                    break;
  1669.         default:   fatalError=113;return -1;
  1670.     }
  1671.     return 0;
  1672. }
  1673.  
  1674. int print7case()
  1675. {
  1676. int    rr;
  1677.  
  1678.     if (operandOveride) rr=16; else rr=32;
  1679.  
  1680.     pr1ntf("imul "); r___(rr); 
  1681.     if (modTable[i_mod]<8 || regTable[i_mod]!=rmTable[i_mod])
  1682.     {   pr1ntf(", "); ref=r_m_(rr); printCol+=2;}
  1683.     pr1ntf(", "); 
  1684.     print_i_byte();
  1685.     printCol+=7;
  1686.     if (isGoodAddress(ref)) 
  1687.     {if (operandOveride) lclass=516; else lclass=514;}
  1688.     return 0;
  1689. }
  1690.  
  1691. int print8case()
  1692. {
  1693. int    rr;
  1694.  
  1695.     if (operandOveride) rr=16; else rr=32;
  1696.  
  1697.     pr1ntf("imul "); r___(rr); 
  1698.     if (modTable[i_mod]<8 || regTable[i_mod]!=rmTable[i_mod])
  1699.     {   pr1ntf(", "); ref=r_m_(rr); printCol+=2;}
  1700.     pr1ntf(", "); 
  1701.     print_i_dword();
  1702.     printCol+=7;
  1703.     if (isGoodAddress(ref)) 
  1704.     {if (operandOveride) lclass=516; else lclass=514;}
  1705.     return 0;
  1706. }
  1707.  
  1708. int print9case()
  1709. {
  1710. int    rr;
  1711.  
  1712.     if (operandOveride) rr=16; else rr=32;
  1713.  
  1714.     specifierFlag = my_ON;
  1715.     switch(i_opcode)
  1716.     {
  1717.         case 0x8F: 
  1718.                    if (regTable[i_mod]>0)
  1719.                    {  
  1720.                        fatalError=115;
  1721.                        specifierFlag = my_OFF;
  1722.                        return -1;
  1723.                    }
  1724.                    pr1ntf("pop "); ref=r_m_(rr); printCol+=4;
  1725.                    if (isGoodAddress(ref)) 
  1726.                    {if (operandOveride) lclass=516; else lclass=514;}
  1727.                    break;
  1728.         case 0xD0:
  1729.                    switch(regTable[i_mod])
  1730.                    {
  1731.                        case 0: pr1ntf("rol "); break;
  1732.                        case 1: pr1ntf("ror "); break;
  1733.                        case 2: pr1ntf("rcl "); break;
  1734.                        case 3: pr1ntf("rcr "); break;
  1735.                        case 4: pr1ntf("shl "); break;
  1736.                        case 5: pr1ntf("shr "); break;
  1737.                        case 7: pr1ntf("sar "); break;
  1738.                        default:    fatalError=117;
  1739.                    }
  1740.                    ref=r_m_( 8); pr1ntf(", 1"); printCol+=7;
  1741.                    if (isGoodAddress(ref)) lclass=520;
  1742.                    break;
  1743.         case 0xD1:
  1744.                    switch(regTable[i_mod])
  1745.                    {
  1746.                        case 0: pr1ntf("rol "); break;
  1747.                        case 1: pr1ntf("ror "); break;
  1748.                        case 2: pr1ntf("rcl "); break;
  1749.                        case 3: pr1ntf("rcr "); break;
  1750.                        case 4: pr1ntf("shl "); break;
  1751.                        case 5: pr1ntf("shr "); break;
  1752.                        case 7: pr1ntf("sar "); break;
  1753.                        default:    fatalError=118;
  1754.                    }
  1755.                    ref=r_m_(rr); pr1ntf(", 1"); printCol+=7;
  1756.                    if (isGoodAddress(ref)) 
  1757.                    {if (operandOveride) lclass=516; else lclass=514;}
  1758.                    break;
  1759.         case 0xD2:
  1760.                    switch(regTable[i_mod])
  1761.                    {
  1762.                        case 0: pr1ntf("rol "); break;
  1763.                        case 1: pr1ntf("ror "); break;
  1764.                        case 2: pr1ntf("rcl "); break;
  1765.                        case 3: pr1ntf("rcr "); break;
  1766.                        case 4: pr1ntf("shl "); break;
  1767.                        case 5: pr1ntf("shr "); break;
  1768.                        case 7: pr1ntf("sar "); break;
  1769.                        default:    fatalError=119;
  1770.                    }
  1771.                    ref=r_m_( 8); pr1ntf(", cl"); printCol+=8;
  1772.                    if (isGoodAddress(ref)) lclass=520;
  1773.                    break;
  1774.         case 0xD3:
  1775.                    switch(regTable[i_mod])
  1776.                    {
  1777.                        case 0: pr1ntf("rol "); break;
  1778.                        case 1: pr1ntf("ror "); break;
  1779.                        case 2: pr1ntf("rcl "); break;
  1780.                        case 3: pr1ntf("rcr "); break;
  1781.                        case 4: pr1ntf("shl "); break;
  1782.                        case 5: pr1ntf("shr "); break;
  1783.                        case 7: pr1ntf("sar "); break;
  1784.                        default:    fatalError=121;
  1785.                    }
  1786.                    ref=r_m_(rr); pr1ntf(", cl"); printCol+=8;
  1787.                    if (isGoodAddress(ref)) 
  1788.                    {if (operandOveride) lclass=516; else lclass=514;}
  1789.                    break;
  1790.         case 0xFE:
  1791.                    switch(regTable[i_mod])
  1792.                    {
  1793.                        case 0: pr1ntf("inc "); ref=r_m_( 8); printCol+=4; break;
  1794.                        case 1: pr1ntf("dec "); ref=r_m_( 8); printCol+=4; break;
  1795.                        default: fatalError=123;
  1796.                    }
  1797.                    if (isGoodAddress(ref)) lclass=520;
  1798.                    break;
  1799.         default: fatalError=125;
  1800.     }
  1801.     specifierFlag=my_OFF;
  1802.     return 0;
  1803. }
  1804.  
  1805. int print10case()
  1806. {
  1807. int    rr;
  1808.  
  1809.     if (operandOveride) rr=16; else rr=32;
  1810.  
  1811.     switch(i_opcode)
  1812.     {
  1813.         case 0x80: 
  1814.                    switch(regTable[i_mod])
  1815.                    {
  1816.                        case 0: pr1ntf("add ");  printCol+=6; break;
  1817.                        case 1: pr1ntf("or ");   printCol+=5; break;
  1818.                        case 2: pr1ntf("adc ");  printCol+=6; break;
  1819.                        case 3: pr1ntf("sbb ");  printCol+=6; break;
  1820.                        case 4: pr1ntf("and ");  printCol+=6; break;
  1821.                        case 5: pr1ntf("sub ");  printCol+=6; break;
  1822.                        case 6: pr1ntf("xor ");  printCol+=6; break;
  1823.                        case 7: pr1ntf("cmp ");  printCol+=6; break;
  1824.                        default:    fatalError=127;
  1825.                    }
  1826.                    ref=r_m_( 8); pr1ntf(", "); print_i_byte();
  1827.                    if (isGoodAddress(ref)) lclass=520;
  1828.                    break;
  1829.         case 0x83:
  1830.                    switch(regTable[i_mod])
  1831.                    {
  1832.                        case 0: pr1ntf("add ");  printCol+=6; break;
  1833.                        case 1: pr1ntf("or ");   printCol+=5; break;
  1834.                        case 2: pr1ntf("adc ");  printCol+=6; break;
  1835.                        case 3: pr1ntf("sbb ");  printCol+=6; break;
  1836.                        case 4: pr1ntf("and ");  printCol+=6; break;
  1837.                        case 5: pr1ntf("sub ");  printCol+=6; break;
  1838.                        case 6: pr1ntf("xor ");  printCol+=6; break;
  1839.                        case 7: pr1ntf("cmp ");  printCol+=6; break;
  1840.                        default:    fatalError=129;
  1841.                    }
  1842.                    ref=r_m_(rr); pr1ntf(", "); print_i_byte32();
  1843.                    if (isGoodAddress(ref)) 
  1844.                    {if (operandOveride) lclass=516; else lclass=514;}
  1845.                    break;
  1846.                    
  1847.         case 0xC0:
  1848.                    switch(regTable[i_mod])
  1849.                    {
  1850.                        case 0: pr1ntf("rol ");  break;
  1851.                        case 1: pr1ntf("ror ");  break;
  1852.                        case 2: pr1ntf("rcl ");  break;
  1853.                        case 3: pr1ntf("rcr ");  break;
  1854.                        case 4: pr1ntf("shl ");  break;
  1855.                        case 5: pr1ntf("shr ");  break;
  1856.                        case 7: pr1ntf("sar ");  break;
  1857.                        default:    fatalError=131;
  1858.                    }
  1859.                    ref=r_m_( 8); pr1ntf(", "); printCol+=6; print_i_byte();
  1860.                    if (isGoodAddress(ref)) lclass=520;
  1861.                    break;
  1862.         case 0xC1:
  1863.                    switch(regTable[i_mod])
  1864.                    {
  1865.                        case 0: pr1ntf("rol ");  break;
  1866.                        case 1: pr1ntf("ror ");  break;
  1867.                        case 2: pr1ntf("rcl ");  break;
  1868.                        case 3: pr1ntf("rcr ");  break;
  1869.                        case 4: pr1ntf("shl ");  break;
  1870.                        case 5: pr1ntf("shr ");  break;
  1871.                        case 7: pr1ntf("sar ");  break;
  1872.                        default:    fatalError=133;
  1873.                    }
  1874.                    ref=r_m_(rr); pr1ntf(", "); printCol+=6; print_i_byte();
  1875.                    if (isGoodAddress(ref)) 
  1876.                    {if (operandOveride) lclass=516; else lclass=514;}
  1877.                    break;
  1878.         case 0xC6:
  1879.                    if (regTable[i_mod]==0)
  1880.                    {
  1881.                        pr1ntf("mov "); ref=r_m_( 8); 
  1882.                        pr1ntf(", "); print_i_byte();  printCol+=6; 
  1883.                        if (isGoodAddress(ref)) lclass=520;
  1884.                    }
  1885.                    else fatalError=135;
  1886.                    break;
  1887.         default: fatalError=137;
  1888.     }
  1889.     return 0;
  1890. }
  1891.  
  1892. int print11case()  
  1893. {
  1894. int    rr;
  1895.  
  1896.     if (operandOveride) rr=16; else rr=32;
  1897.  
  1898.     if (i_opcode==0xC7)
  1899.     {
  1900.         if (regTable[i_mod]>0)
  1901.         {
  1902.             fatalError=139;
  1903.             return -1;
  1904.         }
  1905.         pr1ntf("mov "); dref=r_m_(rr); pr1ntf(", "); 
  1906.         ref=print_i_dword();
  1907.         {if (operandOveride) lclass=516; else lclass=514;}
  1908.         if (nextMode>0)
  1909.         {
  1910.             if (isGoodAddress(dref)) EnterLabel(lclass,dref,cur_position);
  1911.             lclass=1024;
  1912.         }
  1913.         printCol+=6; 
  1914.         return 0;
  1915.     }
  1916.     else        /* is should be 0x81 otherwise i*am*in*big*trouble */
  1917.     {
  1918.         switch(regTable[i_mod])
  1919.         {
  1920.             case 0: pr1ntf("add ");  printCol+=6; break;
  1921.             case 1: pr1ntf("or ");   printCol+=5; break;
  1922.             case 2: pr1ntf("adc ");  printCol+=6; break;
  1923.             case 3: pr1ntf("sbb ");  printCol+=6; break;
  1924.             case 4: pr1ntf("and ");  printCol+=6; break;
  1925.             case 5: pr1ntf("sub ");  printCol+=6; break;
  1926.             case 6: pr1ntf("xor ");  printCol+=6; break;
  1927.             case 7: pr1ntf("cmp ");  printCol+=6; break;
  1928.             default:   fatalError=141;
  1929.         }
  1930.         ref=r_m_(rr); pr1ntf(", "); print_i_dword();
  1931.         if (isGoodAddress(ref)) 
  1932.         {if (operandOveride) lclass=516; else lclass=514;}
  1933.     }
  1934.     return 0;
  1935. }
  1936.  
  1937. int print12case()
  1938. {
  1939. int    rr;
  1940.  
  1941.     if (operandOveride) rr=16; else rr=32;
  1942.  
  1943.     switch(i_opcode)
  1944.     {
  1945.         case 0xD8: 
  1946.             if (i_mod<0xC0)
  1947.             {
  1948.                    switch(regTable[i_mod])
  1949.                    {
  1950.                        case 0: pr1ntf("fadd ");   printCol+=5; break;
  1951.                        case 1: pr1ntf("fmul ");   printCol+=5; break;
  1952.                        case 2: pr1ntf("fcom ");   printCol+=5; break;
  1953.                        case 3: pr1ntf("fcomp ");  printCol+=6; break;
  1954.                        case 4: pr1ntf("fsub ");   printCol+=5; break;
  1955.                        case 5: pr1ntf("fsubr ");  printCol+=6; break;
  1956.                        case 6: pr1ntf("fdiv ");   printCol+=5; break;
  1957.                        case 7: pr1ntf("fdivr ");  printCol+=6; break;
  1958.                        default:    fatalError=143;
  1959.                    }
  1960.                    pr1ntf("32real"); ref=r_m_( 0); printCol+=6;
  1961.                    if (isGoodAddress(ref)) lclass=524;
  1962.             }
  1963.             else
  1964.             {
  1965.                 if (i_mod<0xC8)      {pr2ntf("fadd st(0), st(%1d)",  i_mod-0xC0);printCol+=17;}
  1966.                 else if (i_mod <0xD0){pr2ntf("fmul st(0), st(%1d)",  i_mod-0xC8);printCol+=17;}
  1967.                 else if (i_mod==0xD1){pr1ntf("fcom")                            ;printCol+=4; }
  1968.                 else if (i_mod <0xD8){pr2ntf("fcom st(0), st(%1d)",  i_mod-0xD0);printCol+=17;}
  1969.                 else if (i_mod==0xD9){pr1ntf("fcomp")                           ;printCol+=5; }
  1970.                 else if (i_mod <0xE0){pr2ntf("fcomp st(0), st(%1d)", i_mod-0xD8);printCol+=18;}
  1971.                 else if (i_mod <0xE8){pr2ntf("fsub st(0), st(%1d)",  i_mod-0xE0);printCol+=17;}
  1972.                 else if (i_mod <0xF0){pr2ntf("fsubr st(0), st(%1d)", i_mod-0xE8);printCol+=18;}
  1973.                 else if (i_mod <0xF8){pr2ntf("fdiv st(0), st(%1d)",  i_mod-0xF0);printCol+=17;}
  1974.                 else                 {pr2ntf("fdivr st(0), st(%1d)", i_mod-0xF8);printCol+=18;}
  1975.             }
  1976.             break;
  1977.         case 0xD9: 
  1978.             if (i_mod<0xC0)
  1979.             {
  1980.                    switch(regTable[i_mod])
  1981.                    {
  1982.                        case 0: pr1ntf("fld ");   pr1ntf("32real");    ref=r_m_( 0);
  1983.                                printCol+=10;      if (isGoodAddress(ref)) lclass=524;
  1984.                                break;
  1985.                        case 2: pr1ntf("fst ");   pr1ntf("32real");    ref=r_m_( 0);
  1986.                                printCol+=10;      if (isGoodAddress(ref)) lclass=524;
  1987.                                break;
  1988.                        case 3: pr1ntf("fstp ");  pr1ntf("32real");    ref=r_m_( 0);
  1989.                                printCol+=11;      if (isGoodAddress(ref)) lclass=524;
  1990.                                break;
  1991.                        case 4: pr1ntf("fldenv ");pr1ntf("14/28byte"); ref=r_m_( 0);
  1992.                                printCol+=16;      if (isGoodAddress(ref)) lclass=515;
  1993.                                break;
  1994.                        case 5: pr1ntf("fldcw "); pr1ntf("2byte");     ref=r_m_( 0);
  1995.                                printCol+=11;      if (isGoodAddress(ref)) lclass=516;
  1996.                                break;
  1997.                        case 6: pr1ntf("fnstenv ");pr1ntf("14/28byte");ref=r_m_( 0);
  1998.                                printCol+=17;      if (isGoodAddress(ref)) lclass=515;
  1999.                                break;
  2000.                        case 7: pr1ntf("fnstcw ");pr1ntf("2byte");     ref=r_m_( 0);
  2001.                                printCol+=12;      if (isGoodAddress(ref)) lclass=516;
  2002.                                break;
  2003.                        default:    fatalError=145;
  2004.                    }
  2005.             }
  2006.             else
  2007.             {
  2008.                 if (i_mod<0xC8)      {pr2ntf("fld st(%1d)",  i_mod-0xC0) ;printCol+=9; }
  2009.                 else if (i_mod==0xC9){pr1ntf("fxch")                     ;printCol+=4; }
  2010.                 else if (i_mod <0xD0){pr2ntf("fxch st(%1d)",  i_mod-0xC8);printCol+=10;}
  2011.                 else
  2012.                 {
  2013.                     switch(i_mod)
  2014.                     {
  2015.                         case 0xD0: pr1ntf("fnop");      printCol+=4; break;        
  2016.                         case 0xE0: pr1ntf("fchs");        printCol+=4; break;
  2017.                         case 0xE1: pr1ntf("fabs");        printCol+=4; break;
  2018.                         case 0xE4: pr1ntf("ftst");        printCol+=4; break;
  2019.                         case 0xE5: pr1ntf("fxam");        printCol+=4; break;    
  2020.                         case 0xE8: pr1ntf("fld1");        printCol+=4; break;
  2021.                         case 0xE9: pr1ntf("fldl2t");    printCol+=6; break;
  2022.                         case 0xEA: pr1ntf("fldl2e");    printCol+=6; break;
  2023.                         case 0xEB: pr1ntf("fldpi");        printCol+=5; break;
  2024.                         case 0xEC: pr1ntf("fldlg2");    printCol+=6; break;
  2025.                         case 0xED: pr1ntf("fldln2");    printCol+=6; break;
  2026.                         case 0xEE: pr1ntf("fldz");        printCol+=4; break;
  2027.                         case 0xF0: pr1ntf("f2xm1");        printCol+=5; break;
  2028.                         case 0xF1: pr1ntf("fyl2x");        printCol+=5; break;
  2029.                         case 0xF2: pr1ntf("fptan");        printCol+=5; break;
  2030.                         case 0xF3: pr1ntf("fpatan");    printCol+=6; break;
  2031.                         case 0xF4: pr1ntf("fxtract");    printCol+=7; break;
  2032.                         case 0xF5: pr1ntf("fprem1");    printCol+=6; break;
  2033.                         case 0xF6: pr1ntf("fdecstp");    printCol+=7; break;
  2034.                         case 0xF7: pr1ntf("fincstp");    printCol+=7; break;
  2035.                         case 0xF8: pr1ntf("fprem");        printCol+=5; break;
  2036.                         case 0xF9: pr1ntf("fyl2xp1");    printCol+=7; break;
  2037.                         case 0xFA: pr1ntf("fsqrt");        printCol+=5; break;
  2038.                         case 0xFB: pr1ntf("fsincos");    printCol+=7; break;
  2039.                         case 0xFC: pr1ntf("frndint");    printCol+=7; break;
  2040.                         case 0xFD: pr1ntf("fscale");    printCol+=6; break;
  2041.                         case 0xFE: pr1ntf("fsin");        printCol+=4; break;
  2042.                         case 0xFF: pr1ntf("fcos");        printCol+=4; break;
  2043.                         default:   fatalError=202;
  2044.                     }
  2045.                 }
  2046.             }
  2047.             break;
  2048.         case 0xDA: 
  2049.             if (i_mod<0xC0)
  2050.             {
  2051.                    switch(regTable[i_mod])
  2052.                    {
  2053.                        case 0: pr1ntf("fiadd ");  ref=r_m_(rr); printCol+=6; break;
  2054.                        case 1: pr1ntf("fimul ");  ref=r_m_(rr); printCol+=6; break;
  2055.                        case 2: pr1ntf("ficom ");  ref=r_m_(rr); printCol+=6; break;
  2056.                        case 3: pr1ntf("ficomp "); ref=r_m_(rr); printCol+=7; break;
  2057.                        case 4: pr1ntf("fisub ");  ref=r_m_(rr); printCol+=6; break;
  2058.                        case 5: pr1ntf("fisubr "); ref=r_m_(rr); printCol+=7; break;
  2059.                        case 6: pr1ntf("fidiv ");  ref=r_m_(rr); printCol+=6; break;
  2060.                        case 7: pr1ntf("fidivr "); ref=r_m_(rr); printCol+=7; break;
  2061.                        default:    fatalError=204;
  2062.                    }
  2063.                    if (isGoodAddress(ref)) 
  2064.                    {if (operandOveride) lclass=516; else lclass=514;}
  2065.             }
  2066.             else
  2067.             {
  2068.                 if (i_mod<0xC8)      {pr2ntf("fcmovb st(0), st(%1d)", i_mod-0xC0);printCol+=19;}
  2069.                 else if (i_mod <0xD0){pr2ntf("fcmove st(0), st(%1d)", i_mod-0xC8);printCol+=19;}
  2070.                 else if (i_mod <0xD8){pr2ntf("fcmovbe st(0), st(%1d)",i_mod-0xD0);printCol+=20;}
  2071.                 else if (i_mod <0xE0){pr2ntf("fcmovu st(0), st(%1d)", i_mod-0xD8);printCol+=19;}
  2072.                 else if (i_mod==0xE9){pr1ntf("fucompp")                          ;printCol+=7; }
  2073.             }
  2074.             break;
  2075.         case 0xDB: 
  2076.             if (i_mod<0xC0)
  2077.             {
  2078.                    switch(regTable[i_mod])
  2079.                    {
  2080.                        case 0: pr1ntf("fild ");  ref=r_m_(rr);                  printCol+=5; 
  2081.                                if (isGoodAddress(ref)) 
  2082.                                {if (operandOveride) lclass=516; else lclass=514;}
  2083.                                break;
  2084.                        case 2: pr1ntf("fist ");  ref=r_m_(rr);                  printCol+=5; 
  2085.                                if (isGoodAddress(ref)) 
  2086.                                {if (operandOveride) lclass=516; else lclass=514;}
  2087.                                break;
  2088.                        case 3: pr1ntf("fistp "); ref=r_m_(rr);                  printCol+=6; 
  2089.                                if (isGoodAddress(ref)) 
  2090.                                {if (operandOveride) lclass=516; else lclass=514;}
  2091.                                break;
  2092.                        case 5: pr1ntf("fld ");  pr1ntf("80real"); ref=r_m_( 0); printCol+=10;
  2093.                                if (isGoodAddress(ref)) lclass=517;
  2094.                                break;
  2095.                        case 7: pr1ntf("fstp "); pr1ntf("80real"); ref=r_m_( 0); printCol+=11;
  2096.                                if (isGoodAddress(ref)) lclass=517;
  2097.                                break;
  2098.                        default:    fatalError=206;
  2099.                    }
  2100.             }
  2101.             else
  2102.             {
  2103.                 if (i_mod<0xC8)      {pr2ntf("fcmovnb st(0), st(%1d)", i_mod-0xC0);printCol+=20;}
  2104.                 else if (i_mod <0xD0){pr2ntf("fcmovne st(0), st(%1d)", i_mod-0xC8);printCol+=20;}
  2105.                 else if (i_mod <0xD8){pr2ntf("fcmovnbe st(0), st(%1d)",i_mod-0xD0);printCol+=21;}
  2106.                 else if (i_mod <0xE0){pr2ntf("fcmovnu st(0), st(%1d)", i_mod-0xD8);printCol+=20;}
  2107.                 else if (i_mod==0xE2){pr1ntf("fnclex")                            ;printCol+=6;    }
  2108.                 else if (i_mod==0xE3){pr1ntf("fninit")                            ;printCol+=6;    }
  2109.                 else if (i_mod <0xE8) fatalError=208;
  2110.                 else if (i_mod <0xF0){pr2ntf("fucomi st(0), st(%1d)", i_mod-0xE8) ;printCol+=19;}
  2111.                 else if (i_mod <0xF8){pr2ntf("fcomi st(0), st(%1d)", i_mod-0xF0)  ;printCol+=18;}
  2112.             }
  2113.             break;
  2114.         case 0xDC: 
  2115.             if (i_mod<0xC0)
  2116.             {
  2117.                    switch(regTable[i_mod])
  2118.                    {
  2119.                        case 0: pr1ntf("fadd "); pr1ntf("64real"); ref=r_m_( 0); printCol+=11; 
  2120.                                if (isGoodAddress(ref)) lclass=528;
  2121.                                break;
  2122.                        case 1: pr1ntf("fmul "); pr1ntf("64real"); ref=r_m_( 0); printCol+=11; 
  2123.                                if (isGoodAddress(ref)) lclass=528;
  2124.                                break;
  2125.                        case 2: pr1ntf("fcom "); pr1ntf("64real"); ref=r_m_( 0); printCol+=11; 
  2126.                                if (isGoodAddress(ref)) lclass=528;
  2127.                                break;
  2128.                        case 3: pr1ntf("fcomp ");pr1ntf("64real"); ref=r_m_( 0); printCol+=12; 
  2129.                                if (isGoodAddress(ref)) lclass=528;
  2130.                                break;
  2131.                        case 4: pr1ntf("fsub "); pr1ntf("64real"); ref=r_m_( 0); printCol+=11; 
  2132.                                if (isGoodAddress(ref)) lclass=528;
  2133.                                break;
  2134.                        case 5: pr1ntf("fsubr ");pr1ntf("64real"); ref=r_m_( 0); printCol+=12; 
  2135.                                if (isGoodAddress(ref)) lclass=528;
  2136.                                break;
  2137.                        case 6: pr1ntf("fdiv "); pr1ntf("64real"); ref=r_m_( 0); printCol+=11; 
  2138.                                if (isGoodAddress(ref)) lclass=528;
  2139.                                break;
  2140.                        case 7: pr1ntf("fdivr ");pr1ntf("64real"); ref=r_m_( 0); printCol+=12; 
  2141.                                if (isGoodAddress(ref)) lclass=528;
  2142.                                break;
  2143.                        default:    fatalError=210;
  2144.                    }
  2145.             }
  2146.             else
  2147.             {
  2148.                 if (i_mod<0xC8)      {pr2ntf("fadd st(0), st(%1d)", i_mod-0xC0);printCol+=17;}
  2149.                 else if (i_mod <0xD0){pr2ntf("fmul st(0), st(%1d)", i_mod-0xC8);printCol+=17;}
  2150.                 else if (i_mod <0xE0) fatalError=212;
  2151.                 else if (i_mod <0xE8){pr2ntf("fsubr st(0), st(%1d)",i_mod-0xE0);printCol+=18;}
  2152.                 else if (i_mod <0xF0){pr2ntf("fsub st(0), st(%1d)", i_mod-0xD8);printCol+=17;}
  2153.                 else if (i_mod <0xF8){pr2ntf("fdivr st(0), st(%1d)",i_mod-0xF0);printCol+=18;}
  2154.                 else                 {pr2ntf("fdiv st(0), st(%1d)", i_mod-0xF8);printCol+=17;}
  2155.             }
  2156.             break;
  2157.         case 0xDD: 
  2158.             if (i_mod<0xC0)
  2159.             {
  2160.                    switch(regTable[i_mod])
  2161.                    {
  2162.                        case 0: pr1ntf("fld ");  pr1ntf("64real");   ref=r_m_( 0); printCol+=10; 
  2163.                                if (isGoodAddress(ref)) lclass=528;
  2164.                                break;
  2165.                        case 2: pr1ntf("fst ");  pr1ntf("64real");   ref=r_m_( 0); printCol+=10; 
  2166.                                if (isGoodAddress(ref)) lclass=528;
  2167.                                break;
  2168.                        case 3: pr1ntf("fstp "); pr1ntf("64real");   ref=r_m_( 0); printCol+=11; 
  2169.                                if (isGoodAddress(ref)) lclass=528;
  2170.                                break;
  2171.                        case 4: pr1ntf("frstor ");pr1ntf("94/108byte");ref=r_m_( 0);printCol+=17;
  2172.                                if (isGoodAddress(ref)) lclass=519;
  2173.                                break;
  2174.                        case 6: pr1ntf("fnsave ");pr1ntf("94/108byte");ref=r_m_( 0);printCol+=17;
  2175.                                if (isGoodAddress(ref)) lclass=519;
  2176.                                break;
  2177.                        case 7: pr1ntf("fnstsw ");pr1ntf("2byte"); ref=r_m_( 0);   printCol+=12; 
  2178.                                if (isGoodAddress(ref)) lclass=516;
  2179.                                break;
  2180.                        default:    fatalError=214;
  2181.                    }
  2182.             }
  2183.             else
  2184.             {
  2185.                 if (i_mod<0xC8)      {pr2ntf("ffree st(%1d)", i_mod-0xC0);printCol+=11;}
  2186.                 else if (i_mod <0xD0) fatalError=216;
  2187.                 else if (i_mod <0xD8){pr2ntf("fst st(%1d)",   i_mod-0xD0);printCol+=9; }
  2188.                 else if (i_mod <0xE0){pr2ntf("fstp st(%1d)",  i_mod-0xD8);printCol+=10;}
  2189.                 else if (i_mod==0xE1){pr1ntf("fucom")                    ;printCol+=5; }
  2190.                 else if (i_mod <0xE8){pr2ntf("fucom st(%1d)", i_mod-0xE0);printCol+=11;}
  2191.                 else if (i_mod==0xE9){pr1ntf("fucomp")                   ;printCol+=6; }
  2192.                 else if (i_mod <0xF0){pr2ntf("fucomp st(%1d)",i_mod-0xE8);printCol+=12;}
  2193.                 else fatalError=218;
  2194.             }
  2195.             break;
  2196.         case 0xDE: 
  2197.             if (i_mod<0xC0)
  2198.             {
  2199.                    switch(regTable[i_mod])
  2200.                    {
  2201.                        case 0: pr1ntf("fiadd ");  pr1ntf("16int");ref=r_m_( 0); printCol+=6; 
  2202.                                if (isGoodAddress(ref)) lclass=516;
  2203.                                break;
  2204.                        case 1: pr1ntf("fimul ");  pr1ntf("16int");ref=r_m_( 0); printCol+=6; 
  2205.                                if (isGoodAddress(ref)) lclass=516;
  2206.                                break;
  2207.                        case 2: pr1ntf("ficom ");  pr1ntf("16int");ref=r_m_( 0); printCol+=6; 
  2208.                                if (isGoodAddress(ref)) lclass=516;
  2209.                                break;
  2210.                        case 3: pr1ntf("ficomp "); pr1ntf("16int");ref=r_m_( 0); printCol+=7; 
  2211.                                if (isGoodAddress(ref)) lclass=516;
  2212.                                break;
  2213.                        case 4: pr1ntf("fisub ");  pr1ntf("16int");ref=r_m_( 0); printCol+=6; 
  2214.                                if (isGoodAddress(ref)) lclass=516;
  2215.                                break;
  2216.                        case 5: pr1ntf("fisubr "); pr1ntf("16int");ref=r_m_( 0); printCol+=7; 
  2217.                                if (isGoodAddress(ref)) lclass=516;
  2218.                                break;
  2219.                        case 6: pr1ntf("fidiv ");  pr1ntf("16int");ref=r_m_( 0); printCol+=6; 
  2220.                                if (isGoodAddress(ref)) lclass=516;
  2221.                                break;
  2222.                        case 7: pr1ntf("fidivr "); pr1ntf("16int");ref=r_m_( 0); printCol+=7; 
  2223.                                if (isGoodAddress(ref)) lclass=516;
  2224.                                break;
  2225.                        default:    fatalError=220;
  2226.                    }
  2227.             }
  2228.             else
  2229.             {
  2230.                  if(i_mod==0xC1)      {pr1ntf("faddp")                            ;printCol+=5;    }
  2231.                  else if (i_mod <0xC8){pr2ntf("faddp st(%1d), st(0)", i_mod-0xC0) ;printCol+=18;}
  2232.                  else if (i_mod==0xC9){pr1ntf("fmulp")                            ;printCol+=5;    }
  2233.                  else if (i_mod <0xD0){pr2ntf("fmulp st(%1d), st(0)", i_mod-0xC8) ;printCol+=18;}
  2234.                  else if (i_mod==0xD9){pr1ntf("fcompp")                           ;printCol+=6;    }
  2235.                  else if (i_mod <0xE0) fatalError=222;                               
  2236.                  else if (i_mod==0xE1){pr1ntf("fsubrp");                          ;printCol+=6;    }
  2237.                  else if (i_mod <0xE8){pr2ntf("fsubrp st(%1d), st(0)", i_mod-0xE0);printCol+=19;}
  2238.                  else if (i_mod==0xE9){pr1ntf("fsubp")                               ;printCol+=5;    }
  2239.                  else if (i_mod <0xF0){pr2ntf("fsubp st(%1d), st(0)", i_mod-0xE8) ;printCol+=18;}
  2240.                  else if (i_mod==0xF1){pr1ntf("fdivrp")                           ;printCol+=6;    }
  2241.                  else if (i_mod <0xF8){pr2ntf("fdivrp st(%1d), st(0)", i_mod-0xF0);printCol+=18;}
  2242.                  else if (i_mod==0xF9){pr1ntf("fdivp")                            ;printCol+=5;    }
  2243.                  else                 {pr2ntf("fdivp st(%1d), st(0)", i_mod-0xF8) ;printCol+=18;}
  2244.             }
  2245.             break;
  2246.         case 0xDF: 
  2247.             if (i_mod<0xC0)
  2248.             {
  2249.                    switch(regTable[i_mod])
  2250.                    {
  2251.                        case 0: pr1ntf("fild ");  pr1ntf("16int");ref=r_m_( 0); printCol+=10; 
  2252.                                if (isGoodAddress(ref)) lclass=516;
  2253.                                break;
  2254.                        case 2: pr1ntf("fist ");  pr1ntf("16int");ref=r_m_( 0); printCol+=10; 
  2255.                                if (isGoodAddress(ref)) lclass=516;
  2256.                                break;
  2257.                        case 3: pr1ntf("fistp "); pr1ntf("16int");ref=r_m_( 0); printCol+=11; 
  2258.                                if (isGoodAddress(ref)) lclass=516;
  2259.                                break;
  2260.                        case 4: pr1ntf("fbld ");  pr1ntf("80bcd");ref=r_m_( 0); printCol+=10; 
  2261.                                if (isGoodAddress(ref)) lclass=517;
  2262.                                break;
  2263.                        case 5: pr1ntf("fild ");  pr1ntf("64int");ref=r_m_( 0); printCol+=10; 
  2264.                                if (isGoodAddress(ref)) lclass=528;
  2265.                                break;
  2266.                        case 6: pr1ntf("fbstp "); pr1ntf("80bcd");ref=r_m_( 0); printCol+=11; 
  2267.                                if (isGoodAddress(ref)) lclass=517;
  2268.                                break;
  2269.                        case 7: pr1ntf("fistp "); pr1ntf("64int");ref=r_m_( 0); printCol+=11; 
  2270.                                if (isGoodAddress(ref)) lclass=528;
  2271.                                break;
  2272.                        default:                     fatalError=224;
  2273.                    }
  2274.             }
  2275.             else
  2276.             {
  2277.                  if(i_mod <0xDF)       fatalError=226;
  2278.                  else if (i_mod==0xE0){pr1ntf("fnstsw ax")                         ;printCol+=9; }
  2279.                  else if (i_mod <0xE8) fatalError=228;
  2280.                  else if (i_mod <0xF0){pr2ntf("fucomip st(0), st(%1d)", i_mod-0xE8);printCol+=20;}
  2281.                  else if (i_mod <0xF8){pr2ntf("fcomip st(0), st(%1d)", i_mod-0xF0) ;printCol+=19;}
  2282.                  else                  fatalError=230;
  2283.             }
  2284.             break;
  2285.         default:                       fatalError=232;
  2286.     }
  2287.     return 0;
  2288. } /* print12case() */
  2289.  
  2290.  
  2291. int print13case()
  2292. {
  2293. int    rr;
  2294.  
  2295.     if (operandOveride) rr=16; else rr=32;
  2296.  
  2297.     switch(regTable[i_mod])
  2298.     {                             
  2299.         case 0: pr1ntf("inc ");            ref=r_m_(rr);  printCol+=4; 
  2300.                 if (isGoodAddress(ref)) 
  2301.                 {if (operandOveride) lclass=516; else lclass=514;}
  2302.                 break;
  2303.         case 1: pr1ntf("dec ");            ref=r_m_(rr);  printCol+=4; 
  2304.                 if (isGoodAddress(ref)) 
  2305.                 {if (operandOveride) lclass=516; else lclass=514;}
  2306.                 break;
  2307.         case 2: pr1ntf("call ");                      printCol+=4;
  2308.                 ref = r_m_(rr);
  2309.                 lclass=13;
  2310.                 if (nextMode)
  2311.                 {    
  2312.                     if (i_mod>=0xD0)
  2313.                     {
  2314.                         reg=rmTable[i_mod];
  2315.                         if (temppos[reg]+128>cur_position) 
  2316.                         ref=tempref[reg]; temppos[reg]=cur_position;
  2317.                     }
  2318.                 }
  2319.                 else printName(cur_position);
  2320.                 break;
  2321.         case 3: pr1ntf("call ");     ref = m16_32(); lclass=17;  printCol+=4;
  2322.                 break;
  2323.         case 4: pr1ntf("jmp ");                                     printCol+=4;
  2324.                 ref=r_m_(32);
  2325.                 
  2326.                 if (gotJmpRef) 
  2327.                 {   lclass=128+5; gotJmpRef=0;  } 
  2328.                 else lclass=5;
  2329.                 if (i_mod>=0xD0)
  2330.                 {
  2331.                     reg=rmTable[i_mod];
  2332.                     if (temppos[reg]+128>cur_position) 
  2333.                     ref=tempref[reg]; temppos[reg]=cur_position;
  2334.                 }
  2335.                 
  2336.                 needJump=1;     needJumpNext=cur_position+i_col;
  2337.                 if (nextMode)
  2338.                 {
  2339.                     // it is OK to mark anchor...because it will not be erased easily??
  2340.                     lastAnchor=cur_position+i_col-1;
  2341.                     pushTrace(150);
  2342.                     orMap(lastAnchor, 0x80);
  2343.                     popTrace();
  2344.                 }
  2345.                 else printName(cur_position);
  2346.                 break;
  2347.         case 5: pr1ntf("jmp ");      ref = m16_32();   lclass = 9;  printCol+=4;
  2348.                 needJump=1;     needJumpNext=cur_position+i_col;
  2349.                 break;
  2350.         case 6: pr1ntf("push ");     ref =  r_m_(rr);                printCol+=5;
  2351.                 lclass = 513;
  2352.         // well I really don't know it is reasonably safe to do this.
  2353.         // I think when we push some (possible) address references into stack
  2354.         // there is strong reason to do so. that's why i am doing this. i guess...
  2355.                 break;
  2356.         default: fatalError=234;
  2357.     }  
  2358.     return 0;
  2359. }
  2360.  
  2361. int print14case()
  2362. {
  2363. int    rr;
  2364.  
  2365.     if (operandOveride) rr=16; else rr=32;
  2366.  
  2367.     if (i_opcode==0xF6)
  2368.     {
  2369.         switch(regTable[i_mod])
  2370.         {
  2371.             case 0: pr1ntf("test "); ref=r_m_( 8); pr1ntf(", "); print_i_byte(); printCol+=7; 
  2372.                     if (isGoodAddress(ref)) lclass=520;
  2373.                     break;
  2374.             case 2:    pr1ntf("not ");  ref=r_m_( 8);                               printCol+=4; 
  2375.                     if (isGoodAddress(ref)) lclass=520;
  2376.                     break;
  2377.             case 3:    pr1ntf("neg ");  ref=r_m_( 8);                               printCol+=4; 
  2378.                     if (isGoodAddress(ref)) lclass=520;
  2379.                     break;
  2380.             case 4:    pr1ntf("mul ");  ref=r_m_( 8);                               printCol+=4; 
  2381.                     if (isGoodAddress(ref)) lclass=520;
  2382.                     break;
  2383.             case 5:    pr1ntf("imul "); ref=r_m_( 8);                               printCol+=4; 
  2384.                     if (isGoodAddress(ref)) lclass=520;
  2385.                     break;
  2386.             case 6:    pr1ntf("div ");  ref=r_m_( 8);                               printCol+=4; 
  2387.                     if (isGoodAddress(ref)) lclass=520;
  2388.                     break;
  2389.             case 7:    pr1ntf("idiv "); ref=r_m_( 8);                               printCol+=5; 
  2390.                     if (isGoodAddress(ref)) lclass=520;
  2391.                     break;
  2392.             default: fatalError=303;
  2393.         }
  2394.     }
  2395.     else if (i_opcode==0xF7)
  2396.     {
  2397.         switch(regTable[i_mod])
  2398.         {
  2399.             case 0:    pr1ntf("test "); ref=r_m_(rr); pr1ntf(", "); print_i_dword(); printCol+=7; 
  2400.                     break;
  2401.             case 2:    pr1ntf("not ");  ref=r_m_(rr);                                printCol+=4;
  2402.                     break;
  2403.             case 3:    pr1ntf("neg ");  ref=r_m_(rr);                                printCol+=4;
  2404.                     break;
  2405.             case 4:    pr1ntf("mul ");  ref=r_m_(rr);                                printCol+=4; 
  2406.                     break;
  2407.             case 5:    pr1ntf("imul "); ref=r_m_(rr);                                printCol+=5; 
  2408.                     break;
  2409.             case 6:    pr1ntf("div ");  ref=r_m_(rr);                                printCol+=4;
  2410.                     break;
  2411.             case 7:    pr1ntf("idiv "); ref=r_m_(rr);                                printCol+=5; 
  2412.                     break;
  2413.             default: fatalError=305;
  2414.         }
  2415.         if (isGoodAddress(ref)) 
  2416.         {if (operandOveride) lclass=516; else lclass=514;}
  2417.     }
  2418.     else fatalError=307;
  2419.     return 0;
  2420. }
  2421.  
  2422. int print15case()
  2423. {
  2424. int    rr;
  2425.  
  2426.     if (operandOveride) rr=16; else rr=32;
  2427.  
  2428.     if (i_opcode==0xD9)
  2429.     {
  2430.         if (regTable[i_mod]==6)
  2431.         {
  2432.             pr1ntf("fstenv 14/28byte"); ref=r_m_(rr);  printCol+=16;
  2433.             if (isGoodAddress(ref)) lclass=515;
  2434.         }
  2435.         else if (regTable[i_mod]==7)
  2436.         {
  2437.             pr1ntf("fstcw 2byte");      ref=r_m_(rr);  printCol+=11;
  2438.             if (isGoodAddress(ref)) lclass=516;
  2439.         }
  2440.         else fatalError=309;
  2441.     }
  2442.     else if (i_opcode==0xDB)
  2443.     {
  2444.         if (i_mod==0xE2)      {pr1ntf("fclex ");}            
  2445.         else if (i_mod==0xE3) {pr1ntf("finit ");}             
  2446.         else fatalError=311;  printCol+=6;
  2447.     }
  2448.     else if (i_opcode==0xDD)
  2449.     {
  2450.         if (regTable[i_mod]==6)
  2451.         {
  2452.             pr1ntf("fsave 94/108byte"); ref=r_m_(rr); printCol+=16;
  2453.             if (isGoodAddress(ref)) lclass=519;
  2454.         }
  2455.         else if (regTable[i_mod]==7)
  2456.         {
  2457.             pr1ntf("fstsw 2byte");      ref=r_m_(rr); printCol+=11;
  2458.             if (isGoodAddress(ref)) lclass=516;
  2459.         }
  2460.         else fatalError=313;
  2461.     }
  2462.     else if (i_opcode==0xDF)
  2463.     {
  2464.         if (i_mod==0xE0) {pr1ntf("fstsw ax ");}     
  2465.         else fatalError=315;     printCol+=9;
  2466.     }
  2467.     else if (i_opcode==0x9B) {pr1ntf("wait");     printCol+=4;}  
  2468.     else fatalError=317;
  2469.     return 0;
  2470. }
  2471.  
  2472. int print16case()
  2473. {
  2474. int    rr;
  2475.  
  2476.     if (operandOveride) rr=16; else rr=32;
  2477.  
  2478.     if (prefixStack[i_psp-1]==0xF2)
  2479.     {
  2480.         switch(i_opcode)
  2481.         {
  2482.             case 0xA6: pr1ntf("repne cmpsb"); printCol+=11; break;
  2483.             case 0xA7: if (operandOveride) {pr1ntf("repne cmpsw");}
  2484.                        else                {pr1ntf("repne cmpsd");} printCol+=11; break;
  2485.             case 0xAE: pr1ntf("repne scasb"); printCol+=11; break;
  2486.             case 0xAF: if (operandOveride) {pr1ntf("repne scasw");}
  2487.                        else                {pr1ntf("repne scasd");} printCol+=11; break;
  2488.             default: fatalError=319;
  2489.         }
  2490.     }
  2491.     else if (prefixStack[i_psp-1]==0xF3)
  2492.     {
  2493.         switch(i_opcode)
  2494.         {
  2495.             case 0x6C: pr1ntf("rep ins byte"); 
  2496.                        ref=r_m_( 8);pr1ntf(", port[dx]"); printCol+=22; 
  2497.                        if (isGoodAddress(ref)) lclass=520;
  2498.                        break;
  2499.             case 0x6D: if (operandOveride){pr1ntf("rep ins word") ;printCol+=12;}
  2500.                        else               {pr1ntf("rep ins dword");printCol+=13;}
  2501.                        ref=r_m_(rr);pr1ntf(", port[dx]");            printCol+=10;
  2502.                        if (isGoodAddress(ref)) 
  2503.                        {if (operandOveride) lclass=516; else lclass=514;}
  2504.                        break; 
  2505.             case 0x6E: pr1ntf("rep outs port[dx], byte");             printCol+=23;
  2506.                        ref=r_m_( 8);
  2507.                        if (isGoodAddress(ref)) lclass=520;
  2508.                        break;
  2509.             case 0x6F: if (operandOveride){pr1ntf("rep outs port[dx], word");printCol+=23;}
  2510.                        else{pr1ntf("rep outs port[dx], dword")              ;printCol+=24;} 
  2511.                        r_m_(rr); 
  2512.                        break;
  2513.             case 0xA4: pr1ntf("rep movsb");                        printCol+=9;   
  2514.                        break;
  2515.             case 0xA5: if (operandOveride) {pr1ntf("rep movsw");}
  2516.                        else                {pr1ntf("rep movsd");}    printCol+=9;       
  2517.                        break;
  2518.             case 0xA6: pr1ntf("repe cmpsb");                       printCol+=10;   
  2519.                        break;
  2520.             case 0xA7: if (operandOveride) {pr1ntf("repe cmpsw");}
  2521.                        else                {pr1ntf("repe cmpsd");}   printCol+=10;   
  2522.                        break;
  2523.             case 0xAA: pr1ntf("rep stosb");                        printCol+=9;   
  2524.                        break;
  2525.             case 0xAB: if (operandOveride) {pr1ntf("rep stosw");}
  2526.                        else                {pr1ntf("rep stosd");}    printCol+=9;   
  2527.                        break;
  2528.             case 0xAC: pr1ntf("rep lods al");                      printCol+=11;   
  2529.                        break;
  2530.             case 0xAD: if (operandOveride){pr1ntf("rep lods ax") ;printCol+=11;}
  2531.                        else               {pr1ntf("rep lods eax");printCol+=12;}    
  2532.                        break;
  2533.             case 0xAE: pr1ntf("repe scasb");                       printCol+=10;   
  2534.                        break;
  2535.             case 0xAF: if (operandOveride) {pr1ntf("repe scasw");}
  2536.                        else                {pr1ntf("repe scasd");}   printCol+=10;   
  2537.                        break; 
  2538.             default: fatalError=321;
  2539.         }
  2540.     }
  2541.     else fatalError=323;
  2542.     return 0;
  2543. }
  2544.  
  2545. /* *************************************************************** */
  2546. /* *************************************************************** */
  2547. /*         2 byte opcode printing starts here!                     */
  2548. /* *************************************************************** */
  2549. /* *************************************************************** */
  2550. int print20case()
  2551. {
  2552.     switch(i_opcode)
  2553.     {
  2554.         case 0x06:  pr1ntf("clts");      printCol+=4;  break;
  2555.         case 0x08:  pr1ntf("invd");      printCol+=4;  break;
  2556.         case 0x09:  pr1ntf("wbinvd");    printCol+=6;  break; 
  2557.         case 0x0B:  pr1ntf("ud2");       printCol+=3;  break;   
  2558.         case 0x30:  pr1ntf("wrmsr");     printCol+=5;  break;
  2559.         case 0x31:  pr1ntf("rdtsc");     printCol+=5;  break;
  2560.         case 0x32:  pr1ntf("rdmsr");     printCol+=5;  break;
  2561.         case 0x33:  pr1ntf("rdpmc");     printCol+=5;  break;
  2562.         case 0x34:  pr1ntf("sysenter");     printCol+=8;  break;
  2563.         case 0x35:  pr1ntf("sysexit");     printCol+=7;  break;
  2564.         case 0x77:  pr1ntf("emms");      printCol+=4;  break;   
  2565.         case 0xA0:  pr1ntf("push fs");   printCol+=7;  break;   
  2566.         case 0xA1:  pr1ntf("pop fs");    printCol+=6;  break;  
  2567.         case 0xA2:  pr1ntf("cpuid");     printCol+=5;  break;   
  2568.         case 0xA8:  pr1ntf("push gs");   printCol+=7;  break;   
  2569.         case 0xA9:  pr1ntf("pop gs");    printCol+=6;  break;   
  2570.         case 0xAA:  pr1ntf("rsm");         printCol+=3;  break;   
  2571.         case 0xC8:  pr1ntf("bswap eax"); printCol+=9;  break;   
  2572.         case 0xC9:  pr1ntf("bswap ecx"); printCol+=9;  break;   
  2573.         case 0xCA:  pr1ntf("bswap edx"); printCol+=9;  break;   
  2574.         case 0xCB:  pr1ntf("bswap ebx"); printCol+=9;  break;   
  2575.         case 0xCC:  pr1ntf("bswap esp"); printCol+=9;  break;   
  2576.         case 0xCD:  pr1ntf("bswap ebp"); printCol+=9;  break;   
  2577.         case 0xCE:  pr1ntf("bswap esi"); printCol+=9;  break;   
  2578.         case 0xCF:  pr1ntf("bswap edi"); printCol+=9;  break;   
  2579.         default:    fatalError=325;
  2580.     }
  2581.     return 0;
  2582. }
  2583.  
  2584. int print21case()
  2585. {
  2586.     switch(i_opcode)
  2587.     {
  2588.         case 0x80:  pr1ntf("jo ");     printCol+=3;  break;
  2589.         case 0x81:  pr1ntf("jno ");     printCol+=4;  break;
  2590.         case 0x82:  pr1ntf("jb ");     printCol+=3;  break;
  2591.         case 0x83:  pr1ntf("jae ");     printCol+=4;  break;
  2592.         case 0x84:  pr1ntf("je ");     printCol+=3;  break;
  2593.         case 0x85:  pr1ntf("jne ");     printCol+=4;  break;
  2594.         case 0x86:  pr1ntf("jbe ");     printCol+=4;  break;
  2595.         case 0x87:  pr1ntf("ja ");     printCol+=3;  break;
  2596.         case 0x88:  pr1ntf("js ");     printCol+=3;  break;
  2597.         case 0x89:  pr1ntf("jns ");     printCol+=4;  break;
  2598.         case 0x8A:  pr1ntf("jpe ");     printCol+=4;  break;
  2599.         case 0x8B:  pr1ntf("jpo ");     printCol+=4;  break;
  2600.         case 0x8C:  pr1ntf("jl ");     printCol+=3;  break;
  2601.         case 0x8D:  pr1ntf("jge ");     printCol+=4;  break;
  2602.         case 0x8E:  pr1ntf("jle ");     printCol+=4;  break;
  2603.         case 0x8F:  pr1ntf("jg ");     printCol+=3;  break;
  2604.         default:    fatalError=327;
  2605.     }    
  2606.     ref = print_rel32();  lclass =  4; 
  2607.     return 0;
  2608. }
  2609.  
  2610. int print22case()
  2611. {
  2612. int    rr;
  2613.  
  2614.     if (operandOveride) rr=16; else rr=32;
  2615.  
  2616.     switch(i_opcode)
  2617.     {
  2618.         case 0x02: pr1ntf("lar ");       r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=6;
  2619.                    if (isGoodAddress(ref)) 
  2620.                    {if (operandOveride) lclass=516; else lclass=514;}
  2621.                    break;    
  2622.         case 0x03: pr1ntf("lsl ");       r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=6;
  2623.                    if (isGoodAddress(ref)) 
  2624.                    {if (operandOveride) lclass=516; else lclass=514;}
  2625.                    break;    
  2626.         case 0x20: pr1ntf("mov "); r___(rr);pr2ntf(", cr%1d", rmTable[i_mod]);printCol+=9;
  2627.                    break;    
  2628.         case 0x21: pr1ntf("mov "); r___(rr);pr2ntf(", dr%1d", rmTable[i_mod]);printCol+=9; 
  2629.                    break;   
  2630.         case 0x22: pr2ntf("mov cr%1d, ",rmTable[i_mod]);       r___(rr);printCol+=9;
  2631.                    break;    
  2632.         case 0x23: pr2ntf("mov dr%1d, ",rmTable[i_mod]);       r___(rr);printCol+=9;
  2633.                    break;    
  2634.         case 0x40: pr1ntf("cmovo ");     r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=8;
  2635.                    if (isGoodAddress(ref)) 
  2636.                    {if (operandOveride) lclass=516; else lclass=514;}
  2637.                    break;    
  2638.         case 0x41: pr1ntf("cmovno ");    r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=9;
  2639.                    if (isGoodAddress(ref)) 
  2640.                    {if (operandOveride) lclass=516; else lclass=514;}
  2641.                    break;    
  2642.         case 0x42: pr1ntf("cmovb ");     r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=8;
  2643.                    if (isGoodAddress(ref)) 
  2644.                    {if (operandOveride) lclass=516; else lclass=514;}
  2645.                    break;    
  2646.         case 0x43: pr1ntf("cmovae ");    r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=9;
  2647.                    if (isGoodAddress(ref)) 
  2648.                    {if (operandOveride) lclass=516; else lclass=514;}
  2649.                    break;    
  2650.         case 0x44: pr1ntf("cmove ");     r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=8;
  2651.                    if (isGoodAddress(ref)) 
  2652.                    {if (operandOveride) lclass=516; else lclass=514;}
  2653.                    break;    
  2654.         case 0x45: pr1ntf("cmovne ");    r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=9;
  2655.                    if (isGoodAddress(ref)) 
  2656.                    {if (operandOveride) lclass=516; else lclass=514;}
  2657.                    break;    
  2658.         case 0x46: pr1ntf("cmovbe ");    r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=9;
  2659.                    if (isGoodAddress(ref)) 
  2660.                    {if (operandOveride) lclass=516; else lclass=514;}
  2661.                    break;    
  2662.         case 0x47: pr1ntf("cmova ");     r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=8;
  2663.                    if (isGoodAddress(ref)) 
  2664.                    {if (operandOveride) lclass=516; else lclass=514;}
  2665.                    break;    
  2666.         case 0x48: pr1ntf("cmovs ");     r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=8;
  2667.                    if (isGoodAddress(ref)) 
  2668.                    {if (operandOveride) lclass=516; else lclass=514;}
  2669.                    break;    
  2670.         case 0x49: pr1ntf("cmovns ");    r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=9;
  2671.                    if (isGoodAddress(ref)) 
  2672.                    {if (operandOveride) lclass=516; else lclass=514;}
  2673.                    break;    
  2674.         case 0x4A: pr1ntf("cmovpe ");    r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=9;
  2675.                    if (isGoodAddress(ref)) 
  2676.                    {if (operandOveride) lclass=516; else lclass=514;}
  2677.                    break;    
  2678.         case 0x4B: pr1ntf("cmovpo ");    r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=9;
  2679.                    if (isGoodAddress(ref)) 
  2680.                    {if (operandOveride) lclass=516; else lclass=514;}
  2681.                    break;    
  2682.         case 0x4C: pr1ntf("cmovl ");     r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=8;
  2683.                    if (isGoodAddress(ref)) 
  2684.                    {if (operandOveride) lclass=516; else lclass=514;}
  2685.                    break;    
  2686.         case 0x4D: pr1ntf("cmovge ");    r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=9;
  2687.                    if (isGoodAddress(ref)) 
  2688.                    {if (operandOveride) lclass=516; else lclass=514;}
  2689.                    break;    
  2690.         case 0x4E: pr1ntf("cmovle ");    r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=9;
  2691.                    if (isGoodAddress(ref)) 
  2692.                    {if (operandOveride) lclass=516; else lclass=514;}
  2693.                    break;    
  2694.         case 0x4F: pr1ntf("cmovg ");     r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=8;
  2695.                    if (isGoodAddress(ref)) 
  2696.                    {if (operandOveride) lclass=516; else lclass=514;}
  2697.                    break;    
  2698.         case 0x60: pr1ntf("punpcklbw "); mm____();pr1ntf(", ");ref=r_m_(64);printCol+=12;
  2699.                    if (isGoodAddress(ref)) lclass=518;
  2700.                    break;    
  2701.         case 0x61: pr1ntf("punpcklwd "); mm____();pr1ntf(", ");ref=r_m_(64);printCol+=12;
  2702.                    if (isGoodAddress(ref)) lclass=518;
  2703.                    break;    
  2704.         case 0x62: pr1ntf("punpckldq "); mm____();pr1ntf(", ");ref=r_m_(64);printCol+=12;
  2705.                    if (isGoodAddress(ref)) lclass=518;
  2706.                    break;    
  2707.         case 0x63: pr1ntf("packsswb ");  mm____();pr1ntf(", ");ref=r_m_(64);printCol+=11;
  2708.                    if (isGoodAddress(ref)) lclass=518;
  2709.                    break;    
  2710.         case 0x64: pr1ntf("pcmpgtb ");   mm____();pr1ntf(", ");ref=r_m_(64);printCol+=10;
  2711.                    if (isGoodAddress(ref)) lclass=518;
  2712.                    break;    
  2713.         case 0x65: pr1ntf("pcmpgtw ");   mm____();pr1ntf(", ");ref=r_m_(64);printCol+=10;
  2714.                    if (isGoodAddress(ref)) lclass=518;
  2715.                    break;    
  2716.         case 0x66: pr1ntf("pcmpgtd ");   mm____();pr1ntf(", ");ref=r_m_(64);printCol+=10;
  2717.                    if (isGoodAddress(ref)) lclass=518;
  2718.                    break;    
  2719.         case 0x67: pr1ntf("packuswb ");  mm____();pr1ntf(", ");ref=r_m_(64);printCol+=11;
  2720.                    if (isGoodAddress(ref)) lclass=518;
  2721.                    break;    
  2722.         case 0x68: pr1ntf("punpckhbw "); mm____();pr1ntf(", ");ref=r_m_(64);printCol+=12;
  2723.                    if (isGoodAddress(ref)) lclass=518;
  2724.                    break;    
  2725.         case 0x69: pr1ntf("punpckhwd "); mm____();pr1ntf(", ");ref=r_m_(64);printCol+=12;
  2726.                    if (isGoodAddress(ref)) lclass=518;
  2727.                    break;    
  2728.         case 0x6A: pr1ntf("punpckhdq "); mm____();pr1ntf(", ");ref=r_m_(64);printCol+=12;
  2729.                    if (isGoodAddress(ref)) lclass=518;
  2730.                    break;    
  2731.         case 0x6B: pr1ntf("packssdw ");  mm____();pr1ntf(", ");ref=r_m_(64);printCol+=11;
  2732.                    if (isGoodAddress(ref)) lclass=518;
  2733.                    break;    
  2734.         case 0x6E: pr1ntf("movd ");      mm____();pr1ntf(", ");ref=r_m_(rr);printCol+=7;
  2735.                    if (isGoodAddress(ref)) 
  2736.                    {if (operandOveride) lclass=516; else lclass=514;}
  2737.                    break;    
  2738.         case 0x6F: pr1ntf("movq ");      mm____();pr1ntf(", ");ref=r_m_(64);printCol+=7;
  2739.                    if (isGoodAddress(ref)) lclass=518;
  2740.                    break;    
  2741.         case 0x74: pr1ntf("pcmpeqb ");   mm____();pr1ntf(", ");ref=r_m_(64);printCol+=10;
  2742.                    if (isGoodAddress(ref)) lclass=518;
  2743.                    break;    
  2744.         case 0x75: pr1ntf("pcmpeqw ");   mm____();pr1ntf(", ");ref=r_m_(64);printCol+=10;
  2745.                    if (isGoodAddress(ref)) lclass=518;
  2746.                    break;    
  2747.         case 0x76: pr1ntf("pcmpeqd ");   mm____();pr1ntf(", ");ref=r_m_(64);printCol+=10;
  2748.                    if (isGoodAddress(ref)) lclass=518;
  2749.                    break;    
  2750.         case 0x7E: pr1ntf("movd ");      r_m_(rr);pr1ntf(", ");ref=mm____();printCol+=7;
  2751.                    if (isGoodAddress(ref)) lclass=518;
  2752.                    break;    
  2753.         case 0x7F: pr1ntf("movq ");      r_m_(64);pr1ntf(", ");ref=mm____();printCol+=7;
  2754.                    if (isGoodAddress(ref)) lclass=518;
  2755.                    break;    
  2756.         case 0x90: pr1ntf("seto ");      ref=r_m_( 8);                      printCol+=5;
  2757.                    if (isGoodAddress(ref)) lclass=520;
  2758.                    break; 
  2759.         case 0x91: pr1ntf("setno ");     ref=r_m_( 8);                      printCol+=6;
  2760.                    if (isGoodAddress(ref)) lclass=520;
  2761.                    break; 
  2762.         case 0x92: pr1ntf("setb ");      ref=r_m_( 8);                      printCol+=5;
  2763.                    if (isGoodAddress(ref)) lclass=520;
  2764.                    break; 
  2765.         case 0x93: pr1ntf("setae ");     ref=r_m_( 8);                      printCol+=6;
  2766.                    if (isGoodAddress(ref)) lclass=520;
  2767.                    break; 
  2768.         case 0x94: pr1ntf("sete ");      ref=r_m_( 8);                      printCol+=5;
  2769.                    if (isGoodAddress(ref)) lclass=520;
  2770.                    break; 
  2771.         case 0x95: pr1ntf("setne ");     ref=r_m_( 8);                      printCol+=6;
  2772.                    if (isGoodAddress(ref)) lclass=520;
  2773.                    break; 
  2774.         case 0x96: pr1ntf("setbe ");     ref=r_m_( 8);                      printCol+=6;
  2775.                    if (isGoodAddress(ref)) lclass=520;
  2776.                    break; 
  2777.         case 0x97: pr1ntf("seta ");      ref=r_m_( 8);                      printCol+=5;
  2778.                    if (isGoodAddress(ref)) lclass=520;
  2779.                    break; 
  2780.         case 0x98: pr1ntf("sets ");      ref=r_m_( 8);                      printCol+=5;
  2781.                    if (isGoodAddress(ref)) lclass=520;
  2782.                    break; 
  2783.         case 0x99: pr1ntf("setns ");     ref=r_m_( 8);                      printCol+=6;
  2784.                    if (isGoodAddress(ref)) lclass=520;
  2785.                    break; 
  2786.         case 0x9A: pr1ntf("setpe ");     ref=r_m_( 8);                      printCol+=6;
  2787.                    if (isGoodAddress(ref)) lclass=520;
  2788.                    break; 
  2789.         case 0x9B: pr1ntf("setpo ");     ref=r_m_( 8);                      printCol+=6;
  2790.                    if (isGoodAddress(ref)) lclass=520;
  2791.                    break; 
  2792.         case 0x9C: pr1ntf("setl ");      ref=r_m_( 8);                      printCol+=5;
  2793.                    if (isGoodAddress(ref)) lclass=520;
  2794.                    break; 
  2795.         case 0x9D: pr1ntf("setge ");     ref=r_m_( 8);                         printCol+=6;
  2796.                    if (isGoodAddress(ref)) lclass=520;
  2797.                    break; 
  2798.         case 0x9E: pr1ntf("setle ");     ref=r_m_( 8);                         printCol+=6;
  2799.                    if (isGoodAddress(ref)) lclass=520;
  2800.                    break; 
  2801.         case 0x9F: pr1ntf("setg ");      ref=r_m_( 8);                         printCol+=5;
  2802.                    if (isGoodAddress(ref)) lclass=520;
  2803.                    break; 
  2804.         case 0xA3: pr1ntf("bt ");        ref=r_m_(rr);pr1ntf(", ");r___(rr);printCol+=5;
  2805.                    if (isGoodAddress(ref))
  2806.                    {if (operandOveride) lclass=516; else lclass=514;}
  2807.                    break;    
  2808.         case 0xA5: pr1ntf("shld ");      ref=r_m_(rr);pr1ntf(", ");r___(rr);printCol+=11;
  2809.                                                   pr1ntf(", cl");       
  2810.                    if (isGoodAddress(ref)) 
  2811.                    {if (operandOveride) lclass=516; else lclass=514;}
  2812.                    break;
  2813.         case 0xAB: pr1ntf("bts ");       ref=r_m_(rr);pr1ntf(", ");r___(rr);printCol+=6;
  2814.                    if (isGoodAddress(ref)) 
  2815.                    {if (operandOveride) lclass=516; else lclass=514;}
  2816.                    break;    
  2817.         case 0xAD: pr1ntf("shrd ");      ref=r_m_(rr);pr1ntf(", ");r___(rr);printCol+=11;      
  2818.                                                   pr1ntf(", cl");       
  2819.                    if (isGoodAddress(ref)) 
  2820.                    {if (operandOveride) lclass=516; else lclass=514;}
  2821.                    break;
  2822.         case 0xAF: pr1ntf("imul ");      r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=7;
  2823.                    if (isGoodAddress(ref)) 
  2824.                    {if (operandOveride) lclass=516; else lclass=514;}
  2825.                    break;    
  2826.         case 0xB0: pr1ntf("cmpxchg ");   ref=r_m_( 8);pr1ntf(", ");r___( 8);printCol+=10;
  2827.                    if (isGoodAddress(ref)) lclass=520;
  2828.                    break;    
  2829.         case 0xB1: pr1ntf("cmpxchg ");   ref=r_m_(rr);pr1ntf(", ");r___(rr);printCol+=10;
  2830.                    if (isGoodAddress(ref)) 
  2831.                    {if (operandOveride) lclass=516; else lclass=514;}
  2832.                    break;    
  2833.         case 0xB2: pr1ntf("lss ");       r___(rr);pr1ntf(", ");ref=m16_32();printCol+=6;
  2834.                    if (isGoodAddress(ref)) lclass=516;
  2835.                    break;   
  2836.         case 0xB3: pr1ntf("btr ");       ref=r_m_(rr);pr1ntf(", ");r___(rr);printCol+=6;
  2837.                    if (isGoodAddress(ref)) 
  2838.                    {if (operandOveride) lclass=516; else lclass=514;}
  2839.                    break;    
  2840.         case 0xB4: pr1ntf("lfs ");       r___(rr);pr1ntf(", ");ref=m16_32();printCol+=6;
  2841.                    if (isGoodAddress(ref)) lclass=516;
  2842.                    break;   
  2843.         case 0xB5: pr1ntf("lgs ");       r___(rr);pr1ntf(", ");ref=m16_32();printCol+=6;
  2844.                    if (isGoodAddress(ref)) lclass=516;
  2845.                    break;   
  2846.         case 0xB6: pr1ntf("movzx ");     r___(rr);pr1ntf(", ");ref=r_m_( 8);printCol+=8;
  2847.                    if (isGoodAddress(ref)) lclass=520;
  2848.                    break;    
  2849.         case 0xB7: pr1ntf("movzx ");     r___(rr);pr1ntf(", ");ref=r_m_(16);printCol+=8;
  2850.                    if (isGoodAddress(ref)) lclass=516;
  2851.                    break;    
  2852.         case 0xBB: pr1ntf("btc ");       ref=r_m_(rr);pr1ntf(", ");r___(rr);printCol+=6;
  2853.                    if (isGoodAddress(ref)) 
  2854.                    {if (operandOveride) lclass=516; else lclass=514;}
  2855.                    break;    
  2856.         case 0xBC: pr1ntf("bsf ");       r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=6;
  2857.                    if (isGoodAddress(ref)) 
  2858.                    {if (operandOveride) lclass=516; else lclass=514;}
  2859.                    break;    
  2860.         case 0xBD: pr1ntf("bsr ");         r___(rr);pr1ntf(", ");ref=r_m_(rr);printCol+=6;
  2861.                    if (isGoodAddress(ref)) 
  2862.                    {if (operandOveride) lclass=516; else lclass=514;}
  2863.                    break;    
  2864.         case 0xBE: pr1ntf("movsx ");     r___(rr);pr1ntf(", ");ref=r_m_( 8);printCol+=8;
  2865.                    if (isGoodAddress(ref)) lclass=520;
  2866.                    break;    
  2867.         case 0xBF: pr1ntf("movsx ");     r___(rr);pr1ntf(", ");ref=r_m_(16);printCol+=8;
  2868.                    if (isGoodAddress(ref)) lclass=516;
  2869.                    break;    
  2870.         case 0xC0: pr1ntf("xadd ");      ref=r_m_( 8);pr1ntf(", ");r___( 8);printCol+=7;
  2871.                    if (isGoodAddress(ref)) lclass=520;
  2872.                    break;    
  2873.         case 0xC1: pr1ntf("xadd ");      ref=r_m_(rr);pr1ntf(", ");r___(rr);printCol+=7;
  2874.                    if (isGoodAddress(ref)) 
  2875.                    {if (operandOveride) lclass=516; else lclass=514;}
  2876.                    break;    
  2877.         case 0xD1: pr1ntf("psrlw ");     mm____();pr1ntf(", ");ref=r_m_(64);printCol+=8;
  2878.                    if (isGoodAddress(ref)) lclass=518;
  2879.                    break;   
  2880.         case 0xD2: pr1ntf("psrld ");     mm____();pr1ntf(", ");ref=r_m_(64);printCol+=8;
  2881.                    if (isGoodAddress(ref)) lclass=518;
  2882.                    break;   
  2883.         case 0xD3: pr1ntf("psrlq ");     mm____();pr1ntf(", ");ref=r_m_(64);printCol+=8;
  2884.                    if (isGoodAddress(ref)) lclass=518;
  2885.                    break;   
  2886.         case 0xD5: pr1ntf("pmullw ");    mm____();pr1ntf(", ");ref=r_m_(64);printCol+=9;
  2887.                    if (isGoodAddress(ref)) lclass=518;
  2888.                    break;   
  2889.         case 0xD8: pr1ntf("psubusb ");   mm____();pr1ntf(", ");ref=r_m_(64);printCol+=10;
  2890.                    if (isGoodAddress(ref)) lclass=518;
  2891.                    break;   
  2892.         case 0xD9: pr1ntf("psubusw ");   mm____();pr1ntf(", ");ref=r_m_(64);printCol+=10;
  2893.                    if (isGoodAddress(ref)) lclass=518;
  2894.                    break;   
  2895.         case 0xDB: pr1ntf("pand ");      mm____();pr1ntf(", ");ref=r_m_(64);printCol+=7;
  2896.                    if (isGoodAddress(ref)) lclass=518;
  2897.                    break;   
  2898.         case 0xDC: pr1ntf("paddusb ");   mm____();pr1ntf(", ");ref=r_m_(64);printCol+=10;
  2899.                    if (isGoodAddress(ref)) lclass=518;
  2900.                    break;   
  2901.         case 0xDD: pr1ntf("paddusw ");   mm____();pr1ntf(", ");ref=r_m_(64);printCol+=10;
  2902.                    if (isGoodAddress(ref)) lclass=518;
  2903.                    break;   
  2904.         case 0xDF: pr1ntf("pandn ");     mm____();pr1ntf(", ");ref=r_m_(64);printCol+=8;
  2905.                    if (isGoodAddress(ref)) lclass=518;
  2906.                    break;   
  2907.         case 0xE1: pr1ntf("psraw ");     mm____();pr1ntf(", ");ref=r_m_(64);printCol+=8;
  2908.                    if (isGoodAddress(ref)) lclass=518;
  2909.                    break;   
  2910.         case 0xE2: pr1ntf("psrad ");     mm____();pr1ntf(", ");ref=r_m_(64);printCol+=8;
  2911.                    if (isGoodAddress(ref)) lclass=518;
  2912.                    break;   
  2913.         case 0xE5: pr1ntf("pmulhw ");    mm____();pr1ntf(", ");ref=r_m_(64);printCol+=9;
  2914.                    if (isGoodAddress(ref)) lclass=518;
  2915.                    break;   
  2916.         case 0xE8: pr1ntf("psubsb ");    mm____();pr1ntf(", ");ref=r_m_(64);printCol+=9;
  2917.                    if (isGoodAddress(ref)) lclass=518;
  2918.                    break;   
  2919.         case 0xE9: pr1ntf("psubsw ");    mm____();pr1ntf(", ");ref=r_m_(64);printCol+=9;
  2920.                    if (isGoodAddress(ref)) lclass=518;
  2921.                    break;   
  2922.         case 0xEB: pr1ntf("por ");       mm____();pr1ntf(", ");ref=r_m_(64);printCol+=5;
  2923.                    if (isGoodAddress(ref)) lclass=518;
  2924.                    break;   
  2925.         case 0xEC: pr1ntf("paddsb ");    mm____();pr1ntf(", ");ref=r_m_(64);printCol+=9;
  2926.                    if (isGoodAddress(ref)) lclass=518;
  2927.                    break;   
  2928.         case 0xED: pr1ntf("paddsw ");    mm____();pr1ntf(", ");ref=r_m_(64);printCol+=9;
  2929.                    if (isGoodAddress(ref)) lclass=518;
  2930.                    break;   
  2931.         case 0xEF: pr1ntf("pxor ");      mm____();pr1ntf(", ");ref=r_m_(64);printCol+=7;
  2932.                    if (isGoodAddress(ref)) lclass=518;
  2933.                    break;   
  2934.         case 0xF1: pr1ntf("psllw ");     mm____();pr1ntf(", ");ref=r_m_(64);printCol+=8;
  2935.                    if (isGoodAddress(ref)) lclass=518;
  2936.                    break;   
  2937.         case 0xF2: pr1ntf("pslld ");     mm____();pr1ntf(", ");ref=r_m_(64);printCol+=8;
  2938.                    if (isGoodAddress(ref)) lclass=518;
  2939.                    break;   
  2940.         case 0xF3: pr1ntf("psllq ");     mm____();pr1ntf(", ");ref=r_m_(64);printCol+=8;
  2941.                    if (isGoodAddress(ref)) lclass=518;
  2942.                    break;   
  2943.         case 0xF5: pr1ntf("pmaddwd ");   mm____();pr1ntf(", ");ref=r_m_(64);printCol+=10;
  2944.                    if (isGoodAddress(ref)) lclass=518;
  2945.                    break;   
  2946.         case 0xF8: pr1ntf("psubb ");     mm____();pr1ntf(", ");ref=r_m_(64);printCol+=8;
  2947.                    if (isGoodAddress(ref)) lclass=518;
  2948.                    break;   
  2949.         case 0xF9: pr1ntf("psubw ");     mm____();pr1ntf(", ");ref=r_m_(64);printCol+=8;
  2950.                    if (isGoodAddress(ref)) lclass=518;
  2951.                    break;   
  2952.         case 0xFA: pr1ntf("psubd ");     mm____();pr1ntf(", ");ref=r_m_(64);printCol+=8;
  2953.                    if (isGoodAddress(ref)) lclass=518;
  2954.                    break;   
  2955.         case 0xFC: pr1ntf("paddb ");     mm____();pr1ntf(", ");ref=r_m_(64);printCol+=8;
  2956.                    if (isGoodAddress(ref)) lclass=518;
  2957.                    break;   
  2958.         case 0xFD: pr1ntf("paddw ");     mm____();pr1ntf(", ");ref=r_m_(64);printCol+=8;
  2959.                    if (isGoodAddress(ref)) lclass=518;
  2960.                    break;   
  2961.         case 0xFE: pr1ntf("paddd ");     mm____();pr1ntf(", ");ref=r_m_(64);printCol+=8;
  2962.                    if (isGoodAddress(ref)) lclass=518;
  2963.                    break;
  2964.         default: fatalError=329;
  2965.     }
  2966.     return 0;
  2967. }
  2968.  
  2969. int print23case()
  2970. {
  2971. int    rr;
  2972.  
  2973.     if (operandOveride) rr=16; else rr=32;
  2974.  
  2975.     if (i_opcode==0xA4) 
  2976.     {
  2977.         pr1ntf("shld "); r_m_(rr);
  2978.         pr1ntf(", ");    r___(rr);
  2979.         pr1ntf(", ");    print_i_byte();  printCol+=9;
  2980.     }
  2981.     else
  2982.     {
  2983.         pr1ntf("shrd "); r_m_(rr);
  2984.         pr1ntf(", ");    r___(rr);
  2985.         pr1ntf(", ");    print_i_byte();  printCol+=9;
  2986.     }
  2987.     return 0;
  2988. }
  2989.  
  2990. int print24case()
  2991. {
  2992. int    rr;
  2993.  
  2994.     if (operandOveride) rr=16; else rr=32;
  2995.  
  2996.     if (i_opcode==0x00)
  2997.     {    
  2998.         switch(regTable[i_mod])
  2999.         {
  3000.             case 0: pr1ntf("sldt "); ref=r_m_(rr); printCol+=5; 
  3001.                     if (isGoodAddress(ref)) 
  3002.                     {if (operandOveride) lclass=516; else lclass=514;}
  3003.                     break;           
  3004.             case 1: pr1ntf("str ");  ref=r_m_(16); printCol+=4; 
  3005.                     if (isGoodAddress(ref)) lclass=516;
  3006.                     break;
  3007.             case 2: pr1ntf("lldt "); ref=r_m_(16); printCol+=5; 
  3008.                     if (isGoodAddress(ref)) lclass=516;
  3009.                     break;
  3010.             case 3: pr1ntf("ltr ");  ref=r_m_(16); printCol+=4; 
  3011.                     if (isGoodAddress(ref)) lclass=516;
  3012.                     break;
  3013.             case 4: pr1ntf("verr "); ref=r_m_(16); printCol+=5; 
  3014.                     if (isGoodAddress(ref)) lclass=516;
  3015.                     break;
  3016.             case 5: pr1ntf("verw "); ref=r_m_(16); printCol+=5; 
  3017.                     if (isGoodAddress(ref)) lclass=516;
  3018.                     break;
  3019.             default: fatalError=331;
  3020.         }
  3021.     }
  3022.     else if (i_opcode==0x01)
  3023.     {
  3024.         switch(regTable[i_mod])
  3025.         {
  3026.             case 0: pr1ntf("sgdt ");   ref=m_____(); printCol+=5; 
  3027.                     if (isGoodAddress(ref)) 
  3028.                     {if (operandOveride) lclass=516; else lclass=514;}
  3029.                     break;
  3030.             case 1: pr1ntf("sidt ");   ref=m_____(); printCol+=5; 
  3031.                     if (isGoodAddress(ref)) 
  3032.                     {if (operandOveride) lclass=516; else lclass=514;}
  3033.                     break;
  3034.             case 2: pr1ntf("lgdt ");   ref=m16_32(); printCol+=5; 
  3035.                     if (isGoodAddress(ref)) lclass=516;
  3036.                     break;
  3037.             case 3: pr1ntf("lidt ");   ref=m16_32(); printCol+=5; 
  3038.                     if (isGoodAddress(ref)) lclass=516;
  3039.                     break;
  3040.             case 4: pr1ntf("smsw ");   ref=r_m_(rr); printCol+=5; 
  3041.                     if (isGoodAddress(ref)) 
  3042.                     {if (operandOveride) lclass=516; else lclass=514;}
  3043.                     break;
  3044.             case 6: pr1ntf("lmsw ");   ref=r_m_(16); printCol+=5; 
  3045.                     if (isGoodAddress(ref)) lclass=516;
  3046.                     break;
  3047.             case 7: pr1ntf("invlpg "); ref=m_____(); printCol+=7; 
  3048.                     if (isGoodAddress(ref)) 
  3049.                     {if (operandOveride) lclass=516; else lclass=514;}
  3050.                     break;
  3051.             default: fatalError=333;
  3052.         }
  3053.     }
  3054.     else if (i_opcode==0xAE)
  3055.     {
  3056.              if (regTable[i_mod]==0) {pr1ntf("fxsave") ;printCol+=6;}
  3057.         else if (regTable[i_mod]==1) {pr1ntf("fxrstor");printCol+=7;}
  3058.         else fatalError=334;
  3059.     }
  3060.     else if (i_opcode==0xC7 && regTable[i_mod]==1)
  3061.     {
  3062.         pr1ntf("comxchg8b 64bit");     printCol+=15; 
  3063.         m_____();
  3064.     }
  3065.     else fatalError=335;
  3066.     return 0;
  3067. }
  3068.  
  3069. int print25case()
  3070. {
  3071. int    k;
  3072. int    rr;
  3073.  
  3074.     if (operandOveride) rr=16; else rr=32;
  3075.  
  3076.     k = regTable[i_mod];
  3077.     if (i_opcode==0x71)
  3078.     {
  3079.         if (k==2) 
  3080.         {
  3081.             pr1ntf("psrlw "); mmm___(); pr1ntf(", "); print_i_byte(); printCol+=8; 
  3082.         }
  3083.         else if (k==4)
  3084.         {
  3085.             pr1ntf("psraw "); mmm___(); pr1ntf(", "); print_i_byte(); printCol+=8; 
  3086.         }
  3087.         else if (k==6)
  3088.         {
  3089.             pr1ntf("psllw "); mmm___(); pr1ntf(", "); print_i_byte(); printCol+=8; 
  3090.         }
  3091.         else fatalError=337;
  3092.     }
  3093.     else if (i_opcode==0x72)
  3094.     {
  3095.         if (k==2)
  3096.         {
  3097.             pr1ntf("psrld "); mmm___(); pr1ntf(", "); print_i_byte(); printCol+=8; 
  3098.         }
  3099.         else if (k==4)
  3100.         {
  3101.             pr1ntf("psrad "); mmm___(); pr1ntf(", "); print_i_byte(); printCol+=8; 
  3102.         }
  3103.         else if (k==6)
  3104.         {
  3105.             pr1ntf("pslld "); mmm___(); pr1ntf(", "); print_i_byte(); printCol+=8; 
  3106.         }
  3107.         else fatalError=339;
  3108.     }
  3109.     else if (i_opcode==0x73)
  3110.     {
  3111.         if (k==2)
  3112.         {
  3113.             pr1ntf("psrlq "); mmm___(); pr1ntf(", "); print_i_byte(); printCol+=8; 
  3114.         }
  3115.         else if (k==6)
  3116.         {
  3117.             pr1ntf("psllq "); mmm___(); pr1ntf(", "); print_i_byte(); printCol+=8; 
  3118.         }
  3119.         else fatalError=341;
  3120.     }
  3121.     else if (i_opcode==0xBA)
  3122.     {
  3123.         if (k==4)
  3124.         {
  3125.             pr1ntf("bt ");    ref=r_m_(rr); pr1ntf(", "); print_i_byte32(); printCol+=5;
  3126.             if (isGoodAddress(ref)) 
  3127.             {if (operandOveride) lclass=516; else lclass=514;}
  3128.         }
  3129.         else if (k==5)
  3130.         {
  3131.             pr1ntf("bts ");   ref=r_m_(rr); pr1ntf(", "); print_i_byte32();    printCol+=6; 
  3132.             if (isGoodAddress(ref)) 
  3133.             {if (operandOveride) lclass=516; else lclass=514;}
  3134.         }
  3135.         else if (k==6)
  3136.         {
  3137.             pr1ntf("btr ");   ref=r_m_(rr); pr1ntf(", "); print_i_byte32();    printCol+=6; 
  3138.             if (isGoodAddress(ref)) 
  3139.             {if (operandOveride) lclass=516; else lclass=514;}
  3140.         }
  3141.         else if (k==7)
  3142.         {
  3143.             pr1ntf("btc ");   ref=r_m_(rr); pr1ntf(", "); print_i_byte32();    printCol+=6; 
  3144.             if (isGoodAddress(ref)) 
  3145.             {if (operandOveride) lclass=516; else lclass=514;}
  3146.         }
  3147.         else fatalError=343;
  3148.     }
  3149.     else fatalError=345;
  3150.     return 0;
  3151. }
  3152.