Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-17 11:15:06 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove most of the temporary inline helpers.

Browse Source 
The only one that touched a lot of drivers is this one:

S: memory_set_decrypted_region( *)\(( *)([^,]+)( *),( *)
R: \3->set_decrypted_region\1\(\2
This commit is contained in:
Aaron Giles 2010-08-19 14:19:38 +00:00
parent a86a4c3684
commit 44c78c4939
64 changed files with 87 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/emu/cpu/mcs48/mcs48.c
View File

@ -269,7 +269,7 @@ INLINE UINT8 argument_fetch(mcs48_state *cpustate)
INLINE void update_regptr(mcs48_state *cpustate)
{
cpustate->regptr = (UINT8 *)memory_get_write_ptr(cpustate->data, (cpustate->psw & B_FLAG) ? 24 : 0);
cpustate->regptr = (UINT8 *)cpustate->data->get_write_ptr((cpustate->psw & B_FLAG) ? 24 : 0);
}

4
src/emu/cpu/mcs51/mcs51.c
View File

@ -689,8 +689,8 @@ INLINE UINT8 r_psw(mcs51_state_t *mcs51_state) { return SFR_A(ADDR_PSW); }
INLINE void update_ptrs(mcs51_state_t *mcs51_state)
{
mcs51_state->internal_ram = (UINT8 *)memory_get_write_ptr(mcs51_state->data, 0x00);
mcs51_state->sfr_ram = (UINT8 *)memory_get_write_ptr(mcs51_state->data, 0x100);
mcs51_state->internal_ram = (UINT8 *)mcs51_state->data->get_write_ptr(0x00);
mcs51_state->sfr_ram = (UINT8 *)mcs51_state->data->get_write_ptr(0x100);
}

2
src/emu/cpu/mips/mips3drc.c
View File

@ -794,7 +794,7 @@ static void code_compile_block(mips3_state *mips3, UINT8 mode, offs_t pc)
}
/* validate this code block if we're not pointing into ROM */
if (memory_get_write_ptr(mips3->program, seqhead->physpc) != NULL)
if (mips3->program->get_write_ptr(seqhead->physpc) != NULL)
generate_checksum_block(mips3, block, &compiler, seqhead, seqlast);
/* label this instruction, if it may be jumped to locally */

2
src/emu/cpu/pic16c5x/pic16c5x.c
View File

@ -126,7 +126,7 @@ struct _pic16c5x_opcode
INLINE void update_internalram_ptr(pic16c5x_state *cpustate)
{
cpustate->internalram = (UINT8 *)memory_get_write_ptr(cpustate->data, 0x00);
cpustate->internalram = (UINT8 *)cpustate->data->get_write_ptr(0x00);
}

2
src/emu/cpu/pic16c62x/pic16c62x.c
View File

@ -126,7 +126,7 @@ struct _pic16c62x_instruction
INLINE void update_internalram_ptr(pic16c62x_state *cpustate)
{
cpustate->internalram = (UINT8 *)memory_get_write_ptr(cpustate->data, 0x00);
cpustate->internalram = (UINT8 *)cpustate->data->get_write_ptr(0x00);
}
#define PIC16C62x_RDOP(A) (memory_decrypted_read_word(cpustate->program, (A)<<1))

2
src/emu/cpu/powerpc/ppc_mem.c
View File

@ -207,7 +207,7 @@ static int ppc_translate_address(offs_t *addr_ptr, int flags)
| (((ppc.sdr1 & 0x01FF) & (hash >> 10)) << 16)
| ((hash & 0x03FF) << 6);
pteg_ptr[hash_type] = memory_get_read_ptr(ppc->program, pteg_address);
pteg_ptr[hash_type] = ppc->program->get_read_ptr(pteg_address);
if (pteg_ptr[hash_type])
{
for (i = 0; i < 8; i++)

2
src/emu/cpu/powerpc/ppccom.c
View File

@ -537,7 +537,7 @@ static UINT32 ppccom_translate_address_internal(powerpc_state *ppc, int intentio
for (hashnum = 0; hashnum < 2; hashnum++)
{
offs_t ptegaddr = hashbase | ((hash << 6) & hashmask);
UINT32 *ptegptr = (UINT32 *)memory_get_read_ptr(ppc->program, ptegaddr);
UINT32 *ptegptr = (UINT32 *)ppc->program->get_read_ptr(ptegaddr);
/* should only have valid memory here, but make sure */
if (ptegptr != NULL)

2
src/emu/cpu/powerpc/ppcdrc.c
View File

@ -999,7 +999,7 @@ static void code_compile_block(powerpc_state *ppc, UINT8 mode, offs_t pc)
}
/* validate this code block if we're not pointing into ROM */
if (memory_get_write_ptr(ppc->program, seqhead->physpc) != NULL)
if (ppc->program->get_write_ptr(seqhead->physpc) != NULL)
generate_checksum_block(ppc, block, &compiler, seqhead, seqlast); // <checksum>
/* label this instruction, if it may be jumped to locally */

2
src/emu/cpu/rsp/rspdrc.c
View File

@ -7258,7 +7258,7 @@ static void code_compile_block(rsp_state *rsp, offs_t pc)
}
/* validate this code block if we're not pointing into ROM */
if (memory_get_write_ptr(rsp->program, seqhead->physpc) != NULL)
if (rsp->program->get_write_ptr(seqhead->physpc) != NULL)
generate_checksum_block(rsp, block, &compiler, seqhead, seqlast);
/* label this instruction, if it may be jumped to locally */

2
src/emu/cpu/sh2/sh2drc.c
View File

@ -977,7 +977,7 @@ static void code_compile_block(sh2_state *sh2, UINT8 mode, offs_t pc)
}
/* validate this code block if we're not pointing into ROM */
if (memory_get_write_ptr(sh2->program, seqhead->physpc) != NULL)
if (sh2->program->get_write_ptr(seqhead->physpc) != NULL)
generate_checksum_block(sh2, block, &compiler, seqhead, seqlast);
/* label this instruction, if it may be jumped to locally */

2
src/emu/debug/debugcmd.c
View File

@ -163,7 +163,7 @@ static void execute_hardreset(running_machine *machine, int ref, int params, con
INLINE int cheat_address_is_valid(address_space *space, offs_t address)
{
return debug_cpu_translate(space, TRANSLATE_READ, &address) && (memory_get_write_ptr(space, address) != NULL);
return debug_cpu_translate(space, TRANSLATE_READ, &address) && (space->get_write_ptr(address) != NULL);
}

10
src/emu/debug/debugcpu.c
View File

@ -1133,7 +1133,7 @@ static UINT64 expression_read_program_direct(address_space *_space, int opcode,
if (opcode & 1)
base = (UINT8 *)memory_decrypted_read_ptr(space, address & ~lowmask);
else
base = (UINT8 *)memory_get_read_ptr(space, address & ~lowmask);
base = (UINT8 *)space->get_read_ptr(address & ~lowmask);
/* if we have a valid base, return the appropriate byte */
if (base != NULL)
@ -1306,7 +1306,7 @@ static void expression_write_program_direct(address_space *_space, int opcode, o
if (opcode & 1)
base = (UINT8 *)memory_decrypted_read_ptr(space, address & ~lowmask);
else
base = (UINT8 *)memory_get_read_ptr(space, address & ~lowmask);
base = (UINT8 *)space->get_read_ptr(address & ~lowmask);
/* if we have a valid base, write the appropriate byte */
if (base != NULL)
@ -2592,8 +2592,8 @@ void device_debug::watchpoint_update_flags(address_space &space)
}
// push the flags out globally
memory_enable_read_watchpoints(&space, enableread);
memory_enable_write_watchpoints(&space, enablewrite);
space.enable_read_watchpoints(enableread);
space.enable_write_watchpoints(enablewrite);
}
@ -2789,7 +2789,7 @@ UINT64 device_debug::get_cycles(void *globalref, void *ref)
UINT64 device_debug::get_logunmap(void *globalref, void *ref)
{
address_space *space = reinterpret_cast<address_space *>(ref);
return memory_get_log_unmap(space);
return space->log_unmap();
}

48
src/emu/memory.h
View File

@ -851,52 +851,4 @@ static inline UINT32 memory_decrypted_read_dword(address_space *space, offs_t by
static inline UINT64 memory_decrypted_read_qword(address_space *space, offs_t byteaddress) { return space->direct().read_decrypted_qword(byteaddress); }
static inline void memory_set_decrypted_region(address_space *space, offs_t addrstart, offs_t addrend, void *base)
{
const_cast<address_space *>(space)->set_decrypted_region(addrstart, addrend, base);
}
static inline void *memory_get_read_ptr(address_space *space, offs_t byteaddress)
{
return const_cast<address_space *>(space)->get_read_ptr(byteaddress);
}
static inline void *memory_get_write_ptr(address_space *space, offs_t byteaddress)
{
return const_cast<address_space *>(space)->get_write_ptr(byteaddress);
}
static inline const char *memory_get_handler_string(address_space *space, read_or_write readorwrite, offs_t byteaddress)
{
return const_cast<address_space *>(space)->get_handler_string(readorwrite, byteaddress);
}
static inline void memory_enable_read_watchpoints(address_space *space, bool enable)
{
const_cast<address_space *>(space)->enable_read_watchpoints(enable);
}
static inline void memory_enable_write_watchpoints(address_space *space, bool enable)
{
const_cast<address_space *>(space)->enable_write_watchpoints(enable);
}
static inline void memory_set_debugger_access(address_space *space, bool debugger)
{
const_cast<address_space *>(space)->set_debugger_access(debugger);
}
static inline void memory_set_log_unmap(address_space *space, bool log)
{
const_cast<address_space *>(space)->set_log_unmap(log);
}
static inline bool memory_get_log_unmap(address_space *space)
{
return space->log_unmap();
}
#endif /* __MEMORY_H__ */

2
src/mame/audio/seibu.c
View File

@ -109,7 +109,7 @@ void seibu_sound_decrypt(running_machine *machine,const char *cpu,int length)
UINT8 *rom = memory_region(machine, cpu);
int i;
memory_set_decrypted_region(space, 0x0000, (length < 0x10000) ? (length - 1) : 0x1fff, decrypt);
space->set_decrypted_region(0x0000, (length < 0x10000) ? (length - 1) : 0x1fff, decrypt);
for (i = 0;i < length;i++)
{

2
src/mame/drivers/appoooh.c
View File

@ -606,7 +606,7 @@ static DRIVER_INIT(robowres)
static DRIVER_INIT(robowresb)
{
address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM);
memory_set_decrypted_region(space, 0x0000, 0x7fff, memory_region(machine, "maincpu") + 0x1c000);
space->set_decrypted_region(0x0000, 0x7fff, memory_region(machine, "maincpu") + 0x1c000);
}

4
src/mame/drivers/btime.c
View File

@ -2082,7 +2082,7 @@ static void decrypt_C10707_cpu(running_machine *machine, const char *cputag)
UINT8 *rom = memory_region(machine, cputag);
offs_t addr;
memory_set_decrypted_region(space, 0x0000, 0xffff, decrypt);
space->set_decrypted_region(0x0000, 0xffff, decrypt);
/* Swap bits 5 & 6 for opcodes */
for (addr = 0; addr < 0x10000; addr++)
@ -2111,7 +2111,7 @@ static void init_rom1(running_machine *machine)
UINT8 *rom = memory_region(machine, "maincpu");
decrypted = auto_alloc_array(machine, UINT8, 0x10000);
memory_set_decrypted_region(space, 0x0000, 0xffff, decrypted);
space->set_decrypted_region(0x0000, 0xffff, decrypted);
/* For now, just copy the RAM array over to ROM. Decryption will happen */
/* at run time, since the CPU applies the decryption only if the previous */

2
src/mame/drivers/cabal.c
View File

@ -845,7 +845,7 @@ static void seibu_sound_bootleg(running_machine *machine,const char *cpu,int len
UINT8 *decrypt = auto_alloc_array(machine, UINT8, length);
UINT8 *rom = memory_region(machine, cpu);
memory_set_decrypted_region(space, 0x0000, (length < 0x10000) ? (length - 1) : 0x1fff, decrypt);
space->set_decrypted_region(0x0000, (length < 0x10000) ? (length - 1) : 0x1fff, decrypt);
memcpy(decrypt, rom+length, length);

2
src/mame/drivers/calorie.c
View File

@ -556,7 +556,7 @@ static DRIVER_INIT( calorie )
static DRIVER_INIT( calorieb )
{
address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM);
memory_set_decrypted_region(space, 0x0000, 0x7fff, memory_region(machine, "maincpu") + 0x10000);
space->set_decrypted_region(0x0000, 0x7fff, memory_region(machine, "maincpu") + 0x10000);
}

4
src/mame/drivers/commando.c
View File

@ -526,7 +526,7 @@ static DRIVER_INIT( commando )
UINT8 *decrypt = auto_alloc_array(machine, UINT8, 0xc000);
int A;
memory_set_decrypted_region(space, 0x0000, 0xbfff, decrypt);
space->set_decrypted_region(0x0000, 0xbfff, decrypt);
// the first opcode is *not* encrypted
decrypt[0] = rom[0];
@ -546,7 +546,7 @@ static DRIVER_INIT( spaceinv )
UINT8 *decrypt = auto_alloc_array(machine, UINT8, 0xc000);
int A;
memory_set_decrypted_region(space, 0x0000, 0xbfff, decrypt);
space->set_decrypted_region(0x0000, 0xbfff, decrypt);
// the first opcode *is* encrypted
for (A = 0; A < 0xc000; A++)

2
src/mame/drivers/cps2.c
View File

@ -7910,7 +7910,7 @@ static DRIVER_INIT( gigamn2 )
state_save_register_global_pointer(machine, state->gigamn2_dummyqsound_ram, 0x20000 / 2);
memory_install_readwrite16_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), 0x618000, 0x619fff, 0, 0, gigamn2_dummyqsound_r, gigamn2_dummyqsound_w); // no qsound..
memory_set_decrypted_region(space, 0x000000, (length) - 1, &rom[length/4]);
space->set_decrypted_region(0x000000, (length) - 1, &rom[length/4]);
m68k_set_encrypted_opcode_range(machine->device("maincpu"), 0, length);
}

