home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 405.lha / AppleII_Emulators_src / src-2 / cpu6502.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-06-28  |  9.8 KB  |  397 lines
  1. #include <cpu_prog_model.h>
  2. #include <stdio.h>
  3. #include <in_lines_code.h>
  4. #include <cpu6502_addrm.h>
  5.  
  6. #define FALSE  0
  7. #define TRUE   1
  8.  
  9.  
  10. void    mem_check();
  11. char  * dis_ass(),
  12.         take_char();
  13. short   dummy;
  14.  
  15. void reset( code)
  16. PM *code;
  17. {
  18.    code->PC = code->Me [0xFFFC] | code->Me [0xFFFD] << 8;
  19.  
  20.    code->Ac = 0x00;
  21.    code->Xr = 0x00;
  22.    code->Yr = 0x00;
  23.  
  24.    code->Ne = FALSE;    code->Ov = FALSE;    code->Br = TRUE;
  25.    code->De = FALSE;    code->In = FALSE;    code->Ze = FALSE;
  26.    code->Ca = FALSE;
  27.  
  28.    code->Er = FALSE;
  29.  
  30.    code->SP = 0xFF;
  31.  
  32. }
  33.  
  34.  
  35. void
  36.    ADC_imm(), ADC_zer(), ADC_zex(), ADC_abs(), ADC_abx(), ADC_aby(),
  37.    ADC_inx(), ADC_iny(),
  38.    AND_imm(), AND_zer(), AND_zex(), AND_abs(), AND_abx(), AND_aby(),
  39.    AND_inx(), AND_iny(),
  40.    ASL_acc(), ASL_zer(), ASL_zex(), ASL_abs(), ASL_abx(),
  41.    BCC(),     BCS(),     BEQ(),
  42.    BIT_zer(), BIT_abs(),
  43.    BMI(),     BNE(),     BPL(),
  44.    BRK(),
  45.    BVC(),     BVS(),
  46.    CLC(),     CLD(),     CLI(),     CLV(),
  47.    CMP_imm(), CMP_zer(), CMP_zex(), CMP_abs(), CMP_abx(), CMP_aby(),
  48.    CMP_inx(), CMP_iny(),
  49.    CPX_imm(), CPX_zer(), CPX_abs(),
  50.    CPY_imm(), CPY_zer(), CPY_abs(),
  51.    DEC_zer(), DEC_zex(), DEC_abs(), DEC_abx(),
  52.    DEX(),     DEY(),
  53.    EOR_imm(), EOR_zer(), EOR_zex(), EOR_abs(), EOR_abx(), EOR_aby(),
  54.    EOR_inx(), EOR_iny(),
  55.    INC_zer(), INC_zex(), INC_abs(), INC_abx(),
  56.    INX(),     INY(),
  57.    JSR();
  58.  
  59. void JMP( code)
  60. PM *code;
  61. {
  62.    unsigned short int address;
  63.  
  64.    address = abs_address( code);
  65.    code->PC = address;
  66.    mem_check( address, &dummy, code, Func_JMP);
  67. }
  68.  
  69. void JMP_ind( code)
  70. PM *code;
  71. {
  72.  
  73.    unsigned short int  address;
  74.  
  75.    address = code->Me [code->Me [code->PC] |
  76.                        code->Me [code->PC + 1] << 8]       |
  77.              code->Me [(code->Me [code->PC] |
  78.                        code->Me [code->PC + 1] << 8) + 1] << 8;
  79.  
  80.    code->PC = address;
  81.    mem_check( address, &dummy, code, Func_JMP);
  82. }
  83.  
  84. void
  85.    LDA_imm(), LDA_zer(), LDA_zex(), LDA_abs(), LDA_abx(), LDA_aby(),
  86.    LDA_inx(), LDA_iny(),
  87.    LDX_imm(), LDX_zer(), LDX_zex(), LDX_abs(), LDX_aby(),
  88.    LDY_imm(), LDY_zer(), LDY_zex(), LDY_abs(), LDY_abx(),
  89.    LSR_acc(), LSR_zer(), LSR_zex(), LSR_abs(), LSR_abx();
  90.  
  91. void NOP( code)
  92. PM *code;
  93. {
  94.    /* No operation */
  95. }
  96.  
  97. void
  98.    ORA_imm(), ORA_zer(), ORA_zex(), ORA_abs(), ORA_abx(), ORA_aby(),
  99.    ORA_inx(), ORA_iny(),
  100.    PHA(),     PHP(),     PLA(),     PLP(),
  101.    ROL_acc(), ROL_zer(), ROL_zex(), ROL_abs(), ROL_abx(),
  102.    ROR_acc(), ROR_zer(), ROR_zex(), ROR_abs(), ROR_abx(),
  103.    RTI(),     RTS(),
  104.    SBC_imm(), SBC_zer(), SBC_zex(), SBC_abs(), SBC_abx(), SBC_aby(),
  105.    SBC_inx(), SBC_iny(),
  106.    SEC(),     SED(),     SEI(),
  107.    STA_zer(), STA_zex(), STA_abs(), STA_abx(), STA_aby(), STA_inx(),
  108.    STA_iny(),
  109.    STX_zer(), STX_zex(), STX_abs(),
  110.    STY_zer(), STY_zex(), STY_abs(),
  111.    TAX(),     TAY(),     TSX(),     TXA(),     TXS(),     TYA();
  112.  
  113. Debugg( code)
  114. PM *code;
  115. {
  116.    short               steps;
  117.    unsigned short int  current_PC;
  118.  
  119.    code->Qu = TRUE;
  120.    code->Mo = Mode_SLOW;
  121.    printf("\nInternal signal (DEBUGG)\n\n");
  122.  
  123.    current_PC = code->PC;
  124.    code->PC -=0x10;
  125.    while (code->PC < current_PC + 0x10)
  126.    {
  127.       if ( (code->PC > current_PC - 7) && (code->PC < current_PC + 3) )
  128.       {
  129.          if (code->PC == current_PC - 1)
  130.             printf("%s <-           ; Debugg  ON\n", dis_ass( code, &steps) );
  131.          else
  132.             printf("%s\n", dis_ass( code, &steps) );
  133.       }
  134.  
  135.       else
  136.          dis_ass( code, &steps);
  137.  
  138.       code->PC += steps;
  139.    }
  140.  
  141.    code->PC = current_PC - 1;
  142.    printf("\n$%04x-   ", code->PC);
  143.    reg_dump( code);
  144.    printf("\n");
  145.  
  146.    code->PC = current_PC;
  147. }
  148.  
  149. void none( code)
  150. PM *code;
  151. {
  152.    short steps;   /* Dummy */
  153.  
  154.    code->PC--;
  155.       printf("Can't Evaluate\n");
  156.       printf("\n%s\n", dis_ass( code, &steps) );
  157.    code->PC++;
  158.    code->Er = TRUE;
  159.    code->Qu = TRUE;  /* Quit of type ERROR */
  160. }
  161.  
  162. void (*OP_code[])() = {
  163. /*       00       01       02       03       04       05       06       07 */
  164. /*       08       09       0A       0B       0C       0D       0E       0F */
  165. /* 00 */ BRK,     none,    none,    none,    none,    ORA_zer, ASL_zer, none,
  166.          PHP,     ORA_imm, ASL_acc, none,    none,    ORA_abs, ASL_abs, none,
  167. /* 10 */ BPL,     ORA_iny, none,    none,    none,    ORA_zex, ASL_zex, none,
  168.          CLC,     ORA_aby, none,    none,    none,    ORA_abx, ASL_abx, none,
  169. /* 20 */ JSR,     AND_inx, none,    none,    BIT_zer, AND_zer, ROL_zer, none,
  170.          PLP,     AND_imm, ROL_acc, none,    BIT_abs, AND_abs, ROL_abs, none,
  171. /* 30 */ BMI,     AND_iny, none,    none,    none,    AND_zex, none,    none,
  172.          SEC,     AND_aby, none,    none,    none,    AND_abx, ROL_abx, none,
  173. /* 40 */ none,    EOR_inx, none,    none,    none,    EOR_zer, LSR_zer, none,
  174.          PHA,     EOR_imm, LSR_acc, none,    JMP,     EOR_abs, LSR_abs, none,
  175. /* 50 */ BVC,     EOR_iny, none,    none,    none,    EOR_zex, LSR_zex, none,
  176.          CLI,     EOR_aby, none,    none,    none,    EOR_abx, LSR_abx, none,
  177. /* 60 */ RTS,     ADC_inx, none,    none,    none,    ADC_zer, ROR_zer, none,
  178.          PLA,     ADC_imm, ROR_acc, none,    JMP_ind, ADC_abs, ROR_abs, none,
  179. /* 70 */ BVS,     ADC_iny, none,    none,    none,    ADC_zex, ROR_zex, none,
  180.          SEI,     ADC_aby, none,    none,    none,    none,    ROR_abx, none,
  181. /* 80 */ none,    STA_inx, none,    none,    STY_zer, STA_zer, STX_zer, none,
  182.          DEY,     none,    TXA,     none,    STY_abs, STA_abs, STX_abs, none,
  183. /* 90 */ BCC,     STA_iny, none,    none,    STY_zex, STA_zex, STX_zex, none,
  184.          TYA,     STA_aby, TXS,     none,    none,    STA_abx, none,    none,
  185. /* A0 */ LDY_imm, LDA_inx, LDX_imm, none,    LDY_zer, LDA_zer, LDX_zer, none,
  186.          TAY,     LDA_imm, TAX,     none,    LDY_abs, LDA_abs, LDX_abs, none,
  187. /* B0 */ BCS,     LDA_iny, none,    none,    LDY_zex, LDA_zex, LDX_zex, none,
  188.          CLV,     LDA_aby, TSX,     none,    LDY_abx, LDA_abx, LDX_aby, none,
  189. /* C0 */ CPY_imm, CMP_inx, none,    none,    CPY_zer, CMP_zer, DEC_zer, none,
  190.          INY,     CMP_imm, DEX,     none,    CPY_abs, CMP_abs, DEC_abs, none,
  191. /* D0 */ BNE,     CMP_iny, none,    none,    none,    none,    DEC_zex, none,
  192.          CLD,     CMP_aby, none,    none,    none,    CMP_abx, DEC_abx, none,
  193. /* E0 */ CPX_imm, SBC_inx, none,    none,    CPX_zer, SBC_zer, INC_zer, none,
  194.          INX,     SBC_imm, NOP,     none,    CPX_abs, SBC_abs, INC_abs, none,
  195. /* F0 */ BEQ,     SBC_iny, none,    none,    none,    SBC_zex, INC_zex, none,
  196.          none,    SBC_aby, none,    none,    none,    SBC_abx, INC_abx, Debugg
  197. };
  198.  
  199. tracing( code)
  200. PM *code;
  201. {
  202.    short tecken;
  203.  
  204.    if (code->Tl == 0,1)
  205.    {
  206.       char  buffer [256];
  207.       short steps;   /* Dummy */
  208.  
  209.       reg_dump( code);
  210. /*
  211.       tecken = getc( stdin);
  212.  
  213.       printf("%d->\n", code->Tl);
  214. */
  215. tecken = 0xFF;
  216.       strcpy( buffer, dis_ass( code, &steps) );
  217.       strcat( buffer, "                    " );
  218.       buffer [37] = NULL;
  219.       printf( buffer);
  220.    }
  221.  
  222.    if (code->Me [code->PC] == 0x20)
  223.       code->Tl += 2;
  224.  
  225.    if (code->Me [code->PC] == 0x60)
  226.       code->Tl -= 2;
  227.  
  228.    if (code->Tl < code->SP,0) /*qq*/
  229.    {
  230.       printf("Back from Trace.\n");
  231.       code->Tl = code->SP;
  232.       break_meny( code);
  233.    }
  234.  
  235.    if (tecken == '\b')
  236.       code->Tl --;
  237.  
  238.    if (toupper( tecken) == 'N')
  239.       code->Tl ++;
  240.  
  241.    if ( toupper( tecken) == 'Q')
  242.    {
  243.       printf("Quit ?\n");
  244.       code->Er = TRUE;
  245.    }
  246.  
  247.    if (tecken == '\233')
  248.       code->Tr = FALSE;
  249.  
  250.    if (toupper( tecken) == 'M')
  251.       code->PC = 0xFF65;
  252. }
  253.  
  254. break_meny( code)
  255. PM    * code;
  256. {
  257.    short tecken,
  258.          action;
  259.  
  260.    code->Qu = FALSE;
  261.  
  262.    action = FALSE;
  263.    while (!action)
  264.    {
  265.       printf("\n:");
  266.       tecken = getc( stdin);
  267.  
  268.       switch( toupper( tecken) )
  269.       {
  270.          case 'M':
  271.             printf(" Monitor.\n");
  272.             code->PC = 0xFF65;
  273.             code->Me [0x0036] = 0xF0;
  274.             code->Me [0x0037] = 0xFD;
  275.             code->Me [0x0038] = 0x1B;
  276.             code->Me [0x0039] = 0xFD;
  277.             refresh();
  278.             action = TRUE;
  279.             break;
  280.  
  281.          case 'Q':
  282.             printf(" Quit.\n");
  283.             code->Ex = TRUE;
  284.             code->Qu = TRUE;
  285.             action = TRUE;
  286.             break;
  287.  
  288.          case 'C':
  289.             printf(" Continue.\n");
  290.             action = TRUE;
  291.             break;
  292.  
  293.          case 'T':
  294.             printf(" Trace ON\n");
  295.             code->Tr = TRUE;
  296.             code->Tl = code->SP;
  297.             action = TRUE;
  298.             break;
  299.  
  300.          case 'O':
  301.             printf(" Trace OFF\n");
  302.             code->Tr = FALSE;
  303.             action = TRUE;
  304.             break;
  305.  
  306.          case 'F':
  307.             printf(" Fast.\n");
  308.             code->Mo = Mode_FAST;
  309.             code->Qu = TRUE;
  310.             action = TRUE;
  311.             break;
  312.  
  313.          case 'S':
  314.             printf(" Slow.\n");
  315.             code->Mo = Mode_SLOW;
  316.             code->Qu = TRUE;
  317.             action = TRUE;
  318.             break;
  319.  
  320.          default:
  321.             printf(" M, Q, C, T, O, F, S");
  322.             break;
  323.  
  324.       }  /* End of switch (tecken) */
  325.    }  /* End of while (!action) */
  326.  
  327. }
  328.  
  329. quit_check( code)
  330. PM *code;
  331. {
  332.    if (code->Qu)
  333.       /* Let it pass */
  334.       return;
  335.  
  336.    if (char_check() )
  337.    {
  338.       short tecken;
  339.  
  340.       if ( (tecken = take_char() ) == '\233')
  341.       {
  342.          short tecken_2;
  343.  
  344.          tecken_2 = take_char();
  345.          if (tecken_2 == '\233')
  346.             code->Qu = TRUE;
  347.          else
  348.             char_take_back( tecken_2);
  349.       }
  350.       else
  351.          char_take_back( tecken);
  352.    }
  353. }
  354.  
  355. void slow_cpu( code)
  356. PM *code;
  357. {
  358.    char tecken;
  359.  
  360.    do  /* Until code->Qu == TRUE */
  361.    {
  362.       if (code->Qu)
  363.          break_meny( code);
  364.  
  365.       else
  366.       {
  367. code->Br = TRUE;
  368.          (*OP_code [code->Me [(code->PC)++] ])( code);
  369.  
  370.          /* Check Esc-Esc break */
  371.          quit_check( code);
  372.       }
  373.  
  374.       if (code->Ex)
  375.          break;
  376.  
  377.       if (code->Tr)
  378.          tracing( code);
  379.  
  380.    }  while (!code->Qu);
  381.  
  382. }
  383.  
  384. void fast_cpu( code)
  385. PM *code;
  386. {
  387.  
  388.    while (
  389. code->Br = TRUE,
  390.           !code->Qu)
  391.       (*OP_code [code->Me [(code->PC)++] ])( code);
  392.  
  393. }
  394.  
  395.  
  396.  
  397.