VRac/M6502/perl.c

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

static PerlInterpreter *my_perl;

static M6502 *R;

#if DUMP_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 );
#else
#define dump_R
#endif

void pull_R(M6502 *R) {
        R->A = SvIV( get_sv("M6502::A", FALSE) );
        R->P = SvIV( get_sv("M6502::P", FALSE) );
        R->X = SvIV( get_sv("M6502::X", FALSE) );
        R->Y = SvIV( get_sv("M6502::Y", FALSE) );
        R->S = SvIV( get_sv("M6502::S", FALSE) );
        R->PC.W = SvIV( get_sv("M6502::PC", FALSE) );
        R->IPeriod = SvIV( get_sv("M6502::IPeriod", FALSE) );
        R->IRequest = SvIV( get_sv("M6502::IRequest", FALSE) );
        R->IAutoReset = SvIV( get_sv("M6502::IAutoReset", FALSE) );
        R->TrapBadOps = SvIV( get_sv("M6502::TrapBadOps", FALSE) );
        R->Trap = SvIV( get_sv("M6502::Trap", FALSE) );
        R->Trace = SvIV( get_sv("M6502::Trace", FALSE) );
        printf("pull_R finished\n");
        dump_R;
}

void push_R(M6502 *R) {
        dSP;
        ENTER;
        SAVETMPS;
        PUSHMARK(SP);
        XPUSHs( sv_2mortal( newSViv( R->A ) ) );
        XPUSHs( sv_2mortal( newSViv( R->P ) ) );
        XPUSHs( sv_2mortal( newSViv( R->X ) ) );
        XPUSHs( sv_2mortal( newSViv( R->Y ) ) );
        XPUSHs( sv_2mortal( newSViv( R->S ) ) );
        XPUSHs( sv_2mortal( newSViv( R->PC.W ) ) );
        XPUSHs( sv_2mortal( newSViv( R->IPeriod ) ) );
        XPUSHs( sv_2mortal( newSViv( R->ICount ) ) );
        XPUSHs( sv_2mortal( newSViv( R->IRequest ) ) );
        XPUSHs( sv_2mortal( newSViv( R->IAutoReset ) ) );
        XPUSHs( sv_2mortal( newSViv( R->TrapBadOps ) ) );
        XPUSHs( sv_2mortal( newSViv( R->Trap ) ) );
        XPUSHs( sv_2mortal( newSViv( R->Trace ) ) );
        PUTBACK;
        call_pv("M6502::push_R", G_DISCARD );
        printf("push_R called\n");
        dump_R;
        FREETMPS;
        LEAVE;
}

byte Debug6502(M6502 *R) {
        dump_R;
        return 1; // continue emulation
}

/** 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;
        debugf(("mem(%04x)\n", Addr));
        dSP;
        ENTER;
        SAVETMPS;
        PUSHMARK(SP);
        XPUSHs( sv_2mortal( newSViv( Addr ) ) );
        PUTBACK;
        count = call_pv("Arch::read", G_ARRAY );
        if ( count != 1 ) {
                printf("expect 1 return value, got %d", count);
                exit(1);
        }
        //debugf(("got %d values\n", count));
        SPAGAIN;
        SV *sv;
        sv = POPs;
        byte = SvIV(sv);
        FREETMPS;
        LEAVE;
        //debugf(("mem(%04x) = %02x\n", Addr, byte));
        return byte;
}

byte Rd6502(register word Addr) {
        byte Value;
        Value = mem(Addr);
        debugf(("Rd6502(%04x) = %02x\n", Addr, Value));
        return Value;
}

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

byte Op6502(register word Addr) {
        byte Op;
        Op = mem(Addr);
        debugf(("Op6502(%04x,%02x) PC:%04x\n", Addr, Op, R->PC.W));
        return Op;
}

/** 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 **/

int hw_int = INT_NONE;

byte Loop6502(register M6502 *R) {
        debugf(("Loop6502\n"));
        dump_R;
        return hw_int;
}

/** 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) {
        debugf(("Patch6502(%02x)\n", Op));
        dump_R;
        hw_int = INT_QUIT;
        return 0;
}

void run_forever(void) {
        printf("entered run_forever\n");

        R = malloc(sizeof(M6502));
        if (!R) {
                printf("can't alloc %d bytes for M6502", sizeof(M6502));
                exit(1);
        }

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

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

        int cycles = 1;
        while ( cycles ) {
                dSP;
                PUSHMARK(SP);
                call_pv("Arch::cli", G_DISCARD | G_NOARGS );
                pull_R(R);
                FREETMPS;
                LEAVE;
                cycles = SvIV( get_sv("M6502::run_for", FALSE) );
                if ( cycles > 0 ) {
                        printf("run CPU for %d cycles\n", cycles);
                        dump_R;
                        //Run6502(R);
                        Exec6502(R, cycles);
                        dump_R;
                        push_R(R);
                        printf("end of %d cycles CPU run\n", cycles);
                } else {
                        printf("no cpu cycles set for run\n");
                        cycles = 1; // never exit, prevents segfault
                }
        }
        free(R);
}

/**
 * main code
 *
 **/