2
src/mame/drivers/cshooter.c
View File

@ -666,7 +666,7 @@ static DRIVER_INIT( cshootere )
UINT8 *rom = memory_region(machine, "maincpu");
UINT8 *decrypt = auto_alloc_array(machine, UINT8, 0x8000);
memory_set_decrypted_region(space, 0x0000, 0x7fff, decrypt);
space->set_decrypted_region(0x0000, 0x7fff, decrypt);
for (A = 0x0000;A < 0x8000;A++)
{

2
src/mame/drivers/darkmist.c
View File

@ -457,7 +457,7 @@ static DRIVER_INIT(darkmist)
decrypt[i] = p;
}
memory_set_decrypted_region(space, 0x0000, 0x7fff, decrypt);
space->set_decrypted_region(0x0000, 0x7fff, decrypt);
memory_set_bankptr(space->machine, "bank1",&ROM[0x010000]);
/* adr line swaps */

2
src/mame/drivers/dec8.c
View File

@ -3453,7 +3453,7 @@ static DRIVER_INIT( deco222 )
rom = memory_region(machine, "audiocpu");
decrypt = auto_alloc_array(machine, UINT8, 0x8000);
memory_set_decrypted_region(space, 0x8000, 0xffff, decrypt);
space->set_decrypted_region(0x8000, 0xffff, decrypt);
for (A = 0x8000; A < 0x10000; A++)
decrypt[A - 0x8000] = (rom[A] & 0x9f) | ((rom[A] & 0x20) << 1) | ((rom[A] & 0x40) >> 1);

