Mercurial > audlegacy
comparison Plugins/Input/console/Nes_Cpu.h @ 493:c04dff121e1d trunk
[svn] hostile merge, phase 2: reimport based on new plugin code
author | nenolod |
---|---|
date | Tue, 24 Jan 2006 20:19:01 -0800 |
parents | |
children | 44c3711dd049 |
comparison
equal
deleted
inserted
replaced
492:ccb68bad47b2 | 493:c04dff121e1d |
---|---|
1 | |
2 // Nintendo Entertainment System (NES) 6502 CPU emulator | |
3 | |
4 // Game_Music_Emu 0.3.0 | |
5 | |
6 #ifndef NES_CPU_H | |
7 #define NES_CPU_H | |
8 | |
9 #include "blargg_common.h" | |
10 | |
11 typedef long nes_time_t; // clock cycle count | |
12 typedef unsigned nes_addr_t; // 16-bit address | |
13 | |
14 class Nes_Emu; | |
15 | |
16 class Nes_Cpu { | |
17 typedef BOOST::uint8_t uint8_t; | |
18 enum { page_bits = 11 }; | |
19 enum { page_count = 0x10000 >> page_bits }; | |
20 uint8_t const* code_map [page_count + 1]; | |
21 public: | |
22 Nes_Cpu(); | |
23 | |
24 // Memory read/write function types. Reader must return value from 0 to 255. | |
25 typedef int (*reader_t)( Nes_Emu*, nes_addr_t ); | |
26 typedef void (*writer_t)( Nes_Emu*, nes_addr_t, int data ); | |
27 void set_emu( Nes_Emu* emu ) { callback_data = emu; } | |
28 | |
29 // Clear registers, unmap memory, and map code pages to unmapped_page. | |
30 void reset( const void* unmapped_page = NULL, reader_t read = NULL, writer_t write = NULL ); | |
31 | |
32 // Memory mapping functions take a block of memory of specified 'start' address | |
33 // and 'size' in bytes. Both start address and size must be a multiple of page_size. | |
34 enum { page_size = 1L << page_bits }; | |
35 | |
36 // Map code memory (memory accessed via the program counter) | |
37 void map_code( nes_addr_t start, unsigned long size, const void* code ); | |
38 | |
39 // Set read function for address range | |
40 void set_reader( nes_addr_t start, unsigned long size, reader_t ); | |
41 | |
42 // Set write function for address range | |
43 void set_writer( nes_addr_t start, unsigned long size, writer_t ); | |
44 | |
45 // Set read and write functions for address range | |
46 void map_memory( nes_addr_t start, unsigned long size, reader_t, writer_t ); | |
47 | |
48 // Access memory as the emulated CPU does. | |
49 int read( nes_addr_t ); | |
50 void write( nes_addr_t, int data ); | |
51 uint8_t* get_code( nes_addr_t ); // non-const to allow debugger to modify code | |
52 | |
53 // Push a byte on the stack | |
54 void push_byte( int ); | |
55 | |
56 // NES 6502 registers. *Not* kept updated during a call to run(). | |
57 struct registers_t { | |
58 long pc; // more than 16 bits to allow overflow detection | |
59 BOOST::uint8_t a; | |
60 BOOST::uint8_t x; | |
61 BOOST::uint8_t y; | |
62 BOOST::uint8_t status; | |
63 BOOST::uint8_t sp; | |
64 }; | |
65 registers_t r; | |
66 | |
67 // Reasons that run() returns | |
68 enum result_t { | |
69 result_cycles, // Requested number of cycles (or more) were executed | |
70 result_sei, // I flag just set and IRQ time would generate IRQ now | |
71 result_cli, // I flag just cleared but IRQ should occur *after* next instr | |
72 result_badop // unimplemented/illegal instruction | |
73 }; | |
74 | |
75 result_t run( nes_time_t end_time_ ); | |
76 | |
77 nes_time_t time() const { return base_time + clock_count; } | |
78 void set_time( nes_time_t t ); | |
79 void end_frame( nes_time_t ); | |
80 nes_time_t end_time() const { return base_time + end_time_; } | |
81 nes_time_t irq_time() const { return base_time + irq_time_; } | |
82 void set_end_time( nes_time_t t ); | |
83 void set_irq_time( nes_time_t t ); | |
84 | |
85 // If PC exceeds 0xFFFF and encounters page_wrap_opcode, it will be silently wrapped. | |
86 enum { page_wrap_opcode = 0xF2 }; | |
87 | |
88 // One of the many opcodes that are undefined and stop CPU emulation. | |
89 enum { bad_opcode = 0xD2 }; | |
90 | |
91 // End of public interface | |
92 private: | |
93 // noncopyable | |
94 Nes_Cpu( const Nes_Cpu& ); | |
95 Nes_Cpu& operator = ( const Nes_Cpu& ); | |
96 | |
97 nes_time_t clock_limit; | |
98 nes_time_t base_time; | |
99 nes_time_t clock_count; | |
100 nes_time_t irq_time_; | |
101 nes_time_t end_time_; | |
102 | |
103 Nes_Emu* callback_data; | |
104 | |
105 enum { irq_inhibit = 0x04 }; | |
106 reader_t data_reader [page_count + 1]; // extra entry catches address overflow | |
107 writer_t data_writer [page_count + 1]; | |
108 void set_code_page( int, uint8_t const* ); | |
109 void update_clock_limit(); | |
110 | |
111 public: | |
112 // low_mem is a full page size so it can be mapped with code_map | |
113 uint8_t low_mem [page_size > 0x800 ? page_size : 0x800]; | |
114 }; | |
115 | |
116 inline BOOST::uint8_t* Nes_Cpu::get_code( nes_addr_t addr ) | |
117 { | |
118 #if BLARGG_NONPORTABLE | |
119 return (uint8_t*) code_map [addr >> page_bits] + addr; | |
120 #else | |
121 return (uint8_t*) code_map [addr >> page_bits] + (addr & (page_size - 1)); | |
122 #endif | |
123 } | |
124 | |
125 inline void Nes_Cpu::update_clock_limit() | |
126 { | |
127 nes_time_t t = end_time_; | |
128 if ( t > irq_time_ && !(r.status & irq_inhibit) ) | |
129 t = irq_time_; | |
130 clock_limit = t; | |
131 } | |
132 | |
133 inline void Nes_Cpu::set_end_time( nes_time_t t ) | |
134 { | |
135 end_time_ = t - base_time; | |
136 update_clock_limit(); | |
137 } | |
138 | |
139 inline void Nes_Cpu::set_irq_time( nes_time_t t ) | |
140 { | |
141 irq_time_ = t - base_time; | |
142 update_clock_limit(); | |
143 } | |
144 | |
145 inline void Nes_Cpu::end_frame( nes_time_t end_time_ ) | |
146 { | |
147 base_time -= end_time_; | |
148 assert( time() >= 0 ); | |
149 } | |
150 | |
151 inline void Nes_Cpu::set_time( nes_time_t t ) | |
152 { | |
153 t -= time(); | |
154 clock_limit -= t; | |
155 end_time_ -= t; | |
156 irq_time_ -= t; | |
157 base_time += t; | |
158 } | |
159 | |
160 inline void Nes_Cpu::push_byte( int data ) | |
161 { | |
162 int sp = r.sp; | |
163 r.sp = (sp - 1) & 0xff; | |
164 low_mem [0x100 + sp] = data; | |
165 } | |
166 | |
167 inline void Nes_Cpu::map_memory( nes_addr_t addr, unsigned long s, reader_t r, writer_t w ) | |
168 { | |
169 set_reader( addr, s, r ); | |
170 set_writer( addr, s, w ); | |
171 } | |
172 | |
173 #endif | |
174 |