int main(int argc, char **argv) {
        char *command_line[] = {"", "-e", EMU_START };
        my_perl = perl_alloc();
        perl_construct(my_perl);
        if (perl_parse(my_perl, xs_init, 3, command_line, (char **)NULL)) {
                printf("Failed to parse initial: %s\n", EMU_START );
                return 0;
        }
        perl_run(my_perl);
        if (SvTRUE(ERRSV)) {
                printf("Failed to execute\n");
                return 0;
        } else {
                run_forever();
        }
        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	34	#if DUMP_R
11	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 );
12	dpavlin	33	#else
13			#define dump_R
14			#endif
15	dpavlin	25
16	dpavlin	38	void pull_R(M6502 *R) {
17	dpavlin	33	R->A = SvIV( get_sv("M6502::A", FALSE) );
18	dpavlin	34	R->P = SvIV( get_sv("M6502::P", FALSE) );
19	dpavlin	38	R->X = SvIV( get_sv("M6502::X", FALSE) );
20			R->Y = SvIV( get_sv("M6502::Y", FALSE) );
21			R->S = SvIV( get_sv("M6502::S", FALSE) );
22			R->PC.W = SvIV( get_sv("M6502::PC", FALSE) );
23			R->IPeriod = SvIV( get_sv("M6502::IPeriod", FALSE) );
24	dpavlin	74	R->IRequest = SvIV( get_sv("M6502::IRequest", FALSE) );
25			R->IAutoReset = SvIV( get_sv("M6502::IAutoReset", FALSE) );
26			R->TrapBadOps = SvIV( get_sv("M6502::TrapBadOps", FALSE) );
27			R->Trap = SvIV( get_sv("M6502::Trap", FALSE) );
28			R->Trace = SvIV( get_sv("M6502::Trace", FALSE) );
29	dpavlin	38	printf("pull_R finished\n");
30	dpavlin	25	dump_R;
31	dpavlin	24	}
32
33	dpavlin	38	void push_R(M6502 *R) {
34			dSP;
35			ENTER;
36			SAVETMPS;
37			PUSHMARK(SP);
38			XPUSHs( sv_2mortal( newSViv( R->A ) ) );
39			XPUSHs( sv_2mortal( newSViv( R->P ) ) );
40			XPUSHs( sv_2mortal( newSViv( R->X ) ) );
41			XPUSHs( sv_2mortal( newSViv( R->Y ) ) );
42			XPUSHs( sv_2mortal( newSViv( R->S ) ) );
43			XPUSHs( sv_2mortal( newSViv( R->PC.W ) ) );
44	dpavlin	74	XPUSHs( sv_2mortal( newSViv( R->IPeriod ) ) );
45			XPUSHs( sv_2mortal( newSViv( R->ICount ) ) );
46			XPUSHs( sv_2mortal( newSViv( R->IRequest ) ) );
47			XPUSHs( sv_2mortal( newSViv( R->IAutoReset ) ) );
48			XPUSHs( sv_2mortal( newSViv( R->TrapBadOps ) ) );
49			XPUSHs( sv_2mortal( newSViv( R->Trap ) ) );
50			XPUSHs( sv_2mortal( newSViv( R->Trace ) ) );
51	dpavlin	38	PUTBACK;
52	dpavlin	39	call_pv("M6502::push_R", G_DISCARD );
53	dpavlin	38	printf("push_R called\n");
54			dump_R;
55			FREETMPS;
56			LEAVE;
57			}
58
59	dpavlin	81	byte Debug6502(M6502 *R) {
60			dump_R;
61			return 1; // continue emulation
62			}
63
64	dpavlin	25	/ Rd6502()/Wr6502/Op6502() *******************************/
65			/ These functions are called when access to RAM occurs. /
66			/ They allow to control memory access. Op6502 is the same /
67			/** as Rd6502, but used to read opcodes only, when many **/
68			/ checks can be skipped to make it fast. It is only /
69			/ required if there is a #define FAST_RDOP. /
70			/********************************** TO BE WRITTEN BY USER /
71
72	dpavlin	28	byte mem(word Addr) {
73			byte byte;
74	dpavlin	27	int count;
75	dpavlin	82	debugf(("mem(%04x)\n", Addr));
76	dpavlin	27	dSP;
77			ENTER;
78			SAVETMPS;
79			PUSHMARK(SP);
80	dpavlin	28	XPUSHs( sv_2mortal( newSViv( Addr ) ) );
81	dpavlin	27	PUTBACK;
82	dpavlin	33	count = call_pv("Arch::read", G_ARRAY );
83	dpavlin	27	if ( count != 1 ) {
84			printf("expect 1 return value, got %d", count);
85			exit(1);
86			}
87	dpavlin	33	//debugf(("got %d values\n", count));
88	dpavlin	27	SPAGAIN;
89			SV *sv;
90			sv = POPs;
91	dpavlin	28	byte = SvIV(sv);
92	dpavlin	27	FREETMPS;
93			LEAVE;
94	dpavlin	34	//debugf(("mem(%04x) = %02x\n", Addr, byte));
95	dpavlin	28	return byte;
96			}
97
98			byte Rd6502(register word Addr) {
99			byte Value;
100			Value = mem(Addr);
101	dpavlin	34	debugf(("Rd6502(%04x) = %02x\n", Addr, Value));
102	dpavlin	27	return Value;
103	dpavlin	25	}
104
105			void Wr6502(register word Addr,register byte Value) {
106	dpavlin	33	debugf(("Wr6502(%04x,%02x)\n", Addr, Value));
107	dpavlin	27	dSP;
108			ENTER;
109			SAVETMPS;
110			PUSHMARK(SP);
111			XPUSHs( sv_2mortal( newSViv( Addr ) ) );
112			XPUSHs( sv_2mortal( newSViv( Value ) ) );
113			PUTBACK;
114	dpavlin	33	call_pv("Arch::write", G_DISCARD );
115	dpavlin	27	FREETMPS;
116			LEAVE;
117	dpavlin	25	}
118
119			byte Op6502(register word Addr) {
120			byte Op;
121	dpavlin	28	Op = mem(Addr);
122	dpavlin	36	debugf(("Op6502(%04x,%02x) PC:%04x\n", Addr, Op, R->PC.W));
123	dpavlin	40	return Op;
124	dpavlin	25	}
125
126			/ Loop6502() *********************************************/
127			/ 6502 emulation calls this function periodically to /
128			/ check if the system hardware requires any interrupts. /
129			/ This function must return one of following values: /
130			/ INT_NONE, INT_IRQ, INT_NMI, or INT_QUIT to exit the /
131			/ emulation loop. /
132			/********************************** TO BE WRITTEN BY USER /
133	dpavlin	42
134			int hw_int = INT_NONE;
135
136	dpavlin	25	byte Loop6502(register M6502 *R) {
137	dpavlin	33	debugf(("Loop6502\n"));
138	dpavlin	25	dump_R;
139	dpavlin	42	return hw_int;
140	dpavlin	25	}
141
142			/ Patch6502() ********************************************/
143			/ Emulation calls this function when it encounters an /
144			/ unknown opcode. This can be used to patch the code to /
145			/ emulate BIOS calls, such as disk and tape access. The /
146			/ function should return 1 if the exception was handled, /
147			/ or 0 if the opcode was truly illegal. /
148			/********************************** TO BE WRITTEN BY USER /
149			byte Patch6502(register byte Op,register M6502 *R) {
150	dpavlin	33	debugf(("Patch6502(%02x)\n", Op));
151	dpavlin	25	dump_R;
152	dpavlin	66	hw_int = INT_QUIT;
153	dpavlin	28	return 0;
154	dpavlin	25	}
155
156	dpavlin	80	void run_forever(void) {
157			printf("entered run_forever\n");
158
159			R = malloc(sizeof(M6502));
160			if (!R) {
161			printf("can't alloc %d bytes for M6502", sizeof(M6502));
162			exit(1);
163			}
164
165			printf("reset CPU\n");
166			Reset6502(R);
167
168			printf("call Arch::init\n");
169			dSP;
170			PUSHMARK(SP);
171			call_pv("Arch::init", G_DISCARD \| G_NOARGS );
172			FREETMPS;
173			LEAVE;
174
175			int cycles = 1;
176			while ( cycles ) {
177			dSP;
178			PUSHMARK(SP);
179			call_pv("Arch::cli", G_DISCARD \| G_NOARGS );
180			pull_R(R);
181			FREETMPS;
182			LEAVE;
183			cycles = SvIV( get_sv("M6502::run_for", FALSE) );
184			if ( cycles > 0 ) {
185			printf("run CPU for %d cycles\n", cycles);
186			dump_R;
187			//Run6502(R);
188			Exec6502(R, cycles);
189			dump_R;
190			push_R(R);
191			printf("end of %d cycles CPU run\n", cycles);
192			} else {
193			printf("no cpu cycles set for run\n");
194			cycles = 1; // never exit, prevents segfault
195			}
196			}
197			free(R);
198			}
199
200	dpavlin	25	/**
201			* main code
202			*
203			**/
204
205	dpavlin	24	int main(int argc, char **argv) {
206	dpavlin	30	char *command_line[] = {"", "-e", EMU_START };
207	dpavlin	24	my_perl = perl_alloc();
208			perl_construct(my_perl);
209	dpavlin	29	if (perl_parse(my_perl, xs_init, 3, command_line, (char **)NULL)) {
210	dpavlin	31	printf("Failed to parse initial: %s\n", EMU_START );
211	dpavlin	24	return 0;
212			}
213			perl_run(my_perl);
214			if (SvTRUE(ERRSV)) {
215			printf("Failed to execute\n");
216			return 0;
217			} else {
218	dpavlin	80	run_forever();
219	dpavlin	24	}
220			perl_destruct(my_perl);
221			perl_free(my_perl);
222			return 0;
223			}