6
src/mame/drivers/decocass.c
View File

@ -1362,9 +1362,9 @@ static DRIVER_INIT( decocass )
/* allocate memory and mark all RAM regions with their decrypted pointers */
state->decrypted = auto_alloc_array(machine, UINT8, 0x10000);
memory_set_decrypted_region(space, 0x0000, 0xc7ff, &state->decrypted[0x0000]);
memory_set_decrypted_region(space, 0xd000, 0xdbff, &state->decrypted[0xd000]);
memory_set_decrypted_region(space, 0xf000, 0xffff, &state->decrypted[0xf000]);
space->set_decrypted_region(0x0000, 0xc7ff, &state->decrypted[0x0000]);
space->set_decrypted_region(0xd000, 0xdbff, &state->decrypted[0xd000]);
space->set_decrypted_region(0xf000, 0xffff, &state->decrypted[0xf000]);
/* Swap bits 5 & 6 for opcodes */
for (A = 0xf000; A < 0x10000; A++)

2
src/mame/drivers/freekick.c
View File

@ -1112,7 +1112,7 @@ ROM_END
static DRIVER_INIT(gigasb)
{
address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM);
memory_set_decrypted_region(space, 0x0000, 0xbfff, memory_region(machine, "maincpu") + 0x10000);
space->set_decrypted_region(0x0000, 0xbfff, memory_region(machine, "maincpu") + 0x10000);
}

