VRac/M6502/perl.c

#include <EXTERN.h>
#include <perl.h>
#include "M6502.h"
#include "config.h"

static PerlInterpreter *my_perl;

static M6502 *R;

#define dump_R printf("# PC: %04x A:%02x P:%02x X:%02x Y:%02x S:%02x\n", R->PC.W, R->A, R->P, R->X, R->Y, R->S );

void update_R(M6502 *R) {
        R->A = atoi( SvPV_nolen( get_sv("M6502::A", FALSE) ) );
        R->P = atoi( SvPV_nolen( get_sv("M6502::P", FALSE) ) );
        R->X = atoi( SvPV_nolen( get_sv("M6502::X", FALSE) ) );
        R->Y = atoi( SvPV_nolen( get_sv("M6502::Y", FALSE) ) );
        R->S = atoi( SvPV_nolen( get_sv("M6502::S", FALSE) ) );
        R->PC.W = atoi( SvPV_nolen( get_sv("M6502::PC", FALSE) ) );
        R->IPeriod = atoi( SvPV_nolen( get_sv("M6502::IPeriod", FALSE) ) );
        // ICount IRequest IAutoReset TrapBadOps Trap Trace
        dump_R;
}

/** Rd6502()/Wr6502/Op6502() *********************************/
/** These functions are called when access to RAM occurs.   **/
/** They allow to control memory access. Op6502 is the same **/
/** as Rd6502, but used to read *opcodes* only, when many   **/
/** checks can be skipped to make it fast. It is only       **/
/** required if there is a #define FAST_RDOP.               **/
/************************************ TO BE WRITTEN BY USER **/

byte mem(word Addr) {
        byte byte;
        int count;
        dSP;
        ENTER;
        SAVETMPS;
        PUSHMARK(SP);
        XPUSHs( sv_2mortal( newSViv( Addr ) ) );
        PUTBACK;
        count = call_pv("M6502::read", G_ARRAY );
        if ( count != 1 ) {
                printf("expect 1 return value, got %d", count);
                exit(1);
        }
        printf("got %d values\n", count);
        SPAGAIN;
        SV *sv;
        sv = POPs;
        byte = SvIV(sv);
        FREETMPS;
        LEAVE;
        printf("Rd6502(%04x) = %02x\n", Addr, byte);
        return byte;
}

byte Rd6502(register word Addr) {
        byte Value;
        Value = mem(Addr);
        return Value;
}

void Wr6502(register word Addr,register byte Value) {
        printf("Wr6502(%04x,%02x)\n", Addr, Value);
        dSP;
        ENTER;
        SAVETMPS;
        PUSHMARK(SP);
        XPUSHs( sv_2mortal( newSViv( Addr ) ) );
        XPUSHs( sv_2mortal( newSViv( Value ) ) );
        PUTBACK;
        call_pv("M6502::write", G_DISCARD );
        FREETMPS;
        LEAVE;
}

byte Op6502(register word Addr) {
        byte Op;
        Op = mem(Addr);
        printf("Op6502(%04x,%02x)\n", Addr, Op);
        dump_R;
}

/** Loop6502() ***********************************************/
/** 6502 emulation calls this function periodically to      **/
/** check if the system hardware requires any interrupts.   **/
/** This function must return one of following values:      **/
/** INT_NONE, INT_IRQ, INT_NMI, or INT_QUIT to exit the     **/
/** emulation loop.                                         **/
/************************************ TO BE WRITTEN BY USER **/
byte Loop6502(register M6502 *R) {
        printf("Loop6502\n");
        dump_R;
        return INT_NONE;
}

/** Patch6502() **********************************************/
/** Emulation calls this function when it encounters an     **/
/** unknown opcode. This can be used to patch the code to   **/
/** emulate BIOS calls, such as disk and tape access. The   **/
/** function should return 1 if the exception was handled,  **/
/** or 0 if the opcode was truly illegal.                   **/
/************************************ TO BE WRITTEN BY USER **/
byte Patch6502(register byte Op,register M6502 *R) {
        printf("Patch6502(%02x)\n", Op);
        dump_R;
        return 0;
}

/**
 * main code
 *
 **/

