Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-07-05 18:08:04 +03:00
Code Issues Actions 36 Packages Projects Releases Wiki Activity

Made detection of dynamic attempts to install ROM/RAM handlers more aggressive.

Browse Source 
Previous checks would not catch modifications in DRIVER_INIT or MACHINE_START calls.
Also changed one of the cheat calls back to using more generic switch detection so they can be triggered via joysticks.
This commit is contained in:
Aaron Giles 2008-01-18 19:34:54 +00:00
parent 457df1ad82
commit 806a3de01c
3 changed files with 52 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/emu/cheat.c
View File

@ -4464,7 +4464,7 @@ static int EditCheatMenu(CheatEntry * entry, int index, int selection)
}
else
{
int code = input_code_poll_keyboard_switches(FALSE);
int code = input_code_poll_switches(FALSE);
if(code == KEYCODE_ESC)
{

60
src/emu/memory.c
View File

@ -381,6 +381,7 @@ static void init_cpudata(void);
static void init_addrspace(UINT8 cpunum, UINT8 spacenum);
static void preflight_memory(void);
static void populate_memory(void);
static void install_mem_handler_private(addrspace_data *space, int iswrite, int databits, int ismatchmask, offs_t start, offs_t end, offs_t mask, offs_t mirror, genf *handler, int isfixed, const char *handler_name);
static void install_mem_handler(addrspace_data *space, int iswrite, int databits, int ismatchmask, offs_t start, offs_t end, offs_t mask, offs_t mirror, genf *handler, int isfixed, const char *handler_name);
static genf *assign_dynamic_bank(int cpunum, int spacenum, offs_t start, offs_t end, offs_t mirror, int isfixed, int ismasked);
static UINT8 get_handler_index(handler_data *table, genf *handler, const char *handler_name, offs_t start, offs_t end, offs_t mask);
@ -1452,15 +1453,51 @@ static void populate_memory(void)
int ismatchmask = ((map->flags & AM_FLAGS_MATCH_MASK) != 0);
int isfixed = (map->memory != NULL) || (map->share != 0);
if (map->read.handler != NULL)
install_mem_handler(space, 0, space->dbits, ismatchmask, map->start, map->end, map->mask, map->mirror, map->read.handler, isfixed, map->read_name);
install_mem_handler_private(space, 0, space->dbits, ismatchmask, map->start, map->end, map->mask, map->mirror, map->read.handler, isfixed, map->read_name);
if (map->write.handler != NULL)
install_mem_handler(space, 1, space->dbits, ismatchmask, map->start, map->end, map->mask, map->mirror, map->write.handler, isfixed, map->write_name);
install_mem_handler_private(space, 1, space->dbits, ismatchmask, map->start, map->end, map->mask, map->mirror, map->write.handler, isfixed, map->write_name);
}
}
}
}
/*-------------------------------------------------
install_mem_handler_private - wrapper for
install_mem_handler which is used at
initialization time and converts RAM/ROM
banks to dynamically assigned banks
-------------------------------------------------*/
static void install_mem_handler_private(addrspace_data *space, int iswrite, int databits, int ismatchmask, offs_t start, offs_t end, offs_t mask, offs_t mirror, genf *handler, int isfixed, const char *handler_name)
{
/* translate ROM to RAM/UNMAP here */
if (HANDLER_IS_ROM(handler))
handler = iswrite ? (genf *)STATIC_UNMAP : (genf *)MRA8_RAM;
/* assign banks for RAM/ROM areas */
if (HANDLER_IS_RAM(handler))
{
int ismasked = (mask != 0);
offs_t temp_start = start;
offs_t temp_end = end;
offs_t temp_mask = mask;
offs_t temp_mirror = mirror;
/* adjust the incoming addresses (temporarily) */
adjust_addresses(space, ismatchmask, &temp_start, &temp_end, &temp_mask, &temp_mirror);
/* assign a bank to the adjusted addresses */
handler = (genf *)assign_dynamic_bank(space->cpunum, space->spacenum, temp_start, temp_end, temp_mirror, isfixed, ismasked);
if (!bank_ptr[HANDLER_TO_BANK(handler)])
bank_ptr[HANDLER_TO_BANK(handler)] = memory_find_base(space->cpunum, space->spacenum, iswrite, temp_start);
}
/* then do a normal installation */
install_mem_handler(space, iswrite, databits, ismatchmask, start, end, mask, mirror, handler, isfixed, handler_name);
}
/*-------------------------------------------------
install_mem_handler - installs a handler for
memory operations
@ -1472,10 +1509,11 @@ static void install_mem_handler(addrspace_data *space, int iswrite, int databits
table_data *tabledata = iswrite ? &space->write : &space->read;
UINT8 idx, prev_entry = STATIC_INVALID;
int cur_index, prev_index = 0;
int ismasked = (mask != 0);
int i;
/* sanity check */
if (HANDLER_IS_ROM(handler) || HANDLER_IS_RAM(handler))
fatalerror("fatal: install_mem_handler called with ROM or RAM after initialization");
if (space->dbits != databits)
fatalerror("fatal: install_mem_handler called with a %d-bit handler for a %d-bit address space", databits, space->dbits);
if (start > end)
@ -1508,22 +1546,6 @@ static void install_mem_handler(addrspace_data *space, int iswrite, int databits
/* adjust the incoming addresses */
adjust_addresses(space, ismatchmask, &start, &end, &mask, &mirror);
/* sanity check */
if (HANDLER_IS_RAM(handler))
assert_always(mame_get_phase(Machine) == MAME_PHASE_INIT, "RAM/ROM memory handlers can only be installed at init time");
/* translate ROM to RAM/UNMAP here */
if (HANDLER_IS_ROM(handler))
handler = iswrite ? (genf *)STATIC_UNMAP : (genf *)MRA8_RAM;
/* assign banks for RAM/ROM areas */
if (HANDLER_IS_RAM(handler))
{
handler = (genf *)assign_dynamic_bank(space->cpunum, space->spacenum, start, end, mirror, isfixed, ismasked);
if (!bank_ptr[HANDLER_TO_BANK(handler)])
bank_ptr[HANDLER_TO_BANK(handler)] = memory_find_base(space->cpunum, space->spacenum, iswrite, start);
}
/* if this ended up a bank handler, tag it for reads or writes */
if (HANDLER_IS_BANK(handler))
{

20
src/emu/memory.h
View File

@ -1058,21 +1058,21 @@ extern address_space active_address_space[]; /* address spaces */
#define memory_install_write64_handler(cpu, space, start, end, mask, mirror, handler) \
_memory_install_write64_handler(cpu, space, start, end, mask, mirror, handler, #handler)
#define memory_install_readwrite_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) \
#define memory_install_readwrite_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) do { \
_memory_install_read_handler(cpu, space, start, end, mask, mirror, rhandler, #rhandler); \
_memory_install_write_handler(cpu, space, start, end, mask, mirror, whandler, #whandler)
#define memory_install_readwrite8_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) \
_memory_install_write_handler(cpu, space, start, end, mask, mirror, whandler, #whandler); } while (0)
#define memory_install_readwrite8_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) do { \
_memory_install_read8_handler(cpu, space, start, end, mask, mirror, rhandler, #rhandler); \
_memory_install_write8_handler(cpu, space, start, end, mask, mirror, whandler, #whandler)
#define memory_install_readwrite16_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) \
_memory_install_write8_handler(cpu, space, start, end, mask, mirror, whandler, #whandler); } while (0)
#define memory_install_readwrite16_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) do { \
_memory_install_read16_handler(cpu, space, start, end, mask, mirror, rhandler, #rhandler); \
_memory_install_write16_handler(cpu, space, start, end, mask, mirror, whandler, #whandler)
#define memory_install_readwrite32_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) \
_memory_install_write16_handler(cpu, space, start, end, mask, mirror, whandler, #whandler); } while (0)
#define memory_install_readwrite32_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) do { \
_memory_install_read32_handler(cpu, space, start, end, mask, mirror, rhandler, #rhandler); \
_memory_install_write32_handler(cpu, space, start, end, mask, mirror, whandler, #whandler)
#define memory_install_readwrite64_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) \
_memory_install_write32_handler(cpu, space, start, end, mask, mirror, whandler, #whandler); } while (0)
#define memory_install_readwrite64_handler(cpu, space, start, end, mask, mirror, rhandler, whandler) do { \
_memory_install_read64_handler(cpu, space, start, end, mask, mirror, rhandler, #rhandler); \
_memory_install_write64_handler(cpu, space, start, end, mask, mirror, whandler, #whandler)
_memory_install_write64_handler(cpu, space, start, end, mask, mirror, whandler, #whandler); } while (0)
#define memory_install_read_matchmask_handler(cpu, space, start, end, mask, mirror, handler) \
_memory_install_read_matchmask_handler(cpu, space, start, end, mask, mirror, handler, #handler)