4
src/mame/drivers/funworld.c
View File

@ -4247,7 +4247,7 @@ static DRIVER_INIT( multiwin )
ROM[x+0x10000] = code;
}
memory_set_decrypted_region(space, 0x8000, 0xffff, memory_region(machine, "maincpu") + 0x18000);
space->set_decrypted_region(0x8000, 0xffff, memory_region(machine, "maincpu") + 0x18000);
}
static DRIVER_INIT( royalcdc )
@ -4300,7 +4300,7 @@ static DRIVER_INIT( royalcdc )
ROM[x+0x10000] = code;
}
memory_set_decrypted_region(space, 0x6000, 0xffff, memory_region(machine, "maincpu") + 0x16000);
space->set_decrypted_region(0x6000, 0xffff, memory_region(machine, "maincpu") + 0x16000);
}

2
src/mame/drivers/galaxian.c
View File

@ -2745,7 +2745,7 @@ static DRIVER_INIT( moonqsr )
/* decrypt program code */
decode_mooncrst(machine, 0x8000, decrypt);
memory_set_decrypted_region(space, 0x0000, 0x7fff, decrypt);
space->set_decrypted_region(0x0000, 0x7fff, decrypt);
}
static WRITE8_HANDLER( artic_gfxbank_w )

2
src/mame/drivers/jack.c
View File

@ -1317,7 +1317,7 @@ static void treahunt_decode( running_machine *machine )
UINT8 *decrypt = auto_alloc_array(machine, UINT8, 0x4000);
int data;
memory_set_decrypted_region(space, 0x0000, 0x3fff, decrypt);
space->set_decrypted_region(0x0000, 0x3fff, decrypt);
/* Thanks to Mike Balfour for helping out with the decryption */
for (A = 0; A < 0x4000; A++)

2
src/mame/drivers/kchamp.c
View File

@ -741,7 +741,7 @@ static UINT8 *decrypt_code(running_machine *machine)
UINT8 *rom = memory_region(machine, "maincpu");
int A;
memory_set_decrypted_region(space, 0x0000, 0xffff, decrypted);
space->set_decrypted_region(0x0000, 0xffff, decrypted);
for (A = 0; A < 0x10000; A++)
decrypted[A] = (rom[A] & 0x55) | ((rom[A] & 0x88) >> 2) | ((rom[A] & 0x22) << 2);

2
src/mame/drivers/ladybug.c
View File

@ -1073,7 +1073,7 @@ static DRIVER_INIT( dorodon )
UINT8 *rom = memory_region(machine, "maincpu");
UINT8 *table = memory_region(machine, "user1");
memory_set_decrypted_region(space, 0x0000, 0x5fff, decrypted);
space->set_decrypted_region(0x0000, 0x5fff, decrypted);
for (i = 0; i < 0x6000; i++)
decrypted[i] = table[rom[i]];

4
src/mame/drivers/liberate.c
View File

@ -1373,7 +1373,7 @@ static void sound_cpu_decrypt(running_machine *machine)
for (i = 0xc000; i < 0x10000; i++)
decrypted[i - 0xc000] = ((rom[i] & 0x20) << 1) | ((rom[i] & 0x40) >> 1) | (rom[i] & 0x9f);
memory_set_decrypted_region(space, 0xc000, 0xffff, decrypted);
space->set_decrypted_region(0xc000, 0xffff, decrypted);
}
static DRIVER_INIT( prosport )
@ -1402,7 +1402,7 @@ static DRIVER_INIT( liberate )
UINT8 *decrypted = auto_alloc_array(machine, UINT8, 0x10000);
UINT8 *ROM = memory_region(machine, "maincpu");
memory_set_decrypted_region(space, 0x0000, 0xffff, decrypted);
space->set_decrypted_region(0x0000, 0xffff, decrypted);
/* Swap bits for opcodes only, not data */
for (A = 0; A < 0x10000; A++) {

2
src/mame/drivers/mitchell.c
View File

@ -2120,7 +2120,7 @@ ROM_END
static void bootleg_decode( running_machine *machine )
{
address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM);
memory_set_decrypted_region(space, 0x0000, 0x7fff, memory_region(machine, "maincpu") + 0x50000);
space->set_decrypted_region(0x0000, 0x7fff, memory_region(machine, "maincpu") + 0x50000);
memory_configure_bank_decrypted(machine, "bank1", 0, 16, memory_region(machine, "maincpu") + 0x60000, 0x4000);
}

2
src/mame/drivers/mouser.c
View File

