?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Gambatte: Some Trace/Disassemble fixes
[lsnes.git] / src / emulation / bsnes-legacy / core.cpp
blobea60888641904c572a256a8e17e5dd09b8f9177d
1 /*************************************************************************
2 * Copyright (C) 2011-2013 by Ilari Liusvaara *
3 * *
4 * This program is free software: you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation, either version 3 of the License, or *
7 * (at your option) any later version. *
8 * *
9 * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. *
13 * *
14 * You should have received a copy of the GNU General Public License *
15 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
16 *************************************************************************/
17 #include "lsnes.hpp"
18 #include <sstream>
19 #include <map>
20 #include <string>
21 #include <cctype>
22 #include <vector>
23 #include <fstream>
24 #include <climits>
25 #include "core/audioapi.hpp"
26 #include "core/misc.hpp"
27 #include "core/command.hpp"
28 #include "core/controllerframe.hpp"
29 #include "core/dispatch.hpp"
30 #include "core/framebuffer.hpp"
31 #include "core/settings.hpp"
32 #include "core/window.hpp"
33 #include "interface/cover.hpp"
34 #include "interface/romtype.hpp"
35 #include "interface/setting.hpp"
36 #include "interface/callbacks.hpp"
37 #include "library/framebuffer-pixfmt-lrgb.hpp"
38 #include "library/hex.hpp"
39 #include "library/string.hpp"
40 #include "library/controller-data.hpp"
41 #include "library/framebuffer.hpp"
42 #include "library/lua-base.hpp"
43 #include "lua/internal.hpp"
44 #ifdef BSNES_HAS_DEBUGGER
45 #define DEBUGGER
46 #endif
47 #include <snes/snes.hpp>
48 #include <gameboy/gameboy.hpp>
49 #include LIBSNES_INCLUDE_FILE
50
51 #define DURATION_NTSC_FRAME 357366
52 #define DURATION_NTSC_FIELD 357368
53 #define DURATION_PAL_FRAME 425568
54 #define DURATION_PAL_FIELD 425568
55 #define ROM_TYPE_NONE 0
56 #define ROM_TYPE_SNES 1
57 #define ROM_TYPE_BSX 2
58 #define ROM_TYPE_BSXSLOTTED 3
59 #define ROM_TYPE_SUFAMITURBO 4
60 #define ROM_TYPE_SGB 5
61
62 #define ADDR_KIND_ALL -1
63 #define ADDR_KIND_NONE -2
64
65 namespace
66 {
67 bool p1disable = false;
68 bool do_hreset_flag = false;
69 long do_reset_flag = -1;
70 bool support_hreset = false;
71 bool support_dreset = false;
72 bool save_every_frame = false;
73 bool have_saved_this_frame = false;
74 int16_t blanksound[1070] = {0};
75 int16_t soundbuf[8192] = {0};
76 size_t soundbuf_fill = 0;
77 bool last_hires = false;
78 bool last_interlace = false;
79 bool last_PAL = false;
80 bool disable_breakpoints = false;
81 uint64_t trace_counter;
82 bool trace_cpu_enable;
83 bool trace_smp_enable;
84 SNES::Interface* old;
85 bool stepping_into_save;
86 bool video_refresh_done;
87 bool forced_hook = false;
88 std::map<int16_t, std::pair<uint64_t, uint64_t>> ptrmap;
89 uint32_t cover_fbmem[512 * 448];
90 //Delay reset.
91 unsigned long long delayreset_cycles_run;
92 unsigned long long delayreset_cycles_target;
93
94 //Framebuffer.
95 struct framebuffer::info cover_fbinfo = {
96 &framebuffer::pixfmt_lrgb, //Format.
97 (char*)cover_fbmem, //Memory.
98 512, 448, 2048, //Physical size.
99 512, 448, 2048, //Logical size.
100 0, 0 //Offset.
101 };
102
103 struct interface_device_reg snes_registers[] = {
104 {"pbpc", []() -> uint64_t { return SNES::cpu.regs.pc; }, [](uint64_t v) { SNES::cpu.regs.pc = v; }},
105 {"pb", []() -> uint64_t { return SNES::cpu.regs.pc >> 16; },
106 [](uint64_t v) { SNES::cpu.regs.pc = (v << 16) | (SNES::cpu.regs.pc & 0xFFFF); }},
107 {"pc", []() -> uint64_t { return SNES::cpu.regs.pc & 0xFFFF; },
108 [](uint64_t v) { SNES::cpu.regs.pc = (v & 0xFFFF) | (SNES::cpu.regs.pc & ~0xFFFF); }},
109 {"r0", []() -> uint64_t { return SNES::cpu.regs.r[0]; }, [](uint64_t v) { SNES::cpu.regs.r[0] = v; }},
110 {"r1", []() -> uint64_t { return SNES::cpu.regs.r[1]; }, [](uint64_t v) { SNES::cpu.regs.r[1] = v; }},
111 {"r2", []() -> uint64_t { return SNES::cpu.regs.r[2]; }, [](uint64_t v) { SNES::cpu.regs.r[2] = v; }},
112 {"r3", []() -> uint64_t { return SNES::cpu.regs.r[3]; }, [](uint64_t v) { SNES::cpu.regs.r[3] = v; }},
113 {"r4", []() -> uint64_t { return SNES::cpu.regs.r[4]; }, [](uint64_t v) { SNES::cpu.regs.r[4] = v; }},
114 {"r5", []() -> uint64_t { return SNES::cpu.regs.r[5]; }, [](uint64_t v) { SNES::cpu.regs.r[5] = v; }},
115 {"a", []() -> uint64_t { return SNES::cpu.regs.a; }, [](uint64_t v) { SNES::cpu.regs.a = v; }},
116 {"x", []() -> uint64_t { return SNES::cpu.regs.x; }, [](uint64_t v) { SNES::cpu.regs.x = v; }},
117 {"y", []() -> uint64_t { return SNES::cpu.regs.y; }, [](uint64_t v) { SNES::cpu.regs.y = v; }},
118 {"z", []() -> uint64_t { return SNES::cpu.regs.z; }, [](uint64_t v) { SNES::cpu.regs.z = v; }},
119 {"s", []() -> uint64_t { return SNES::cpu.regs.s; }, [](uint64_t v) { SNES::cpu.regs.s = v; }},
120 {"d", []() -> uint64_t { return SNES::cpu.regs.d; }, [](uint64_t v) { SNES::cpu.regs.d = v; }},
121 {"db", []() -> uint64_t { return SNES::cpu.regs.db; }, [](uint64_t v) { SNES::cpu.regs.db = v; }},
122 {"p", []() -> uint64_t { return SNES::cpu.regs.p; }, [](uint64_t v) { SNES::cpu.regs.p = v; }},
123 {"e", []() -> uint64_t { return SNES::cpu.regs.e; }, [](uint64_t v) { SNES::cpu.regs.e = v; }},
124 {"irq", []() -> uint64_t { return SNES::cpu.regs.irq; }, [](uint64_t v) { SNES::cpu.regs.irq = v; }},
125 {"wai", []() -> uint64_t { return SNES::cpu.regs.wai; }, [](uint64_t v) { SNES::cpu.regs.wai = v; }},
126 {"mdr", []() -> uint64_t { return SNES::cpu.regs.mdr; }, [](uint64_t v) { SNES::cpu.regs.mdr = v; }},
127 {"vector", []() -> uint64_t { return SNES::cpu.regs.vector; },
128 [](uint64_t v) { SNES::cpu.regs.vector = v; }},
129 {"aa", []() -> uint64_t { return SNES::cpu.aa; }, [](uint64_t v) { SNES::cpu.aa = v; }},
130 {"rd", []() -> uint64_t { return SNES::cpu.rd; }, [](uint64_t v) { SNES::cpu.rd = v; }},
131 {"sp", []() -> uint64_t { return SNES::cpu.sp; }, [](uint64_t v) { SNES::cpu.sp = v; }},
132 {"dp", []() -> uint64_t { return SNES::cpu.dp; }, [](uint64_t v) { SNES::cpu.dp = v; }},
133 {"p_n", []() -> uint64_t { return SNES::cpu.regs.p.n; }, [](uint64_t v) { SNES::cpu.regs.p.n = v; },
134 true},
135 {"p_v", []() -> uint64_t { return SNES::cpu.regs.p.v; }, [](uint64_t v) { SNES::cpu.regs.p.v = v; },
136 true},
137 {"p_m", []() -> uint64_t { return SNES::cpu.regs.p.m; }, [](uint64_t v) { SNES::cpu.regs.p.m = v; },
138 true},
139 {"p_x", []() -> uint64_t { return SNES::cpu.regs.p.x; }, [](uint64_t v) { SNES::cpu.regs.p.x = v; },
140 true},
141 {"p_d", []() -> uint64_t { return SNES::cpu.regs.p.d; }, [](uint64_t v) { SNES::cpu.regs.p.d = v; },
142 true},
143 {"p_i", []() -> uint64_t { return SNES::cpu.regs.p.i; }, [](uint64_t v) { SNES::cpu.regs.p.i = v; },
144 true},
145 {"p_z", []() -> uint64_t { return SNES::cpu.regs.p.z; }, [](uint64_t v) { SNES::cpu.regs.p.z = v; },
146 true},
147 {"p_c", []() -> uint64_t { return SNES::cpu.regs.p.c; }, [](uint64_t v) { SNES::cpu.regs.p.c = v; },
148 true},
149 #ifdef BSNES_IS_COMPAT
150 {"ppu_display_disabled", []() -> uint64_t { return SNES::ppu.regs.display_disabled; },
151 [](uint64_t v) { SNES::ppu.regs.display_disabled = v; }, true},
152 {"ppu_oam_priority", []() -> uint64_t { return SNES::ppu.regs.oam_priority; },
153 [](uint64_t v) { SNES::ppu.regs.oam_priority = v; }, true},
154 {"ppu_bg_tilesize[0]", []() -> uint64_t { return SNES::ppu.regs.bg_tilesize[0]; },
155 [](uint64_t v) { SNES::ppu.regs.bg_tilesize[0] = v; }, true},
156 {"ppu_bg_tilesize[1]", []() -> uint64_t { return SNES::ppu.regs.bg_tilesize[1]; },
157 [](uint64_t v) { SNES::ppu.regs.bg_tilesize[1] = v; }, true},
158 {"ppu_bg_tilesize[2]", []() -> uint64_t { return SNES::ppu.regs.bg_tilesize[2]; },
159 [](uint64_t v) { SNES::ppu.regs.bg_tilesize[2] = v; }, true},
160 {"ppu_bg_tilesize[3]", []() -> uint64_t { return SNES::ppu.regs.bg_tilesize[3]; },
161 [](uint64_t v) { SNES::ppu.regs.bg_tilesize[3] = v; }, true},
162 {"ppu_bg3_priority", []() -> uint64_t { return SNES::ppu.regs.bg3_priority; },
163 [](uint64_t v) { SNES::ppu.regs.bg3_priority = v; }, true},
164 {"ppu_mosaic_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.mosaic_enabled[0]; },
165 [](uint64_t v) { SNES::ppu.regs.mosaic_enabled[0] = v; }, true},
166 {"ppu_mosaic_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.mosaic_enabled[1]; },
167 [](uint64_t v) { SNES::ppu.regs.mosaic_enabled[1] = v; }, true},
168 {"ppu_mosaic_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.mosaic_enabled[2]; },
169 [](uint64_t v) { SNES::ppu.regs.mosaic_enabled[2] = v; }, true},
170 {"ppu_mosaic_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.mosaic_enabled[3]; },
171 [](uint64_t v) { SNES::ppu.regs.mosaic_enabled[3] = v; }, true},
172 {"ppu_vram_incmode", []() -> uint64_t { return SNES::ppu.regs.vram_incmode; },
173 [](uint64_t v) { SNES::ppu.regs.vram_incmode = v; }, true},
174 {"ppu_mode7_vflip", []() -> uint64_t { return SNES::ppu.regs.mode7_vflip; },
175 [](uint64_t v) { SNES::ppu.regs.mode7_vflip = v; }, true},
176 {"ppu_mode7_hflip", []() -> uint64_t { return SNES::ppu.regs.mode7_hflip; },
177 [](uint64_t v) { SNES::ppu.regs.mode7_hflip = v; }, true},
178 {"ppu_window1_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.window1_enabled[0]; },
179 [](uint64_t v) { SNES::ppu.regs.window1_enabled[0] = v; }, true},
180 {"ppu_window1_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.window1_enabled[1]; },
181 [](uint64_t v) { SNES::ppu.regs.window1_enabled[1] = v; }, true},
182 {"ppu_window1_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.window1_enabled[2]; },
183 [](uint64_t v) { SNES::ppu.regs.window1_enabled[2] = v; }, true},
184 {"ppu_window1_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.window1_enabled[3]; },
185 [](uint64_t v) { SNES::ppu.regs.window1_enabled[3] = v; }, true},
186 {"ppu_window1_enabled[4]", []() -> uint64_t { return SNES::ppu.regs.window1_enabled[4]; },
187 [](uint64_t v) { SNES::ppu.regs.window1_enabled[4] = v; }, true},
188 {"ppu_window1_enabled[5]", []() -> uint64_t { return SNES::ppu.regs.window1_enabled[5]; },
189 [](uint64_t v) { SNES::ppu.regs.window1_enabled[5] = v; }, true},
190 {"ppu_window1_invert[0]", []() -> uint64_t { return SNES::ppu.regs.window1_invert[0]; },
191 [](uint64_t v) { SNES::ppu.regs.window1_invert[0] = v; }, true},
192 {"ppu_window1_invert[1]", []() -> uint64_t { return SNES::ppu.regs.window1_invert[1]; },
193 [](uint64_t v) { SNES::ppu.regs.window1_invert[1] = v; }, true},
194 {"ppu_window1_invert[2]", []() -> uint64_t { return SNES::ppu.regs.window1_invert[2]; },
195 [](uint64_t v) { SNES::ppu.regs.window1_invert[2] = v; }, true},
196 {"ppu_window1_invert[3]", []() -> uint64_t { return SNES::ppu.regs.window1_invert[3]; },
197 [](uint64_t v) { SNES::ppu.regs.window1_invert[3] = v; }, true},
198 {"ppu_window1_invert[4]", []() -> uint64_t { return SNES::ppu.regs.window1_invert[4]; },
199 [](uint64_t v) { SNES::ppu.regs.window1_invert[4] = v; }, true},
200 {"ppu_window1_invert[5]", []() -> uint64_t { return SNES::ppu.regs.window1_invert[5]; },
201 [](uint64_t v) { SNES::ppu.regs.window1_invert[5] = v; }, true},
202 {"ppu_window2_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.window2_enabled[0]; },
203 [](uint64_t v) { SNES::ppu.regs.window2_enabled[0] = v; }, true},
204 {"ppu_window2_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.window2_enabled[1]; },
205 [](uint64_t v) { SNES::ppu.regs.window2_enabled[1] = v; }, true},
206 {"ppu_window2_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.window2_enabled[2]; },
207 [](uint64_t v) { SNES::ppu.regs.window2_enabled[2] = v; }, true},
208 {"ppu_window2_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.window2_enabled[3]; },
209 [](uint64_t v) { SNES::ppu.regs.window2_enabled[3] = v; }, true},
210 {"ppu_window2_enabled[4]", []() -> uint64_t { return SNES::ppu.regs.window2_enabled[4]; },
211 [](uint64_t v) { SNES::ppu.regs.window2_enabled[4] = v; }, true},
212 {"ppu_window2_enabled[5]", []() -> uint64_t { return SNES::ppu.regs.window2_enabled[5]; },
213 [](uint64_t v) { SNES::ppu.regs.window2_enabled[5] = v; }, true},
214 {"ppu_window2_invert[0]", []() -> uint64_t { return SNES::ppu.regs.window2_invert[0]; },
215 [](uint64_t v) { SNES::ppu.regs.window2_invert[0] = v; }, true},
216 {"ppu_window2_invert[1]", []() -> uint64_t { return SNES::ppu.regs.window2_invert[1]; },
217 [](uint64_t v) { SNES::ppu.regs.window2_invert[1] = v; }, true},
218 {"ppu_window2_invert[2]", []() -> uint64_t { return SNES::ppu.regs.window2_invert[2]; },
219 [](uint64_t v) { SNES::ppu.regs.window2_invert[2] = v; }, true},
220 {"ppu_window2_invert[3]", []() -> uint64_t { return SNES::ppu.regs.window2_invert[3]; },
221 [](uint64_t v) { SNES::ppu.regs.window2_invert[3] = v; }, true},
222 {"ppu_window2_invert[4]", []() -> uint64_t { return SNES::ppu.regs.window2_invert[4]; },
223 [](uint64_t v) { SNES::ppu.regs.window2_invert[4] = v; }, true},
224 {"ppu_window2_invert[5]", []() -> uint64_t { return SNES::ppu.regs.window2_invert[5]; },
225 [](uint64_t v) { SNES::ppu.regs.window2_invert[5] = v; }, true},
226 {"ppu_bg_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.bg_enabled[0]; },
227 [](uint64_t v) { SNES::ppu.regs.bg_enabled[0] = v; }, true},
228 {"ppu_bg_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.bg_enabled[1]; },
229 [](uint64_t v) { SNES::ppu.regs.bg_enabled[1] = v; }, true},
230 {"ppu_bg_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.bg_enabled[2]; },
231 [](uint64_t v) { SNES::ppu.regs.bg_enabled[2] = v; }, true},
232 {"ppu_bg_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.bg_enabled[3]; },
233 [](uint64_t v) { SNES::ppu.regs.bg_enabled[3] = v; }, true},
234 {"ppu_bg_enabled[4]", []() -> uint64_t { return SNES::ppu.regs.bg_enabled[4]; },
235 [](uint64_t v) { SNES::ppu.regs.bg_enabled[4] = v; }, true},
236 {"ppu_bgsub_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.bgsub_enabled[0]; },
237 [](uint64_t v) { SNES::ppu.regs.bgsub_enabled[0] = v; }, true},
238 {"ppu_bgsub_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.bgsub_enabled[1]; },
239 [](uint64_t v) { SNES::ppu.regs.bgsub_enabled[1] = v; }, true},
240 {"ppu_bgsub_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.bgsub_enabled[2]; },
241 [](uint64_t v) { SNES::ppu.regs.bgsub_enabled[2] = v; }, true},
242 {"ppu_bgsub_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.bgsub_enabled[3]; },
243 [](uint64_t v) { SNES::ppu.regs.bgsub_enabled[3] = v; }, true},
244 {"ppu_bgsub_enabled[4]", []() -> uint64_t { return SNES::ppu.regs.bgsub_enabled[4]; },
245 [](uint64_t v) { SNES::ppu.regs.bgsub_enabled[4] = v; }, true},
246 {"ppu_window_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.window_enabled[0]; },
247 [](uint64_t v) { SNES::ppu.regs.window_enabled[0] = v; }, true},
248 {"ppu_window_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.window_enabled[1]; },
249 [](uint64_t v) { SNES::ppu.regs.window_enabled[1] = v; }, true},
250 {"ppu_window_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.window_enabled[2]; },
251 [](uint64_t v) { SNES::ppu.regs.window_enabled[2] = v; }, true},
252 {"ppu_window_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.window_enabled[3]; },
253 [](uint64_t v) { SNES::ppu.regs.window_enabled[3] = v; }, true},
254 {"ppu_window_enabled[4]", []() -> uint64_t { return SNES::ppu.regs.window_enabled[4]; },
255 [](uint64_t v) { SNES::ppu.regs.window_enabled[4] = v; }, true},
256 {"ppu_sub_window_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.sub_window_enabled[0]; },
257 [](uint64_t v) { SNES::ppu.regs.sub_window_enabled[0] = v; }, true},
258 {"ppu_sub_window_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.sub_window_enabled[1]; },
259 [](uint64_t v) { SNES::ppu.regs.sub_window_enabled[1] = v; }, true},
260 {"ppu_sub_window_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.sub_window_enabled[2]; },
261 [](uint64_t v) { SNES::ppu.regs.sub_window_enabled[2] = v; }, true},
262 {"ppu_sub_window_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.sub_window_enabled[3]; },
263 [](uint64_t v) { SNES::ppu.regs.sub_window_enabled[3] = v; }, true},
264 {"ppu_sub_window_enabled[4]", []() -> uint64_t { return SNES::ppu.regs.sub_window_enabled[4]; },
265 [](uint64_t v) { SNES::ppu.regs.sub_window_enabled[4] = v; }, true},
266 {"ppu_addsub_mode", []() -> uint64_t { return SNES::ppu.regs.addsub_mode; },
267 [](uint64_t v) { SNES::ppu.regs.addsub_mode = v; }, true},
268 {"ppu_direct_color", []() -> uint64_t { return SNES::ppu.regs.direct_color; },
269 [](uint64_t v) { SNES::ppu.regs.direct_color = v; }, true},
270 {"ppu_color_mode", []() -> uint64_t { return SNES::ppu.regs.color_mode; },
271 [](uint64_t v) { SNES::ppu.regs.color_mode = v; }, true},
272 {"ppu_color_halve", []() -> uint64_t { return SNES::ppu.regs.color_halve; },
273 [](uint64_t v) { SNES::ppu.regs.color_halve = v; }, true},
274 {"ppu_color_enabled[0]", []() -> uint64_t { return SNES::ppu.regs.color_enabled[0]; },
275 [](uint64_t v) { SNES::ppu.regs.color_enabled[0] = v; }, true},
276 {"ppu_color_enabled[1]", []() -> uint64_t { return SNES::ppu.regs.color_enabled[1]; },
277 [](uint64_t v) { SNES::ppu.regs.color_enabled[1] = v; }, true},
278 {"ppu_color_enabled[2]", []() -> uint64_t { return SNES::ppu.regs.color_enabled[2]; },
279 [](uint64_t v) { SNES::ppu.regs.color_enabled[2] = v; }, true},
280 {"ppu_color_enabled[3]", []() -> uint64_t { return SNES::ppu.regs.color_enabled[3]; },
281 [](uint64_t v) { SNES::ppu.regs.color_enabled[3] = v; }, true},
282 {"ppu_color_enabled[4]", []() -> uint64_t { return SNES::ppu.regs.color_enabled[4]; },
283 [](uint64_t v) { SNES::ppu.regs.color_enabled[4] = v; }, true},
284 {"ppu_color_enabled[5]", []() -> uint64_t { return SNES::ppu.regs.color_enabled[5]; },
285 [](uint64_t v) { SNES::ppu.regs.color_enabled[5] = v; }, true},
286 {"ppu_mode7_extbg", []() -> uint64_t { return SNES::ppu.regs.mode7_extbg; },
287 [](uint64_t v) { SNES::ppu.regs.mode7_extbg = v; }, true},
288 {"ppu_pseudo_hires", []() -> uint64_t { return SNES::ppu.regs.pseudo_hires; },
289 [](uint64_t v) { SNES::ppu.regs.pseudo_hires = v; }, true},
290 {"ppu_overscan", []() -> uint64_t { return SNES::ppu.regs.overscan; },
291 [](uint64_t v) { SNES::ppu.regs.overscan = v; }, true},
292 {"ppu_oam_interlace", []() -> uint64_t { return SNES::ppu.regs.oam_interlace; },
293 [](uint64_t v) { SNES::ppu.regs.oam_interlace = v; }, true},
294 {"ppu_interlace", []() -> uint64_t { return SNES::ppu.regs.interlace; },
295 [](uint64_t v) { SNES::ppu.regs.interlace = v; }, true},
296 {"ppu_latch_hcounter", []() -> uint64_t { return SNES::ppu.regs.latch_hcounter; },
297 [](uint64_t v) { SNES::ppu.regs.latch_hcounter = v; }, true},
298 {"ppu_latch_vcounter", []() -> uint64_t { return SNES::ppu.regs.latch_vcounter; },
299 [](uint64_t v) { SNES::ppu.regs.latch_vcounter = v; }, true},
300 {"ppu_counters_latched", []() -> uint64_t { return SNES::ppu.regs.counters_latched; },
301 [](uint64_t v) { SNES::ppu.regs.counters_latched = v; }, true},
302 {"ppu_time_over", []() -> uint64_t { return SNES::ppu.regs.time_over; },
303 [](uint64_t v) { SNES::ppu.regs.time_over = v; }, true},
304 {"ppu_range_over", []() -> uint64_t { return SNES::ppu.regs.range_over; },
305 [](uint64_t v) { SNES::ppu.regs.range_over = v; }, true},
306 {"ppu_ppu1_mdr", []() -> uint64_t { return SNES::ppu.regs.ppu1_mdr; },
307 [](uint64_t v) { SNES::ppu.regs.ppu1_mdr = v; }},
308 {"ppu_ppu2_mdr", []() -> uint64_t { return SNES::ppu.regs.ppu2_mdr; },
309 [](uint64_t v) { SNES::ppu.regs.ppu2_mdr = v; }},
310 {"ppu_bg_y[0]", []() -> uint64_t { return SNES::ppu.regs.bg_y[0]; },
311 [](uint64_t v) { SNES::ppu.regs.bg_y[0] = v; }},
312 {"ppu_bg_y[1]", []() -> uint64_t { return SNES::ppu.regs.bg_y[1]; },
313 [](uint64_t v) { SNES::ppu.regs.bg_y[1] = v; }},
314 {"ppu_bg_y[2]", []() -> uint64_t { return SNES::ppu.regs.bg_y[2]; },
315 [](uint64_t v) { SNES::ppu.regs.bg_y[2] = v; }},
316 {"ppu_bg_y[3]", []() -> uint64_t { return SNES::ppu.regs.bg_y[3]; },
317 [](uint64_t v) { SNES::ppu.regs.bg_y[3] = v; }},
318 {"ppu_ioamaddr", []() -> uint64_t { return SNES::ppu.regs.ioamaddr; },
319 [](uint64_t v) { SNES::ppu.regs.ioamaddr = v; }},
320 {"ppu_icgramaddr", []() -> uint64_t { return SNES::ppu.regs.icgramaddr; },
321 [](uint64_t v) { SNES::ppu.regs.icgramaddr = v; }},
322 {"ppu_display_brightness", []() -> uint64_t { return SNES::ppu.regs.display_brightness; },
323 [](uint64_t v) { SNES::ppu.regs.display_brightness = v; }},
324 {"ppu_oam_basesize", []() -> uint64_t { return SNES::ppu.regs.oam_basesize; },
325 [](uint64_t v) { SNES::ppu.regs.oam_basesize = v; }},
326 {"ppu_oam_nameselect", []() -> uint64_t { return SNES::ppu.regs.oam_nameselect; },
327 [](uint64_t v) { SNES::ppu.regs.oam_nameselect = v; }},
328 {"ppu_oam_tdaddr", []() -> uint64_t { return SNES::ppu.regs.oam_tdaddr; },
329 [](uint64_t v) { SNES::ppu.regs.oam_tdaddr = v; }},
330 {"ppu_oam_baseaddr", []() -> uint64_t { return SNES::ppu.regs.oam_baseaddr; },
331 [](uint64_t v) { SNES::ppu.regs.oam_baseaddr = v; }},
332 {"ppu_oam_addr", []() -> uint64_t { return SNES::ppu.regs.oam_addr; },
333 [](uint64_t v) { SNES::ppu.regs.oam_addr = v; }},
334 {"ppu_oam_firstsprite", []() -> uint64_t { return SNES::ppu.regs.oam_firstsprite; },
335 [](uint64_t v) { SNES::ppu.regs.oam_firstsprite = v; }},
336 {"ppu_oam_latchdata", []() -> uint64_t { return SNES::ppu.regs.oam_latchdata; },
337 [](uint64_t v) { SNES::ppu.regs.oam_latchdata = v; }},
338 {"ppu_bg_mode", []() -> uint64_t { return SNES::ppu.regs.bg_mode; },
339 [](uint64_t v) { SNES::ppu.regs.bg_mode = v; }},
340 {"ppu_mosaic_size", []() -> uint64_t { return SNES::ppu.regs.mosaic_size; },
341 [](uint64_t v) { SNES::ppu.regs.mosaic_size = v; }},
342 {"ppu_mosaic_countdown", []() -> uint64_t { return SNES::ppu.regs.mosaic_countdown; },
343 [](uint64_t v) { SNES::ppu.regs.mosaic_countdown = v; }},
344 {"ppu_bg_scaddr[0]", []() -> uint64_t { return SNES::ppu.regs.bg_scaddr[0]; },
345 [](uint64_t v) { SNES::ppu.regs.bg_scaddr[0] = v; }},
346 {"ppu_bg_scaddr[1]", []() -> uint64_t { return SNES::ppu.regs.bg_scaddr[1]; },
347 [](uint64_t v) { SNES::ppu.regs.bg_scaddr[1] = v; }},
348 {"ppu_bg_scaddr[2]", []() -> uint64_t { return SNES::ppu.regs.bg_scaddr[2]; },
349 [](uint64_t v) { SNES::ppu.regs.bg_scaddr[2] = v; }},
350 {"ppu_bg_scaddr[3]", []() -> uint64_t { return SNES::ppu.regs.bg_scaddr[3]; },
351 [](uint64_t v) { SNES::ppu.regs.bg_scaddr[3] = v; }},
352 {"ppu_bg_scsize[0]", []() -> uint64_t { return SNES::ppu.regs.bg_scsize[0]; },
353 [](uint64_t v) { SNES::ppu.regs.bg_scsize[0] = v; }},
354 {"ppu_bg_scsize[1]", []() -> uint64_t { return SNES::ppu.regs.bg_scsize[1]; },
355 [](uint64_t v) { SNES::ppu.regs.bg_scsize[1] = v; }},
356 {"ppu_bg_scsize[2]", []() -> uint64_t { return SNES::ppu.regs.bg_scsize[2]; },
357 [](uint64_t v) { SNES::ppu.regs.bg_scsize[2] = v; }},
358 {"ppu_bg_scsize[3]", []() -> uint64_t { return SNES::ppu.regs.bg_scsize[3]; },
359 [](uint64_t v) { SNES::ppu.regs.bg_scsize[3] = v; }},
360 {"ppu_bg_tdaddr[0]", []() -> uint64_t { return SNES::ppu.regs.bg_tdaddr[0]; },
361 [](uint64_t v) { SNES::ppu.regs.bg_tdaddr[0] = v; }},
362 {"ppu_bg_tdaddr[1]", []() -> uint64_t { return SNES::ppu.regs.bg_tdaddr[1]; },
363 [](uint64_t v) { SNES::ppu.regs.bg_tdaddr[1] = v; }},
364 {"ppu_bg_tdaddr[2]", []() -> uint64_t { return SNES::ppu.regs.bg_tdaddr[2]; },
365 [](uint64_t v) { SNES::ppu.regs.bg_tdaddr[2] = v; }},
366 {"ppu_bg_tdaddr[3]", []() -> uint64_t { return SNES::ppu.regs.bg_tdaddr[3]; },
367 [](uint64_t v) { SNES::ppu.regs.bg_tdaddr[3] = v; }},
368 {"ppu_bg_ofslatch", []() -> uint64_t { return SNES::ppu.regs.bg_ofslatch; },
369 [](uint64_t v) { SNES::ppu.regs.bg_ofslatch = v; }},
370 {"ppu_m7_hofs", []() -> uint64_t { return SNES::ppu.regs.m7_hofs; },
371 [](uint64_t v) { SNES::ppu.regs.m7_hofs = v; }},
372 {"ppu_m7_vofs", []() -> uint64_t { return SNES::ppu.regs.m7_vofs; },
373 [](uint64_t v) { SNES::ppu.regs.m7_vofs = v; }},
374 {"ppu_bg_hofs[0]", []() -> uint64_t { return SNES::ppu.regs.bg_hofs[0]; },
375 [](uint64_t v) { SNES::ppu.regs.bg_hofs[0] = v; }},
376 {"ppu_bg_hofs[1]", []() -> uint64_t { return SNES::ppu.regs.bg_hofs[1]; },
377 [](uint64_t v) { SNES::ppu.regs.bg_hofs[1] = v; }},
378 {"ppu_bg_hofs[2]", []() -> uint64_t { return SNES::ppu.regs.bg_hofs[2]; },
379 [](uint64_t v) { SNES::ppu.regs.bg_hofs[2] = v; }},
380 {"ppu_bg_hofs[3]", []() -> uint64_t { return SNES::ppu.regs.bg_hofs[3]; },
381 [](uint64_t v) { SNES::ppu.regs.bg_hofs[3] = v; }},
382 {"ppu_bg_vofs[0]", []() -> uint64_t { return SNES::ppu.regs.bg_vofs[0]; },
383 [](uint64_t v) { SNES::ppu.regs.bg_vofs[0] = v; }},
384 {"ppu_bg_vofs[1]", []() -> uint64_t { return SNES::ppu.regs.bg_vofs[1]; },
385 [](uint64_t v) { SNES::ppu.regs.bg_vofs[1] = v; }},
386 {"ppu_bg_vofs[2]", []() -> uint64_t { return SNES::ppu.regs.bg_vofs[2]; },
387 [](uint64_t v) { SNES::ppu.regs.bg_vofs[2] = v; }},
388 {"ppu_bg_vofs[3]", []() -> uint64_t { return SNES::ppu.regs.bg_vofs[3]; },
389 [](uint64_t v) { SNES::ppu.regs.bg_vofs[3] = v; }},
390 {"ppu_vram_mapping", []() -> uint64_t { return SNES::ppu.regs.vram_mapping; },
391 [](uint64_t v) { SNES::ppu.regs.vram_mapping = v; }},
392 {"ppu_vram_incsize", []() -> uint64_t { return SNES::ppu.regs.vram_incsize; },
393 [](uint64_t v) { SNES::ppu.regs.vram_incsize = v; }},
394 {"ppu_vram_addr", []() -> uint64_t { return SNES::ppu.regs.vram_addr; },
395 [](uint64_t v) { SNES::ppu.regs.vram_addr = v; }},
396 {"ppu_mode7_repeat", []() -> uint64_t { return SNES::ppu.regs.mode7_repeat; },
397 [](uint64_t v) { SNES::ppu.regs.mode7_repeat = v; }},
398 {"ppu_m7_latch", []() -> uint64_t { return SNES::ppu.regs.m7_latch; },
399 [](uint64_t v) { SNES::ppu.regs.m7_latch = v; }},
400 {"ppu_m7a", []() -> uint64_t { return SNES::ppu.regs.m7a; },
401 [](uint64_t v) { SNES::ppu.regs.m7a = v; }},
402 {"ppu_m7b", []() -> uint64_t { return SNES::ppu.regs.m7b; },
403 [](uint64_t v) { SNES::ppu.regs.m7b = v; }},
404 {"ppu_m7c", []() -> uint64_t { return SNES::ppu.regs.m7c; },
405 [](uint64_t v) { SNES::ppu.regs.m7c = v; }},
406 {"ppu_m7d", []() -> uint64_t { return SNES::ppu.regs.m7d; },
407 [](uint64_t v) { SNES::ppu.regs.m7d = v; }},
408 {"ppu_m7x", []() -> uint64_t { return SNES::ppu.regs.m7x; },
409 [](uint64_t v) { SNES::ppu.regs.m7x = v; }},
410 {"ppu_m7y", []() -> uint64_t { return SNES::ppu.regs.m7y; },
411 [](uint64_t v) { SNES::ppu.regs.m7y = v; }},
412 {"ppu_cgram_addr", []() -> uint64_t { return SNES::ppu.regs.cgram_addr; },
413 [](uint64_t v) { SNES::ppu.regs.cgram_addr = v; }},
414 {"ppu_cgram_latchdata", []() -> uint64_t { return SNES::ppu.regs.cgram_latchdata; },
415 [](uint64_t v) { SNES::ppu.regs.cgram_latchdata = v; }},
416 {"ppu_window1_left", []() -> uint64_t { return SNES::ppu.regs.window1_left; },
417 [](uint64_t v) { SNES::ppu.regs.window1_left = v; }},
418 {"ppu_window1_right", []() -> uint64_t { return SNES::ppu.regs.window1_right; },
419 [](uint64_t v) { SNES::ppu.regs.window1_right = v; }},
420 {"ppu_window2_left", []() -> uint64_t { return SNES::ppu.regs.window2_left; },
421 [](uint64_t v) { SNES::ppu.regs.window2_left = v; }},
422 {"ppu_window2_right", []() -> uint64_t { return SNES::ppu.regs.window2_right; },
423 [](uint64_t v) { SNES::ppu.regs.window2_right = v; }},
424 {"ppu_window_mask[0]", []() -> uint64_t { return SNES::ppu.regs.window_mask[0]; },
425 [](uint64_t v) { SNES::ppu.regs.window_mask[0] = v; }},
426 {"ppu_window_mask[1]", []() -> uint64_t { return SNES::ppu.regs.window_mask[1]; },
427 [](uint64_t v) { SNES::ppu.regs.window_mask[1] = v; }},
428 {"ppu_window_mask[2]", []() -> uint64_t { return SNES::ppu.regs.window_mask[2]; },
429 [](uint64_t v) { SNES::ppu.regs.window_mask[2] = v; }},
430 {"ppu_window_mask[3]", []() -> uint64_t { return SNES::ppu.regs.window_mask[3]; },
431 [](uint64_t v) { SNES::ppu.regs.window_mask[3] = v; }},
432 {"ppu_window_mask[4]", []() -> uint64_t { return SNES::ppu.regs.window_mask[4]; },
433 [](uint64_t v) { SNES::ppu.regs.window_mask[4] = v; }},
434 {"ppu_window_mask[5]", []() -> uint64_t { return SNES::ppu.regs.window_mask[5]; },
435 [](uint64_t v) { SNES::ppu.regs.window_mask[5] = v; }},
436 {"ppu_color_mask", []() -> uint64_t { return SNES::ppu.regs.color_mask; },
437 [](uint64_t v) { SNES::ppu.regs.color_mask = v; }},
438 {"ppu_colorsub_mask", []() -> uint64_t { return SNES::ppu.regs.colorsub_mask; },
439 [](uint64_t v) { SNES::ppu.regs.colorsub_mask = v; }},
440 {"ppu_color_r", []() -> uint64_t { return SNES::ppu.regs.color_r; },
441 [](uint64_t v) { SNES::ppu.regs.color_r = v; }},
442 {"ppu_color_g", []() -> uint64_t { return SNES::ppu.regs.color_g; },
443 [](uint64_t v) { SNES::ppu.regs.color_g = v; }},
444 {"ppu_color_b", []() -> uint64_t { return SNES::ppu.regs.color_b; },
445 [](uint64_t v) { SNES::ppu.regs.color_b = v; }},
446 {"ppu_color_rgb", []() -> uint64_t { return SNES::ppu.regs.color_rgb; },
447 [](uint64_t v) { SNES::ppu.regs.color_rgb = v; }},
448 {"ppu_scanlines", []() -> uint64_t { return SNES::ppu.regs.scanlines; },
449 [](uint64_t v) { SNES::ppu.regs.scanlines = v; }},
450 {"ppu_hcounter", []() -> uint64_t { return SNES::ppu.regs.hcounter; },
451 [](uint64_t v) { SNES::ppu.regs.hcounter = v; }},
452 {"ppu_vcounter", []() -> uint64_t { return SNES::ppu.regs.vcounter; },
453 [](uint64_t v) { SNES::ppu.regs.vcounter = v; }},
454 {"ppu_vram_readbuffer", []() -> uint64_t { return SNES::ppu.regs.vram_readbuffer; },
455 [](uint64_t v) { SNES::ppu.regs.vram_readbuffer = v; }},
456 {"ppu_oam_itemcount", []() -> uint64_t { return SNES::ppu.regs.oam_itemcount; },
457 [](uint64_t v) { SNES::ppu.regs.oam_itemcount = v; }},
458 {"ppu_oam_tilecount", []() -> uint64_t { return SNES::ppu.regs.oam_tilecount; },
459 [](uint64_t v) { SNES::ppu.regs.oam_tilecount = v; }},
460 #endif
461 //TODO: SMP registers, DSP registers, chip registers.
462 {NULL, NULL, NULL}
463 };
464
465 #include "ports.inc"
466
467 core_region region_auto{{"autodetect", "Autodetect", 1, 0, true, {178683, 10738636}, {0,1,2}}};
468 core_region region_pal{{"pal", "PAL", 0, 2, false, {6448, 322445}, {2}}};
469 core_region region_ntsc{{"ntsc", "NTSC", 0, 1, false, {178683, 10738636}, {1}}};
470
471 std::vector<core_setting_value_param> boolean_values = {{"0", "False", 0}, {"1", "True", 1}};
472 core_setting_group bsnes_settings = {
473 {"port1", "Port 1 Type", "gamepad", {
474 {"none", "None", 0},
475 {"gamepad", "Gamepad", 1},
476 {"gamepad16", "Gamepad (16-button)", 2},
477 {"ygamepad16", "Y-cabled gamepad (16-button)", 9},
478 {"multitap", "Multitap", 3},
479 {"multitap16", "Multitap (16-button)", 4},
480 {"mouse", "Mouse", 5}
481 }},
482 {"port2", "Port 2 Type", "none", {
483 {"none", "None", 0},
484 {"gamepad", "Gamepad", 1},
485 {"gamepad16", "Gamepad (16-button)", 2},
486 {"ygamepad16", "Y-cabled gamepad (16-button)", 9},
487 {"multitap", "Multitap", 3},
488 {"multitap16", "Multitap (16-button)", 4},
489 {"mouse", "Mouse", 5},
490 {"superscope", "Super Scope", 8},
491 {"justifier", "Justifier", 6},
492 {"justifiers", "2 Justifiers", 7}
493 }},
494 {"hardreset", "Support hard resets", "0", boolean_values},
495 {"saveevery", "Emulate saving each frame", "0", boolean_values},
496 {"radominit", "Random initial state", "0", boolean_values},
497 {"compact", "Don't support delayed resets", "0", boolean_values},
498 #ifdef BSNES_SUPPORTS_ALT_TIMINGS
499 {"alttimings", "Alternate poll timings", "0", boolean_values},
500 #endif
501 };
502
503 ////////////////// PORTS COMMON ///////////////////
504 port_type* index_to_ptype[] = {
505 &none, &gamepad, &gamepad16, &multitap, &multitap16, &mouse, &justifier, &justifiers, &superscope,
506 &ygamepad16
507 };
508 unsigned index_to_bsnes_type[] = {
509 SNES_DEVICE_NONE, SNES_DEVICE_JOYPAD, SNES_DEVICE_JOYPAD, SNES_DEVICE_MULTITAP, SNES_DEVICE_MULTITAP,
510 SNES_DEVICE_MOUSE, SNES_DEVICE_JUSTIFIER, SNES_DEVICE_JUSTIFIERS, SNES_DEVICE_SUPER_SCOPE,
511 SNES_DEVICE_JOYPAD
512 };
513
514 bool port_is_ycable[2];
515
516 void snesdbg_on_break();
517 void snesdbg_on_trace();
518 std::pair<int, uint64_t> recognize_address(uint64_t addr);
519
520 class my_interfaced : public SNES::Interface
521 {
522 string path(SNES::Cartridge::Slot slot, const string &hint)
523 {
524 return "./";
525 }
526 };
527
528 void basic_init()
529 {
530 static bool done = false;
531 if(done)
532 return;
533 done = true;
534 static my_interfaced i;
535 SNES::interface = &i;
536 }
537
538 core_type* internal_rom = NULL;
539
540 template<bool(*T)(const char*,const unsigned char*, unsigned)>
541 bool load_rom_X1(core_romimage* img)
542 {
543 return T(img[0].markup, img[0].data, img[0].size);
544 }
545
546 template<bool(*T)(const char*,const unsigned char*, unsigned, const char*,const unsigned char*, unsigned)>
547 bool load_rom_X2(core_romimage* img)
548 {
549 return T(img[0].markup, img[0].data, img[0].size,
550 img[1].markup, img[1].data, img[1].size);
551 }
552
553 template<bool(*T)(const char*,const unsigned char*, unsigned, const char*,const unsigned char*, unsigned,
554 const char*,const unsigned char*, unsigned)>
555 bool load_rom_X3(core_romimage* img)
556 {
557 return T(img[0].markup, img[0].data, img[0].size,
558 img[1].markup, img[1].data, img[1].size,
559 img[2].markup, img[2].data, img[2].size);
560 }
561
562
563 int load_rom(core_type* ctype, core_romimage* img, std::map<std::string, std::string>& settings,
564 uint64_t secs, uint64_t subsecs, bool(*fun)(core_romimage*))
565 {
566 std::map<std::string, std::string> _settings = settings;
567 bsnes_settings.fill_defaults(_settings);
568 signed type1 = bsnes_settings.ivalue_to_index(_settings, "port1");
569 signed type2 = bsnes_settings.ivalue_to_index(_settings, "port2");
570 signed hreset = bsnes_settings.ivalue_to_index(_settings, "hardreset");
571 signed compact = bsnes_settings.ivalue_to_index(_settings, "compact");
572 signed esave = bsnes_settings.ivalue_to_index(_settings, "saveevery");
573 signed irandom = bsnes_settings.ivalue_to_index(_settings, "radominit");
574 #ifdef BSNES_SUPPORTS_ALT_TIMINGS
575 signed ialttimings = bsnes_settings.ivalue_to_index(_settings, "alttimings");
576 #endif
577
578 basic_init();
579 snes_term();
580 snes_unload_cartridge();
581 SNES::config.random = (irandom != 0);
582 save_every_frame = (esave != 0);
583 support_hreset = (hreset != 0 || compact != 0);
584 support_dreset = (compact == 0);
585 SNES::config.expansion_port = SNES::System::ExpansionPortDevice::None;
586 #ifdef BSNES_SUPPORTS_ALT_TIMINGS
587 SNES::config.cpu.alt_poll_timings = (ialttimings != 0);
588 #endif
589 bool r = fun(img);
590 if(r) {
591 internal_rom = ctype;
592 snes_set_controller_port_device(false, index_to_bsnes_type[type1]);
593 snes_set_controller_port_device(true, index_to_bsnes_type[type2]);
594 port_is_ycable[0] = (type1 == 9);
595 port_is_ycable[1] = (type2 == 9);
596 have_saved_this_frame = false;
597 do_reset_flag = -1;
598 if(ecore_callbacks)
599 ecore_callbacks->action_state_updated();
600 }
601 return r ? 0 : -1;
602 }
603
604 controller_set bsnes_controllerconfig(std::map<std::string, std::string>& settings)
605 {
606 std::map<std::string, std::string> _settings = settings;
607 bsnes_settings.fill_defaults(_settings);
608 signed type1 = bsnes_settings.ivalue_to_index(_settings, "port1");
609 signed type2 = bsnes_settings.ivalue_to_index(_settings, "port2");
610 signed hreset = bsnes_settings.ivalue_to_index(_settings, "hardreset");
611 signed compact = bsnes_settings.ivalue_to_index(_settings, "compact");
612 controller_set r;
613 if(compact)
614 r.ports.push_back(&psystem_compact);
615 else if(hreset)
616 r.ports.push_back(&psystem_hreset);
617 else
618 r.ports.push_back(&psystem);
619 r.ports.push_back(index_to_ptype[type1]);
620 r.ports.push_back(index_to_ptype[type2]);
621 unsigned p1controllers = r.ports[1]->controller_info->controllers.size();
622 unsigned p2controllers = r.ports[2]->controller_info->controllers.size();
623 r.logical_map.resize(p1controllers + p2controllers);
624 if(p1controllers == 4) {
625 r.logical_map[0] = std::make_pair(1, 0);
626 for(size_t j = 0; j < p2controllers; j++)
627 r.logical_map[j + 1] = std::make_pair(2U, j);
628 for(size_t j = 1; j < p1controllers; j++)
629 r.logical_map[j + p2controllers] = std::make_pair(1U, j);
630 } else {
631 for(size_t j = 0; j < p1controllers; j++)
632 r.logical_map[j] = std::make_pair(1, j);
633 for(size_t j = 0; j < p2controllers; j++)
634 r.logical_map[j + p1controllers] = std::make_pair(2U, j);
635 }
636 return r;
637 }
638
639 class my_interface : public SNES::Interface
640 {
641 string path(SNES::Cartridge::Slot slot, const string &hint)
642 {
643 const char* _hint = hint;
644 std::string _hint2 = _hint;
645 std::string fwp = ecore_callbacks->get_firmware_path();
646 regex_results r;
647 std::string msubase = ecore_callbacks->get_base_path();
648 if(regex_match(".*\\.sfc", msubase))
649 msubase = msubase.substr(0, msubase.length() - 4);
650
651 if(_hint2 == "msu1.rom" || _hint2 == ".msu") {
652 //MSU-1 main ROM.
653 std::string x = msubase + ".msu";
654 messages << "MSU main data file: " << x << std::endl;
655 return x.c_str();
656 }
657 if(r = regex("(track)?(-([0-9])+\\.pcm)", _hint2)) {
658 //MSU track.
659 std::string x = msubase + r[2];
660 messages << "MSU track " << r[3] << "': " << x << std::endl;
661 return x.c_str();
662 }
663 std::string finalpath = fwp + "/" + _hint2;
664 return finalpath.c_str();
665 }
666
667 time_t currentTime()
668 {
669 return ecore_callbacks->get_time();
670 }
671
672 time_t randomSeed()
673 {
674 return ecore_callbacks->get_randomseed();
675 }
676
677 void notifyLatched()
678 {
679 std::list<std::string> dummy;
680 ecore_callbacks->notify_latch(dummy);
681 }
682
683 void videoRefresh(const uint32_t* data, bool hires, bool interlace, bool overscan);
684
685 void audioSample(int16_t l_sample, int16_t r_sample)
686 {
687 uint16_t _l = l_sample;
688 uint16_t _r = r_sample;
689 soundbuf[soundbuf_fill++] = l_sample;
690 soundbuf[soundbuf_fill++] = r_sample;
691 //The SMP emits a sample every 768 ticks of its clock. Use this in order to keep track of
692 //time.
693 ecore_callbacks->timer_tick(768, SNES::system.apu_frequency());
694 }
695
696 int16_t inputPoll(bool port, SNES::Input::Device device, unsigned index, unsigned id)
697 {
698 if(port_is_ycable[port ? 1 : 0]) {
699 int16_t bit0 = ecore_callbacks->get_input(port ? 2 : 1, 0, id);
700 int16_t bit1 = ecore_callbacks->get_input(port ? 2 : 1, 1, id);
701 return bit0 + 2 * bit1;
702 }
703 int16_t offset = 0;
704 //The superscope/justifier handling is nuts.
705 if(port && SNES::input.port2) {
706 SNES::SuperScope* ss = dynamic_cast<SNES::SuperScope*>(SNES::input.port2);
707 SNES::Justifier* js = dynamic_cast<SNES::Justifier*>(SNES::input.port2);
708 if(ss && index == 0) {
709 if(id == 0)
710 offset = ss->x;
711 if(id == 1)
712 offset = ss->y;
713 }
714 if(js && index == 0) {
715 if(id == 0)
716 offset = js->player1.x;
717 if(id == 1)
718 offset = js->player1.y;
719 }
720 if(js && js->chained && index == 1) {
721 if(id == 0)
722 offset = js->player2.x;
723 if(id == 1)
724 offset = js->player2.y;
725 }
726 }
727 return ecore_callbacks->get_input(port ? 2 : 1, index, id) - offset;
728 }
729 } my_interface_obj;
730
731 bool trace_fn()
732 {
733 #ifdef BSNES_HAS_DEBUGGER
734 if(trace_counter && !--trace_counter) {
735 //Trace counter did transition 1->0. Call the hook.
736 snesdbg_on_trace();
737 }
738 if(trace_cpu_enable) {
739 char buffer[1024];
740 SNES::cpu.disassemble_opcode(buffer, SNES::cpu.regs.pc);
741 ecore_callbacks->memory_trace(0, buffer);
742 }
743 return false;
744 #endif
745 }
746 bool smp_trace_fn()
747 {
748 #ifdef BSNES_HAS_DEBUGGER
749 if(trace_smp_enable) {
750 nall::string _disasm = SNES::smp.disassemble_opcode(SNES::smp.regs.pc);
751 std::string disasm(_disasm, _disasm.length());
752 ecore_callbacks->memory_trace(1, disasm.c_str());
753 }
754 return false;
755 #endif
756 }
757 bool delayreset_fn()
758 {
759 trace_fn(); //Call this also.
760 if(delayreset_cycles_run == delayreset_cycles_target || video_refresh_done)
761 return true;
762 delayreset_cycles_run++;
763 return false;
764 }
765
766
767 bool trace_enabled()
768 {
769 return (trace_counter || !!trace_cpu_enable);
770 }
771
772 void update_trace_hook_state()
773 {
774 if(forced_hook)
775 return;
776 #ifdef BSNES_HAS_DEBUGGER
777 if(!trace_enabled())
778 SNES::cpu.step_event = nall::function<bool()>();
779 else
780 SNES::cpu.step_event = trace_fn;
781 if(!trace_smp_enable)
782 SNES::smp.step_event = nall::function<bool()>();
783 else
784 SNES::smp.step_event = smp_trace_fn;
785 #endif
786 }
787
788 std::string sram_name(const nall::string& _id, SNES::Cartridge::Slot slotname)
789 {
790 std::string id(_id, _id.length());
791 //Fixup name change by bsnes v087...
792 if(id == "bsx.ram")
793 id = ".bss";
794 if(id == "bsx.psram")
795 id = ".bsp";
796 if(id == "program.rtc")
797 id = ".rtc";
798 if(id == "upd96050.ram")
799 id = ".dsp";
800 if(id == "program.ram")
801 id = ".srm";
802 if(slotname == SNES::Cartridge::Slot::SufamiTurboA)
803 return "slota." + id.substr(1);
804 if(slotname == SNES::Cartridge::Slot::SufamiTurboB)
805 return "slotb." + id.substr(1);
806 return id.substr(1);
807 }
808
809 uint8_t snes_bus_iospace_rw(uint64_t offset, uint8_t data, bool write)
810 {
811 uint8_t val = 0;
812 disable_breakpoints = true;
813 if(write)
814 SNES::bus.write(offset, data);
815 else
816 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS
817 val = SNES::bus.read(offset, false);
818 #else
819 val = SNES::bus.read(offset);
820 #endif
821 disable_breakpoints = false;
822 return val;
823 }
824
825 uint8_t ptrtable_iospace_rw(uint64_t offset, uint8_t data, bool write)
826 {
827 uint16_t entry = offset >> 4;
828 if(!ptrmap.count(entry))
829 return 0;
830 uint64_t val = ((offset & 15) < 8) ? ptrmap[entry].first : ptrmap[entry].second;
831 uint8_t byte = offset & 7;
832 //These things are always little-endian.
833 return (val >> (8 * byte));
834 }
835
836 void create_region(std::list<core_vma_info>& inf, const std::string& name, uint64_t base, uint64_t size,
837 uint8_t (*iospace_rw)(uint64_t offset, uint8_t data, bool write)) throw(std::bad_alloc)
838 {
839 if(size == 0)
840 return;
841 core_vma_info i;
842 i.name = name;
843 i.base = base;
844 i.size = size;
845 i.endian = -1;
846 i.iospace_rw = iospace_rw;
847 inf.push_back(i);
848 }
849
850 void create_region(std::list<core_vma_info>& inf, const std::string& name, uint64_t base, uint8_t* memory,
851 uint64_t size, bool readonly, bool native_endian = false) throw(std::bad_alloc)
852 {
853 if(size == 0)
854 return;
855 core_vma_info i;
856 i.name = name;
857 i.base = base;
858 i.size = size;
859 i.backing_ram = memory;
860 i.readonly = readonly;
861 i.endian = native_endian ? 0 : -1;
862 i.volatile_flag = true;
863 //SRAMs aren't volatile.
864 for(unsigned j = 0; j < SNES::cartridge.nvram.size(); j++) {
865 SNES::Cartridge::NonVolatileRAM& r = SNES::cartridge.nvram[j];
866 if(r.data == memory)
867 i.volatile_flag = false;
868 }
869 inf.push_back(i);
870 }
871
872 void create_region(std::list<core_vma_info>& inf, const std::string& name, uint64_t base,
873 SNES::MappedRAM& memory, bool readonly, bool native_endian = false) throw(std::bad_alloc)
874 {
875 create_region(inf, name, base, memory.data(), memory.size(), readonly, native_endian);
876 }
877
878 void map_internal(std::list<core_vma_info>& inf, const std::string& name, uint16_t index, void* memory,
879 size_t memsize)
880 {
881 ptrmap[index] = std::make_pair(reinterpret_cast<uint64_t>(memory), static_cast<uint64_t>(memsize));
882 create_region(inf, name, 0x101000000 + index * 0x1000000, reinterpret_cast<uint8_t*>(memory),
883 memsize, true, true);
884 }
885
886 std::list<core_vma_info> get_VMAlist();
887 std::set<std::string> bsnes_srams()
888 {
889 std::set<std::string> r;
890 if(!internal_rom)
891 return r;
892 for(unsigned i = 0; i < SNES::cartridge.nvram.size(); i++) {
893 SNES::Cartridge::NonVolatileRAM& s = SNES::cartridge.nvram[i];
894 r.insert(sram_name(s.id, s.slot));
895 }
896 return r;
897 }
898
899 uint64_t translate_class_address(uint8_t clazz, unsigned offset)
900 {
901 switch(clazz) {
902 case 1: //ROM.
903 return 0x80000000 + offset;
904 case 2: //SRAM.
905 return 0x10000000 + offset;
906 case 3: //WRAM
907 return 0x007E0000 + offset;
908 case 8: //SufamiTurboA ROM.
909 return 0x90000000 + offset;
910 case 9: //SufamiTurboB ROM.
911 return 0xA0000000 + offset;
912 case 10: //SufamiTurboA RAM.
913 return 0x20000000 + offset;
914 case 11: //SufamiTurboB RAM.
915 return 0x30000000 + offset;
916 case 12: //BSX flash.
917 return 0x90000000 + offset;
918 default: //Other, including bus.
919 return 0xFFFFFFFFFFFFFFFFULL;
920 }
921 }
922
923 void bsnes_debug_read(uint8_t clazz, unsigned offset, unsigned addr, uint8_t val, bool exec)
924 {
925 if(disable_breakpoints) return;
926 uint64_t _addr = translate_class_address(clazz, offset);
927 if(_addr != 0xFFFFFFFFFFFFFFFFULL) {
928 if(exec)
929 ecore_callbacks->memory_execute(_addr, 0);
930 else
931 ecore_callbacks->memory_read(_addr, val);
932 }
933 if(exec)
934 ecore_callbacks->memory_execute(0x1000000 + _addr, 0);
935 else
936 ecore_callbacks->memory_read(0x1000000 + _addr, val);
937 }
938
939 void bsnes_debug_write(uint8_t clazz, unsigned offset, unsigned addr, uint8_t val)
940 {
941 if(disable_breakpoints) return;
942 uint64_t _addr = translate_class_address(clazz, offset);
943 if(_addr != 0xFFFFFFFFFFFFFFFFULL)
944 ecore_callbacks->memory_write(_addr, val);
945 ecore_callbacks->memory_write(0x1000000 + _addr, val);
946 }
947
948 void redraw_cover_fbinfo();
949
950 struct _bsnes_core : public core_core
951 {
952 _bsnes_core() : core_core({&gamepad, &gamepad16, &justifier, &justifiers, &mouse, &multitap,
953 &multitap16, &none, &superscope, &psystem, &psystem_hreset, &psystem_compact}, {
954 {0, "Soft reset", "reset", {}},
955 {1, "Hard reset", "hardreset", {}},
956 #ifdef BSNES_HAS_DEBUGGER
957 {2, "Delayed soft reset", "delayreset", {
958 {"Delay","int:0,99999999"}
959 }},
960 {3, "Delayed hard reset", "delayhardreset", {
961 {"Delay","int:0,99999999"}
962 }},
963 #endif
964 #ifdef BSNES_IS_COMPAT
965 {4, "Layers‣BG1 Priority 0", "bg1pri0", {{"", "toggle"}}},
966 {5, "Layers‣BG1 Priority 1", "bg1pri1", {{"", "toggle"}}},
967 {8, "Layers‣BG2 Priority 0", "bg2pri0", {{"", "toggle"}}},
968 {9, "Layers‣BG2 Priority 1", "bg2pri1", {{"", "toggle"}}},
969 {12, "Layers‣BG3 Priority 0", "bg3pri0", {{"", "toggle"}}},
970 {13, "Layers‣BG3 Priority 1", "bg3pri1", {{"", "toggle"}}},
971 {16, "Layers‣BG4 Priority 0", "bg4pri0", {{"", "toggle"}}},
972 {17, "Layers‣BG4 Priority 1", "bg4pri1", {{"", "toggle"}}},
973 {20, "Layers‣Sprite Priority 0", "oampri0", {{"", "toggle"}}},
974 {21, "Layers‣Sprite Priority 1", "oampri1", {{"", "toggle"}}},
975 {22, "Layers‣Sprite Priority 2", "oampri2", {{"", "toggle"}}},
976 {23, "Layers‣Sprite Priority 3", "oampri3", {{"", "toggle"}}},
977 #endif
978 }) {}
979
980 std::string c_core_identifier() {
981 return (stringfmt() << snes_library_id() << " (" << SNES::Info::Profile << " core)").str();
982 }
983 bool c_set_region(core_region& region) {
984 if(&region == &region_auto)
985 SNES::config.region = SNES::System::Region::Autodetect;
986 else if(&region == &region_ntsc)
987 SNES::config.region = SNES::System::Region::NTSC;
988 else if(&region == &region_pal)
989 SNES::config.region = SNES::System::Region::PAL;
990 else
991 return false;
992 return true;
993 }
994 std::pair<uint32_t, uint32_t> c_video_rate() {
995 if(!internal_rom)
996 return std::make_pair(60, 1);
997 uint32_t div;
998 if(SNES::system.region() == SNES::System::Region::PAL)
999 div = last_interlace ? DURATION_PAL_FIELD : DURATION_PAL_FRAME;
1000 else
1001 div = last_interlace ? DURATION_NTSC_FIELD : DURATION_NTSC_FRAME;
1002 return std::make_pair(SNES::system.cpu_frequency(), div);
1003 }
1004 double c_get_PAR() {
1005 double base = (SNES::system.region() == SNES::System::Region::PAL) ? 1.25 : 1.146;
1006 return base;
1007 }
1008 std::pair<uint32_t, uint32_t> c_audio_rate() {
1009 if(!internal_rom)
1010 return std::make_pair(64081, 2);
1011 return std::make_pair(SNES::system.apu_frequency(), static_cast<uint32_t>(768));
1012 }
1013 std::map<std::string, std::vector<char>> c_save_sram() throw(std::bad_alloc) {
1014 std::map<std::string, std::vector<char>> out;
1015 if(!internal_rom)
1016 return out;
1017 for(unsigned i = 0; i < SNES::cartridge.nvram.size(); i++) {
1018 SNES::Cartridge::NonVolatileRAM& r = SNES::cartridge.nvram[i];
1019 std::string savename = sram_name(r.id, r.slot);
1020 std::vector<char> x;
1021 x.resize(r.size);
1022 memcpy(&x[0], r.data, r.size);
1023 out[savename] = x;
1024 }
1025 return out;
1026 }
1027 void c_load_sram(std::map<std::string, std::vector<char>>& sram) throw(std::bad_alloc) {
1028 std::set<std::string> used;
1029 if(!internal_rom) {
1030 for(auto i : sram)
1031 messages << "WARNING: SRAM '" << i.first << ": Not found on cartridge."
1032 << std::endl;
1033 return;
1034 }
1035 if(sram.empty())
1036 return;
1037 for(unsigned i = 0; i < SNES::cartridge.nvram.size(); i++) {
1038 SNES::Cartridge::NonVolatileRAM& r = SNES::cartridge.nvram[i];
1039 std::string savename = sram_name(r.id, r.slot);
1040 if(sram.count(savename)) {
1041 std::vector<char>& x = sram[savename];
1042 if(r.size != x.size())
1043 messages << "WARNING: SRAM '" << savename << "': Loaded " << x.size()
1044 << " bytes, but the SRAM is " << r.size << "." << std::endl;
1045 memcpy(r.data, &x[0], (r.size < x.size()) ? r.size : x.size());
1046 used.insert(savename);
1047 } else
1048 messages << "WARNING: SRAM '" << savename << ": No data." << std::endl;
1049 }
1050 for(auto i : sram)
1051 if(!used.count(i.first))
1052 messages << "WARNING: SRAM '" << i.first << ": Not found on cartridge."
1053 << std::endl;
1054 }
1055 void c_serialize(std::vector<char>& out) {
1056 if(!internal_rom)
1057 throw std::runtime_error("No ROM loaded");
1058 serializer s = SNES::system.serialize();
1059 out.resize(s.size());
1060 memcpy(&out[0], s.data(), s.size());
1061 }
1062 void c_unserialize(const char* in, size_t insize) {
1063 if(!internal_rom)
1064 throw std::runtime_error("No ROM loaded");
1065 serializer s(reinterpret_cast<const uint8_t*>(in), insize);
1066 if(!SNES::system.unserialize(s))
1067 throw std::runtime_error("SNES core rejected savestate");
1068 have_saved_this_frame = true;
1069 do_reset_flag = -1;
1070 }
1071 core_region& c_get_region() {
1072 return (SNES::system.region() == SNES::System::Region::PAL) ? region_pal : region_ntsc;
1073 }
1074 void c_power() {
1075 if(internal_rom) snes_power();
1076 }
1077 void c_unload_cartridge() {
1078 if(!internal_rom) return;
1079 snes_term();
1080 snes_unload_cartridge();
1081 internal_rom = NULL;
1082 }
1083 std::pair<uint32_t, uint32_t> c_get_scale_factors(uint32_t width, uint32_t height) {
1084 return std::make_pair((width < 400) ? 2 : 1, (height < 400) ? 2 : 1);
1085 }
1086 void c_install_handler() {
1087 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS
1088 SNES::bus.debug_read = bsnes_debug_read;
1089 SNES::bus.debug_write = bsnes_debug_write;
1090 #endif
1091 basic_init();
1092 old = SNES::interface;
1093 SNES::interface = &my_interface_obj;
1094 SNES::system.init();
1095 magic_flags |= 1;
1096 }
1097 void c_uninstall_handler() { SNES::interface = old; }
1098 void c_emulate() {
1099 if(!internal_rom)
1100 return;
1101 bool was_delay_reset = false;
1102 int16_t reset = ecore_callbacks->get_input(0, 0, 1);
1103 int16_t hreset = 0;
1104 if(support_hreset)
1105 hreset = ecore_callbacks->get_input(0, 0, 4);
1106 if(reset) {
1107 long hi = ecore_callbacks->get_input(0, 0, 2);
1108 long lo = ecore_callbacks->get_input(0, 0, 3);
1109 long delay = 10000 * hi + lo;
1110 if(delay > 0) {
1111 was_delay_reset = true;
1112 #ifdef BSNES_HAS_DEBUGGER
1113 messages << "Executing delayed reset... This can take some time!"
1114 << std::endl;
1115 video_refresh_done = false;
1116 delayreset_cycles_run = 0;
1117 delayreset_cycles_target = delay;
1118 forced_hook = true;
1119 SNES::cpu.step_event = delayreset_fn;
1120 again:
1121 SNES::system.run();
1122 if(SNES::scheduler.exit_reason() == SNES::Scheduler::ExitReason::DebuggerEvent
1123 && SNES::debugger.break_event ==
1124 SNES::Debugger::BreakEvent::BreakpointHit) {
1125 snesdbg_on_break();
1126 goto again;
1127 }
1128 SNES::cpu.step_event = nall::function<bool()>();
1129 forced_hook = false;
1130 update_trace_hook_state();
1131 if(video_refresh_done) {
1132 //Force the reset here.
1133 do_reset_flag = -1;
1134 messages << "SNES reset (forced at " << delayreset_cycles_run << ")"
1135 << std::endl;
1136 if(hreset)
1137 SNES::system.power();
1138 else
1139 SNES::system.reset();
1140 return;
1141 }
1142 if(hreset)
1143 SNES::system.power();
1144 else
1145 SNES::system.reset();
1146 messages << "SNES reset (delayed " << delayreset_cycles_run << ")"
1147 << std::endl;
1148 #else
1149 messages << "Delayresets not supported on this bsnes version "
1150 "(needs v084 or v085)" << std::endl;
1151 if(hreset)
1152 SNES::system.power();
1153 else
1154 SNES::system.reset();
1155 #endif
1156 } else if(delay == 0) {
1157 if(hreset)
1158 SNES::system.power();
1159 else
1160 SNES::system.reset();
1161 messages << "SNES reset" << std::endl;
1162 }
1163 }
1164 do_reset_flag = -1;
1165
1166 if(!have_saved_this_frame && save_every_frame && !was_delay_reset)
1167 SNES::system.runtosave();
1168 #ifdef BSNES_HAS_DEBUGGER
1169 if(trace_enabled())
1170 SNES::cpu.step_event = trace_fn;
1171 #endif
1172 again2:
1173 SNES::system.run();
1174 if(SNES::scheduler.exit_reason() == SNES::Scheduler::ExitReason::DebuggerEvent &&
1175 SNES::debugger.break_event == SNES::Debugger::BreakEvent::BreakpointHit) {
1176 snesdbg_on_break();
1177 goto again2;
1178 }
1179 #ifdef BSNES_HAS_DEBUGGER
1180 SNES::cpu.step_event = nall::function<bool()>();
1181 #endif
1182 have_saved_this_frame = false;
1183 }
1184 void c_runtosave() {
1185 if(!internal_rom)
1186 return;
1187 stepping_into_save = true;
1188 SNES::system.runtosave();
1189 have_saved_this_frame = true;
1190 stepping_into_save = false;
1191 }
1192 bool c_get_pflag() { return SNES::cpu.controller_flag; }
1193 void c_set_pflag(bool pflag) { SNES::cpu.controller_flag = pflag; }
1194 framebuffer::raw& c_draw_cover() {
1195 static framebuffer::raw x(cover_fbinfo);
1196 redraw_cover_fbinfo();
1197 return x;
1198 }
1199 std::string c_get_core_shortname()
1200 {
1201 #ifdef BSNES_IS_COMPAT
1202 return (stringfmt() << "bsnes" << BSNES_VERSION << "c").str();
1203 #else
1204 return (stringfmt() << "bsnes" << BSNES_VERSION << "a").str();
1205 #endif
1206 }
1207 void c_pre_emulate_frame(controller_frame& cf)
1208 {
1209 cf.axis3(0, 0, 1, (do_reset_flag >= 0) ? 1 : 0);
1210 if(support_hreset)
1211 cf.axis3(0, 0, 4, do_hreset_flag ? 1 : 0);
1212 if(do_reset_flag >= 0) {
1213 cf.axis3(0, 0, 2, do_reset_flag / 10000);
1214 cf.axis3(0, 0, 3, do_reset_flag % 10000);
1215 } else {
1216 cf.axis3(0, 0, 2, 0);
1217 cf.axis3(0, 0, 3, 0);
1218 }
1219 }
1220 void c_execute_action(unsigned id, const std::vector<interface_action_paramval>& p)
1221 {
1222 switch(id) {
1223 case 0: //Soft reset.
1224 do_reset_flag = 0;
1225 do_hreset_flag = false;
1226 break;
1227 case 1: //Hard reset.
1228 do_reset_flag = 0;
1229 do_hreset_flag = true;
1230 break;
1231 case 2: //Delayed soft reset.
1232 do_reset_flag = p[0].i;
1233 do_hreset_flag = false;
1234 break;
1235 case 3: //Delayed hard reset.
1236 do_reset_flag = p[0].i;
1237 do_hreset_flag = true;
1238 break;
1239 }
1240 #ifdef BSNES_IS_COMPAT
1241 if(id >= 4 && id <= 23) {
1242 unsigned y = (id - 4) / 4;
1243 SNES::ppu.layer_enabled[y][id % 4] = !SNES::ppu.layer_enabled[y][id % 4];
1244 ecore_callbacks->action_state_updated();
1245 }
1246 #endif
1247 }
1248 const interface_device_reg* c_get_registers() { return snes_registers; }
1249 unsigned c_action_flags(unsigned id)
1250 {
1251 if((id == 2 || id == 3) && !support_dreset)
1252 return 0;
1253 if(id == 0 || id == 2)
1254 return 1;
1255 if(id == 1 || id == 3)
1256 return support_hreset ? 1 : 0;
1257 #ifdef BSNES_IS_COMPAT
1258 if(id >= 4 && id <= 23) {
1259 unsigned y = (id - 4) / 4;
1260 return SNES::ppu.layer_enabled[y][id % 4] ? 3 : 1;
1261 }
1262 #endif
1263 }
1264 int c_reset_action(bool hard)
1265 {
1266 return hard ? (support_hreset ? 1 : -1) : 0;
1267 }
1268 std::pair<uint64_t, uint64_t> c_get_bus_map()
1269 {
1270 return std::make_pair(0x1000000, 0x1000000);
1271 }
1272 std::list<core_vma_info> c_vma_list() { return get_VMAlist(); }
1273 std::set<std::string> c_srams() { return bsnes_srams(); }
1274 std::pair<unsigned, unsigned> c_lightgun_scale() {
1275 return std::make_pair(256, last_PAL ? 239 : 224);
1276 }
1277 void c_set_debug_flags(uint64_t addr, unsigned int sflags, unsigned int cflags)
1278 {
1279 if(addr == 0) {
1280 if(sflags & 8) trace_cpu_enable = true;
1281 if(cflags & 8) trace_cpu_enable = false;
1282 update_trace_hook_state();
1283 }
1284 if(addr == 1) {
1285 if(sflags & 8) trace_smp_enable = true;
1286 if(cflags & 8) trace_smp_enable = false;
1287 update_trace_hook_state();
1288 }
1289 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS
1290 auto _addr = recognize_address(addr);
1291 if(_addr.first == ADDR_KIND_ALL)
1292 SNES::bus.debugFlags(sflags & 7, cflags & 7);
1293 else if(_addr.first != ADDR_KIND_NONE && ((sflags | cflags) & 7))
1294 SNES::bus.debugFlags(sflags & 7, cflags & 7, _addr.first, _addr.second);
1295 #endif
1296 }
1297 void c_set_cheat(uint64_t addr, uint64_t value, bool set)
1298 {
1299 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS
1300 bool s = false;
1301 auto _addr = recognize_address(addr);
1302 if(_addr.first == ADDR_KIND_NONE || _addr.first == ADDR_KIND_ALL)
1303 return;
1304 unsigned x = 0;
1305 while(x < 0x1000000) {
1306 x = SNES::bus.enumerateMirrors(_addr.first, _addr.second, x);
1307 if(x < 0x1000000) {
1308 if(set) {
1309 for(size_t i = 0; i < SNES::cheat.size(); i++) {
1310 if(SNES::cheat[i].addr == x) {
1311 SNES::cheat[i].data = value;
1312 s = true;
1313 break;
1314 }
1315 }
1316 if(!s) SNES::cheat.append({x, (uint8_t)value, true});
1317 } else
1318 for(size_t i = 0; i < SNES::cheat.size(); i++) {
1319 if(SNES::cheat[i].addr == x) {
1320 SNES::cheat.remove(i);
1321 break;
1322 }
1323 }
1324 }
1325 x++;
1326 }
1327 SNES::cheat.synchronize();
1328 #endif
1329 }
1330 void c_debug_reset()
1331 {
1332 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS
1333 SNES::bus.clearDebugFlags();
1334 SNES::cheat.reset();
1335 #endif
1336 trace_cpu_enable = false;
1337 trace_smp_enable = false;
1338 update_trace_hook_state();
1339 }
1340 std::vector<std::string> c_get_trace_cpus()
1341 {
1342 std::vector<std::string> r;
1343 r.push_back("cpu");
1344 r.push_back("smp");
1345 //TODO: Trace various chips.
1346 return r;
1347 }
1348 } bsnes_core;
1349
1350 struct _type_snes : public core_type
1351 {
1352 _type_snes()
1353 : core_type({{
1354 .iname = "snes",
1355 .hname = "SNES",
1356 .id = 0,
1357 .sysname = "SNES",
1358 .bios = NULL,
1359 .regions = {&region_auto, &region_ntsc, &region_pal},
1360 .images = {{"rom", "Cartridge ROM", 1, 0, 512,
1361 "sfc;smc;swc;fig;ufo;sf2;gd3;gd7;dx2;mgd;mgh"}},
1362 .settings = bsnes_settings,
1363 .core = &bsnes_core,
1364 }}) {}
1365
1366 int t_load_rom(core_romimage* img, std::map<std::string, std::string>& settings,
1367 uint64_t secs, uint64_t subsecs)
1368 {
1369 return load_rom(this, img, settings, secs, subsecs,
1370 load_rom_X1<snes_load_cartridge_normal>);
1371 }
1372 controller_set t_controllerconfig(std::map<std::string, std::string>& settings)
1373 {
1374 return bsnes_controllerconfig(settings);
1375 }
1376 } type_snes;
1377 core_sysregion snes_pal("snes_pal", type_snes, region_pal);
1378 core_sysregion snes_ntsc("snes_ntsc", type_snes, region_ntsc);
1379
1380 struct _type_bsx : public core_type, public core_sysregion
1381 {
1382 _type_bsx()
1383 : core_type({{
1384 .iname = "bsx",
1385 .hname = "BS-X (non-slotted)",
1386 .id = 1,
1387 .sysname = "BS-X",
1388 .bios = "bsx.sfc",
1389 .regions = {&region_ntsc},
1390 .images = {{"rom", "BS-X BIOS", 1, 0, 512,
1391 "sfc;smc;swc;fig;ufo;sf2;gd3;gd7;dx2;mgd;mgh"},
1392 {"bsx", "BS-X Flash", 2, 0, 512, "bs"}},
1393 .settings = bsnes_settings,
1394 .core = &bsnes_core,
1395 }}),
1396 core_sysregion("bsx", *this, region_ntsc) {}
1397
1398 int t_load_rom(core_romimage* img, std::map<std::string, std::string>& settings,
1399 uint64_t secs, uint64_t subsecs)
1400 {
1401 return load_rom(this, img, settings, secs, subsecs,
1402 load_rom_X2<snes_load_cartridge_bsx>);
1403 }
1404 controller_set t_controllerconfig(std::map<std::string, std::string>& settings)
1405 {
1406 return bsnes_controllerconfig(settings);
1407 }
1408 } type_bsx;
1409
1410 struct _type_bsxslotted : public core_type, public core_sysregion
1411 {
1412 _type_bsxslotted()
1413 : core_type({{
1414 .iname = "bsxslotted",
1415 .hname = "BS-X (slotted)",
1416 .id = 2,
1417 .sysname = "BS-X",
1418 .bios = "bsxslotted.sfc",
1419 .regions = {&region_ntsc},
1420 .images = {{"rom", "BS-X BIOS", 1, 0, 512,
1421 "sfc;smc;swc;fig;ufo;sf2;gd3;gd7;dx2;mgd;mgh"},
1422 {"bsx", "BS-X Flash", 2, 0, 512, "bss"}},
1423 .settings = bsnes_settings,
1424 .core = &bsnes_core,
1425 }}),
1426 core_sysregion("bsxslotted", *this, region_ntsc) {}
1427 int t_load_rom(core_romimage* img, std::map<std::string, std::string>& settings,
1428 uint64_t secs, uint64_t subsecs)
1429 {
1430 return load_rom(this, img, settings, secs, subsecs,
1431 load_rom_X2<snes_load_cartridge_bsx_slotted>);
1432 }
1433 controller_set t_controllerconfig(std::map<std::string, std::string>& settings)
1434 {
1435 return bsnes_controllerconfig(settings);
1436 }
1437 } type_bsxslotted;
1438
1439 struct _type_sufamiturbo : public core_type, public core_sysregion
1440 {
1441 _type_sufamiturbo()
1442 : core_type({{
1443 .iname = "sufamiturbo",
1444 .hname = "Sufami Turbo",
1445 .id = 3,
1446 .sysname = "SufamiTurbo",
1447 .bios = "sufamiturbo.sfc",
1448 .regions = {&region_ntsc},
1449 .images = {
1450 {"rom", "ST BIOS", 1, 0, 512, "sfc;smc;swc;fig;ufo;sf2;gd3;gd7;dx2;mgd;mgh"},
1451 {"slot-a", "ST SLOT A ROM", 2, 0, 512, "st"},
1452 {"slot-b", "ST SLOT B ROM", 2, 0, 512, "st"}
1453 },
1454 .settings = bsnes_settings,
1455 .core = &bsnes_core,
1456 }}),
1457 core_sysregion("sufamiturbo", *this, region_ntsc) {}
1458 int t_load_rom(core_romimage* img, std::map<std::string, std::string>& settings,
1459 uint64_t secs, uint64_t subsecs)
1460 {
1461 return load_rom(this, img, settings, secs, subsecs,
1462 load_rom_X3<snes_load_cartridge_sufami_turbo>);
1463 }
1464 controller_set t_controllerconfig(std::map<std::string, std::string>& settings)
1465 {
1466 return bsnes_controllerconfig(settings);
1467 }
1468 } type_sufamiturbo;
1469
1470 struct _type_sgb : public core_type
1471 {
1472 _type_sgb()
1473 : core_type({{
1474 .iname = "sgb",
1475 .hname = "Super Game Boy",
1476 .id = 4,
1477 .sysname = "SGB",
1478 .bios = "sgb.sfc",
1479 .regions = {&region_auto, &region_ntsc, &region_pal},
1480 .images = {{"rom", "SGB BIOS", 1, 0, 512,
1481 "sfc;smc;swc;fig;ufo;sf2;gd3;gd7;dx2;mgd;mgh"},
1482 {"dmg", "DMG ROM", 2, 0, 512, "gb;dmg;sgb"}},
1483 .settings = bsnes_settings,
1484 .core = &bsnes_core,
1485 }}) {}
1486 int t_load_rom(core_romimage* img, std::map<std::string, std::string>& settings,
1487 uint64_t secs, uint64_t subsecs)
1488 {
1489 return load_rom(this, img, settings, secs, subsecs,
1490 load_rom_X2<snes_load_cartridge_super_game_boy>);
1491 }
1492 controller_set t_controllerconfig(std::map<std::string, std::string>& settings)
1493 {
1494 return bsnes_controllerconfig(settings);
1495 }
1496 } type_sgb;
1497 core_sysregion sgb_pal("sgb_pal", type_sgb, region_pal);
1498 core_sysregion sgb_ntsc("sgb_ntsc", type_sgb, region_ntsc);
1499
1500 void redraw_cover_fbinfo()
1501 {
1502 for(size_t i = 0; i < sizeof(cover_fbmem) / sizeof(cover_fbmem[0]); i++)
1503 cover_fbmem[i] = 0;
1504 std::string ident = bsnes_core.get_core_identifier();
1505 cover_render_string(cover_fbmem, 0, 0, ident, 0x7FFFF, 0x00000, 512, 448, 2048, 4);
1506 std::ostringstream name;
1507 name << "Internal ROM name: ";
1508 disable_breakpoints = true;
1509 for(unsigned i = 0; i < 21; i++) {
1510 unsigned busaddr = 0x00FFC0 + i;
1511 #ifdef BSNES_SUPPORTS_ADV_BREAKPOINTS
1512 unsigned char ch = SNES::bus.read(busaddr, false);
1513 #else
1514 unsigned char ch = SNES::bus.read(busaddr);
1515 #endif
1516 if(ch < 32 || ch > 126)
1517 name << "<" << hex::to8(ch) << ">";
1518 else
1519 name << ch;
1520 }
1521 disable_breakpoints = false;
1522 cover_render_string(cover_fbmem, 0, 16, name.str(), 0x7FFFF, 0x00000, 512, 448, 2048, 4);
1523 unsigned y = 32;
1524 for(auto i : cover_information()) {
1525 cover_render_string(cover_fbmem, 0, y, i, 0x7FFFF, 0x00000, 512, 448, 2048, 4);
1526 y += 16;
1527 }
1528 #ifdef BSNES_SUPPORTS_ALT_TIMINGS
1529 if(SNES::config.cpu.alt_poll_timings) {
1530 cover_render_string(cover_fbmem, 0, y, "Alternate timings enabled.", 0x7FFFF, 0x00000,
1531 512, 448, 2048, 4);
1532 y += 16;
1533 }
1534 #endif
1535 }
1536
1537 void my_interface::videoRefresh(const uint32_t* data, bool hires, bool interlace, bool overscan)
1538 {
1539 last_hires = hires;
1540 last_interlace = interlace;
1541 bool region = (SNES::system.region() == SNES::System::Region::PAL);
1542 last_PAL = region;
1543 if(stepping_into_save)
1544 messages << "Got video refresh in runtosave, expect desyncs!" << std::endl;
1545 video_refresh_done = true;
1546 uint32_t fps_n, fps_d;
1547 auto fps = bsnes_core.get_video_rate();
1548 fps_n = fps.first;
1549 fps_d = fps.second;
1550 uint32_t g = gcd(fps_n, fps_d);
1551 fps_n /= g;
1552 fps_d /= g;
1553
1554 framebuffer::info inf;
1555 inf.type = &framebuffer::pixfmt_lrgb;
1556 inf.mem = const_cast<char*>(reinterpret_cast<const char*>(data));
1557 inf.physwidth = 512;
1558 inf.physheight = 512;
1559 inf.physstride = 2048;
1560 inf.width = hires ? 512 : 256;
1561 inf.height = (region ? 239 : 224) * (interlace ? 2 : 1);
1562 inf.stride = interlace ? 2048 : 4096;
1563 inf.offset_x = 0;
1564 inf.offset_y = (region ? (overscan ? 9 : 1) : (overscan ? 16 : 9)) * 2;
1565 framebuffer::raw ls(inf);
1566
1567 ecore_callbacks->output_frame(ls, fps_n, fps_d);
1568 if(soundbuf_fill > 0) {
1569 auto freq = SNES::system.apu_frequency();
1570 audioapi_submit_buffer(soundbuf, soundbuf_fill / 2, true, freq / 768.0);
1571 soundbuf_fill = 0;
1572 }
1573 }
1574
1575 std::list<core_vma_info> get_VMAlist()
1576 {
1577 std::list<core_vma_info> ret;
1578 if(!internal_rom)
1579 return ret;
1580 create_region(ret, "WRAM", 0x007E0000, SNES::cpu.wram, 131072, false);
1581 create_region(ret, "APURAM", 0x00000000, SNES::smp.apuram, 65536, false);
1582 create_region(ret, "VRAM", 0x00010000, SNES::ppu.vram, 65536, false);
1583 create_region(ret, "OAM", 0x00020000, SNES::ppu.oam, 544, false);
1584 create_region(ret, "CGRAM", 0x00021000, SNES::ppu.cgram, 512, false);
1585 if(SNES::cartridge.has_srtc()) create_region(ret, "RTC", 0x00022000, SNES::srtc.rtc, 20, false);
1586 if(SNES::cartridge.has_spc7110rtc()) create_region(ret, "RTC", 0x00022000, SNES::spc7110.rtc, 20,
1587 false);
1588 if(SNES::cartridge.has_necdsp()) {
1589 create_region(ret, "DSPRAM", 0x00023000, reinterpret_cast<uint8_t*>(SNES::necdsp.dataRAM),
1590 4096, false, true);
1591 create_region(ret, "DSPPROM", 0xF0000000, reinterpret_cast<uint8_t*>(SNES::necdsp.programROM),
1592 65536, true, true);
1593 create_region(ret, "DSPDROM", 0xF0010000, reinterpret_cast<uint8_t*>(SNES::necdsp.dataROM),
1594 4096, true, true);
1595 }
1596 create_region(ret, "SRAM", 0x10000000, SNES::cartridge.ram, false);
1597 create_region(ret, "ROM", 0x80000000, SNES::cartridge.rom, true);
1598 create_region(ret, "BUS", 0x1000000, 0x1000000, snes_bus_iospace_rw);
1599 create_region(ret, "PTRTABLE", 0x100000000, 0x100000, ptrtable_iospace_rw);
1600 map_internal(ret, "CPU_STATE", 0, &SNES::cpu, sizeof(SNES::cpu));
1601 map_internal(ret, "PPU_STATE", 1, &SNES::ppu, sizeof(SNES::ppu));
1602 map_internal(ret, "SMP_STATE", 2, &SNES::smp, sizeof(SNES::smp));
1603 map_internal(ret, "DSP_STATE", 3, &SNES::dsp, sizeof(SNES::dsp));
1604 if(internal_rom == &type_bsx || internal_rom == &type_bsxslotted) {
1605 create_region(ret, "BSXFLASH", 0x90000000, SNES::bsxflash.memory, true);
1606 create_region(ret, "BSX_RAM", 0x20000000, SNES::bsxcartridge.sram, false);
1607 create_region(ret, "BSX_PRAM", 0x30000000, SNES::bsxcartridge.psram, false);
1608 }
1609 if(internal_rom == &type_sufamiturbo) {
1610 create_region(ret, "SLOTA_ROM", 0x90000000, SNES::sufamiturbo.slotA.rom, true);
1611 create_region(ret, "SLOTB_ROM", 0xA0000000, SNES::sufamiturbo.slotB.rom, true);
1612 create_region(ret, "SLOTA_RAM", 0x20000000, SNES::sufamiturbo.slotA.ram, false);
1613 create_region(ret, "SLOTB_RAM", 0x30000000, SNES::sufamiturbo.slotB.ram, false);
1614 }
1615 if(internal_rom == &type_sgb) {
1616 map_internal(ret, "GBCPU_STATE", 4, &GameBoy::cpu, sizeof(GameBoy::cpu));
1617 create_region(ret, "GBROM", 0x90000000, GameBoy::cartridge.romdata,
1618 GameBoy::cartridge.romsize, true);
1619 create_region(ret, "GBRAM", 0x20000000, GameBoy::cartridge.ramdata,
1620 GameBoy::cartridge.ramsize, false);
1621 create_region(ret, "GBWRAM", 0x00030000, GameBoy::cpu.wram, 32768, false);
1622 create_region(ret, "GBHRAM", 0x00038000, GameBoy::cpu.hram, 128, true);
1623 }
1624 return ret;
1625 }
1626
1627 std::pair<int, uint64_t> recognize_address(uint64_t addr)
1628 {
1629 if(addr == 0xFFFFFFFFFFFFFFFFULL)
1630 return std::make_pair(ADDR_KIND_ALL, 0);
1631 if(addr >= 0x80000000 && addr <= 0x8FFFFFFF) //Rom.
1632 return std::make_pair(1, addr - 0x80000000);
1633 if(addr >= 0x10000000 && addr <= 0x1FFFFFFF) //SRAM.
1634 return std::make_pair(2, addr - 0x10000000);
1635 if(addr >= 0x007E0000 && addr <= 0x007FFFFF) //WRAM.
1636 return std::make_pair(3, addr - 0x007E0000);
1637 if(internal_rom == &type_sufamiturbo) {
1638 if(addr >= 0x90000000 && addr <= 0x9FFFFFFF) //SufamiTurboA Rom.
1639 return std::make_pair(8, addr - 0x90000000);
1640 if(addr >= 0xA0000000 && addr <= 0xAFFFFFFF) //SufamiTurboB Rom.
1641 return std::make_pair(9, addr - 0x90000000);
1642 if(addr >= 0x20000000 && addr <= 0x2FFFFFFF) //SufamiTurboA Ram.
1643 return std::make_pair(10, addr - 0x20000000);
1644 if(addr >= 0x20000000 && addr <= 0x3FFFFFFF) //SufamiTurboB Ram.
1645 return std::make_pair(11, addr - 0x30000000);
1646 }
1647 if(internal_rom == &type_bsx || internal_rom == &type_bsxslotted) {
1648 if(addr >= 0x90000000 && addr <= 0x9FFFFFFF) //BSX flash.
1649 return std::make_pair(12, addr - 0x90000000);
1650 }
1651 if(addr >= 0x01000000 && addr <= 0x01FFFFFF) //BUS.
1652 return std::make_pair(255, addr - 0x01000000);
1653 return std::make_pair(ADDR_KIND_NONE, 0);
1654 }
1655
1656 command::fnptr<command::arg_filename> dump_core(lsnes_cmd, "dump-core", "No description available",
1657 "No description available\n",
1658 [](command::arg_filename args) throw(std::bad_alloc, std::runtime_error) {
1659 std::vector<char> out;
1660 bsnes_core.serialize(out);
1661 std::ofstream x(args, std::ios_base::out | std::ios_base::binary);
1662 x.write(&out[0], out.size());
1663 });
1664
1665 #ifdef BSNES_HAS_DEBUGGER
1666 lua::state* snes_debug_cb_keys[SNES::Debugger::Breakpoints];
1667 lua::state* snes_debug_cb_trace;
1668
1669 void snesdbg_execute_callback(lua::state*& cb, signed r)
1670 {
1671 if(!cb)
1672 return;
1673 cb->pushlightuserdata(&cb);
1674 cb->gettable(LUA_REGISTRYINDEX);
1675 cb->pushnumber(r);
1676 if(cb->type(-2) == LUA_TFUNCTION) {
1677 int s = cb->pcall(1, 0, 0);
1678 if(s)
1679 cb->pop(1);
1680 } else {
1681 messages << "Can't execute debug callback" << std::endl;
1682 cb->pop(2);
1683 }
1684 if(lua_requests_repaint) {
1685 lua_requests_repaint = false;
1686 lsnes_cmd.invoke("repaint");
1687 }
1688 }
1689
1690 void snesdbg_on_break()
1691 {
1692 signed r = SNES::debugger.breakpoint_hit;
1693 snesdbg_execute_callback(snes_debug_cb_keys[r], r);
1694 }
1695
1696 void snesdbg_on_trace()
1697 {
1698 snesdbg_execute_callback(snes_debug_cb_trace, -1);
1699 }
1700
1701 void snesdbg_set_callback(lua::state& L, lua::state*& cb)
1702 {
1703 cb = &L.get_master();
1704 L.pushlightuserdata(&cb);
1705 L.pushvalue(-2);
1706 L.settable(LUA_REGISTRYINDEX);
1707 }
1708
1709 bool snesdbg_get_bp_enabled(lua::state& L)
1710 {
1711 bool r;
1712 L.getfield(-1, "addr");
1713 r = (L.type(-1) == LUA_TNUMBER);
1714 L.pop(1);
1715 return r;
1716 }
1717
1718 uint32_t snesdbg_get_bp_addr(lua::state& L)
1719 {
1720 uint32_t r = 0;
1721 L.getfield(-1, "addr");
1722 if(L.type(-1) == LUA_TNUMBER)
1723 r = static_cast<uint32_t>(L.tonumber(-1));
1724 L.pop(1);
1725 return r;
1726 }
1727
1728 uint32_t snesdbg_get_bp_data(lua::state& L)
1729 {
1730 signed r = -1;
1731 L.getfield(-1, "data");
1732 if(L.type(-1) == LUA_TNUMBER)
1733 r = static_cast<signed>(L.tonumber(-1));
1734 L.pop(1);
1735 return r;
1736 }
1737
1738 SNES::Debugger::Breakpoint::Mode snesdbg_get_bp_mode(lua::state& L)
1739 {
1740 SNES::Debugger::Breakpoint::Mode r = SNES::Debugger::Breakpoint::Mode::Exec;
1741 L.getfield(-1, "mode");
1742 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "e"))
1743 r = SNES::Debugger::Breakpoint::Mode::Exec;
1744 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "x"))
1745 r = SNES::Debugger::Breakpoint::Mode::Exec;
1746 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "exec"))
1747 r = SNES::Debugger::Breakpoint::Mode::Exec;
1748 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "r"))
1749 r = SNES::Debugger::Breakpoint::Mode::Read;
1750 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "read"))
1751 r = SNES::Debugger::Breakpoint::Mode::Read;
1752 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "w"))
1753 r = SNES::Debugger::Breakpoint::Mode::Write;
1754 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "write"))
1755 r = SNES::Debugger::Breakpoint::Mode::Write;
1756 L.pop(1);
1757 return r;
1758 }
1759
1760 SNES::Debugger::Breakpoint::Source snesdbg_get_bp_source(lua::state& L)
1761 {
1762 SNES::Debugger::Breakpoint::Source r = SNES::Debugger::Breakpoint::Source::CPUBus;
1763 L.getfield(-1, "source");
1764 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "cpubus"))
1765 r = SNES::Debugger::Breakpoint::Source::CPUBus;
1766 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "apuram"))
1767 r = SNES::Debugger::Breakpoint::Source::APURAM;
1768 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "vram"))
1769 r = SNES::Debugger::Breakpoint::Source::VRAM;
1770 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "oam"))
1771 r = SNES::Debugger::Breakpoint::Source::OAM;
1772 if(L.type(-1) == LUA_TSTRING && !strcmp(L.tostring(-1), "cgram"))
1773 r = SNES::Debugger::Breakpoint::Source::CGRAM;
1774 L.pop(1);
1775 return r;
1776 }
1777
1778 void snesdbg_get_bp_callback(lua::state& L)
1779 {
1780 L.getfield(-1, "callback");
1781 }
1782
1783 int setdebug(lua::state& L, lua::parameters& P)
1784 {
1785 unsigned r;
1786 int ltbl;
1787
1788 P(r);
1789
1790 if(r >= SNES::Debugger::Breakpoints)
1791 throw std::runtime_error("Bad breakpoint number");
1792 if(P.is_novalue()) {
1793 //Clear breakpoint.
1794 SNES::debugger.breakpoint[r].enabled = false;
1795 return 0;
1796 } else if(P.is_table()) {
1797 P(P.table(ltbl));
1798 L.pushvalue(ltbl);
1799 auto& x = SNES::debugger.breakpoint[r];
1800 x.enabled = snesdbg_get_bp_enabled(L);
1801 x.addr = snesdbg_get_bp_addr(L);
1802 x.data = snesdbg_get_bp_data(L);
1803 x.mode = snesdbg_get_bp_mode(L);
1804 x.source = snesdbg_get_bp_source(L);
1805 snesdbg_get_bp_callback(L);
1806 snesdbg_set_callback(L, snes_debug_cb_keys[r]);
1807 L.pop(2);
1808 return 0;
1809 } else
1810 P.expected("table or nil");
1811 }
1812
1813 int setstep(lua::state& L, lua::parameters& P)
1814 {
1815 uint64_t r;
1816 int lfn = 2;
1817
1818 P(r);
1819 if(P.is_function() || P.is_novalue()) lfn = P.skip();
1820
1821 L.pushvalue(lfn);
1822 snesdbg_set_callback(L, snes_debug_cb_trace);
1823 trace_counter = r;
1824 update_trace_hook_state();
1825 L.pop(1);
1826 return 0;
1827 }
1828
1829 int settrace(lua::state& L, lua::parameters& P)
1830 {
1831 std::string r;
1832
1833 P(r);
1834
1835 lsnes_cmd.invoke("tracelog cpu " + r);
1836 }
1837
1838 command::fnptr<const std::string&> start_trace(lsnes_cmd, "set-trace", "No description available",
1839 "No description available\n",
1840 [](const std::string& r) throw(std::bad_alloc, std::runtime_error) {
1841 lsnes_cmd.invoke("tracelog cpu " + r);
1842 });
1843
1844 #ifdef BSNES_IS_COMPAT
1845 int enablelayer(lua::state& L, lua::parameters& P)
1846 {
1847 unsigned layer, priority;
1848 bool enabled;
1849
1850 P(layer, priority, enabled);
1851
1852 SNES::ppu.layer_enable(layer, priority, enabled);
1853 return 0;
1854 }
1855 #endif
1856
1857 int smpdisasm(lua::state& L, lua::parameters& P)
1858 {
1859 uint64_t addr;
1860
1861 P(addr);
1862
1863 nall::string _disasm = SNES::smp.disassemble_opcode(addr);
1864 std::string disasm(_disasm, _disasm.length());
1865 L.pushlstring(disasm);
1866 return 1;
1867 }
1868
1869 lua::functions debug_fns_snes(lua_func_misc, "bsnes", {
1870 #ifdef BSNES_IS_COMPAT
1871 {"enablelayer", enablelayer},
1872 #endif
1873 {"smpdisasm", smpdisasm},
1874 });
1875
1876 lua::functions debug_fns_memory(lua_func_misc, "memory", {
1877 {"setdebug", setdebug},
1878 {"setstep", setstep},
1879 {"settrace", settrace},
1880 });
1881 #else
1882 void snesdbg_on_break() {}
1883 void snesdbg_on_trace() {}
1884 #endif
1885
1886 struct oninit {
1887 oninit()
1888 {
1889 register_sysregion_mapping("snes_pal", "SNES");
1890 register_sysregion_mapping("snes_ntsc", "SNES");
1891 register_sysregion_mapping("bsx", "SNES");
1892 register_sysregion_mapping("bsxslotted", "SNES");
1893 register_sysregion_mapping("sufamiturbo", "SNES");
1894 register_sysregion_mapping("sgb_ntsc", "SGB");
1895 register_sysregion_mapping("sgb_pal", "SGB");
1896 }
1897 } _oninit;
1898 }
Rerecording SNES/GB(C) emulator based on bsnes / gambatte core