annotate emu/main.c @ 28:6d32e54e5c16

emulator overhauled really, new a better memory structure
also cleaned up the file system some what.

#include <stdio.h>
#include <stdlib.h>

#define MAIN
#include "mem.h"
#include "iset.h"

/* fill instruction table 
 * MCS-51 - this needs to be stored in code memory */
void (*iset[256])(void) = {
    NOP, NOP, NOP, NOP, NOP, NOP, NOP, NOP,
    SET, CLR, SET, CLR, SET, CLR, CPL, CPL,
    XCSD, SFA, LAF, MOV, MOV, MOV, MOV, MOV,
    MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
    MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
    MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
    MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
    MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
    MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
    MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
    MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
    MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
    MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
    MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
    MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
    MOV, MOV, MOV, MOV, MOV, MOV, MOV, MOV,
    ANL, ANL, ANL, ANL, ANL, ANL, ANL, ANL,
    ORL, ORL, ORL, ORL, ORL, ORL, ORL, ORL,
    XRL, XRL, XRL, XRL, XRL, XRL, XRL, XRL,
    RL, RLC, RR, RRC, INC, DEC, INC, DEC,
    ADD, ADD, ADD, ADD, ADD, ADD, ADD, ADD,
    ADDC, ADDC, ADDC, ADDC, ADDC, ADDC, ADDC, ADDC,
    SUB, SUB, SUB, SUB, SUB, SUB, SUB, SUB,
    SUBB, SUBB, SUBB, SUBB, SUBB, SUBB, SUBB, SUBB,
    PJMP, PJMP, PJMP, PJMP, PJMP, PJMP, PJMP, PJMP,
    PCALL, PCALL, PCALL, PCALL, PCALL, PCALL, PCALL, PCALL,
    DJNZ, DJNZ, DJNZ, DJNZ, CJNE, CJNE, CJNE, CJNE,
    LJMP, LCALL, RET, RETI, SJMP, JMP, JMP, CJNE,
    JZ, JNZ, JC, JNC, JPO, JPE, JS, JNS,
    PUSH, PUSH, PUSH, PUSH, PUSH, PUSH, PUSH, PUSH,
    POP, POP, POP, POP, POP, POP, POP, POP,
    MUL, DIV, DA, NOP, IN, OUT, INT, HLT
};

BYTE run;
WIDE ac;
BYTE args[4];

/* don't need the file on the MCS-51 version */
FILE *fp;
void
snd(BYTE c) {
    /* putchar(c); */
    fp = fopen("out", "a");
    fputc(c, fp);
    fclose(fp);
}

BYTE
rcv(void) {
    return getchar();
}

void
step(void) {
    IR = fetch();
    (*iset[IR])();
}

void
boot(void) {
    run = 0;
}


void dbgi() {
    if (run == 0) {
        switch (rcv()) {

            /* step */
            case 0x00:
                step();
                break;

            /* run */
            case 0x01:
                run = 1;
                break;

            /* set reg */
            case 0x02:
                args[0] = rcv(); /* reg */
                args[1] = rcv(); /* val */
                regs[args[0]] = args[1];
                break;

            /* get reg */
            case 0x03:
                args[0] = rcv(); /* reg */
                snd(regs[args[0]]);
                break;

            /* set flag */
            case 0x04:
                args[0] = rcv(); /* flag */
                args[1] = rcv(); /* on? */
                set_flag(args[0], args[1]);
                break;
    
            /* get flag */
            case 0x05:
                args[0] = rcv(); /* flag */
                snd(get_flag(args[0]));
                break;

            /* write mem block */
            case 0x06:
                args[0] = rcv(); /* addr high */
                args[1] = rcv(); /* addr low */
                args[2] = rcv(); /* length high */
                args[3] = rcv(); /* length low */
                tmpw = args[1] | (args[0] << 8);           
                for (ac = tmpw; ac < (tmpw + (args[3] | (args[2] << 8))); ac++) {
                    if (ac >= 0xFFFF) {
                        break;
                    }
                    mem[ac] = rcv();
                }
                break;

            /* read mem block */
            case 0x07:
                args[0] = rcv(); /* addr high */
                args[1] = rcv(); /* addr low */
                args[2] = rcv(); /* length high */
                args[3] = rcv(); /* length low */
                tmpw = args[1] | (args[0] << 8);
                for (ac = tmpw; ac < (tmpw + (args[3] | (args[2] << 8))); ac++) {
                    if (ac >= 0xFFFF) {
                        break;
                    }
                    snd(mem[ac]);
                }
                break;

            /* get A */
            case 0x09:
                snd(A);
            
            /* get flags */
            case 0x0F:
                snd(flags);
            
            /* get instruction register */
            case 0x10:
                snd(IR);
       }
    }
}

void 
main(void) {
    
    A = 0xAA;
    IR = 0x12;
    
    unsigned char i;
    for (i = 0 ; i < 8 ; i++) {
        set_flag(i, 1);
    }
    
    set_wide(DPTR, 0xDE1D);
    set_wide(PC, 0xBEFA);
    set_wide(SP, 0xADEA);
    set_wide(TMP, 0xEFC3);
    
    for (i = 0; i < 4; i++) {
        regs[i] = i; 
    }

    for (i = 8; i < 0x0C; i++) {
        regs[i] = 0x10 | (i - 8);
    }
    
    /* 0xAA 0x12 0xFF 
     * 0x00 0x01 0x02 0x03
     * 0xDE 0xAD 0xBE 0xFF
     * 0x10 0x11 0x12 0x13
     * 0x1D 0xEA 0xFA 0xC3 */
    
    putchar(A);
    putchar(IR);
    putchar(flags);

    for (i = 0; i < 0x10; i++) {
        putchar(regs[i]);
    }

    unsigned short int data_pointer = get_wide(DPTR);
    unsigned short int program_counter = get_wide(PC);
    unsigned short int stack_pointer = get_wide(SP);
    unsigned short int temp = get_wide(tmp);
    



}