@ -291,7 +291,7 @@ static DRIVER_INIT( mouser )
UINT8 *decrypted = auto_alloc_array(machine, UINT8, 0x6000);
UINT8 *table = memory_region(machine, "user1");
memory_set_decrypted_region(space, 0x0000, 0x5fff, decrypted);
space->set_decrypted_region(0x0000, 0x5fff, decrypted);
for (i = 0; i < 0x6000; i++)
{

2
src/mame/drivers/ninjakd2.c
View File

@ -1447,7 +1447,7 @@ static DRIVER_INIT( ninjakd2 )
static DRIVER_INIT( bootleg )
{
address_space *space = cputag_get_address_space(machine, "soundcpu", ADDRESS_SPACE_PROGRAM);
memory_set_decrypted_region(space, 0x0000, 0x7fff, memory_region(machine, "soundcpu") + 0x10000);
space->set_decrypted_region(0x0000, 0x7fff, memory_region(machine, "soundcpu") + 0x10000);
gfx_unscramble(machine);
}

4
src/mame/drivers/pacman.c
View File

@ -5354,7 +5354,7 @@ static void maketrax_rom_decode(running_machine *machine)
/* patch protection using a copy of the opcodes so ROM checksum */
/* tests will not fail */
memory_set_decrypted_region(space, 0x0000, 0x3fff, decrypted);
space->set_decrypted_region(0x0000, 0x3fff, decrypted);
memcpy(decrypted,rom,0x4000);
@ -5386,7 +5386,7 @@ static void korosuke_rom_decode(running_machine *machine)
/* patch protection using a copy of the opcodes so ROM checksum */
/* tests will not fail */
memory_set_decrypted_region(space, 0x0000, 0x3fff, decrypted);
space->set_decrypted_region(0x0000, 0x3fff, decrypted);
memcpy(decrypted,rom,0x4000);

2
src/mame/drivers/pcktgal.c
View File

@ -418,7 +418,7 @@ static DRIVER_INIT( deco222 )
UINT8 *decrypted = auto_alloc_array(machine, UINT8, 0x10000);
UINT8 *rom = memory_region(machine, "audiocpu");
memory_set_decrypted_region(space, 0x8000, 0xffff, decrypted);
space->set_decrypted_region(0x8000, 0xffff, decrypted);
/* bits 5 and 6 of the opcodes are swapped */
for (A = 0x8000;A < 0x18000;A++)

2
src/mame/drivers/pengo.c
View File

@ -665,7 +665,7 @@ static DRIVER_INIT( penta )
UINT8 *rom = memory_region(machine, "maincpu");
int A;
memory_set_decrypted_region(space, 0x0000, 0x7fff, decrypt);
space->set_decrypted_region(0x0000, 0x7fff, decrypt);
for (A = 0x0000;A < 0x8000;A++)
{

4
src/mame/drivers/progolf.c
View File

@ -515,7 +515,7 @@ static DRIVER_INIT( progolf )
UINT8 *rom = memory_region(machine, "maincpu");
UINT8* decrypted = auto_alloc_array(machine, UINT8, 0x10000);
memory_set_decrypted_region(space,0x0000,0xffff, decrypted);
space->set_decrypted_region(0x0000,0xffff, decrypted);
/* Swap bits 5 & 6 for opcodes */
for (A = 0xb000 ; A < 0x10000 ; A++)
@ -529,7 +529,7 @@ static DRIVER_INIT( progolfa )
UINT8 *rom = memory_region(machine, "maincpu");
UINT8* decrypted = auto_alloc_array(machine, UINT8, 0x10000);
memory_set_decrypted_region(space,0x0000,0xffff, decrypted);
space->set_decrypted_region(0x0000,0xffff, decrypted);
/* data is likely to not be encrypted, just the opcodes are. */
for (A = 0x0000 ; A < 0x10000 ; A++)

4
src/mame/drivers/qix.c
View File

@ -1287,7 +1287,7 @@ static DRIVER_INIT( kram3 )
rom = memory_region(machine, "maincpu");
decrypted = auto_alloc_array(machine, UINT8, 0x6000);
memory_set_decrypted_region(mainspace, 0xa000, 0xffff, decrypted);
mainspace->set_decrypted_region(0xa000, 0xffff, decrypted);
memcpy(decrypted,&rom[0xa000],0x6000);
for (i = 0xa000; i < 0x10000; ++i)
@ -1300,7 +1300,7 @@ static DRIVER_INIT( kram3 )
rom = memory_region(machine, "videocpu");
decrypted = auto_alloc_array(machine, UINT8, 0x6000);
memory_set_decrypted_region(videospace, 0xa000, 0xffff, decrypted);
videospace->set_decrypted_region(0xa000, 0xffff, decrypted);
memcpy(decrypted,&rom[0xa000],0x6000);
for (i = 0xa000; i < 0x10000; ++i)

4
src/mame/drivers/segahang.c
View File

@ -1871,7 +1871,7 @@ static DRIVER_INIT( endurobl )
UINT16 *decrypt = auto_alloc_array(machine, UINT16, 0x40000/2);
hangon_generic_init(machine);
memory_set_decrypted_region(space, 0x000000, 0x03ffff, decrypt);
space->set_decrypted_region(0x000000, 0x03ffff, decrypt);
memcpy(decrypt + 0x00000/2, rom + 0x30000/2, 0x10000);
memcpy(decrypt + 0x10000/2, rom + 0x10000/2, 0x20000);
@ -1885,7 +1885,7 @@ static DRIVER_INIT( endurob2 )
UINT16 *decrypt = auto_alloc_array(machine, UINT16, 0x40000/2);
hangon_generic_init(machine);
memory_set_decrypted_region(space, 0x000000, 0x03ffff, decrypt);
space->set_decrypted_region(0x000000, 0x03ffff, decrypt);
memcpy(decrypt, rom, 0x30000);
/* missing data ROM */

2
src/mame/drivers/shootout.c
View File

@ -419,7 +419,7 @@ static DRIVER_INIT( shootout )
UINT8 *rom = memory_region(machine, "maincpu");
int A;
memory_set_decrypted_region(space, 0x8000, 0xffff, decrypt);
space->set_decrypted_region(0x8000, 0xffff, decrypt);
for (A = 0x8000;A < length;A++)
decrypt[A-0x8000] = (rom[A] & 0x9f) | ((rom[A] & 0x40) >> 1) | ((rom[A] & 0x20) << 1);

10
src/mame/drivers/suna8.c
View File

@ -83,7 +83,7 @@ static DRIVER_INIT( hardhead )
static DRIVER_INIT( hardhedb )
{
address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM);
memory_set_decrypted_region(space, 0x0000, 0x7fff, memory_region(machine, "maincpu") + 0x48000);
space->set_decrypted_region(0x0000, 0x7fff, memory_region(machine, "maincpu") + 0x48000);
memory_configure_bank(machine, "bank1", 0, 16, memory_region(machine, "maincpu") + 0x10000, 0x4000);
}
@ -101,7 +101,7 @@ static UINT8 *brickzn_decrypt(running_machine *machine)
UINT8 *decrypt = auto_alloc_array(machine, UINT8, size);
int i;
memory_set_decrypted_region(space, 0x0000, 0x7fff, decrypt);
space->set_decrypted_region(0x0000, 0x7fff, decrypt);
/* Opcodes and data */
for (i = 0; i < 0x50000; i++)
@ -212,7 +212,7 @@ static DRIVER_INIT( hardhea2 )
UINT8 x;
int i;
memory_set_decrypted_region(space, 0x0000, 0x7fff, decrypt);
space->set_decrypted_region(0x0000, 0x7fff, decrypt);
/* Address lines scrambling */
memcpy(decrypt, RAM, size);
@ -299,7 +299,7 @@ static DRIVER_INIT( starfigh )
UINT8 x;
int i;
memory_set_decrypted_region(space, 0x0000, 0x7fff, decrypt);
space->set_decrypted_region(0x0000, 0x7fff, decrypt);
/* Address lines scrambling */
memcpy(decrypt, RAM, size);
@ -367,7 +367,7 @@ static DRIVER_INIT( sparkman )
UINT8 x;
int i;
memory_set_decrypted_region(space, 0x0000, 0x7fff, decrypt);
space->set_decrypted_region(0x0000, 0x7fff, decrypt);
/* Address lines scrambling */
memcpy(decrypt, RAM, size);

4
src/mame/drivers/system1.c
View File

@ -4649,7 +4649,7 @@ static DRIVER_INIT( nobb )
static DRIVER_INIT( bootleg )
{
address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM);
memory_set_decrypted_region(space, 0x0000, 0x7fff, memory_region(machine, "maincpu") + 0x10000);
space->set_decrypted_region(0x0000, 0x7fff, memory_region(machine, "maincpu") + 0x10000);
DRIVER_INIT_CALL(bank00);
}
@ -4657,7 +4657,7 @@ static DRIVER_INIT( bootleg )
static DRIVER_INIT( bootsys2 )
{
address_space *space = cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM);
memory_set_decrypted_region(space, 0x0000, 0x7fff, memory_region(machine, "maincpu") + 0x20000);
space->set_decrypted_region(0x0000, 0x7fff, memory_region(machine, "maincpu") + 0x20000);
memory_configure_bank_decrypted(machine, "bank1", 0, 4, memory_region(machine, "maincpu") + 0x30000, 0x4000);
DRIVER_INIT_CALL(bank0c);
}

