summaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
author Vas Crabb <vas@vastheman.com>2017-12-01 05:34:53 +1100
committer Vas Crabb <vas@vastheman.com>2017-12-01 05:34:53 +1100
commit199f92a2b0fa29da5ce52fce8114a4331dd3466b (patch)
tree308c7f414d3410b0862a57b05c971724ce36b65a
parent19addd3df55fd79735653c6894835c4ac5fce45c (diff)
(nw) misc cleanup: start replacing auto_alloc_* with smart pointers, get
rid of reference constants in the debugger in favour of capturing the value in the bind/lambda (less ugly casting)
-rw-r--r--src/devices/cpu/i386/i386.cpp33
-rw-r--r--src/emu/debug/debugcmd.cpp25
-rw-r--r--src/emu/debug/debugcmd.h18
-rw-r--r--src/emu/debug/debugcpu.cpp96
-rw-r--r--src/emu/debug/debugcpu.h22
-rw-r--r--src/emu/debug/express.cpp73
-rw-r--r--src/emu/debug/express.h13
-rw-r--r--src/frontend/mame/cheat.cpp8
-rw-r--r--src/frontend/mame/cheat.h4
-rw-r--r--src/mame/drivers/amusco.cpp7
-rw-r--r--src/mame/drivers/coolridr.cpp180
-rw-r--r--src/mame/includes/cave.h53
-rw-r--r--src/mame/includes/wecleman.h34
-rw-r--r--src/mame/video/cave.cpp34
-rw-r--r--src/mame/video/wecleman.cpp77
15 files changed, 310 insertions, 367 deletions
diff --git a/src/devices/cpu/i386/i386.cpp b/src/devices/cpu/i386/i386.cpp
index 637af658c6e..15379c18d7b 100644
--- a/src/devices/cpu/i386/i386.cpp
+++ b/src/devices/cpu/i386/i386.cpp
@@ -3171,36 +3171,13 @@ uint64_t i386_device::debug_virttophys(symbol_table &table, int params, const ui
return result;
}
-uint64_t i386_debug_segbase(symbol_table &table, void *ref, int params, const uint64_t *param)
-{
- i386_device *i386 = (i386_device *)(ref);
- return i386->debug_segbase(table, params, param);
-}
-
-uint64_t i386_debug_seglimit(symbol_table &table, void *ref, int params, const uint64_t *param)
-{
- i386_device *i386 = (i386_device *)(ref);
- return i386->debug_seglimit(table, params, param);
-}
-
-uint64_t i386_debug_segofftovirt(symbol_table &table, void *ref, int params, const uint64_t *param)
-{
- i386_device *i386 = (i386_device *)(ref);
- return i386->debug_segofftovirt(table, params, param);
-}
-
-static uint64_t i386_debug_virttophys(symbol_table &table, void *ref, int params, const uint64_t *param)
-{
- i386_device *i386 = (i386_device *)(ref);
- return i386->debug_virttophys(table, params, param);
-}
-
void i386_device::device_debug_setup()
{
- debug()->symtable().add("segbase", (void *)this, 1, 1, i386_debug_segbase);
- debug()->symtable().add("seglimit", (void *)this, 1, 1, i386_debug_seglimit);
- debug()->symtable().add("segofftovirt", (void *)this, 2, 2, i386_debug_segofftovirt);
- debug()->symtable().add("virttophys", (void *)this, 1, 1, i386_debug_virttophys);
+ using namespace std::placeholders;
+ debug()->symtable().add("segbase", 1, 1, std::bind(&i386_device::debug_segbase, this, _1, _2, _3));
+ debug()->symtable().add("seglimit", 1, 1, std::bind(&i386_device::debug_seglimit, this, _1, _2, _3));
+ debug()->symtable().add("segofftovirt", 2, 2, std::bind(&i386_device::debug_segofftovirt, this, _1, _2, _3));
+ debug()->symtable().add("virttophys", 1, 1, std::bind(&i386_device::debug_virttophys, this, _1, _2, _3));
}
/*************************************************************************/
diff --git a/src/emu/debug/debugcmd.cpp b/src/emu/debug/debugcmd.cpp
index 40fd990f037..18f581361fd 100644
--- a/src/emu/debug/debugcmd.cpp
+++ b/src/emu/debug/debugcmd.cpp
@@ -100,15 +100,15 @@ debugger_commands::debugger_commands(running_machine& machine, debugger_cpu& cpu
, m_cpu(cpu)
, m_console(console)
{
- m_global_array = auto_alloc_array_clear(m_machine, global_entry, MAX_GLOBALS);
+ m_global_array = std::make_unique<global_entry []>(MAX_GLOBALS);
symbol_table *symtable = m_cpu.get_global_symtable();
/* add a few simple global functions */
using namespace std::placeholders;
- symtable->add("min", nullptr, 2, 2, std::bind(&debugger_commands::execute_min, this, _1, _2, _3, _4));
- symtable->add("max", nullptr, 2, 2, std::bind(&debugger_commands::execute_max, this, _1, _2, _3, _4));
- symtable->add("if", nullptr, 3, 3, std::bind(&debugger_commands::execute_if, this, _1, _2, _3, _4));
+ symtable->add("min", 2, 2, std::bind(&debugger_commands::execute_min, this, _1, _2, _3));
+ symtable->add("max", 2, 2, std::bind(&debugger_commands::execute_max, this, _1, _2, _3));
+ symtable->add("if", 3, 3, std::bind(&debugger_commands::execute_if, this, _1, _2, _3));
/* add all single-entry save state globals */
for (int itemnum = 0; itemnum < MAX_GLOBALS; itemnum++)
@@ -128,7 +128,10 @@ debugger_commands::debugger_commands(running_machine& machine, debugger_cpu& cpu
sprintf(symname, ".%s", strrchr(name, '/') + 1);
m_global_array[itemnum].base = base;
m_global_array[itemnum].size = valsize;
- symtable->add(symname, &m_global_array, std::bind(&debugger_commands::global_get, this, _1, _2), std::bind(&debugger_commands::global_set, this, _1, _2, _3));
+ symtable->add(
+ symname,
+ std::bind(&debugger_commands::global_get, this, _1, &m_global_array[itemnum]),
+ std::bind(&debugger_commands::global_set, this, _1, &m_global_array[itemnum], _2));
}
}
@@ -293,7 +296,7 @@ debugger_commands::debugger_commands(running_machine& machine, debugger_cpu& cpu
execute_min - return the minimum of two values
-------------------------------------------------*/
-u64 debugger_commands::execute_min(symbol_table &table, void *ref, int params, const u64 *param)
+u64 debugger_commands::execute_min(symbol_table &table, int params, const u64 *param)
{
return (param[0] < param[1]) ? param[0] : param[1];
}
@@ -303,7 +306,7 @@ u64 debugger_commands::execute_min(symbol_table &table, void *ref, int params, c
execute_max - return the maximum of two values
-------------------------------------------------*/
-u64 debugger_commands::execute_max(symbol_table &table, void *ref, int params, const u64 *param)
+u64 debugger_commands::execute_max(symbol_table &table, int params, const u64 *param)
{
return (param[0] > param[1]) ? param[0] : param[1];
}
@@ -313,7 +316,7 @@ u64 debugger_commands::execute_max(symbol_table &table, void *ref, int params, c
execute_if - if (a) return b; else return c;
-------------------------------------------------*/
-u64 debugger_commands::execute_if(symbol_table &table, void *ref, int params, const u64 *param)
+u64 debugger_commands::execute_if(symbol_table &table, int params, const u64 *param)
{
return param[0] ? param[1] : param[2];
}
@@ -328,9 +331,8 @@ u64 debugger_commands::execute_if(symbol_table &table, void *ref, int params, co
global_get - symbol table getter for globals
-------------------------------------------------*/
-u64 debugger_commands::global_get(symbol_table &table, void *ref)
+u64 debugger_commands::global_get(symbol_table &table, global_entry *global)
{
- global_entry *global = (global_entry *)ref;
switch (global->size)
{
case 1: return *(u8 *)global->base;
@@ -346,9 +348,8 @@ u64 debugger_commands::global_get(symbol_table &table, void *ref)
global_set - symbol table setter for globals
-------------------------------------------------*/
-void debugger_commands::global_set(symbol_table &table, void *ref, u64 value)
+void debugger_commands::global_set(symbol_table &table, global_entry *global, u64 value)
{
- global_entry *global = (global_entry *)ref;
switch (global->size)
{
case 1: *(u8 *)global->base = value; break;
diff --git a/src/emu/debug/debugcmd.h b/src/emu/debug/debugcmd.h
index 7eca669908e..98b6d8ae03d 100644
--- a/src/emu/debug/debugcmd.h
+++ b/src/emu/debug/debugcmd.h
@@ -37,8 +37,10 @@ public:
private:
struct global_entry
{
- void * base;
- u32 size;
+ global_entry() { }
+
+ void * base = nullptr;
+ u32 size = 0;
};
@@ -79,12 +81,12 @@ private:
u64 cheat_byte_swap(const cheat_system *cheatsys, u64 value);
u64 cheat_read_extended(const cheat_system *cheatsys, address_space &space, offs_t address);
- u64 execute_min(symbol_table &table, void *ref, int params, const u64 *param);
- u64 execute_max(symbol_table &table, void *ref, int params, const u64 *param);
- u64 execute_if(symbol_table &table, void *ref, int params, const u64 *param);
+ u64 execute_min(symbol_table &table, int params, const u64 *param);
+ u64 execute_max(symbol_table &table, int params, const u64 *param);
+ u64 execute_if(symbol_table &table, int params, const u64 *param);
- u64 global_get(symbol_table &table, void *ref);
- void global_set(symbol_table &table, void *ref, u64 value);
+ u64 global_get(symbol_table &table, global_entry *global);
+ void global_set(symbol_table &table, global_entry *global, u64 value);
int mini_printf(char *buffer, const char *format, int params, u64 *param);
@@ -162,7 +164,7 @@ private:
debugger_cpu& m_cpu;
debugger_console& m_console;
- global_entry *m_global_array;
+ std::unique_ptr<global_entry []> m_global_array;
cheat_system m_cheat;
static const size_t MAX_GLOBALS;
diff --git a/src/emu/debug/debugcpu.cpp b/src/emu/debug/debugcpu.cpp
index c5f5a532599..60c41c0b5ee 100644
--- a/src/emu/debug/debugcpu.cpp
+++ b/src/emu/debug/debugcpu.cpp
@@ -72,10 +72,10 @@ debugger_cpu::debugger_cpu(running_machine &machine)
m_symtable->add("wpdata", symbol_table::READ_ONLY, &m_wpdata);
using namespace std::placeholders;
- m_symtable->add("cpunum", nullptr, std::bind(&debugger_cpu::get_cpunum, this, _1, _2));
- m_symtable->add("beamx", (void *)first_screen, std::bind(&debugger_cpu::get_beamx, this, _1, _2));
- m_symtable->add("beamy", (void *)first_screen, std::bind(&debugger_cpu::get_beamy, this, _1, _2));
- m_symtable->add("frame", (void *)first_screen, std::bind(&debugger_cpu::get_frame, this, _1, _2));
+ m_symtable->add("cpunum", std::bind(&debugger_cpu::get_cpunum, this, _1));
+ m_symtable->add("beamx", std::bind(&debugger_cpu::get_beamx, this, _1, first_screen));
+ m_symtable->add("beamy", std::bind(&debugger_cpu::get_beamy, this, _1, first_screen));
+ m_symtable->add("frame", std::bind(&debugger_cpu::get_frame, this, _1, first_screen));
/* add the temporary variables to the global symbol table */
for (int regnum = 0; regnum < NUM_TEMP_VARIABLES; regnum++)
@@ -1341,9 +1341,8 @@ expression_error::error_code debugger_cpu::expression_validate(void *param, cons
get_beamx - get beam horizontal position
-------------------------------------------------*/
-u64 debugger_cpu::get_beamx(symbol_table &table, void *ref)
+u64 debugger_cpu::get_beamx(symbol_table &table, screen_device *screen)
{
- screen_device *screen = reinterpret_cast<screen_device *>(ref);
return (screen != nullptr) ? screen->hpos() : 0;
}
@@ -1352,9 +1351,8 @@ u64 debugger_cpu::get_beamx(symbol_table &table, void *ref)
get_beamy - get beam vertical position
-------------------------------------------------*/
-u64 debugger_cpu::get_beamy(symbol_table &table, void *ref)
+u64 debugger_cpu::get_beamy(symbol_table &table, screen_device *screen)
{
- screen_device *screen = reinterpret_cast<screen_device *>(ref);
return (screen != nullptr) ? screen->vpos() : 0;
}
@@ -1363,9 +1361,8 @@ u64 debugger_cpu::get_beamy(symbol_table &table, void *ref)
get_frame - get current frame number
-------------------------------------------------*/
-u64 debugger_cpu::get_frame(symbol_table &table, void *ref)
+u64 debugger_cpu::get_frame(symbol_table &table, screen_device *screen)
{
- screen_device *screen = reinterpret_cast<screen_device *>(ref);
return (screen != nullptr) ? screen->frame_number() : 0;
}
@@ -1375,7 +1372,7 @@ u64 debugger_cpu::get_frame(symbol_table &table, void *ref)
'cpunum' symbol
-------------------------------------------------*/
-u64 debugger_cpu::get_cpunum(symbol_table &table, void *ref)
+u64 debugger_cpu::get_cpunum(symbol_table &table)
{
execute_interface_iterator iter(m_machine.root_device());
return iter.indexof(m_visiblecpu->execute());
@@ -1538,22 +1535,34 @@ device_debug::device_debug(device_t &device)
// add global symbol for cycles and totalcycles
if (m_exec != nullptr)
{
- m_symtable.add("cycles", nullptr, get_cycles);
- m_symtable.add("totalcycles", nullptr, get_totalcycles);
- m_symtable.add("lastinstructioncycles", nullptr, get_lastinstructioncycles);
+ m_symtable.add("cycles", get_cycles);
+ m_symtable.add("totalcycles", get_totalcycles);
+ m_symtable.add("lastinstructioncycles", get_lastinstructioncycles);
}
// add entries to enable/disable unmap reporting for each space
if (m_memory != nullptr)
{
if (m_memory->has_space(AS_PROGRAM))
- m_symtable.add("logunmap", (void *)&m_memory->space(AS_PROGRAM), get_logunmap, set_logunmap);
+ m_symtable.add(
+ "logunmap",
+ [&space = m_memory->space(AS_PROGRAM)] (symbol_table &table) { return space.log_unmap(); },
+ [&space = m_memory->space(AS_PROGRAM)] (symbol_table &table, u64 value) { return space.set_log_unmap(bool(value)); });
if (m_memory->has_space(AS_DATA))
- m_symtable.add("logunmapd", (void *)&m_memory->space(AS_DATA), get_logunmap, set_logunmap);
+ m_symtable.add(
+ "logunmap",
+ [&space = m_memory->space(AS_DATA)] (symbol_table &table) { return space.log_unmap(); },
+ [&space = m_memory->space(AS_DATA)] (symbol_table &table, u64 value) { return space.set_log_unmap(bool(value)); });
if (m_memory->has_space(AS_IO))
- m_symtable.add("logunmapi", (void *)&m_memory->space(AS_IO), get_logunmap, set_logunmap);
+ m_symtable.add(
+ "logunmap",
+ [&space = m_memory->space(AS_IO)] (symbol_table &table) { return space.log_unmap(); },
+ [&space = m_memory->space(AS_IO)] (symbol_table &table, u64 value) { return space.set_log_unmap(bool(value)); });
if (m_memory->has_space(AS_OPCODES))
- m_symtable.add("logunmapo", (void *)&m_memory->space(AS_OPCODES), get_logunmap, set_logunmap);
+ m_symtable.add(
+ "logunmap",
+ [&space = m_memory->space(AS_OPCODES)] (symbol_table &table) { return space.log_unmap(); },
+ [&space = m_memory->space(AS_OPCODES)] (symbol_table &table, u64 value) { return space.set_log_unmap(bool(value)); });
}
// add all registers into it
@@ -1563,8 +1572,13 @@ device_debug::device_debug(device_t &device)
// TODO: floating point registers
if (!entry->is_float())
{
+ using namespace std::placeholders;
strmakelower(tempstr.assign(entry->symbol()));
- m_symtable.add(tempstr.c_str(), (void *)(uintptr_t)entry->index(), get_state, entry->writeable() ? set_state : nullptr, entry->format_string());
+ m_symtable.add(
+ tempstr.c_str(),
+ std::bind(&device_debug::get_state, _1, entry->index()),
+ entry->writeable() ? std::bind(&device_debug::set_state, _1, entry->index(), _2) : symbol_table::setter_func(nullptr),
+ entry->format_string());
}
}
}
@@ -1575,8 +1589,8 @@ device_debug::device_debug(device_t &device)
m_flags = DEBUG_FLAG_OBSERVING | DEBUG_FLAG_HISTORY;
// if no curpc, add one
- if (m_state != nullptr && m_symtable.find("curpc") == nullptr)
- m_symtable.add("curpc", nullptr, get_current_pc);
+ if (m_state && !m_symtable.find("curpc"))
+ m_symtable.add("curpc", get_current_pc);
}
// set up trace
@@ -2875,7 +2889,7 @@ void device_debug::hotspot_check(address_space &space, offs_t address)
// current instruction pointer
//-------------------------------------------------
-u64 device_debug::get_current_pc(symbol_table &table, void *ref)
+u64 device_debug::get_current_pc(symbol_table &table)
{
device_t *device = reinterpret_cast<device_t *>(table.globalref());
return device->safe_pcbase();
@@ -2887,7 +2901,7 @@ u64 device_debug::get_current_pc(symbol_table &table, void *ref)
// 'cycles' symbol
//-------------------------------------------------
-u64 device_debug::get_cycles(symbol_table &table, void *ref)
+u64 device_debug::get_cycles(symbol_table &table)
{
device_t *device = reinterpret_cast<device_t *>(table.globalref());
return device->debug()->m_exec->cycles_remaining();
@@ -2899,7 +2913,7 @@ u64 device_debug::get_cycles(symbol_table &table, void *ref)
// 'totalcycles' symbol
//-------------------------------------------------
-u64 device_debug::get_totalcycles(symbol_table &table, void *ref)
+u64 device_debug::get_totalcycles(symbol_table &table)
{
device_t *device = reinterpret_cast<device_t *>(table.globalref());
return device->debug()->m_total_cycles;
@@ -2911,7 +2925,7 @@ u64 device_debug::get_totalcycles(symbol_table &table, void *ref)
// 'lastinstructioncycles' symbol
//-------------------------------------------------
-u64 device_debug::get_lastinstructioncycles(symbol_table &table, void *ref)
+u64 device_debug::get_lastinstructioncycles(symbol_table &table)
{
device_t *device = reinterpret_cast<device_t *>(table.globalref());
device_debug *debug = device->debug();
@@ -2920,38 +2934,14 @@ u64 device_debug::get_lastinstructioncycles(symbol_table &table, void *ref)
//-------------------------------------------------
-// get_logunmap - getter callback for the logumap
-// symbols
-//-------------------------------------------------
-
-u64 device_debug::get_logunmap(symbol_table &table, void *ref)
-{
- address_space &space = *reinterpret_cast<address_space *>(table.globalref());
- return space.log_unmap();
-}
-
-
-//-------------------------------------------------
-// set_logunmap - setter callback for the logumap
-// symbols
-//-------------------------------------------------
-
-void device_debug::set_logunmap(symbol_table &table, void *ref, u64 value)
-{
- address_space &space = *reinterpret_cast<address_space *>(table.globalref());
- space.set_log_unmap(value ? true : false);
-}
-
-
-//-------------------------------------------------
// get_state - getter callback for a device's
// state symbols
//-------------------------------------------------
-u64 device_debug::get_state(symbol_table &table, void *ref)
+u64 device_debug::get_state(symbol_table &table, int index)
{
device_t *device = reinterpret_cast<device_t *>(table.globalref());
- return device->debug()->m_state->state_int(reinterpret_cast<uintptr_t>(ref));
+ return device->debug()->m_state->state_int(index);
}
@@ -2960,10 +2950,10 @@ u64 device_debug::get_state(symbol_table &table, void *ref)
// state symbols
//-------------------------------------------------
-void device_debug::set_state(symbol_table &table, void *ref, u64 value)
+void device_debug::set_state(symbol_table &table, int index, u64 value)
{
device_t *device = reinterpret_cast<device_t *>(table.globalref());
- device->debug()->m_state->set_state_int(reinterpret_cast<uintptr_t>(ref), value);
+ device->debug()->m_state->set_state_int(index, value);
}
diff --git a/src/emu/debug/debugcpu.h b/src/emu/debug/debugcpu.h
index e00ac9576cc..388e497cb0a 100644
--- a/src/emu/debug/debugcpu.h
+++ b/src/emu/debug/debugcpu.h
@@ -288,14 +288,12 @@ private:
void hotspot_check(address_space &space, offs_t address);
// symbol get/set callbacks
- static u64 get_current_pc(symbol_table &table, void *ref);
- static u64 get_cycles(symbol_table &table, void *ref);
- static u64 get_totalcycles(symbol_table &table, void *ref);
- static u64 get_lastinstructioncycles(symbol_table &table, void *ref);
- static u64 get_logunmap(symbol_table &table, void *ref);
- static void set_logunmap(symbol_table &table, void *ref, u64 value);
- static u64 get_state(symbol_table &table, void *ref);
- static void set_state(symbol_table &table, void *ref, u64 value);
+ static u64 get_current_pc(symbol_table &table);
+ static u64 get_cycles(symbol_table &table);
+ static u64 get_totalcycles(symbol_table &table);
+ static u64 get_lastinstructioncycles(symbol_table &table);
+ static u64 get_state(symbol_table &table, int index);
+ static void set_state(symbol_table &table, int index, u64 value);
// basic device information
device_t & m_device; // device we are attached to
@@ -585,10 +583,10 @@ private:
device_t* expression_get_device(const char *tag);
/* variable getters/setters */
- u64 get_cpunum(symbol_table &table, void *ref);
- u64 get_beamx(symbol_table &table, void *ref);
- u64 get_beamy(symbol_table &table, void *ref);
- u64 get_frame(symbol_table &table, void *ref);
+ u64 get_cpunum(symbol_table &table);
+ u64 get_beamx(symbol_table &table, screen_device *screen);
+ u64 get_beamy(symbol_table &table, screen_device *screen);
+ u64 get_frame(symbol_table &table, screen_device *screen);
/* internal helpers */
void on_vblank(screen_device &device, bool vblank_state);
diff --git a/src/emu/debug/express.cpp b/src/emu/debug/express.cpp
index 9661d80a35a..06e12e09800 100644
--- a/src/emu/debug/express.cpp
+++ b/src/emu/debug/express.cpp
@@ -114,7 +114,7 @@ public:
// construction/destruction
integer_symbol_entry(symbol_table &table, const char *name, symbol_table::read_write rw, u64 *ptr = nullptr);
integer_symbol_entry(symbol_table &table, const char *name, u64 constval);
- integer_symbol_entry(symbol_table &table, const char *name, void *ref, symbol_table::getter_func getter, symbol_table::setter_func setter, const std::string &format);
+ integer_symbol_entry(symbol_table &table, const char *name, symbol_table::getter_func getter, symbol_table::setter_func setter, const std::string &format);
// symbol access
virtual bool is_lval() const override;
@@ -122,10 +122,6 @@ public:
virtual void set_value(u64 newvalue) override;
private:
- // internal helpers
- static u64 internal_getter(symbol_table &table, void *symref);
- static void internal_setter(symbol_table &table, void *symref, u64 value);
-
// internal state
symbol_table::getter_func m_getter;
symbol_table::setter_func m_setter;
@@ -138,7 +134,7 @@ class function_symbol_entry : public symbol_entry
{
public:
// construction/destruction
- function_symbol_entry(symbol_table &table, const char *name, void *ref, int minparams, int maxparams, symbol_table::execute_func execute);
+ function_symbol_entry(symbol_table &table, const char *name, int minparams, int maxparams, symbol_table::execute_func execute);
// symbol access
virtual bool is_lval() const override;
@@ -203,13 +199,12 @@ const char *expression_error::code_string() const
// symbol_entry - constructor
//-------------------------------------------------
-symbol_entry::symbol_entry(symbol_table &table, symbol_type type, const char *name, const std::string &format, void *ref)
+symbol_entry::symbol_entry(symbol_table &table, symbol_type type, const char *name, const std::string &format)
: m_next(nullptr),
m_table(table),
m_type(type),
m_name(name),
- m_format(format),
- m_ref(ref)
+ m_format(format)
{
}
@@ -233,25 +228,31 @@ symbol_entry::~symbol_entry()
//-------------------------------------------------
integer_symbol_entry::integer_symbol_entry(symbol_table &table, const char *name, symbol_table::read_write rw, u64 *ptr)
- : symbol_entry(table, SMT_INTEGER, name, "", (ptr == nullptr) ? &m_value : ptr),
- m_getter(internal_getter),
- m_setter((rw == symbol_table::READ_ONLY) ? nullptr : internal_setter),
+ : symbol_entry(table, SMT_INTEGER, name, ""),
+ m_getter(ptr
+ ? symbol_table::getter_func([ptr] (symbol_table &table) { return *ptr; })
+ : symbol_table::getter_func([this] (symbol_table &table) { return m_value; })),
+ m_setter((rw == symbol_table::READ_ONLY)
+ ? symbol_table::setter_func(nullptr)
+ : ptr
+ ? symbol_table::setter_func([ptr] (symbol_table &table, u64 value) { *ptr = value; })
+ : symbol_table::setter_func([this] (symbol_table &table, u64 value) { m_value = value; })),
m_value(0)
{
}
integer_symbol_entry::integer_symbol_entry(symbol_table &table, const char *name, u64 constval)
- : symbol_entry(table, SMT_INTEGER, name, "", &m_value),
- m_getter(internal_getter),
+ : symbol_entry(table, SMT_INTEGER, name, ""),
+ m_getter([this] (symbol_table &table) { return m_value; }),
m_setter(nullptr),
m_value(constval)
{
}
-integer_symbol_entry::integer_symbol_entry(symbol_table &table, const char *name, void *ref, symbol_table::getter_func getter, symbol_table::setter_func setter, const std::string &format)
- : symbol_entry(table, SMT_INTEGER, name, format, ref),
+integer_symbol_entry::integer_symbol_entry(symbol_table &table, const char *name, symbol_table::getter_func getter, symbol_table::setter_func setter, const std::string &format)
+ : symbol_entry(table, SMT_INTEGER, name, format),
m_getter(getter),
m_setter(setter),
m_value(0)
@@ -275,7 +276,7 @@ bool integer_symbol_entry::is_lval() const
u64 integer_symbol_entry::value() const
{
- return m_getter(m_table, m_ref);
+ return m_getter(m_table);
}
@@ -286,34 +287,12 @@ u64 integer_symbol_entry::value() const
void integer_symbol_entry::set_value(u64 newvalue)
{
if (m_setter != nullptr)
- m_setter(m_table, m_ref, newvalue);
+ m_setter(m_table, newvalue);
else
throw emu_fatalerror("Symbol '%s' is read-only", m_name.c_str());
}
-//-------------------------------------------------
-// internal_getter - internal helper for
-// returning the value of a variable
-//-------------------------------------------------
-
-u64 integer_symbol_entry::internal_getter(symbol_table &table, void *symref)
-{
- return *(u64 *)symref;
-}
-
-
-//-------------------------------------------------
-// internal_setter - internal helper for setting
-// the value of a variable
-//-------------------------------------------------
-
-void integer_symbol_entry::internal_setter(symbol_table &table, void *symref, u64 value)
-{
- *(u64 *)symref = value;
-}
-
-
//**************************************************************************
// FUNCTION SYMBOL ENTRY
@@ -323,8 +302,8 @@ void integer_symbol_entry::internal_setter(symbol_table &table, void *symref, u6
// function_symbol_entry - constructor
//-------------------------------------------------
-function_symbol_entry::function_symbol_entry(symbol_table &table, const char *name, void *ref, int minparams, int maxparams, symbol_table::execute_func execute)
- : symbol_entry(table, SMT_FUNCTION, name, "", ref),
+function_symbol_entry::function_symbol_entry(symbol_table &table, const char *name, int minparams, int maxparams, symbol_table::execute_func execute)
+ : symbol_entry(table, SMT_FUNCTION, name, ""),
m_minparams(minparams),
m_maxparams(maxparams),
m_execute(execute)
@@ -372,7 +351,7 @@ u64 function_symbol_entry::execute(int numparams, const u64 *paramlist)
throw emu_fatalerror("Function '%s' requires at least %d parameters", m_name.c_str(), m_minparams);
if (numparams > m_maxparams)
throw emu_fatalerror("Function '%s' accepts no more than %d parameters", m_name.c_str(), m_maxparams);
- return m_execute(m_table, m_ref, numparams, paramlist);
+ return m_execute(m_table, numparams, paramlist);
}
@@ -435,10 +414,10 @@ void symbol_table::add(const char *name, u64 value)
// add - add a new register symbol
//-------------------------------------------------
-void symbol_table::add(const char *name, void *ref, getter_func getter, setter_func setter, const std::string &format_string)
+void symbol_table::add(const char *name, getter_func getter, setter_func setter, const std::string &format_string)
{
m_symlist.erase(name);
- m_symlist.emplace(name, std::make_unique<integer_symbol_entry>(*this, name, ref, getter, setter, format_string));
+ m_symlist.emplace(name, std::make_unique<integer_symbol_entry>(*this, name, getter, setter, format_string));
}
@@ -446,10 +425,10 @@ void symbol_table::add(const char *name, void *ref, getter_func getter, setter_f
// add - add a new function symbol
//-------------------------------------------------
-void symbol_table::add(const char *name, void *ref, int minparams, int maxparams, execute_func execute)
+void symbol_table::add(const char *name, int minparams, int maxparams, execute_func execute)
{
m_symlist.erase(name);
- m_symlist.emplace(name, std::make_unique<function_symbol_entry>(*this, name, ref, minparams, maxparams, execute));
+ m_symlist.emplace(name, std::make_unique<function_symbol_entry>(*this, name, minparams, maxparams, execute));
}
diff --git a/src/emu/debug/express.h b/src/emu/debug/express.h
index 19381786d1b..8084cf84e8f 100644
--- a/src/emu/debug/express.h
+++ b/src/emu/debug/express.h
@@ -114,7 +114,7 @@ protected:
};
// construction/destruction
- symbol_entry(symbol_table &table, symbol_type type, const char *name, const std::string &format, void *ref);
+ symbol_entry(symbol_table &table, symbol_type type, const char *name, const std::string &format);
public:
virtual ~symbol_entry();
@@ -138,7 +138,6 @@ protected:
symbol_type m_type; // type of symbol
std::string m_name; // name of the symbol
std::string m_format; // format of symbol (or empty if unspecified)
- void * m_ref; // internal reference
};
@@ -150,11 +149,11 @@ class symbol_table
{
public:
// callback functions for getting/setting a symbol value
- typedef std::function<u64(symbol_table &table, void *symref)> getter_func;
- typedef std::function<void(symbol_table &table, void *symref, u64 value)> setter_func;
+ typedef std::function<u64(symbol_table &table)> getter_func;
+ typedef std::function<void(symbol_table &table, u64 value)> setter_func;
// callback functions for function execution
- typedef std::function<u64(symbol_table &table, void *symref, int numparams, const u64 *paramlist)> execute_func;
+ typedef std::function<u64(symbol_table &table, int numparams, const u64 *paramlist)> execute_func;
// callback functions for memory reads/writes
typedef std::function<expression_error::error_code(void *cbparam, const char *name, expression_space space)> valid_func;
@@ -181,8 +180,8 @@ public:
// symbol access
void add(const char *name, read_write rw, u64 *ptr = nullptr);
void add(const char *name, u64 constvalue);
- void add(const char *name, void *ref, getter_func getter, setter_func setter = nullptr, const std::string &format_string = "");
- void add(const char *name, void *ref, int minparams, int maxparams, execute_func execute);
+ void add(const char *name, getter_func getter, setter_func setter = nullptr, const std::string &format_string = "");
+ void add(const char *name, int minparams, int maxparams, execute_func execute);
symbol_entry *find(const char *name) const { if (name) { auto search = m_symlist.find(name); if (search != m_symlist.end()) return search->second.get(); else return nullptr; } else return nullptr; }
symbol_entry *find_deep(const char *name);
diff --git a/src/frontend/mame/cheat.cpp b/src/frontend/mame/cheat.cpp
index 06d87596e68..1ac5039fa7f 100644
--- a/src/frontend/mame/cheat.cpp
+++ b/src/frontend/mame/cheat.cpp
@@ -1069,8 +1069,8 @@ cheat_manager::cheat_manager(running_machine &machine)
// create a global symbol table
m_symtable.add("frame", symbol_table::READ_ONLY, &m_framecount);
- m_symtable.add("frombcd", nullptr, 1, 1, execute_frombcd);
- m_symtable.add("tobcd", nullptr, 1, 1, execute_tobcd);
+ m_symtable.add("frombcd", 1, 1, execute_frombcd);
+ m_symtable.add("tobcd", 1, 1, execute_tobcd);
// we rely on the debugger expression callbacks; if the debugger isn't
// enabled, we must jumpstart them manually
@@ -1320,7 +1320,7 @@ std::string cheat_manager::quote_expression(const parsed_expression &expression)
// execute_frombcd - convert a value from BCD
//-------------------------------------------------
-uint64_t cheat_manager::execute_frombcd(symbol_table &table, void *ref, int params, const uint64_t *param)
+uint64_t cheat_manager::execute_frombcd(symbol_table &table, int params, const uint64_t *param)
{
uint64_t value(param[0]);
uint64_t multiplier(1);
@@ -1340,7 +1340,7 @@ uint64_t cheat_manager::execute_frombcd(symbol_table &table, void *ref, int para
// execute_tobcd - convert a value to BCD
//-------------------------------------------------
-uint64_t cheat_manager::execute_tobcd(symbol_table &table, void *ref, int params, const uint64_t *param)
+uint64_t cheat_manager::execute_tobcd(symbol_table &table, int params, const uint64_t *param)
{
uint64_t value(param[0]);
uint64_t result(0);
diff --git a/src/frontend/mame/cheat.h b/src/frontend/mame/cheat.h
index b685dba2c33..d05890c7152 100644
--- a/src/frontend/mame/cheat.h
+++ b/src/frontend/mame/cheat.h
@@ -327,8 +327,8 @@ public:
// global helpers
static std::string quote_expression(parsed_expression const &expression);
- static uint64_t execute_frombcd(symbol_table &table, void *ref, int params, uint64_t const *param);
- static uint64_t execute_tobcd(symbol_table &table, void *ref, int params, uint64_t const *param);
+ static uint64_t execute_frombcd(symbol_table &table, int params, uint64_t const *param);
+ static uint64_t execute_tobcd(symbol_table &table, int params, uint64_t const *param);
private:
// internal helpers
diff --git a/src/mame/drivers/amusco.cpp b/src/mame/drivers/amusco.cpp
index 21611946c46..af39e4757e3 100644
--- a/src/mame/drivers/amusco.cpp
+++ b/src/mame/drivers/amusco.cpp
@@ -131,7 +131,7 @@ protected:
virtual void video_start() override;
virtual void machine_start() override;
private:
- uint8_t *m_videoram;
+ std::unique_ptr<uint8_t []> m_videoram;
tilemap_t *m_bg_tilemap;
required_device<cpu_device> m_maincpu;
@@ -180,9 +180,10 @@ void amusco_state::video_start()
m_bg_tilemap = &machine().tilemap().create(*m_gfxdecode, tilemap_get_info_delegate(FUNC(amusco_state::get_bg_tile_info),this), TILEMAP_SCAN_ROWS, 8, 10, 74, 24);
m_blink_state = false;
- m_videoram = auto_alloc_array_clear(machine(), uint8_t, videoram_size);
+ m_videoram = std::make_unique<uint8_t []>(videoram_size);
+ std::fill_n(m_videoram.get(), videoram_size, 0);
- save_pointer(NAME(m_videoram), videoram_size);
+ save_pointer(NAME(m_videoram.get()), videoram_size);
}
void amusco_state::machine_start()
diff --git a/src/mame/drivers/coolridr.cpp b/src/mame/drivers/coolridr.cpp
index da086c8a82d..4fdeb9a63a0 100644
--- a/src/mame/drivers/coolridr.cpp
+++ b/src/mame/drivers/coolridr.cpp
@@ -468,21 +468,26 @@ public:
struct cool_render_object
{
- uint8_t* indirect_tiles;
- uint32_t* indirect_zoom;
+ cool_render_object(coolridr_state &s) : state(s), colbase(s.m_colbase)
+ {
+ std::copy(std::begin(s.m_spriteblit), std::end(s.m_spriteblit), std::begin(spriteblit));
+ }
+
+ std::unique_ptr<uint8_t []> indirect_tiles;
+ std::unique_ptr<uint32_t []> indirect_zoom;
uint32_t spriteblit[12];
- bitmap_ind16* drawbitmap;
- //bitmap_ind16* zbitmap;
- uint16_t zpri;
- uint8_t blittype;
- coolridr_state* state;
+ bitmap_ind16* drawbitmap = nullptr;
+ //bitmap_ind16* zbitmap = nullptr;
+ uint16_t zpri = 0;
+ uint8_t blittype = 0;
+ coolridr_state& state;
uint32_t clipvals[3];
- int screen;
+ int screen = 0;
int colbase;
};
- struct cool_render_object **m_cool_render_object_list1;
- struct cool_render_object **m_cool_render_object_list2;
+ std::unique_ptr<std::unique_ptr<cool_render_object> []> m_cool_render_object_list1;
+ std::unique_ptr<std::unique_ptr<cool_render_object> []> m_cool_render_object_list2;
int m_listcount1;
int m_listcount2;
@@ -1020,11 +1025,11 @@ uint32_t coolridr_state::screen_update_coolridr2(screen_device &screen, bitmap_i
} \
if (!indirect_tile_enable && size < DECODECACHE_NUMSPRITETILES) \
{ \
- object->state->decode[screen].objcache[use_object].tiles[v*used_hCellCount + h].tempshape_multi_decoded = true; \
+ object->state.decode[screen].objcache[use_object].tiles[v*used_hCellCount + h].tempshape_multi_decoded = true; \
if (blankcount==0) \
- object->state->decode[screen].objcache[use_object].tiles[v*used_hCellCount + h].is_blank = true; \
+ object->state.decode[screen].objcache[use_object].tiles[v*used_hCellCount + h].is_blank = true; \
else \
- object->state->decode[screen].objcache[use_object].tiles[v*used_hCellCount + h].is_blank = false; \
+ object->state.decode[screen].objcache[use_object].tiles[v*used_hCellCount + h].is_blank = false; \
/* if (object->screen==0) printf("marking offset %04x as decoded (sprite number %08x ptr %08x)\n", v*used_hCellCount + h, spriteNumber, ((uint64_t)(void*)tempshape)&0xffffffff);*/ \
} \
} \
@@ -1055,7 +1060,7 @@ uint32_t coolridr_state::screen_update_coolridr2(screen_device &screen, bitmap_i
} \
if (!indirect_tile_enable && size < DECODECACHE_NUMSPRITETILES) \
{ \
- if (object->state->decode[screen].objcache[use_object].tiles[v*used_hCellCount + h].is_blank == true) \
+ if (object->state.decode[screen].objcache[use_object].tiles[v*used_hCellCount + h].is_blank == true) \
continue; \
} \
else \
@@ -1292,7 +1297,7 @@ TODO: fix anything that isn't text.
void *coolridr_state::draw_object_threaded(void *param, int threadid)
{
- cool_render_object *object = reinterpret_cast<cool_render_object *>(param);
+ const std::unique_ptr<cool_render_object> object(reinterpret_cast<cool_render_object *>(param));
bitmap_ind16* drawbitmap = object->drawbitmap;
/************* object->spriteblit[3] *************/
@@ -1317,8 +1322,8 @@ void *coolridr_state::draw_object_threaded(void *param, int threadid)
- uint16_t* rearranged_16bit_gfx = object->state->m_rearranged_16bit_gfx.get();
- uint16_t* expanded_10bit_gfx = object->state->m_expanded_10bit_gfx.get();
+ uint16_t* rearranged_16bit_gfx = object->state.m_rearranged_16bit_gfx.get();
+ uint16_t* expanded_10bit_gfx = object->state.m_expanded_10bit_gfx.get();
int16_t clipminX = CLIPMINX_FULL;
int16_t clipmaxX = CLIPMAXX_FULL;
@@ -1338,7 +1343,7 @@ void *coolridr_state::draw_object_threaded(void *param, int threadid)
if (b1mode)
{
- // b1colorNumber = object->state->machine().rand()&0xfff;
+ // b1colorNumber = object->state.machine().rand()&0xfff;
}
/************* object->spriteblit[3] *************/
@@ -1410,9 +1415,9 @@ void *coolridr_state::draw_object_threaded(void *param, int threadid)
// note the road always has 0x8000 bit set in the palette. I *think* this is because they do a gradual blend of some kind between the road types
// see the number of transitional road bits which have various values above set
- if (blit4blendlevel==object->state->debug_randompal)
+ if (blit4blendlevel==object->state.debug_randompal)
{
- b1colorNumber = object->state->machine().rand()&0xfff;
+ b1colorNumber = object->state.machine().rand()&0xfff;
}
@@ -1439,18 +1444,7 @@ void *coolridr_state::draw_object_threaded(void *param, int threadid)
// if we have no vertical zoom value there's no point in going any further
// because there are no known vertical indirect modes
if (!vZoom)
- {
- // abort, but make sure we clean up
- if (object->indirect_tiles)
- free(object->indirect_tiles);
-
- if (object->indirect_zoom)
- free(object->indirect_zoom);
-
- free (object);
-
return nullptr;
- }
/************* object->spriteblit[9] *************/
@@ -1781,7 +1775,7 @@ void *coolridr_state::draw_object_threaded(void *param, int threadid)
if (clipminY>clipmaxY) clipminY = clipmaxY;
- //b1colorNumber = object->state->machine().rand()&0xfff;
+ //b1colorNumber = object->state.machine().rand()&0xfff;
}
/* DRAW */
@@ -1820,16 +1814,16 @@ void *coolridr_state::draw_object_threaded(void *param, int threadid)
for (int k=0;k<DECODECACHE_NUMOBJECTCACHES;k++)
{
- if(((object->state->decode[screen].objcache[k].lastromoffset == b3romoffset)) &&
- ((object->state->decode[screen].objcache[k].lastused_flipx == used_flipx)) &&
- ((object->state->decode[screen].objcache[k].lastused_flipy == used_flipy)) &&
- ((object->state->decode[screen].objcache[k].lastblit_rotate == blit_rotate)) &&
- ((object->state->decode[screen].objcache[k].lastb1mode == b1mode)) &&
- ((object->state->decode[screen].objcache[k].lastb1colorNumber == b1colorNumber)) &&
- ((object->state->decode[screen].objcache[k].lastb2colorNumber == b2colorNumber)) &&
- ((object->state->decode[screen].objcache[k].lastused_hCellCount == used_hCellCount)) &&
- ((object->state->decode[screen].objcache[k].lastused_vCellCount == used_vCellCount)) &&
- ((object->state->decode[screen].objcache[k].lastb2altpenmask == b2altpenmask)))
+ if(((object->state.decode[screen].objcache[k].lastromoffset == b3romoffset)) &&
+ ((object->state.decode[screen].objcache[k].lastused_flipx == used_flipx)) &&
+ ((object->state.decode[screen].objcache[k].lastused_flipy == used_flipy)) &&
+ ((object->state.decode[screen].objcache[k].lastblit_rotate == blit_rotate)) &&
+ ((object->state.decode[screen].objcache[k].lastb1mode == b1mode)) &&
+ ((object->state.decode[screen].objcache[k].lastb1colorNumber == b1colorNumber)) &&
+ ((object->state.decode[screen].objcache[k].lastb2colorNumber == b2colorNumber)) &&
+ ((object->state.decode[screen].objcache[k].lastused_hCellCount == used_hCellCount)) &&
+ ((object->state.decode[screen].objcache[k].lastused_vCellCount == used_vCellCount)) &&
+ ((object->state.decode[screen].objcache[k].lastb2altpenmask == b2altpenmask)))
{
found = k;
break;
@@ -1838,32 +1832,32 @@ void *coolridr_state::draw_object_threaded(void *param, int threadid)
if (found != -1)
{
- object->state->decode[screen].objcache[found].repeatcount++;
+ object->state.decode[screen].objcache[found].repeatcount++;
use_object = found;
}
else
{
- use_object = object->state->decode[screen].current_object;
+ use_object = object->state.decode[screen].current_object;
// dirty the cache
for (int i=0;i<DECODECACHE_NUMSPRITETILES;i++)
- object->state->decode[screen].objcache[use_object].tiles[i].tempshape_multi_decoded = false;
-
- object->state->decode[screen].objcache[use_object].lastromoffset = b3romoffset;
- object->state->decode[screen].objcache[use_object].lastused_flipx = used_flipx;
- object->state->decode[screen].objcache[use_object].lastused_flipy = used_flipy;
- object->state->decode[screen].objcache[use_object].lastblit_rotate = blit_rotate;
- object->state->decode[screen].objcache[use_object].lastb1mode = b1mode;
- object->state->decode[screen].objcache[use_object].lastb1colorNumber = b1colorNumber;
- object->state->decode[screen].objcache[use_object].lastb2colorNumber = b2colorNumber;
- object->state->decode[screen].objcache[use_object].lastused_hCellCount = used_hCellCount;
- object->state->decode[screen].objcache[use_object].lastused_vCellCount = used_vCellCount;
- object->state->decode[screen].objcache[use_object].lastb2altpenmask = b2altpenmask;
- object->state->decode[screen].objcache[use_object].repeatcount = 0;
-
- object->state->decode[screen].current_object++;
- if (object->state->decode[screen].current_object >= DECODECACHE_NUMOBJECTCACHES)
- object->state->decode[screen].current_object = 0;
+ object->state.decode[screen].objcache[use_object].tiles[i].tempshape_multi_decoded = false;
+
+ object->state.decode[screen].objcache[use_object].lastromoffset = b3romoffset;
+ object->state.decode[screen].objcache[use_object].lastused_flipx = used_flipx;
+ object->state.decode[screen].objcache[use_object].lastused_flipy = used_flipy;
+ object->state.decode[screen].objcache[use_object].lastblit_rotate = blit_rotate;
+ object->state.decode[screen].objcache[use_object].lastb1mode = b1mode;
+ object->state.decode[screen].objcache[use_object].lastb1colorNumber = b1colorNumber;
+ object->state.decode[screen].objcache[use_object].lastb2colorNumber = b2colorNumber;
+ object->state.decode[screen].objcache[use_object].lastused_hCellCount = used_hCellCount;
+ object->state.decode[screen].objcache[use_object].lastused_vCellCount = used_vCellCount;
+ object->state.decode[screen].objcache[use_object].lastb2altpenmask = b2altpenmask;
+ object->state.decode[screen].objcache[use_object].repeatcount = 0;
+
+ object->state.decode[screen].current_object++;
+ if (object->state.decode[screen].current_object >= DECODECACHE_NUMOBJECTCACHES)
+ object->state.decode[screen].current_object = 0;
}
}
@@ -1957,8 +1951,8 @@ void *coolridr_state::draw_object_threaded(void *param, int threadid)
if (!indirect_tile_enable && size < DECODECACHE_NUMSPRITETILES)
{
- tempshape = object->state->decode[screen].objcache[use_object].tiles[v*used_hCellCount + h].tempshape_multi;
- current_decoded = object->state->decode[screen].objcache[use_object].tiles[v*used_hCellCount + h].tempshape_multi_decoded;
+ tempshape = object->state.decode[screen].objcache[use_object].tiles[v*used_hCellCount + h].tempshape_multi;
+ current_decoded = object->state.decode[screen].objcache[use_object].tiles[v*used_hCellCount + h].tempshape_multi_decoded;
/*
if (object->screen==0)
{
@@ -1970,7 +1964,7 @@ void *coolridr_state::draw_object_threaded(void *param, int threadid)
else
{
//if (object->screen==0) printf("using base tempshape\n");
- tempshape = object->state->decode[screen].tempshape;
+ tempshape = object->state.decode[screen].tempshape;
}
@@ -2127,14 +2121,6 @@ void *coolridr_state::draw_object_threaded(void *param, int threadid)
end:
- if (object->indirect_tiles)
- free(object->indirect_tiles);
-
- if (object->indirect_zoom)
- free(object->indirect_zoom);
-
- free (object);
-
return nullptr;
}
@@ -2239,13 +2225,7 @@ void coolridr_state::blit_current_sprite(address_space &space)
return;
}
- cool_render_object* testobject = (cool_render_object *)malloc(sizeof(cool_render_object));
-
- testobject->state = this;
- testobject->colbase = m_colbase;
-
- for (int i=0;i<12;i++)
- testobject->spriteblit[i] = m_spriteblit[i];
+ std::unique_ptr<cool_render_object> testobject(new cool_render_object(*this));
// cache some values that are looked up from RAM to be safe.. alternatively we could stall the rendering if they get written to, but they're a direct memory pointer..
int test_indirect_tile_enable = (m_spriteblit[5] & 0x00010000)>>16;
@@ -2256,7 +2236,7 @@ void coolridr_state::blit_current_sprite(address_space &space)
uint16_t test_hCellCount = (m_spriteblit[6] & 0x00003ff);
uint16_t test_vCellCount = (m_spriteblit[6] & 0x03ff0000) >> 16;
int bytes = test_vCellCount*test_hCellCount;
- testobject->indirect_tiles = (uint8_t*)malloc(bytes);
+ testobject->indirect_tiles = std::make_unique<uint8_t []>(bytes);
for (int i=0;i<bytes;i++)
{
testobject->indirect_tiles[i] = space.read_byte(test_textlookup + i);
@@ -2273,7 +2253,7 @@ void coolridr_state::blit_current_sprite(address_space &space)
uint32_t test_blit10 = m_spriteblit[10];
uint16_t test_vCellCount = (m_spriteblit[6] & 0x03ff0000) >> 16;
int bytes = test_vCellCount * 4 * 16;
- testobject->indirect_zoom = (uint32_t*)malloc(bytes);
+ testobject->indirect_zoom = std::make_unique<uint32_t []>(bytes/4);
for (int i=0;i<bytes/4;i++)
{
testobject->indirect_zoom[i] = space.read_dword(test_blit10 + i*4);
@@ -2320,11 +2300,11 @@ void coolridr_state::blit_current_sprite(address_space &space)
#if 0
if (m_usethreads)
{
- osd_work_item_queue(queue, draw_object_threaded, testobject, WORK_ITEM_FLAG_AUTO_RELEASE);
+ osd_work_item_queue(queue, draw_object_threaded, testobject.release(), WORK_ITEM_FLAG_AUTO_RELEASE);
}
else
{
- draw_object_threaded((void*)testobject,0);
+ draw_object_threaded(testobject.release(), 0);
}
#else
@@ -2332,7 +2312,7 @@ void coolridr_state::blit_current_sprite(address_space &space)
{
if (m_listcount1<1000000)
{
- m_cool_render_object_list1[m_listcount1] = testobject;
+ m_cool_render_object_list1[m_listcount1] = std::move(testobject);
m_listcount1++;
}
else
@@ -2344,7 +2324,7 @@ void coolridr_state::blit_current_sprite(address_space &space)
{
if (m_listcount2<1000000)
{
- m_cool_render_object_list2[m_listcount2] = testobject;
+ m_cool_render_object_list2[m_listcount2] = std::move(testobject);
m_listcount2++;
}
else
@@ -2587,16 +2567,12 @@ WRITE32_MEMBER(coolridr_state::sysh1_fb_data_w)
m_clipblitterMode[0] = 0xff;
/* bubble sort, might be something better to use instead */
- for (int pass = 0 ; pass < ( m_listcount1 - 1 ); pass++)
+ for (int pass = 0 ; pass < (m_listcount1 - 1); pass++)
{
for (int elem2 = 0 ; elem2 < m_listcount1 - pass - 1; elem2++)
{
if (m_cool_render_object_list1[elem2]->zpri > m_cool_render_object_list1[elem2+1]->zpri)
- {
- cool_render_object* temp = m_cool_render_object_list1[elem2];
- m_cool_render_object_list1[elem2] = m_cool_render_object_list1[elem2+1];
- m_cool_render_object_list1[elem2+1] = temp;
- }
+ std::swap(m_cool_render_object_list1[elem2], m_cool_render_object_list1[elem2+1]);
}
}
@@ -2604,11 +2580,11 @@ WRITE32_MEMBER(coolridr_state::sysh1_fb_data_w)
{
if (m_usethreads)
{
- osd_work_item_queue(m_work_queue[0], draw_object_threaded, m_cool_render_object_list1[i], WORK_ITEM_FLAG_AUTO_RELEASE);
+ osd_work_item_queue(m_work_queue[0], draw_object_threaded, m_cool_render_object_list1[i].release(), WORK_ITEM_FLAG_AUTO_RELEASE);
}
else
{
- draw_object_threaded((void*)m_cool_render_object_list1[i],0);
+ draw_object_threaded((void*)m_cool_render_object_list1[i].release(), 0);
}
}
@@ -2638,17 +2614,13 @@ WRITE32_MEMBER(coolridr_state::sysh1_fb_data_w)
m_clipvals[1][2] = 0;
m_clipblitterMode[1] = 0xff;
- /* bubble sort, might be something better to use instead */
- for (int pass = 0 ; pass < ( m_listcount2 - 1 ); pass++)
+ /* bubble sort, might be something better to use instead */
+ for (int pass = 0 ; pass < (m_listcount2 - 1); pass++)
{
for (int elem2 = 0 ; elem2 < m_listcount2 - pass - 1; elem2++)
{
if (m_cool_render_object_list2[elem2]->zpri > m_cool_render_object_list2[elem2+1]->zpri)
- {
- cool_render_object* temp = m_cool_render_object_list2[elem2];
- m_cool_render_object_list2[elem2] = m_cool_render_object_list2[elem2+1];
- m_cool_render_object_list2[elem2+1] = temp;
- }
+ std::swap(m_cool_render_object_list2[elem2], m_cool_render_object_list2[elem2+1]);
}
}
@@ -2656,11 +2628,11 @@ WRITE32_MEMBER(coolridr_state::sysh1_fb_data_w)
{
if (m_usethreads)
{
- osd_work_item_queue(m_work_queue[1], draw_object_threaded, m_cool_render_object_list2[i], WORK_ITEM_FLAG_AUTO_RELEASE);
+ osd_work_item_queue(m_work_queue[1], draw_object_threaded, m_cool_render_object_list2[i].release(), WORK_ITEM_FLAG_AUTO_RELEASE);
}
else
{
- draw_object_threaded((void*)m_cool_render_object_list2[i],0);
+ draw_object_threaded((void*)m_cool_render_object_list2[i].release(), 0);
}
}
@@ -3666,10 +3638,10 @@ void coolridr_state::machine_start()
m_h1_pcg = make_unique_clear<uint8_t[]>(VRAM_SIZE);
m_h1_pal = make_unique_clear<uint16_t[]>(VRAM_SIZE);
- m_cool_render_object_list1 = auto_alloc_array_clear(machine(), struct cool_render_object*, 1000000);
+ m_cool_render_object_list1 = std::make_unique<std::unique_ptr<cool_render_object> []>(1000000);
m_listcount1 = 0;
- m_cool_render_object_list2 = auto_alloc_array_clear(machine(), struct cool_render_object*, 1000000);
+ m_cool_render_object_list2 = std::make_unique<std::unique_ptr<cool_render_object> []>(1000000);
m_listcount2 = 0;
m_work_queue[0] = osd_work_queue_alloc(WORK_QUEUE_FLAG_HIGH_FREQ);
diff --git a/src/mame/includes/cave.h b/src/mame/includes/cave.h
index d78be9c2fa6..8f9c2d5fa28 100644
--- a/src/mame/includes/cave.h
+++ b/src/mame/includes/cave.h
@@ -1,5 +1,9 @@
// license:BSD-3-Clause
// copyright-holders:Luca Elia
+#ifndef MAME_INCLUDES_CAVE_H
+#define MAME_INCLUDES_CAVE_H
+
+#pragma once
/***************************************************************************
@@ -14,26 +18,31 @@
#include "sound/okim6295.h"
#include "screen.h"
-struct sprite_cave
+class cave_state : public driver_device
{
- int priority, flags;
+public:
+ enum
+ {
+ MAX_PRIORITY = 4,
+ MAX_SPRITE_NUM = 0x400
+ };
- const uint8_t *pen_data; /* points to top left corner of tile data */
- int line_offset;
+ struct sprite_cave
+ {
+ sprite_cave() { }
- pen_t base_pen;
- int tile_width, tile_height;
- int total_width, total_height; /* in screen coordinates */
- int x, y, xcount0, ycount0;
- int zoomx_re, zoomy_re;
-};
+ int priority = 0, flags = 0;
-#define MAX_PRIORITY 4
-#define MAX_SPRITE_NUM 0x400
+ const uint8_t *pen_data = nullptr; /* points to top left corner of tile data */
+ int line_offset = 0;
+
+ pen_t base_pen = 0;
+ int tile_width = 0, tile_height = 0;
+ int total_width = 0, total_height = 0; /* in screen coordinates */
+ int x = 0, y = 0, xcount0 = 0, ycount0 = 0;
+ int zoomx_re = 0, zoomy_re = 0;
+ };
-class cave_state : public driver_device
-{
-public:
cave_state(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag)
, m_videoregs(*this, "videoregs.%u", 0)
@@ -63,8 +72,8 @@ public:
optional_shared_ptr_array<uint16_t, 4> m_paletteram;
/* video-related */
- struct sprite_cave *m_sprite[4];
- struct sprite_cave *m_sprite_table[4][MAX_PRIORITY][MAX_SPRITE_NUM + 1];
+ std::unique_ptr<sprite_cave []> m_sprite[4];
+ sprite_cave *m_sprite_table[4][MAX_PRIORITY][MAX_SPRITE_NUM + 1];
struct
{
@@ -268,10 +277,10 @@ private:
void get_sprite_info_donpachi(int chip);
void sprite_init_cave();
void cave_sprite_check(int chip, screen_device &screen, const rectangle &clip);
- void do_blit_zoom32_cave( int chip, const struct sprite_cave *sprite );
- void do_blit_zoom32_cave_zb( int chip, const struct sprite_cave *sprite );
- void do_blit_32_cave( int chip, const struct sprite_cave *sprite );
- void do_blit_32_cave_zb( int chip, const struct sprite_cave *sprite );
+ void do_blit_zoom32_cave( int chip, const sprite_cave *sprite );
+ void do_blit_zoom32_cave_zb( int chip, const sprite_cave *sprite );
+ void do_blit_32_cave( int chip, const sprite_cave *sprite );
+ void do_blit_32_cave_zb( int chip, const sprite_cave *sprite );
void sprite_draw_cave( int chip, int priority );
void sprite_draw_cave_zbuf( int chip, int priority );
void sprite_draw_donpachi( int chip, int priority );
@@ -279,3 +288,5 @@ private:
void init_cave();
void show_leds();
};
+
+#endif // MAME_INCLUDES_CAVE_H
diff --git a/src/mame/includes/wecleman.h b/src/mame/includes/wecleman.h
index 2fa3508c51c..35756625ed2 100644
--- a/src/mame/includes/wecleman.h
+++ b/src/mame/includes/wecleman.h
@@ -1,5 +1,9 @@
// license:BSD-3-Clause
// copyright-holders:Luca Elia
+#ifndef MAME_INCLUDES_WECLEMAN_H
+#define MAME_INCLUDES_WECLEMAN_H
+
+#pragma once
#include "machine/gen_latch.h"
#include "machine/timer.h"
@@ -68,8 +72,6 @@ public:
int m_sound_hw_type;
bool m_hotchase_sound_hs;
pen_t m_black_pen;
- struct sprite *m_sprite_list;
- struct sprite **m_spr_ptr_list;
DECLARE_READ16_MEMBER(wecleman_protection_r);
DECLARE_WRITE16_MEMBER(wecleman_protection_w);
DECLARE_WRITE16_MEMBER(irqctrl_w);
@@ -114,8 +116,6 @@ public:
void hotchase_sprite_decode( int num16_banks, int bank_size );
void get_sprite_info();
void sortsprite(int *idx_array, int *key_array, int size);
- template<class _BitmapClass> void do_blit_zoom32(_BitmapClass &bitmap, const rectangle &cliprect, struct sprite *sprite);
- template<class _BitmapClass> void sprite_draw(_BitmapClass &bitmap, const rectangle &cliprect);
void wecleman_draw_road(bitmap_rgb32 &bitmap, const rectangle &cliprect, int priority);
void hotchase_draw_road(bitmap_ind16 &bitmap, const rectangle &cliprect);
K051316_CB_MEMBER(hotchase_zoom_callback_1);
@@ -136,4 +136,30 @@ public:
required_device<palette_device> m_palette;
required_device<screen_device> m_screen;
required_device<generic_latch_8_device> m_soundlatch;
+
+private:
+ struct sprite_t
+ {
+ sprite_t() { }
+
+ uint8_t *pen_data = nullptr; /* points to top left corner of tile data */
+ int line_offset = 0;
+
+ const pen_t *pal_data = nullptr;
+ rgb_t pal_base;
+
+ int x_offset = 0, y_offset = 0;
+ int tile_width = 0, tile_height = 0;
+ int total_width = 0, total_height = 0; /* in screen coordinates */
+ int x = 0, y = 0;
+ int shadow_mode = 0, flags = 0;
+ };
+
+ template<class _BitmapClass> void do_blit_zoom32(_BitmapClass &bitmap, const rectangle &cliprect, const sprite_t &sprite);
+ template<class _BitmapClass> void sprite_draw(_BitmapClass &bitmap, const rectangle &cliprect);
+
+ std::unique_ptr<sprite_t []> m_sprite_list;
+ sprite_t **m_spr_ptr_list;
};
+
+#endif // MAME_INCLUDES_WECLEMAN_H
diff --git a/src/mame/video/cave.cpp b/src/mame/video/cave.cpp
index b77c6553450..75d32eafeb2 100644
--- a/src/mame/video/cave.cpp
+++ b/src/mame/video/cave.cpp
@@ -506,7 +506,7 @@ void cave_state::get_sprite_info_cave(int chip)
uint16_t *source;
uint16_t *finish;
- struct sprite_cave *sprite = m_sprite[chip];
+ sprite_cave *sprite = m_sprite[chip].get();
int glob_flipx = m_videoregs[chip][0] & 0x8000;
int glob_flipy = m_videoregs[chip][1] & 0x8000;
@@ -623,7 +623,7 @@ void cave_state::get_sprite_info_cave(int chip)
sprite++;
}
- m_num_sprites[chip] = sprite - m_sprite[chip];
+ m_num_sprites[chip] = sprite - m_sprite[chip].get();
}
void cave_state::get_sprite_info_donpachi(int chip)
@@ -636,7 +636,7 @@ void cave_state::get_sprite_info_donpachi(int chip)
uint16_t *source;
uint16_t *finish;
- struct sprite_cave *sprite = m_sprite[chip];
+ sprite_cave *sprite = m_sprite[chip].get();
int glob_flipx = m_videoregs[chip][0] & 0x8000;
int glob_flipy = m_videoregs[chip][1] & 0x8000;
@@ -709,7 +709,7 @@ void cave_state::get_sprite_info_donpachi(int chip)
sprite++;
}
- m_num_sprites[chip] = sprite - m_sprite[chip];
+ m_num_sprites[chip] = sprite - m_sprite[chip].get();
}
@@ -732,8 +732,10 @@ void cave_state::sprite_init_cave()
for (int chip = 0; chip < 4; chip++)
{
m_num_sprites[chip] = m_spriteram[chip].bytes() / 0x10 / 2;
- m_sprite[chip] = auto_alloc_array_clear(machine(), struct sprite_cave, m_num_sprites[chip]);
- memset(m_sprite_table, 0, sizeof(m_sprite_table));
+ m_sprite[chip] = std::make_unique<sprite_cave []>(m_num_sprites[chip]);
+ for (auto &prio : m_sprite_table[chip])
+ for (sprite_cave *&spr : prio)
+ spr = nullptr;
m_spriteram_bank[chip] = m_spriteram_bank_delay[chip] = 0;
}
@@ -768,8 +770,8 @@ void cave_state::cave_sprite_check(int chip, screen_device &screen, const rectan
}
{ /* check priority & sprite type */
- struct sprite_cave *sprite = m_sprite[chip];
- const struct sprite_cave *finish = &sprite[m_num_sprites[chip]];
+ sprite_cave *sprite = m_sprite[chip].get();
+ const sprite_cave *const finish = &sprite[m_num_sprites[chip]];
int i[4] = {0,0,0,0};
int priority_check = 0;
int spritetype = m_spritetype[1];
@@ -829,7 +831,7 @@ void cave_state::cave_sprite_check(int chip, screen_device &screen, const rectan
}
}
-void cave_state::do_blit_zoom32_cave( int chip, const struct sprite_cave *sprite )
+void cave_state::do_blit_zoom32_cave( int chip, const sprite_cave *sprite )
{
/* assumes SPRITE_LIST_RAW_DATA flag is set */
int x1, x2, y1, y2, dx, dy;
@@ -961,7 +963,7 @@ void cave_state::do_blit_zoom32_cave( int chip, const struct sprite_cave *sprite
}
-void cave_state::do_blit_zoom32_cave_zb( int chip, const struct sprite_cave *sprite )
+void cave_state::do_blit_zoom32_cave_zb( int chip, const sprite_cave *sprite )
{
/* assumes SPRITE_LIST_RAW_DATA flag is set */
int x1, x2, y1, y2, dx, dy;
@@ -1059,7 +1061,7 @@ void cave_state::do_blit_zoom32_cave_zb( int chip, const struct sprite_cave *spr
uint32_t *dest = (uint32_t *)(m_blit.baseaddr + m_blit.line_offset * y1);
int pitchz = m_blit.line_offset_zbuf * dy / 2;
uint16_t *zbf = (uint16_t *)(m_blit.baseaddr_zbuf + m_blit.line_offset_zbuf * y1);
- uint16_t pri_sp = (uint16_t)(sprite - m_sprite[chip]) + m_sprite_zbuf_baseval;
+ uint16_t pri_sp = (uint16_t)(sprite - m_sprite[chip].get()) + m_sprite_zbuf_baseval;
int ycount = ycount0;
for (y = y1; y != y2; y += dy)
@@ -1096,7 +1098,7 @@ void cave_state::do_blit_zoom32_cave_zb( int chip, const struct sprite_cave *spr
}
}
-void cave_state::do_blit_32_cave( int chip, const struct sprite_cave *sprite )
+void cave_state::do_blit_32_cave( int chip, const sprite_cave *sprite )
{
/* assumes SPRITE_LIST_RAW_DATA flag is set */
int x1, x2, y1, y2, dx, dy;
@@ -1191,7 +1193,7 @@ void cave_state::do_blit_32_cave( int chip, const struct sprite_cave *sprite )
}
-void cave_state::do_blit_32_cave_zb( int chip, const struct sprite_cave *sprite )
+void cave_state::do_blit_32_cave_zb( int chip, const sprite_cave *sprite )
{
/* assumes SPRITE_LIST_RAW_DATA flag is set */
int x1, x2, y1, y2, dx, dy;
@@ -1269,7 +1271,7 @@ void cave_state::do_blit_32_cave_zb( int chip, const struct sprite_cave *sprite
uint32_t *dest = (uint32_t *)(m_blit.baseaddr + m_blit.line_offset * y1);
int pitchz = m_blit.line_offset_zbuf * dy / 2;
uint16_t *zbf = (uint16_t *)(m_blit.baseaddr_zbuf + m_blit.line_offset_zbuf * y1);
- uint16_t pri_sp = (uint16_t)(sprite - m_sprite[chip]) + m_sprite_zbuf_baseval;
+ uint16_t pri_sp = (uint16_t)(sprite - m_sprite[chip].get()) + m_sprite_zbuf_baseval;
pen_data += sprite->line_offset * ycount0 + xcount0;
for (y = y1; y != y2; y += dy)
@@ -1299,7 +1301,7 @@ void cave_state::sprite_draw_cave( int chip, int priority )
int i = 0;
while (m_sprite_table[chip][priority][i])
{
- const struct sprite_cave *sprite = m_sprite_table[chip][priority][i++];
+ const sprite_cave *sprite = m_sprite_table[chip][priority][i++];
if ((sprite->tile_width == sprite->total_width) && (sprite->tile_height == sprite->total_height))
do_blit_32_cave(chip, sprite);
else
@@ -1312,7 +1314,7 @@ void cave_state::sprite_draw_cave_zbuf( int chip, int priority )
int i = 0;
while (m_sprite_table[chip][priority][i])
{
- const struct sprite_cave *sprite = m_sprite_table[chip][priority][i++];
+ const sprite_cave *sprite = m_sprite_table[chip][priority][i++];
if ((sprite->tile_width == sprite->total_width) && (sprite->tile_height == sprite->total_height))
do_blit_32_cave_zb(chip, sprite);
else
diff --git a/src/mame/video/wecleman.cpp b/src/mame/video/wecleman.cpp
index 3e74180e665..0eec8fcfb88 100644
--- a/src/mame/video/wecleman.cpp
+++ b/src/mame/video/wecleman.cpp
@@ -23,21 +23,6 @@
#define SPRITE_FLIPY 0x02
#define NUM_SPRITES 256
-struct sprite
-{
- uint8_t *pen_data; /* points to top left corner of tile data */
- int line_offset;
-
- const pen_t *pal_data;
- rgb_t pal_base;
-
- int x_offset, y_offset;
- int tile_width, tile_height;
- int total_width, total_height; /* in screen coordinates */
- int x, y;
- int shadow_mode, flags;
-};
-
/***************************************************************************
@@ -82,12 +67,12 @@ void wecleman_state::get_sprite_info()
uint16_t *source = m_spriteram;
- struct sprite *sprite = m_sprite_list;
- struct sprite *finish = m_sprite_list + NUM_SPRITES;
+ sprite_t *sprite = m_sprite_list.get();
+ sprite_t *const finish = sprite + NUM_SPRITES;
int bank, code, gfx, zoom;
- for (m_spr_count=0; sprite<finish; source+=0x10/2, sprite++)
+ for (m_spr_count = 0; sprite < finish; source += 0x10/2, sprite++)
{
if (source[0x00/2] == 0xffff) break;
@@ -170,7 +155,7 @@ void wecleman_state::sortsprite(int *idx_array, int *key_array, int size)
// draws a 8bpp palette sprites on a 16bpp direct RGB target (sub-par implementation)
template<class _BitmapClass>
-void wecleman_state::do_blit_zoom32(_BitmapClass &bitmap, const rectangle &cliprect, struct sprite *sprite)
+void wecleman_state::do_blit_zoom32(_BitmapClass &bitmap, const rectangle &cliprect, const sprite_t &sprite)
{
#define PRECISION_X 20
#define PRECISION_Y 20
@@ -181,10 +166,10 @@ void wecleman_state::do_blit_zoom32(_BitmapClass &bitmap, const rectangle &clipr
int x1, x2, y1, y2, dx, dy, sx, sy;
int xcount0=0, ycount0=0;
- if (sprite->flags & SPRITE_FLIPX)
+ if (sprite.flags & SPRITE_FLIPX)
{
- x2 = sprite->x;
- x1 = x2 + sprite->total_width;
+ x2 = sprite.x;
+ x1 = x2 + sprite.total_width;
dx = -1;
if (x2 < cliprect.min_x) x2 = cliprect.min_x;
if (x1 > cliprect.max_x )
@@ -197,8 +182,8 @@ void wecleman_state::do_blit_zoom32(_BitmapClass &bitmap, const rectangle &clipr
}
else
{
- x1 = sprite->x;
- x2 = x1 + sprite->total_width;
+ x1 = sprite.x;
+ x2 = x1 + sprite.total_width;
dx = 1;
if (x1 < cliprect.min_x )
{
@@ -209,10 +194,10 @@ void wecleman_state::do_blit_zoom32(_BitmapClass &bitmap, const rectangle &clipr
if (x1 >= x2) return;
}
- if (sprite->flags & SPRITE_FLIPY)
+ if (sprite.flags & SPRITE_FLIPY)
{
- y2 = sprite->y;
- y1 = y2 + sprite->total_height;
+ y2 = sprite.y;
+ y1 = y2 + sprite.total_height;
dy = -1;
if (y2 < cliprect.min_y ) y2 = cliprect.min_y;
if (y1 > cliprect.max_y )
@@ -225,8 +210,8 @@ void wecleman_state::do_blit_zoom32(_BitmapClass &bitmap, const rectangle &clipr
}
else
{
- y1 = sprite->y;
- y2 = y1 + sprite->total_height;
+ y1 = sprite.y;
+ y2 = y1 + sprite.total_height;
dy = 1;
if (y1 < cliprect.min_y )
{
@@ -238,14 +223,14 @@ void wecleman_state::do_blit_zoom32(_BitmapClass &bitmap, const rectangle &clipr
}
// calculate entry point decimals
- src_fdy = (sprite->tile_height<<PRECISION_Y) / sprite->total_height;
+ src_fdy = (sprite.tile_height<<PRECISION_Y) / sprite.total_height;
src_f0y = src_fdy * ycount0 + FPY_HALF;
- src_fdx = (sprite->tile_width<<PRECISION_X) / sprite->total_width;
+ src_fdx = (sprite.tile_width<<PRECISION_X) / sprite.total_width;
src_f0x = src_fdx * xcount0;
// pre-loop assignments and adjustments
- pal_base = sprite->pal_data;
+ pal_base = sprite.pal_data;
if (x1 > cliprect.min_x)
{
@@ -255,13 +240,13 @@ void wecleman_state::do_blit_zoom32(_BitmapClass &bitmap, const rectangle &clipr
for (sy = y1; sy != y2; sy += dy)
{
- uint8_t *row_base = sprite->pen_data + (src_f0y>>PRECISION_Y) * sprite->line_offset;
+ uint8_t *row_base = sprite.pen_data + (src_f0y>>PRECISION_Y) * sprite.line_offset;
src_fpx = src_f0x;
typename _BitmapClass::pixel_t *dst_ptr = &bitmap.pix(sy);
if (bitmap.format() == BITMAP_FORMAT_RGB32) // Wec Le Mans
{
- if (!sprite->shadow_mode)
+ if (!sprite.shadow_mode)
{
for (sx = x1; sx != x2; sx += dx)
{
@@ -291,9 +276,9 @@ void wecleman_state::do_blit_zoom32(_BitmapClass &bitmap, const rectangle &clipr
}
else // Hot Chase
{
- pen_t base = sprite->pal_base;
+ pen_t base = sprite.pal_base;
- if (!sprite->shadow_mode)
+ if (!sprite.shadow_mode)
{
for (sx = x1; sx != x2; sx += dx)
{
@@ -338,11 +323,11 @@ void wecleman_state::sprite_draw(_BitmapClass &bitmap, const rectangle &cliprect
{
sortsprite(m_spr_idx_list, m_spr_pri_list, m_spr_count);
- for (i=0; i<m_spr_count; i++) do_blit_zoom32(bitmap, cliprect, m_spr_ptr_list[m_spr_idx_list[i]]);
+ for (i=0; i<m_spr_count; i++) do_blit_zoom32(bitmap, cliprect, *m_spr_ptr_list[m_spr_idx_list[i]]);
}
else // Hot Chase
{
- for (i=0; i<m_spr_count; i++) do_blit_zoom32(bitmap, cliprect, m_spr_ptr_list[i]);
+ for (i=0; i<m_spr_count; i++) do_blit_zoom32(bitmap, cliprect, *m_spr_ptr_list[i]);
}
}
@@ -904,11 +889,11 @@ VIDEO_START_MEMBER(wecleman_state,wecleman)
m_cloud_visible = 0;
m_black_pen = m_palette->black_pen();
- m_rgb_half = (uint16_t*)(buffer + 0x00000);
- m_t32x32pm = (int*)(buffer + 0x10020);
- m_spr_ptr_list = (struct sprite **)(buffer + 0x12000);
- m_spr_idx_list = (int *)(buffer + 0x12400);
- m_spr_pri_list = (int *)(buffer + 0x12800);
+ m_rgb_half = (uint16_t*)(buffer + 0x00000);
+ m_t32x32pm = (int*)(buffer + 0x10020);
+ m_spr_ptr_list = (sprite_t **)(buffer + 0x12000);
+ m_spr_idx_list = (int *)(buffer + 0x12400);
+ m_spr_pri_list = (int *)(buffer + 0x12800);
for (i=0; i<0x8000; i++)
{
@@ -924,7 +909,7 @@ VIDEO_START_MEMBER(wecleman_state,wecleman)
}
}
- m_sprite_list = auto_alloc_array_clear(machine(), struct sprite, NUM_SPRITES);
+ m_sprite_list = std::make_unique<sprite_t []>(NUM_SPRITES);
m_bg_tilemap = &machine().tilemap().create(*m_gfxdecode, tilemap_get_info_delegate(FUNC(wecleman_state::wecleman_get_bg_tile_info),this),
TILEMAP_SCAN_ROWS,
@@ -1001,9 +986,9 @@ VIDEO_START_MEMBER(wecleman_state,hotchase)
m_spr_offsy = 0;
m_black_pen = m_palette->black_pen();
- m_spr_ptr_list = (struct sprite **)buffer;
+ m_spr_ptr_list = (sprite_t **)buffer;
- m_sprite_list = auto_alloc_array_clear(machine(), struct sprite, NUM_SPRITES);
+ m_sprite_list = std::make_unique<sprite_t []>(NUM_SPRITES);
}