int main(int argc, char **argv) {
        char *command_line[] = {"", "-e",
                "use M6502; print \"Loaded M6502 module\n\";"};
        my_perl = perl_alloc();
        perl_construct(my_perl);
        if (perl_parse(my_perl, xs_init, 3, command_line, (char **)NULL)) {
                printf("Failed to parse\n");
                return 0;
        }
        perl_run(my_perl);
        if (SvTRUE(ERRSV)) {
                printf("Failed to execute\n");
                return 0;
        } else {
                R = malloc(sizeof(M6502));
                if (!R) {
                        printf("can't alloc %d bytes for M6502", sizeof(M6502));
                        exit(1);
                }

                update_R(R);

                printf("reset CPU\n");
                Reset6502(R);

                printf("call M6502::init\n");
                dSP;
                PUSHMARK(SP);
                call_pv("M6502::init", G_DISCARD | G_NOARGS );

                printf("run CPU\n");
                Run6502(R);

        }
        free(R);
        perl_destruct(my_perl);
        perl_free(my_perl);
        return 0;
}
1	dpavlin	24	#include <EXTERN.h>
2			#include <perl.h>
3			#include "M6502.h"
4			#include "config.h"
5
6			static PerlInterpreter *my_perl;
7
8			static M6502 *R;
9
10	dpavlin	26	#define dump_R printf("# PC: %04x A:%02x P:%02x X:%02x Y:%02x S:%02x\n", R->PC.W, R->A, R->P, R->X, R->Y, R->S );
11	dpavlin	25
12			void update_R(M6502 *R) {
13	dpavlin	26	R->A = atoi( SvPV_nolen( get_sv("M6502::A", FALSE) ) );
14			R->P = atoi( SvPV_nolen( get_sv("M6502::P", FALSE) ) );
15			R->X = atoi( SvPV_nolen( get_sv("M6502::X", FALSE) ) );
16			R->Y = atoi( SvPV_nolen( get_sv("M6502::Y", FALSE) ) );
17			R->S = atoi( SvPV_nolen( get_sv("M6502::S", FALSE) ) );
18			R->PC.W = atoi( SvPV_nolen( get_sv("M6502::PC", FALSE) ) );
19			R->IPeriod = atoi( SvPV_nolen( get_sv("M6502::IPeriod", FALSE) ) );
20	dpavlin	25	// ICount IRequest IAutoReset TrapBadOps Trap Trace
21			dump_R;
22	dpavlin	24	}
23
24	dpavlin	25	/ Rd6502()/Wr6502/Op6502() *******************************/
25			/ These functions are called when access to RAM occurs. /
26			/ They allow to control memory access. Op6502 is the same /
27			/** as Rd6502, but used to read opcodes only, when many **/
28			/ checks can be skipped to make it fast. It is only /
29			/ required if there is a #define FAST_RDOP. /
30			/********************************** TO BE WRITTEN BY USER /
31
32	dpavlin	28	byte mem(word Addr) {
33			byte byte;
34	dpavlin	27	int count;
35			dSP;
36			ENTER;
37			SAVETMPS;
38			PUSHMARK(SP);
39	dpavlin	28	XPUSHs( sv_2mortal( newSViv( Addr ) ) );
40	dpavlin	27	PUTBACK;
41			count = call_pv("M6502::read", G_ARRAY );
42			if ( count != 1 ) {
43			printf("expect 1 return value, got %d", count);
44			exit(1);
45			}
46			printf("got %d values\n", count);
47			SPAGAIN;
48			SV *sv;
49			sv = POPs;
50	dpavlin	28	byte = SvIV(sv);
51	dpavlin	27	FREETMPS;
52			LEAVE;
53	dpavlin	28	printf("Rd6502(%04x) = %02x\n", Addr, byte);
54			return byte;
55			}
56
57			byte Rd6502(register word Addr) {
58			byte Value;
59			Value = mem(Addr);
60	dpavlin	27	return Value;
61	dpavlin	25	}
62
63			void Wr6502(register word Addr,register byte Value) {
64			printf("Wr6502(%04x,%02x)\n", Addr, Value);
65	dpavlin	27	dSP;
66			ENTER;
67			SAVETMPS;
68			PUSHMARK(SP);
69			XPUSHs( sv_2mortal( newSViv( Addr ) ) );
70			XPUSHs( sv_2mortal( newSViv( Value ) ) );
71			PUTBACK;
72			call_pv("M6502::write", G_DISCARD );
73			FREETMPS;
74			LEAVE;
75	dpavlin	25	}
76
77			byte Op6502(register word Addr) {
78			byte Op;
79	dpavlin	28	Op = mem(Addr);
80	dpavlin	25	printf("Op6502(%04x,%02x)\n", Addr, Op);
81			dump_R;
82			}
83
84			/ Loop6502() *********************************************/
85			/ 6502 emulation calls this function periodically to /
86			/ check if the system hardware requires any interrupts. /
87			/ This function must return one of following values: /
88			/ INT_NONE, INT_IRQ, INT_NMI, or INT_QUIT to exit the /
89			/ emulation loop. /
90			/********************************** TO BE WRITTEN BY USER /
91			byte Loop6502(register M6502 *R) {
92			printf("Loop6502\n");
93			dump_R;
94	dpavlin	28	return INT_NONE;
95	dpavlin	25	}
96
97			/ Patch6502() ********************************************/
98			/ Emulation calls this function when it encounters an /
99			/ unknown opcode. This can be used to patch the code to /
100			/ emulate BIOS calls, such as disk and tape access. The /
101			/ function should return 1 if the exception was handled, /
102			/ or 0 if the opcode was truly illegal. /
103			/********************************** TO BE WRITTEN BY USER /
104			byte Patch6502(register byte Op,register M6502 *R) {
105			printf("Patch6502(%02x)\n", Op);
106			dump_R;
107	dpavlin	28	return 0;
108	dpavlin	25	}
109
110			/**
111			* main code
112			*
113			**/
114
115	dpavlin	24	int main(int argc, char **argv) {
116			char *command_line[] = {"", "-e",
117			"use M6502; print \"Loaded M6502 module\n\";"};
118			my_perl = perl_alloc();
119			perl_construct(my_perl);
120	dpavlin	29	if (perl_parse(my_perl, xs_init, 3, command_line, (char **)NULL)) {
121	dpavlin	24	printf("Failed to parse\n");
122			return 0;
123			}
124			perl_run(my_perl);
125			if (SvTRUE(ERRSV)) {
126			printf("Failed to execute\n");
127			return 0;
128			} else {
129			R = malloc(sizeof(M6502));
130			if (!R) {
131			printf("can't alloc %d bytes for M6502", sizeof(M6502));
132			exit(1);
133			}
134	dpavlin	26
135	dpavlin	25	update_R(R);
136	dpavlin	26
137	dpavlin	24	printf("reset CPU\n");
138			Reset6502(R);
139	dpavlin	26
140			printf("call M6502::init\n");
141			dSP;
142			PUSHMARK(SP);
143			call_pv("M6502::init", G_DISCARD \| G_NOARGS );
144
145			printf("run CPU\n");
146	dpavlin	25	Run6502(R);
147	dpavlin	24
148			}
149			free(R);
150			perl_destruct(my_perl);
151			perl_free(my_perl);
152			return 0;
153			}