2
src/mame/drivers/system16.c
View File

@ -3375,7 +3375,7 @@ static DRIVER_INIT( goldnaxeb1 )
state->decrypted_region[i] = ROM[i] ^ data[(i & 0xfff) ^ 1];
}
memory_set_decrypted_region(space, 0x00000, 0xbffff, state->decrypted_region);
space->set_decrypted_region(0x00000, 0xbffff, state->decrypted_region);
DRIVER_INIT_CALL(common);

2
src/mame/drivers/tcl.c
View File

@ -206,7 +206,7 @@ static DRIVER_INIT(tcl)
}
auto_free(machine, src);
memory_set_decrypted_region(space, 0x0000, 0x7fff, dest+0x10000);
space->set_decrypted_region(0x0000, 0x7fff, dest+0x10000);
}
GAME( 1995, tcl, 0, tcl, tcl, tcl, ROT0, "Uniwang", "Taiwan Chess Legend", GAME_NOT_WORKING )

2
src/mame/drivers/toki.c
View File

@ -841,7 +841,7 @@ static DRIVER_INIT(jujub)
memcpy(decrypt,rom,0x20000);
memory_set_decrypted_region(space, 0x0000, 0x1fff, decrypt);
space->set_decrypted_region(0x0000, 0x1fff, decrypt);
for (i = 0;i < 0x2000;i++)
{

2
src/mame/drivers/trackfld.c
View File

@ -1381,7 +1381,7 @@ static DRIVER_INIT( atlantol )
for (A = 0; A < 0x6000; A++)
decrypt[A] = rom[A];
memory_set_decrypted_region(space, 0x0000, 0xffff, decrypt);
space->set_decrypted_region(0x0000, 0xffff, decrypt);
memory_install_write8_handler(space, 0x0800, 0x0800, 0, 0, atlantol_gfxbank_w);
memory_nop_write(space, 0x1000, 0x1000, 0, 0);

2
src/mame/drivers/wiz.c
View File

@ -1056,7 +1056,7 @@ static DRIVER_INIT( stinger )
int A;
const UINT8 *tbl;
memory_set_decrypted_region(space, 0x0000, 0xffff, decrypt);
space->set_decrypted_region(0x0000, 0xffff, decrypt);
for (A = 0x0000;A < 0x10000;A++)
{

2
src/mame/drivers/zaxxon.c
View File

@ -1455,7 +1455,7 @@ static void zaxxonj_decode(running_machine *machine, const char *cputag)
int size = memory_region_length(machine, cputag);
UINT8 *decrypt = auto_alloc_array(machine, UINT8, size);
memory_set_decrypted_region(space, 0x0000, size - 1, decrypt);
space->set_decrypted_region(0x0000, size - 1, decrypt);
for (A = 0x0000; A < size; A++)
{

2
src/mame/machine/cclimber.c
View File

@ -11,7 +11,7 @@ static void cclimber_decode(running_machine *machine, const UINT8 convtable[8][1
UINT8 *decrypt = auto_alloc_array(machine, UINT8, 0x10000);
int A;
memory_set_decrypted_region(space, 0x0000, 0xffff, decrypt);
space->set_decrypted_region(0x0000, 0xffff, decrypt);
for (A = 0x0000;A < 0x10000;A++)
{

2
src/mame/machine/cps2crpt.c
View File

@ -720,7 +720,7 @@ static void cps2_decrypt(running_machine *machine, const UINT32 *master_key, UIN
}
}
memory_set_decrypted_region(space, 0x000000, length - 1, dec);
space->set_decrypted_region(0x000000, length - 1, dec);
m68k_set_encrypted_opcode_range(machine->device("maincpu"), 0, length);
}

2
src/mame/machine/deco102.c
View File

@ -58,7 +58,7 @@ void deco102_decrypt_cpu(running_machine *machine, const char *cputag, int addre
memcpy(buf, rom, size);
memory_set_decrypted_region(space, 0, size - 1, opcodes);
space->set_decrypted_region(0, size - 1, opcodes);
m68k_set_encrypted_opcode_range(machine->device(cputag), 0, size);
for (i = 0; i < size / 2; i++)

2
src/mame/machine/fd1089.c
View File

@ -411,7 +411,7 @@ static void sys16_decrypt(running_machine *machine, const UINT8 *key,int cputype
decrypted = auto_alloc_array(machine, UINT16, size/2);
machine->add_notifier(MACHINE_NOTIFY_EXIT, clear_decrypted);
memory_set_decrypted_region(space, 0x000000, size - 1, decrypted);
space->set_decrypted_region(0x000000, size - 1, decrypted);
for (A = 0;A < size;A+=2)
{

2
src/mame/machine/galaxold.c
View File

@ -323,7 +323,7 @@ DRIVER_INIT( moonqsr )
UINT8 *rom = memory_region(machine, "maincpu");
UINT8 *decrypt = auto_alloc_array(machine, UINT8, 0x8000);
memory_set_decrypted_region(space, 0x0000, 0x7fff, decrypt);
space->set_decrypted_region(0x0000, 0x7fff, decrypt);
for (i = 0;i < 0x8000;i++)
decrypt[i] = decode_mooncrst(rom[i],i);

4
src/mame/machine/kabuki.c
View File

@ -167,7 +167,7 @@ static void mitchell_decode(running_machine *machine, int swap_key1,int swap_key
int numbanks = (memory_region_length(machine, "maincpu") - 0x10000) / 0x4000;
int i;
memory_set_decrypted_region(space, 0x0000, 0x7fff, decrypt);
space->set_decrypted_region(0x0000, 0x7fff, decrypt);
kabuki_decode(rom,decrypt,rom,0x0000,0x8000, swap_key1,swap_key2,addr_key,xor_key);
rom += 0x10000;
@ -206,7 +206,7 @@ static void cps1_decode(running_machine *machine,int swap_key1,int swap_key2,int
UINT8 *decrypt = auto_alloc_array(machine, UINT8, 0x8000);
UINT8 *rom = memory_region(machine, "audiocpu");
memory_set_decrypted_region(space, 0x0000, 0x7fff, decrypt);
space->set_decrypted_region(0x0000, 0x7fff, decrypt);
kabuki_decode(rom,decrypt,rom,0x0000,0x8000, swap_key1,swap_key2,addr_key,xor_key);
}

2
src/mame/machine/konami1.c
View File

@ -48,7 +48,7 @@ UINT8 *konami1_decode(running_machine *machine, const char *cpu)
int A;
UINT8 *decrypted = auto_alloc_array(machine, UINT8, size);
memory_set_decrypted_region(space, 0x0000, 0xffff, decrypted);
space->set_decrypted_region(0x0000, 0xffff, decrypted);
for (A = 0;A < size;A++)
{

2
src/mame/machine/mc8123.c
View File

@ -385,7 +385,7 @@ void mc8123_decrypt_rom(running_machine *machine, const char *cpu, const char *k
UINT8 *key = memory_region(machine, keyrgn);
int A, bank;
memory_set_decrypted_region(space, 0x0000, fixed_length-1, decrypted1);
space->set_decrypted_region(0x0000, fixed_length-1, decrypted1);
for (A = 0x0000;A < fixed_length;A++)
{

2
src/mame/machine/s16fd.c
View File

@ -45,7 +45,7 @@ static void set_decrypted_region(running_machine *machine)
if (fd1094_set_decrypted != NULL)
(*fd1094_set_decrypted)(machine, (UINT8 *)fd1094_userregion);
else
memory_set_decrypted_region(cputag_get_address_space(machine, fd1094_cputag, ADDRESS_SPACE_PROGRAM), 0, fd1094_cpuregionsize - 1, fd1094_userregion);
machine->device<cpu_device>(fd1094_cputag)->space(AS_PROGRAM)->set_decrypted_region(0, fd1094_cpuregionsize - 1, fd1094_userregion);
}
/* this function checks the cache to see if the current state is cached,

4
src/mame/machine/s24fd.c
View File

@ -55,7 +55,7 @@ static void s24_fd1094_setstate_and_decrypt(running_machine *machine, int state)
{
/* copy cached state */
s24_fd1094_userregion = s24_fd1094_cacheregion[i];
memory_set_decrypted_region(cputag_get_address_space(machine, "sub", ADDRESS_SPACE_PROGRAM), 0, s24_fd1094_cpuregionsize - 1, s24_fd1094_userregion);
machine->device<cpu_device>("sub")->space(AS_PROGRAM)->set_decrypted_region(0, s24_fd1094_cpuregionsize - 1, s24_fd1094_userregion);
m68k_set_encrypted_opcode_range(machine->device("sub"), 0, s24_fd1094_cpuregionsize);
return;
@ -76,7 +76,7 @@ static void s24_fd1094_setstate_and_decrypt(running_machine *machine, int state)
/* copy newly decrypted data to user region */
s24_fd1094_userregion = s24_fd1094_cacheregion[fd1094_current_cacheposition];
memory_set_decrypted_region(cputag_get_address_space(machine, "sub", ADDRESS_SPACE_PROGRAM), 0, s24_fd1094_cpuregionsize - 1, s24_fd1094_userregion);
machine->device<cpu_device>("sub")->space(AS_PROGRAM)->set_decrypted_region(0, s24_fd1094_cpuregionsize - 1, s24_fd1094_userregion);
m68k_set_encrypted_opcode_range(machine->device("sub"), 0, s24_fd1094_cpuregionsize);
fd1094_current_cacheposition++;

2
src/mame/machine/segacrp2.c
View File

@ -64,7 +64,7 @@ static void sega_decode_2(running_machine *machine,const char *cputag,
UINT8 *rom = memory_region(machine, cputag);
UINT8 *decrypted = auto_alloc_array(machine, UINT8, 0x8000);
memory_set_decrypted_region(space, 0x0000, 0x7fff, decrypted);
space->set_decrypted_region(0x0000, 0x7fff, decrypted);
for (A = 0x0000;A < 0x8000;A++)

6
src/mame/machine/segacrpt.c
View File

@ -223,7 +223,7 @@ static void sega_decode(running_machine *machine, const char *cputag, const UINT
UINT8 *rom = memory_region(machine, cputag);
UINT8 *decrypted = auto_alloc_array(machine, UINT8, 0xc000);
memory_set_decrypted_region(space, 0x0000, cryptlen - 1, decrypted);
space->set_decrypted_region(0x0000, cryptlen - 1, decrypted);
for (A = 0x0000;A < cryptlen;A++)
{
@ -473,7 +473,7 @@ void toprollr_decode(running_machine *machine, const char *cputag, const char *r
memory_configure_bank(machine, "bank1",0,3, memory_region(machine, regiontag),0x6000);
memory_configure_bank_decrypted(machine, "bank1",0,3,decrypted,0x6000);
memory_set_decrypted_region(space, 0x0000, 0x5fff, decrypted);
space->set_decrypted_region(0x0000, 0x5fff, decrypted);
memory_set_bank(space->machine, "bank1", 0);
}
@ -832,7 +832,7 @@ void jongkyo_decode(running_machine *machine, const char *cputag)
memory_configure_bank(machine, "bank1",0,8, memory_region(machine, cputag)+0x7000,0x0400);
memory_configure_bank_decrypted(machine, "bank1",0,8,decrypted+0x7000,0x0400);
memory_set_decrypted_region(space, 0x0000, 0x6bff, decrypted);
space->set_decrypted_region(0x0000, 0x6bff, decrypted);
memory_set_bank(space->machine, "bank1", 0);
}

2
src/mame/machine/segas32.c
View File

@ -42,7 +42,7 @@ static void nec_v25_cpu_decrypt(running_machine *machine)
UINT8* temp = auto_alloc_array(machine, UINT8, 0x100000);
// set CPU3 opcode base
memory_set_decrypted_region(space, 0x00000, 0xfffff, decrypted);
space->set_decrypted_region(0x00000, 0xfffff, decrypted);
// make copy of ROM so original can be overwritten
memcpy(temp, rom, 0x10000);

2
src/mame/machine/stfight.c
View File

@ -54,7 +54,7 @@ DRIVER_INIT( empcity )
int A;
decrypt = auto_alloc_array(machine, UINT8, 0x8000);
memory_set_decrypted_region(space, 0x0000, 0x7fff, decrypt);
space->set_decrypted_region(0x0000, 0x7fff, decrypt);
for (A = 0;A < 0x8000;A++)
{

2
src/mame/video/jaguar.c
View File

@ -494,7 +494,7 @@ static void jaguar_set_palette(UINT16 vmode)
static UINT8 *get_jaguar_memory(running_machine *machine, UINT32 offset)
{
address_space *space = cputag_get_address_space(machine, "gpu", ADDRESS_SPACE_PROGRAM);
return (UINT8 *)memory_get_read_ptr(space, offset);
return (UINT8 *)space->get_read_ptr(offset);
}