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

Diff of /M6502/perl.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 34 by dpavlin, Mon Jul 30 21:34:30 2007 UTC revision 81 by dpavlin, Wed Aug 1 15:53:54 2007 UTC
# Line 5  Line 5 
5    
6  #if DEBUGF  #if DEBUGF
7  #define debugf(x)  do {         \  #define debugf(x)  do {         \
8            PerlIO_stdoutf("#> ");  \
9          PerlIO_stdoutf x ;      \          PerlIO_stdoutf x ;      \
10  } while (0)  } while (0)
11  #else  #else
# Line 21  static M6502 *R; Line 22  static M6502 *R;
22  #define dump_R  #define dump_R
23  #endif  #endif
24    
25  void update_R(M6502 *R) {  void pull_R(M6502 *R) {
26          R->A = SvIV( get_sv("M6502::A", FALSE) );          R->A = SvIV( get_sv("M6502::A", FALSE) );
         printf("--%d", get_sv("M6502::A", FALSE) );  
27          R->P = SvIV( get_sv("M6502::P", FALSE) );          R->P = SvIV( get_sv("M6502::P", FALSE) );
28          R->X = atoi( SvPV_nolen( get_sv("M6502::X", FALSE) ) );          R->X = SvIV( get_sv("M6502::X", FALSE) );
29          R->Y = atoi( SvPV_nolen( get_sv("M6502::Y", FALSE) ) );          R->Y = SvIV( get_sv("M6502::Y", FALSE) );
30          R->S = atoi( SvPV_nolen( get_sv("M6502::S", FALSE) ) );          R->S = SvIV( get_sv("M6502::S", FALSE) );
31          R->PC.W = atoi( SvPV_nolen( get_sv("M6502::PC", FALSE) ) );          R->PC.W = SvIV( get_sv("M6502::PC", FALSE) );
32          R->IPeriod = atoi( SvPV_nolen( get_sv("M6502::IPeriod", FALSE) ) );          R->IPeriod = SvIV( get_sv("M6502::IPeriod", FALSE) );
33          // ICount IRequest IAutoReset TrapBadOps Trap Trace          R->IRequest = SvIV( get_sv("M6502::IRequest", FALSE) );
34            R->IAutoReset = SvIV( get_sv("M6502::IAutoReset", FALSE) );
35            R->TrapBadOps = SvIV( get_sv("M6502::TrapBadOps", FALSE) );
36            R->Trap = SvIV( get_sv("M6502::Trap", FALSE) );
37            R->Trace = SvIV( get_sv("M6502::Trace", FALSE) );
38            printf("pull_R finished\n");
39          dump_R;          dump_R;
40  }  }
41    
42    void push_R(M6502 *R) {
43            dSP;
44            ENTER;
45            SAVETMPS;
46            PUSHMARK(SP);
47            XPUSHs( sv_2mortal( newSViv( R->A ) ) );
48            XPUSHs( sv_2mortal( newSViv( R->P ) ) );
49            XPUSHs( sv_2mortal( newSViv( R->X ) ) );
50            XPUSHs( sv_2mortal( newSViv( R->Y ) ) );
51            XPUSHs( sv_2mortal( newSViv( R->S ) ) );
52            XPUSHs( sv_2mortal( newSViv( R->PC.W ) ) );
53            XPUSHs( sv_2mortal( newSViv( R->IPeriod ) ) );
54            XPUSHs( sv_2mortal( newSViv( R->ICount ) ) );
55            XPUSHs( sv_2mortal( newSViv( R->IRequest ) ) );
56            XPUSHs( sv_2mortal( newSViv( R->IAutoReset ) ) );
57            XPUSHs( sv_2mortal( newSViv( R->TrapBadOps ) ) );
58            XPUSHs( sv_2mortal( newSViv( R->Trap ) ) );
59            XPUSHs( sv_2mortal( newSViv( R->Trace ) ) );
60            PUTBACK;
61            call_pv("M6502::push_R", G_DISCARD );
62            printf("push_R called\n");
63            dump_R;
64            FREETMPS;
65            LEAVE;
66    }
67    
68    byte Debug6502(M6502 *R) {
69            dump_R;
70            return 1; // continue emulation
71    }
72    
73  /** Rd6502()/Wr6502/Op6502() *********************************/  /** Rd6502()/Wr6502/Op6502() *********************************/
74  /** These functions are called when access to RAM occurs.   **/  /** These functions are called when access to RAM occurs.   **/
75  /** They allow to control memory access. Op6502 is the same **/  /** They allow to control memory access. Op6502 is the same **/
# Line 91  void Wr6502(register word Addr,register Line 127  void Wr6502(register word Addr,register
127  byte Op6502(register word Addr) {  byte Op6502(register word Addr) {
128          byte Op;          byte Op;
129          Op = mem(Addr);          Op = mem(Addr);
130          debugf(("Op6502(%04x,%02x)\n", Addr, Op));          debugf(("Op6502(%04x,%02x) PC:%04x\n", Addr, Op, R->PC.W));
131          dump_R;          return Op;
132  }  }
133    
134  /** Loop6502() ***********************************************/  /** Loop6502() ***********************************************/
# Line 102  byte Op6502(register word Addr) { Line 138  byte Op6502(register word Addr) {
138  /** INT_NONE, INT_IRQ, INT_NMI, or INT_QUIT to exit the     **/  /** INT_NONE, INT_IRQ, INT_NMI, or INT_QUIT to exit the     **/
139  /** emulation loop.                                         **/  /** emulation loop.                                         **/
140  /************************************ TO BE WRITTEN BY USER **/  /************************************ TO BE WRITTEN BY USER **/
141    
142    int hw_int = INT_NONE;
143    
144  byte Loop6502(register M6502 *R) {  byte Loop6502(register M6502 *R) {
145          debugf(("Loop6502\n"));          debugf(("Loop6502\n"));
146          dump_R;          dump_R;
147          return INT_NONE;          return hw_int;
148  }  }
149    
150  /** Patch6502() **********************************************/  /** Patch6502() **********************************************/
# Line 118  byte Loop6502(register M6502 *R) { Line 157  byte Loop6502(register M6502 *R) {
157  byte Patch6502(register byte Op,register M6502 *R) {  byte Patch6502(register byte Op,register M6502 *R) {
158          debugf(("Patch6502(%02x)\n", Op));          debugf(("Patch6502(%02x)\n", Op));
159          dump_R;          dump_R;
160            hw_int = INT_QUIT;
161          return 0;          return 0;
162  }  }
163    
164    void run_forever(void) {
165            printf("entered run_forever\n");
166    
167            R = malloc(sizeof(M6502));
168            if (!R) {
169                    printf("can't alloc %d bytes for M6502", sizeof(M6502));
170                    exit(1);
171            }
172    
173            printf("reset CPU\n");
174            Reset6502(R);
175    
176            printf("call Arch::init\n");
177            dSP;
178            PUSHMARK(SP);
179            call_pv("Arch::init", G_DISCARD | G_NOARGS );
180            FREETMPS;
181            LEAVE;
182    
183            int cycles = 1;
184            while ( cycles ) {
185                    dSP;
186                    PUSHMARK(SP);
187                    call_pv("Arch::cli", G_DISCARD | G_NOARGS );
188                    pull_R(R);
189                    FREETMPS;
190                    LEAVE;
191                    cycles = SvIV( get_sv("M6502::run_for", FALSE) );
192                    if ( cycles > 0 ) {
193                            printf("run CPU for %d cycles\n", cycles);
194                            dump_R;
195                            //Run6502(R);
196                            Exec6502(R, cycles);
197                            dump_R;
198                            push_R(R);
199                            printf("end of %d cycles CPU run\n", cycles);
200                    } else {
201                            printf("no cpu cycles set for run\n");
202                            cycles = 1; // never exit, prevents segfault
203                    }
204            }
205            free(R);
206    }
207    
208  /**  /**
209   * main code   * main code
210   *   *
# Line 139  int main(int argc, char **argv) { Line 223  int main(int argc, char **argv) {
223                  printf("Failed to execute\n");                  printf("Failed to execute\n");
224                  return 0;                  return 0;
225          } else {          } else {
226                  R = malloc(sizeof(M6502));                  run_forever();
                 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 );  
   
                 update_R(R);  
                 printf("run CPU\n");  
                 Run6502(R);  
   
227          }          }
         free(R);  
228          perl_destruct(my_perl);          perl_destruct(my_perl);
229          perl_free(my_perl);          perl_free(my_perl);
230          return 0;          return 0;
Legend:
Removed from v.34  
changed lines
  Added in v.81
  ViewVC Help
Powered by ViewVC 1.1.26