/[VRac]/M6502/perl.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Contents of /M6502/perl.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 82 - (show annotations)
Wed Aug 1 21:40:17 2007 UTC (12 years ago) by dpavlin
File MIME type: text/plain
File size: 5719 byte(s)
begin refactoring into proper XS module (really need to do this so I can handle SDL event loop)
1 #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 #if DUMP_R
11 #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 #else
13 #define dump_R
14 #endif
15
16 void pull_R(M6502 *R) {
17 R->A = SvIV( get_sv("M6502::A", FALSE) );
18 R->P = SvIV( get_sv("M6502::P", FALSE) );
19 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 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 printf("pull_R finished\n");
30 dump_R;
31 }
32
33 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 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 PUTBACK;
52 call_pv("M6502::push_R", G_DISCARD );
53 printf("push_R called\n");
54 dump_R;
55 FREETMPS;
56 LEAVE;
57 }
58
59 byte Debug6502(M6502 *R) {
60 dump_R;
61 return 1; // continue emulation
62 }
63
64 /** 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 byte mem(word Addr) {
73 byte byte;
74 int count;
75 debugf(("mem(%04x)\n", Addr));
76 dSP;
77 ENTER;
78 SAVETMPS;
79 PUSHMARK(SP);
80 XPUSHs( sv_2mortal( newSViv( Addr ) ) );
81 PUTBACK;
82 count = call_pv("Arch::read", G_ARRAY );
83 if ( count != 1 ) {
84 printf("expect 1 return value, got %d", count);
85 exit(1);
86 }
87 //debugf(("got %d values\n", count));
88 SPAGAIN;
89 SV *sv;
90 sv = POPs;
91 byte = SvIV(sv);
92 FREETMPS;
93 LEAVE;
94 //debugf(("mem(%04x) = %02x\n", Addr, byte));
95 return byte;
96 }
97
98 byte Rd6502(register word Addr) {
99 byte Value;
100 Value = mem(Addr);
101 debugf(("Rd6502(%04x) = %02x\n", Addr, Value));
102 return Value;
103 }
104
105 void Wr6502(register word Addr,register byte Value) {
106 debugf(("Wr6502(%04x,%02x)\n", Addr, Value));
107 dSP;
108 ENTER;
109 SAVETMPS;
110 PUSHMARK(SP);
111 XPUSHs( sv_2mortal( newSViv( Addr ) ) );
112 XPUSHs( sv_2mortal( newSViv( Value ) ) );
113 PUTBACK;
114 call_pv("Arch::write", G_DISCARD );
115 FREETMPS;
116 LEAVE;
117 }
118
119 byte Op6502(register word Addr) {
120 byte Op;
121 Op = mem(Addr);
122 debugf(("Op6502(%04x,%02x) PC:%04x\n", Addr, Op, R->PC.W));
123 return Op;
124 }
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
134 int hw_int = INT_NONE;
135
136 byte Loop6502(register M6502 *R) {
137 debugf(("Loop6502\n"));
138 dump_R;
139 return hw_int;
140 }
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 debugf(("Patch6502(%02x)\n", Op));
151 dump_R;
152 hw_int = INT_QUIT;
153 return 0;
154 }
155
156 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 /**
201 * main code
202 *
203 **/
204
205 int main(int argc, char **argv) {
206 char *command_line[] = {"", "-e", EMU_START };
207 my_perl = perl_alloc();
208 perl_construct(my_perl);
209 if (perl_parse(my_perl, xs_init, 3, command_line, (char **)NULL)) {
210 printf("Failed to parse initial: %s\n", EMU_START );
211 return 0;
212 }
213 perl_run(my_perl);
214 if (SvTRUE(ERRSV)) {
215 printf("Failed to execute\n");
216 return 0;
217 } else {
218 run_forever();
219 }
220 perl_destruct(my_perl);
221 perl_free(my_perl);
222 return 0;
223 }

  ViewVC Help
Powered by ViewVC 1.1.26