home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 405.lha / AppleII_Emulators_src / src-2 / dis_ass6502.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-06-28  |  18.2 KB  |  427 lines
  1. #include <cpu_prog_model.h>
  2. #include <stdio.h>
  3.  
  4. #define FALSE  0
  5. #define TRUE   1
  6.  
  7. char *Mnemonic [] =
  8. {
  9. /*             00               01                02                03     */
  10. /*             04               05                06                07     */
  11. /*             08               09                0A                0B     */
  12. /*             0C               0D                0E                0F     */
  13. /*
  14. /* 00 */  "\001BRK",        "\000???",        "\000???",        "\000???",
  15. /*    */  "\000???",        "\003ORA",        "\003ASL",        "\000???",
  16. /*    */  "\001PHP",        "\002ORA",        "\015ASL",        "\000???",
  17. /*    */  "\000???",        "\006ORA",        "\006ASL",        "\000???",
  18. /* 10 */  "\014BPL",        "\012ORA",        "\000???",        "\000???",
  19. /*    */  "\000???",        "\004ORA",        "\004ASL",        "\000???",
  20. /*    */  "\001CLC",        "\006ORA",        "\000???",        "\000???",
  21. /*    */  "\000???",        "\007ORA",        "\007ASL",        "\000???",
  22. /* 20 */  "\006JSR",        "\011AND",        "\000???",        "\000???",
  23. /*    */  "\003BIT",        "\003AND",        "\003ROL",        "\000???",
  24. /*    */  "\001PLP",        "\002AND",        "\015ROL",        "\000???",
  25. /*    */  "\006BIT",        "\006AND",        "\006ROL",        "\000???",
  26. /* 30 */  "\014BMI",        "\000???",        "\000???",        "\000???",
  27. /*    */  "\000???",        "\004AND",        "\004ROL",        "\000???",
  28. /*    */  "\001SEC",        "\010AND",        "\000???",        "\000???",
  29. /*    */  "\000???",        "\007AND",        "\007ROL",        "\000???",
  30. /* 40 */  "\001RTI",        "\011EOR",        "\000???",        "\000???",
  31. /*    */  "\000???",        "\003EOR",        "\003LSR",        "\000???",
  32. /*    */  "\001PHA",        "\002EOR",        "\015LSR",        "\000???",
  33. /*    */  "\006JMP",        "\006EOR",        "\006LSR",        "\000???",
  34. /* 50 */  "\014BVC",        "\012EOR",        "\000???",        "\000???",
  35. /*    */  "\000???",        "\004EOR",        "\004LSR",        "\000???",
  36. /*    */  "\001CLI",        "\010EOR",        "\000???",        "\000???",
  37. /*    */  "\000???",        "\007EOR",        "\007LSR",        "\000???",
  38. /* 60 */  "\001RTS",        "\000???",        "\000???",        "\000???",
  39. /*    */  "\000???",        "\003ADC",        "\003ROR",        "\000???",
  40. /*    */  "\001PLA",        "\002ADC",        "\015ROR",        "\000???",
  41. /*    */  "\013JMP",        "\006ADC",        "\006ROR",        "\000???",
  42. /* 70 */  "\014BVS",        "\012ADC",        "\000???",        "\000???",
  43. /*    */  "\000???",        "\004ADC",        "\004ROR",        "\000???",
  44. /*    */  "\001SEI",        "\000???",        "\000???",        "\000???",
  45. /*    */  "\000???",        "\000???",        "\007ROR",        "\000???",
  46. /* 80 */  "\000???",        "\000???",        "\000???",        "\000???",
  47. /*    */  "\003STY",        "\003STA",        "\003STX",        "\000???",
  48. /*    */  "\001DEY",        "\000???",        "\001TXA",        "\000???",
  49. /*    */  "\006STY",        "\006STA",        "\006STX",        "\000???",
  50. /* 90 */  "\014BCC",        "\012STA",        "\000???",        "\000???",
  51. /*    */  "\004STY",        "\004STA",        "\005STX",        "\000???",
  52. /*    */  "\001TYA",        "\010STA",        "\001TXS",        "\000???",
  53. /*    */  "\000???",        "\007STA",        "\000???",        "\000???",
  54. /* A0 */  "\002LDY",        "\011LDA",        "\002LDX",        "\000???",
  55. /*    */  "\003LDY",        "\003LDA",        "\003LDX",        "\000???",
  56. /*    */  "\001TAY",        "\002LDA",        "\001TAX",        "\001???",
  57. /*    */  "\006LDY",        "\006LDA",        "\006LDX",        "\000???",
  58. /* B0 */  "\014BCS",        "\012LDA",        "\000???",        "\000???",
  59. /*    */  "\004LDY",        "\004LDA",        "\005LDX",        "\000???",
  60. /*    */  "\001CLV",        "\010LDA",        "\001TSX",        "\000???",
  61. /*    */  "\007LDY",        "\007LDA",        "\010LDX",        "\000???",
  62. /* C0 */  "\002CPY",        "\000???",        "\000???",        "\000???",
  63. /*    */  "\003CPY",        "\003CMP",        "\003DEC",        "\000???",
  64. /*    */  "\001INY",        "\002CMP",        "\001DEX",        "\000???",
  65. /*    */  "\006CPY",        "\006CMP",        "\006DEC",        "\000???",
  66. /* D0 */  "\014BNE",        "\012CMP",        "\000???",        "\000???",
  67. /*    */  "\000???",        "\004CMP",        "\004DEC",        "\000???",
  68. /*    */  "\001CLD",        "\010CMP",        "\000???",        "\000???",
  69. /*    */  "\000???",        "\007CMP",        "\007DEC",        "\000???",
  70. /* E0 */  "\002CPX",        "\000???",        "\000???",        "\000???",
  71. /*    */  "\003CPX",        "\003SBC",        "\003INC",        "\000???",
  72. /*    */  "\001INX",        "\002SBC",        "\001NOP",        "\000???",
  73. /*    */  "\006CPX",        "\006SBC",        "\006INC",        "\000???",
  74. /* F0 */  "\014BEQ",        "\012SBC",        "\000???",        "\000???",
  75. /*    */  "\000???",        "\004SBC",        "\004INC",        "\000???",
  76. /*    */  "\001SED",        "\000???",        "\000???",        "\000???",
  77. /*    */  "\000???",        "\007SBC",        "\007INC",        "\001DBG"
  78. };
  79.  
  80. char *jumpers_FDxx [] =
  81. {
  82. /* FD00 */   "", "", "", "", "", "", "", "", "", "", "", "",
  83. /* FD0C */   "      ; $FD0C = RdKey",
  84. /* FD0D */   "", "", "",
  85. /* FD10 */   "", "", "", "", "", "", "", "", "", "", "",
  86. /* FD1B */   "      ; $FD1B = KeyIn",
  87. /* FD1C */   "", "", "", "",
  88. /* FD20 */   "",
  89. /* FD21 */   "      ; $FD21 = KeyIn2",
  90. /* FD22 */   "", "", "", "", "", "", "", "", "", "", "", "", "",
  91. /* FD2F */   "      ; $FD2F = Esc",
  92. /* FD30 */   "", "", "", "", "",
  93. /* FD35 */   "      ; $FD35 = RdChar",
  94. /* FD36 */   "", "", "", "", "", "", "",
  95. /* FD3D */   "      ; $FD3D = NotCr",
  96. /* FD3E */   "", "",
  97. /* FD40 */   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
  98. /* FD50 */   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
  99. /* FD5F */   "      ; $FD5F = NotCr1",
  100. /* FD60 */   "", "",
  101. /* FD62 */   "      ; $FD62 = Cancel",
  102. /* FD63 */   "", "", "", "",
  103. /* FD67 */   "      ; $FD67 = GetLnZ",
  104. /* FD68 */   "", "",
  105. /* FD6A */   "      ; $FD6A = GetLn",
  106. /* FD6B */   "", "", "", "", "",
  107. /* FD70 */   "",
  108. /* FD71 */   "      ; $FD71 = BckSpc",
  109. /* FD72 */   "", "", "",
  110. /* FD75 */   "      ; $FD75 = NxtChar",
  111. /* FD76 */   "", "", "", "", "", "", "", "",
  112. /* FD7E */   "      ; $FD7E = CapTst",
  113. /* FD7F */   "",
  114. /* FD80 */   "", "", "", "",
  115. /* FD84 */   "      ; $FD84 = AddInp",
  116. /* FD85 */   "", "", "", "", "", "", "", "", "",
  117. /* FD8E */   "      ; $FD8E = CrOut",
  118. /* FD8F */   "",
  119. /* FD90 */   "", "",
  120. /* FD92 */   "      ; $FD92 = Pra1",
  121. /* FD93 */   "", "", "",
  122. /* FD96 */   "      ; $FD96 = PrYX2",
  123. /* FD97 */   "", "", "", "", "", "", "", "", "",
  124. /* FDA0 */   "", "", "",
  125. /* FDA3 */   "      ; $FDA3 = XAm8",
  126. /* FDA4 */   "", "", "", "", "", "", "", "", "",
  127. /* FDAD */   "      ; $FDAD = Mod8Chk",
  128. /* FDAE */   "", "",
  129. /* FDB0 */   "", "", "",
  130. /* FDB3 */   "      ; $FDB3 = Xam",
  131. /* FDB4 */   "", "",
  132. /* FDB6 */   "      ; $FDB6 = DataOut",
  133. /* FDB7 */   "", "", "", "", "", "", "", "", "",
  134. /* FDC0 */   "", "", "", "", "",
  135. /* FDC5 */   "      ; $FDC5 = Rts4c",
  136. /* FDC6 */   "      ; $FDC6 = XAmpm",
  137. /* FDC7 */   "", "", "", "", "", "", "", "", "",
  138. /* FDD0 */   "",
  139. /* FDD1 */   "      ; $FDD1 = Add",
  140. /* FDD2 */   "", "", "", "", "", "", "", "",
  141. /* FDDA */   "      ; $FDDA = PrByte",
  142. /* FDDB */   "", "", "", "", "",
  143. /* FDE0 */   "", "", "",
  144. /* FDE3 */   "      ; $FDE3 = PrHex",
  145. /* FDE4 */   "",
  146. /* FDE5 */   "      ; $FDE5 = PrHexZ",
  147. /* FDE6 */   "", "", "", "", "", "", "",
  148. /* FDED */   "      ; $FDED = COut",
  149. /* FDEE */   "", "",
  150. /* FDF0 */   "      ; $FDF0 = COut1",
  151. /* FDF1 */   "", "", "", "", "",
  152. /* FDF6 */   "      ; $FDF6 = COutZ",
  153. /* FDF7 */   "", "", "", "", "", "", "", "", ""
  154. };
  155.  
  156. char *jump_check( address)
  157. unsigned short int address;
  158. {
  159.    static char out_string [256];
  160.  
  161.    sprintf( out_string, "$%04x", address);
  162.    if ( ((address >> 8) == 0xFD) && (*jumpers_FDxx [address & 0xFF]) )
  163.       strcat( out_string, jumpers_FDxx [address & 0xFF]);
  164.  
  165.    return (out_string);
  166. }
  167.  
  168. char  * dis_ass( code, length)
  169. PM    * code;
  170. short * length;
  171. {
  172.    char        * string,
  173.                  temp_buffer [256];
  174.    static char   out_buffer  [256];
  175.  
  176.    unsigned short int value;
  177.    static short int   DFB_flag = FALSE;
  178.  
  179.    short  position,
  180.           temp_pos,
  181.           dfb_str_flag;
  182.  
  183.    sprintf( out_buffer, "$%04x-   ", code->PC );
  184.    string = Mnemonic [code->Me [code->PC] ];
  185.  
  186.    if (DFB_flag)
  187.       *string = '\000';
  188.  
  189.    switch (*string)
  190.    {
  191.       case NONE:   /* \000 */
  192.          DFB_flag = TRUE;
  193.          sprintf( out_buffer + strlen( out_buffer) , "            DFB   ");
  194.          for (position = 0; (position < 2) &
  195.                             ( (code->Me [code->PC + position] & 0x7F) >=
  196.                                                          0x20);  position++)
  197.             /* Take onle thre realy letters to the buffer */
  198.             temp_buffer [position] = code->Me [code->PC + position];
  199.  
  200.          /* Don't forget the last character */
  201.          temp_buffer [position++] = code->Me [code->PC + position];
  202.  
  203.          /* Check the first letter */
  204.          dfb_str_flag = FALSE;
  205.          if ( ((*temp_buffer & 0x7F) > 0x20) && (*temp_buffer != 0xFF) )
  206.          {
  207.             /* This is a string */
  208.             strcat( out_buffer + 27, "\"");   /* Print  " */
  209.             dfb_str_flag = TRUE;
  210.          }
  211.  
  212.          for (temp_pos = 0; temp_pos < position; temp_pos ++)
  213.          {
  214.             char tecken;     /* pos 9 */
  215.             sprintf( out_buffer + 9 + temp_pos * 3, "%02x ",
  216.                                                     temp_buffer [temp_pos] );
  217.             out_buffer [9 + (temp_pos + 1) * 3] = ' ';
  218.  
  219.             tecken = temp_buffer [temp_pos];
  220.             if (tecken == 0)
  221.             {
  222.                if (dfb_str_flag)
  223.                   strcat( out_buffer, "\", 0");
  224.                else
  225.                   strcat( out_buffer, "0");
  226.                dfb_str_flag = FALSE;
  227.                DFB_flag = FALSE;
  228.                break;
  229.             }
  230.  
  231.             if ( ((tecken & 0x7F) < 0x20) || (tecken == 0xFF) )
  232.             {
  233.                if (dfb_str_flag)
  234.                   sprintf( out_buffer + strlen( out_buffer), "\", $%02x",
  235.                                                                   tecken  );
  236.                else
  237.                   sprintf( out_buffer + strlen( out_buffer), "$%02x", tecken);
  238.  
  239.                dfb_str_flag = FALSE;
  240.                DFB_flag = FALSE;
  241.                break;
  242.             }
  243.  
  244.             if ( (tecken == '\\') || (tecken == '\"') )
  245.                strcat( out_buffer, "\\");
  246.  
  247.             sprintf( out_buffer + strlen( out_buffer), "%c", tecken);
  248.          }
  249.  
  250.          if (dfb_str_flag)
  251.             strcat( out_buffer, "\"");
  252.  
  253.          *length = position;
  254.          break;
  255.  
  256.       case Implied:   /* \001 */
  257.          sprintf( out_buffer + strlen( out_buffer), "%02x          ",
  258.                                                     code->Me [code->PC]);
  259.          sprintf( out_buffer + strlen( out_buffer), string + 1);
  260.          *length = 1;
  261.          break;
  262.  
  263.       case Immediate:   /* \002 */
  264.          sprintf( out_buffer + strlen( out_buffer), "%02x %02x       ",
  265.                                                     code->Me [code->PC],
  266.                                                     code->Me [code->PC + 1]);
  267.          sprintf( out_buffer + strlen( out_buffer), string + 1);
  268.          sprintf( out_buffer + strlen( out_buffer),
  269.                                        "   #$%02x",
  270.                                        code->Me [code->PC + 1]);
  271.  
  272.          if ( ((code->Me [code->PC + 1] & 0x7F) >= 0x20) &&
  273.               ((code->Me [code->PC + 1] & 0x7F) != 0x7F)     )
  274.             sprintf( out_buffer + strlen( out_buffer),
  275.                             "       ;   $%02x = '%c'",
  276.                               code->Me [code->PC + 1],
  277.                               code->Me [code->PC + 1]  );
  278.  
  279.          *length = 2;
  280.          break;
  281.  
  282.       case Zero_page:   /* \003 */
  283.          sprintf( out_buffer + strlen( out_buffer), "%02x %02x       ",
  284.                                                     code->Me [code->PC],
  285.                                                     code->Me [code->PC + 1]);
  286.          sprintf( out_buffer + strlen( out_buffer), string + 1);
  287.          sprintf( out_buffer + strlen( out_buffer),
  288.                                         "   $%02x",
  289.                                         code->Me [code->PC + 1]);
  290.  
  291.          *length = 2;
  292.          break;
  293.  
  294.       case Zero_page_X:   /* \004 */
  295.          sprintf( out_buffer + strlen( out_buffer), "%02x %02x       ",
  296.                                                     code->Me [code->PC],
  297.                                                     code->Me [code->PC + 1]);
  298.          sprintf( out_buffer + strlen( out_buffer), string + 1);
  299.          sprintf( out_buffer + strlen( out_buffer), "   $%02x,X",
  300.                                          code->Me [code->PC + 1]  );
  301.  
  302.          *length = 2;
  303.          break;
  304.  
  305.       case Zero_page_Y:   /* \005 */
  306.          sprintf( out_buffer + strlen( out_buffer), "%02x %02x       ",
  307.                                                     code->Me [code->PC],
  308.                                                     code->Me [code->PC + 1]);
  309.          sprintf( out_buffer + strlen( out_buffer), string + 1);
  310.          sprintf( out_buffer + strlen( out_buffer), "   $%02x,Y",
  311.                                          code->Me [code->PC + 1]  );
  312.  
  313.          *length = 2;
  314.          break;
  315.  
  316.       case Absolute:    /* \006 */
  317.          sprintf( out_buffer + strlen( out_buffer), "%02x %02x %02x    ",
  318.                                                     code->Me [code->PC],
  319.                                                     code->Me [code->PC + 1],
  320.                                                     code->Me [code->PC + 2] );
  321.          sprintf( out_buffer + strlen( out_buffer), string + 1);
  322.          sprintf( out_buffer + strlen( out_buffer), "   %s",
  323.                   jump_check( code->Me [code->PC + 1] |
  324.                               code->Me [code->PC + 2] << 8) );
  325.          *length = 3;
  326.          break;
  327.  
  328.       case Absolute_X:   /* \007 */
  329.          sprintf( out_buffer + strlen( out_buffer), "%02x %02x %02x    ",
  330.                                                     code->Me [code->PC],
  331.                                                     code->Me [code->PC + 1],
  332.                                                     code->Me [code->PC + 2] );
  333.          sprintf( out_buffer + strlen( out_buffer), string + 1);
  334.          sprintf( out_buffer + strlen( out_buffer),
  335.                   "   %s,X", jump_check( code->Me [code->PC + 1] |
  336.                                          code->Me [code->PC + 2] << 8) );
  337.          *length = 3;
  338.          break;
  339.  
  340.       case Absolute_Y:   /* \010 */
  341.          sprintf( out_buffer + strlen( out_buffer), "%02x %02x %02x    ",
  342.                                                     code->Me [code->PC],
  343.                                                     code->Me [code->PC + 1],
  344.                                                     code->Me [code->PC + 2] );
  345.          sprintf( out_buffer + strlen( out_buffer), string + 1);
  346.          sprintf( out_buffer + strlen( out_buffer),
  347.                   "   %s,Y", jump_check( code->Me [code->PC + 1] |
  348.                                          code->Me [code->PC + 2] << 8) );
  349.          *length = 3;
  350.          break;
  351.  
  352.       case Indirect_Y:   /* \012 */
  353.          sprintf( out_buffer + strlen( out_buffer), "%02x %02x       ",
  354.                                                     code->Me [code->PC],
  355.                                                     code->Me [code->PC + 1] );
  356.          sprintf( out_buffer + strlen( out_buffer), string + 1);
  357.          sprintf( out_buffer + strlen( out_buffer), "   (%s),Y",
  358.                   jump_check( code->Me [code->Me [code->PC + 1] ] |
  359.                               code->Me [code->Me [code->PC + 1] + 1] << 8) );
  360.          *length = 2;
  361.          break;
  362.  
  363.       case Indirect_X:   /* \011 */
  364.          sprintf( out_buffer + strlen( out_buffer), "%02x %02x       ",
  365.                                                     code->Me [code->PC],
  366.                                                     code->Me [code->PC + 1] );
  367.          sprintf( out_buffer + strlen( out_buffer), string + 1);
  368.          sprintf( out_buffer + strlen( out_buffer), "   (%s)",
  369.                   jump_check( code->Me [code->Me [code->PC + 1] +
  370.                                         code->Xr                  ] |
  371.                               code->Me [code->Me [code->PC + 1] +
  372.                                         code->Xr + 1              ] << 8) );
  373.          *length = 2;
  374.          break;
  375.  
  376.       case Indirect:
  377.          sprintf( out_buffer + strlen( out_buffer), "%02x %02x %02x    ",
  378.                                                     code->Me [code->PC],
  379.                                                     code->Me [code->PC + 1],
  380.                                                     code->Me [code->PC + 2] );
  381.          sprintf( out_buffer + strlen( out_buffer), string + 1);
  382.          sprintf( out_buffer + strlen( out_buffer), "   %s",
  383.                   jump_check(
  384.                      code->Me [code->Me [code->PC + 1] |
  385.                                code->Me [code->PC + 2] << 8] |
  386.                      code->Me [(code->Me [code->PC + 1] |
  387.                                 code->Me [code->PC + 2] << 8) + 1] << 8) );
  388.  
  389.          *length = 3;
  390.          break;
  391.  
  392.       case Relative:
  393.          value = code->Me [code->PC + 1];
  394.          if (value >= 0x80)
  395.             value |= (-1 ^ 0xFF);
  396.          value += (code->PC + 2);
  397.          value &= 0xFFFF;
  398.  
  399.          sprintf( out_buffer + strlen( out_buffer), "%02x %02x       ",
  400.                                                     code->Me [code->PC],
  401.                                                     code->Me [code->PC + 1]);
  402.          sprintf( out_buffer + strlen( out_buffer), string + 1);
  403.          sprintf( out_buffer + strlen( out_buffer), "   %s",
  404.                                                     jump_check( value) );
  405.          *length = 2;
  406.          break;
  407.  
  408.       case Accumulator:   /* \015 */
  409.          sprintf( out_buffer + strlen( out_buffer), "%02x          ",
  410.                                                     code->Me [code->PC] );
  411.          sprintf( out_buffer + strlen( out_buffer), string + 1);
  412.          strcat( out_buffer, "   A");
  413.          *length = 1;
  414.          break;
  415.  
  416.       default:
  417. printf("Bugg '%s'  case %d\n", string + 1, *string);
  418.          printf( "Internal Error!\n");
  419.          exit (-1);
  420.    }
  421.  
  422.    return (out_buffer);
  423. }
  424.  
  425.  
  426.  
  427.