home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 7 / PC World Interactive 7.iso / program / cprog.EXE / OBJ2ASM.ZIP / ODISFP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-05-26  |  3.4 KB  |  113 lines
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include "o.h"
  4.  
  5. static char *esc_0x0X[] = {
  6.     "fchs"   , "fabs"   ,  ""      , "",            /* [0C:0] - [0C:3] */
  7.     "ftst"   , "fxam"   ,  ""      , "",            /* [0C:4] - [0C:7] */
  8.     "fld1"   , "fldl2t" , "fldl2e" , "fldpi",       /* [0D:0] - [0D:3] */
  9.     "fldlg2" , "fldln2" , "fldz"   , "",            /* [0D:4] - [0D:7] */
  10.     "f2xm1"  , "fyl2x"  , "fptan"  , "fpatan",      /* [0E:0] - [0E:3] */
  11.     "fxtract", "fprem1" , "fdecstp", "fincstp",     /* [0E:4] - [0E:7] */
  12.     "fprem"  , "fyl2xp1", "fsqrt"  , "fsincos",     /* [0F:0] - [0F:3] */
  13.     "frndint", "fscale" , "fsin"   , "fcos"     };  /* [0F:4] - [0F:7] */
  14.  
  15. static char *esc_0x1C[] = {
  16.     "fneni"  , "fndisi" , "fnclex" , "fninit",      /* [1C:0] - [1C:3] */
  17.     ""       , ""       , ""       , ""         };  /* [1C:4] - [1C:7] */
  18.  
  19. void esc_special( opcode, operand, esc_byte, reg )
  20.     char            *opcode;
  21.     char            *operand;
  22.     int             esc_byte;
  23.     int             reg;
  24. {
  25.     int             element;
  26.  
  27.     strcpy( opcode, "" );
  28.     strcpy( operand, "" );
  29.     
  30.     /*
  31.     ** This routine is bad, but it would make no more sense if it listed
  32.     ** out all of the possible esc_byte and register combinations!
  33.     */
  34.     if ( esc_byte == 0x0A ) {
  35.         if ( reg == 0x00 ) {
  36.             strcpy( opcode, "fnop" );
  37.         }
  38.         return;
  39.     }
  40.     if ( esc_byte == 0x0B ) {
  41.         return;
  42.     }
  43.     if ( esc_byte >= 0x0C && esc_byte <= 0x0F ) {
  44.         element = (esc_byte - 0x0C) * 8 + reg;
  45.         strcpy( opcode, esc_0x0X[element] );
  46.         return;
  47.     }
  48.     if ( esc_byte >= 0x10 && esc_byte <= 0x1F ) {
  49.         if ( esc_byte == 0x15 && reg == 0x01 ) {
  50.             strcpy( opcode, "fucompp" );
  51.         }
  52.         if ( esc_byte == 0x1C ) {
  53.             strcpy( opcode, esc_0x1C[reg] );
  54.         }
  55.         return;
  56.     }
  57.     if ( esc_byte == 0x22 || esc_byte == 0x23 || esc_byte == 0x29 
  58.          || (esc_byte >= 0x2C && esc_byte <= 0x2F) ) {
  59.         return;
  60.     }
  61.     if ( esc_byte == 0x33 ) {
  62.         if ( reg == 0x01 ) {
  63.             strcpy( opcode, "fcompp" );
  64.         }
  65.         return;
  66.     }   
  67.     if ( esc_byte == 0x32 ) {
  68.         return;
  69.     }
  70.     if ( esc_byte == 0x38 || esc_byte == 0x39
  71.       || esc_byte == 0x3A || esc_byte == 0x3B ) {
  72.         return;
  73.     }
  74.     if ( esc_byte == 0x3C ) {
  75.         if ( reg == 0x00 ) {
  76.             strcpy( opcode, "fstsw" );
  77.             strcpy( operand, "ax" );
  78.         }
  79.         return;
  80.     }
  81.     if ( esc_byte == 0x3D || esc_byte == 0x3E || esc_byte == 0x3F ) {
  82.         return;
  83.     }
  84.     element = esc_byte & 0x0F;
  85.     if (    element == 0x02 || element == 0x03 || element == 0x08
  86.          || element == 0x09 || element == 0x0A || element == 0x0B ) {
  87.         sprintf( operand, "st(%d)", reg );
  88.     } else {
  89.         if ( esc_byte >= 0x10 ) {
  90.             sprintf( operand, "st(%d),st", reg );
  91.         } else {
  92.             sprintf( operand, "st,st(%d)", reg );
  93.         }
  94.     }
  95.     if (    esc_byte == 0x24 || esc_byte == 0x34
  96.          || esc_byte == 0x26 || esc_byte == 0x36 ) {
  97.         element++;
  98.     }
  99.     if (    esc_byte == 0x25 || esc_byte == 0x35
  100.          || esc_byte == 0x27 || esc_byte == 0x37 ) {
  101.         --element;
  102.     }
  103.     if ( esc_byte == 0x09 ) {
  104.         strcpy( opcode, "fxch" );
  105.     } else {
  106.         strcpy( opcode, esc_inst[element] );
  107.     }
  108.     if ( esc_byte >= 0x30 ) {
  109.         strcat( opcode, "p" );
  110.     }
  111. }
  112.  
  113.