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

Make expressions octal for applicable address spaces in disassembly view

Browse Source 
debug/express.cpp, debugcpu.cpp: General cleanup (nw)
- Change default base from hardcoded macro to dynamic parameter for parsed_expression
- Change symbol table parameters and variables to references or std::reference_wrapper
- Remove the (unused) ability to construct a parsed_expression without a symbol table
- Eliminate symbol_table &table and void *memory_param arguments from callbacks (superfluous now that std::function can bind everything necessary)
- Eliminate globalref pointer from symbol_table
- Add explicitly defaulted move constructor and move assignment operator
This commit is contained in:
AJR 2020-04-13 19:57:13 -04:00
parent dcf2109120
commit 86e7693df0
14 changed files with 192 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/devices/cpu/i386/i386.cpp
View File

@ -1777,7 +1777,7 @@ uint32_t i386_device::i386_get_debug_desc(I386_SREG *seg)
return seg->valid; return seg->valid;
} }
uint64_t i386_device::debug_segbase(symbol_table &table, int params, const uint64_t *param) uint64_t i386_device::debug_segbase(int params, const uint64_t *param)
{ {
uint32_t result; uint32_t result;
I386_SREG seg; I386_SREG seg;
@ -1800,7 +1800,7 @@ uint64_t i386_device::debug_segbase(symbol_table &table, int params, const uint6
return result; return result;
} }
uint64_t i386_device::debug_seglimit(symbol_table &table, int params, const uint64_t *param) uint64_t i386_device::debug_seglimit(int params, const uint64_t *param)
{ {
uint32_t result = 0; uint32_t result = 0;
I386_SREG seg; I386_SREG seg;
@ -1816,7 +1816,7 @@ uint64_t i386_device::debug_seglimit(symbol_table &table, int params, const uint
return result; return result;
} }
uint64_t i386_device::debug_segofftovirt(symbol_table &table, int params, const uint64_t *param) uint64_t i386_device::debug_segofftovirt(int params, const uint64_t *param)
{ {
uint32_t result; uint32_t result;
I386_SREG seg; I386_SREG seg;
@ -1854,7 +1854,7 @@ uint64_t i386_device::debug_segofftovirt(symbol_table &table, int params, const
return result; return result;
} }
uint64_t i386_device::debug_virttophys(symbol_table &table, int params, const uint64_t *param) uint64_t i386_device::debug_virttophys(int params, const uint64_t *param)
{ {
uint32_t result = param[0]; uint32_t result = param[0];
@ -1863,7 +1863,7 @@ uint64_t i386_device::debug_virttophys(symbol_table &table, int params, const ui
return result; return result;
} }
uint64_t i386_device::debug_cacheflush(symbol_table &table, int params, const uint64_t *param) uint64_t i386_device::debug_cacheflush(int params, const uint64_t *param)
{ {
uint32_t option; uint32_t option;
bool invalidate; bool invalidate;
@ -1886,11 +1886,11 @@ uint64_t i386_device::debug_cacheflush(symbol_table &table, int params, const ui
void i386_device::device_debug_setup() void i386_device::device_debug_setup()
{ {
using namespace std::placeholders; using namespace std::placeholders;
debug()->symtable().add("segbase", 1, 1, std::bind(&i386_device::debug_segbase, this, _1, _2, _3)); debug()->symtable().add("segbase", 1, 1, std::bind(&i386_device::debug_segbase, this, _1, _2));
debug()->symtable().add("seglimit", 1, 1, std::bind(&i386_device::debug_seglimit, this, _1, _2, _3)); debug()->symtable().add("seglimit", 1, 1, std::bind(&i386_device::debug_seglimit, this, _1, _2));
debug()->symtable().add("segofftovirt", 2, 2, std::bind(&i386_device::debug_segofftovirt, this, _1, _2, _3)); debug()->symtable().add("segofftovirt", 2, 2, std::bind(&i386_device::debug_segofftovirt, this, _1, _2));
debug()->symtable().add("virttophys", 1, 1, std::bind(&i386_device::debug_virttophys, this, _1, _2, _3)); debug()->symtable().add("virttophys", 1, 1, std::bind(&i386_device::debug_virttophys, this, _1, _2));
debug()->symtable().add("cacheflush", 0, 1, std::bind(&i386_device::debug_cacheflush, this, _1, _2, _3)); debug()->symtable().add("cacheflush", 0, 1, std::bind(&i386_device::debug_cacheflush, this, _1, _2));
} }
/*************************************************************************/ /*************************************************************************/

10
src/devices/cpu/i386/i386.h
View File

@ -36,11 +36,11 @@ public:
auto smiact() { return m_smiact.bind(); } auto smiact() { return m_smiact.bind(); }
auto ferr() { return m_ferr_handler.bind(); } auto ferr() { return m_ferr_handler.bind(); }
uint64_t debug_segbase(symbol_table &table, int params, const uint64_t *param); uint64_t debug_segbase(int params, const uint64_t *param);
uint64_t debug_seglimit(symbol_table &table, int params, const uint64_t *param); uint64_t debug_seglimit(int params, const uint64_t *param);
uint64_t debug_segofftovirt(symbol_table &table, int params, const uint64_t *param); uint64_t debug_segofftovirt(int params, const uint64_t *param);
uint64_t debug_virttophys(symbol_table &table, int params, const uint64_t *param); uint64_t debug_virttophys(int params, const uint64_t *param);
uint64_t debug_cacheflush(symbol_table &table, int params, const uint64_t *param); uint64_t debug_cacheflush(int params, const uint64_t *param);
protected: protected:
i386_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock, int program_data_width, int program_addr_width, int io_data_width); i386_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock, int program_data_width, int program_addr_width, int io_data_width);

42
src/emu/debug/debugcmd.cpp
View File

@ -103,13 +103,13 @@ debugger_commands::debugger_commands(running_machine& machine, debugger_cpu& cpu
{ {
m_global_array = std::make_unique<global_entry []>(MAX_GLOBALS); m_global_array = std::make_unique<global_entry []>(MAX_GLOBALS);
symbol_table *symtable = m_cpu.get_global_symtable(); symbol_table &symtable = m_cpu.global_symtable();
/* add a few simple global functions */ /* add a few simple global functions */
using namespace std::placeholders; using namespace std::placeholders;
symtable->add("min", 2, 2, std::bind(&debugger_commands::execute_min, this, _1, _2, _3)); symtable.add("min", 2, 2, std::bind(&debugger_commands::execute_min, this, _1, _2));
symtable->add("max", 2, 2, std::bind(&debugger_commands::execute_max, this, _1, _2, _3)); symtable.add("max", 2, 2, std::bind(&debugger_commands::execute_max, this, _1, _2));
symtable->add("if", 3, 3, std::bind(&debugger_commands::execute_if, this, _1, _2, _3)); symtable.add("if", 3, 3, std::bind(&debugger_commands::execute_if, this, _1, _2));
/* add all single-entry save state globals */ /* add all single-entry save state globals */
for (int itemnum = 0; itemnum < MAX_GLOBALS; itemnum++) for (int itemnum = 0; itemnum < MAX_GLOBALS; itemnum++)
@ -129,10 +129,10 @@ debugger_commands::debugger_commands(running_machine& machine, debugger_cpu& cpu
sprintf(symname, ".%s", strrchr(name, '/') + 1); sprintf(symname, ".%s", strrchr(name, '/') + 1);
m_global_array[itemnum].base = base; m_global_array[itemnum].base = base;
m_global_array[itemnum].size = valsize; m_global_array[itemnum].size = valsize;
symtable->add( symtable.add(
symname, symname,
std::bind(&debugger_commands::global_get, this, _1, &m_global_array[itemnum]), std::bind(&debugger_commands::global_get, this, &m_global_array[itemnum]),
std::bind(&debugger_commands::global_set, this, _1, &m_global_array[itemnum], _2)); std::bind(&debugger_commands::global_set, this, &m_global_array[itemnum], _1));
} }
} }
@ -306,7 +306,7 @@ debugger_commands::debugger_commands(running_machine& machine, debugger_cpu& cpu
execute_min - return the minimum of two values execute_min - return the minimum of two values
-------------------------------------------------*/ -------------------------------------------------*/
u64 debugger_commands::execute_min(symbol_table &table, int params, const u64 *param) u64 debugger_commands::execute_min(int params, const u64 *param)
{ {
return (param[0] < param[1]) ? param[0] : param[1]; return (param[0] < param[1]) ? param[0] : param[1];
} }
@ -316,7 +316,7 @@ u64 debugger_commands::execute_min(symbol_table &table, int params, const u64 *p
execute_max - return the maximum of two values execute_max - return the maximum of two values
-------------------------------------------------*/ -------------------------------------------------*/
u64 debugger_commands::execute_max(symbol_table &table, int params, const u64 *param) u64 debugger_commands::execute_max(int params, const u64 *param)
{ {
return (param[0] > param[1]) ? param[0] : param[1]; return (param[0] > param[1]) ? param[0] : param[1];
} }
@ -326,7 +326,7 @@ u64 debugger_commands::execute_max(symbol_table &table, int params, const u64 *p
execute_if - if (a) return b; else return c; execute_if - if (a) return b; else return c;
-------------------------------------------------*/ -------------------------------------------------*/
u64 debugger_commands::execute_if(symbol_table &table, int params, const u64 *param) u64 debugger_commands::execute_if(int params, const u64 *param)
{ {
return param[0] ? param[1] : param[2]; return param[0] ? param[1] : param[2];
} }
@ -341,7 +341,7 @@ u64 debugger_commands::execute_if(symbol_table &table, int params, const u64 *pa
global_get - symbol table getter for globals global_get - symbol table getter for globals
-------------------------------------------------*/ -------------------------------------------------*/
u64 debugger_commands::global_get(symbol_table &table, global_entry *global) u64 debugger_commands::global_get(global_entry *global)
{ {
switch (global->size) switch (global->size)
{ {
@ -358,7 +358,7 @@ u64 debugger_commands::global_get(symbol_table &table, global_entry *global)
global_set - symbol table setter for globals global_set - symbol table setter for globals
-------------------------------------------------*/ -------------------------------------------------*/
void debugger_commands::global_set(symbol_table &table, global_entry *global, u64 value) void debugger_commands::global_set(global_entry *global, u64 value)
{ {
switch (global->size) switch (global->size)
{ {
@ -385,7 +385,7 @@ bool debugger_commands::validate_number_parameter(const std::string &param, u64
/* evaluate the expression; success if no error */ /* evaluate the expression; success if no error */
try try
{ {
parsed_expression expression(m_cpu.get_visible_symtable(), param.c_str(), &result); result = parsed_expression(m_cpu.visible_symtable(), param.c_str()).execute();
return true; return true;
} }
catch (expression_error &error) catch (expression_error &error)
@ -454,7 +454,7 @@ bool debugger_commands::validate_cpu_parameter(const char *param, device_t *&res
u64 cpunum; u64 cpunum;
try try
{ {
parsed_expression expression(m_cpu.get_visible_symtable(), param, &cpunum); cpunum = parsed_expression(m_cpu.visible_symtable(), param).execute();
} }
catch (expression_error &) catch (expression_error &)
{ {
@ -759,7 +759,7 @@ void debugger_commands::execute_tracesym(int ref, const std::vector<std::string>
for (int i = 0; i < params.size(); i++) for (int i = 0; i < params.size(); i++)
{ {
// find this symbol // find this symbol
symbol_entry *sym = m_cpu.get_visible_symtable()->find(params[i].c_str()); symbol_entry *sym = m_cpu.visible_symtable().find(params[i].c_str());
if (!sym) if (!sym)
{ {
m_console.printf("Unknown symbol: %s\n", params[i].c_str()); m_console.printf("Unknown symbol: %s\n", params[i].c_str());
@ -925,7 +925,7 @@ void debugger_commands::execute_go_time(int ref, const std::vector<std::string>
-------------------------------------------------*/ -------------------------------------------------*/
void debugger_commands::execute_go_privilege(int ref, const std::vector<std::string> &params) void debugger_commands::execute_go_privilege(int ref, const std::vector<std::string> &params)
{ {
parsed_expression condition(&m_cpu.get_visible_cpu()->debug()->symtable()); parsed_expression condition(m_cpu.get_visible_cpu()->debug()->symtable());
if (params.size() > 0 && !debug_command_parameter_expression(params[0], condition)) if (params.size() > 0 && !debug_command_parameter_expression(params[0], condition))
return; return;
@ -1319,7 +1319,7 @@ void debugger_commands::execute_bpset(int ref, const std::vector<std::string> &p
return; return;
/* param 2 is the condition */ /* param 2 is the condition */
parsed_expression condition(&cpu->debug()->symtable()); parsed_expression condition(cpu->debug()->symtable());
if (params.size() > 1 && !debug_command_parameter_expression(params[1], condition)) if (params.size() > 1 && !debug_command_parameter_expression(params[1], condition))
return; return;
@ -1477,7 +1477,7 @@ void debugger_commands::execute_wpset(int ref, const std::vector<std::string> &p
} }
/* param 4 is the condition */ /* param 4 is the condition */
parsed_expression condition(&space->device().debug()->symtable()); parsed_expression condition(space->device().debug()->symtable());
if (params.size() > 3 && !debug_command_parameter_expression(params[3], condition)) if (params.size() > 3 && !debug_command_parameter_expression(params[3], condition))
return; return;
@ -1619,7 +1619,7 @@ void debugger_commands::execute_rpset(int ref, const std::vector<std::string> &p
return; return;
/* param 1 is the condition */ /* param 1 is the condition */
parsed_expression condition(&cpu->debug()->symtable()); parsed_expression condition(cpu->debug()->symtable());
if (params.size() > 0 && !debug_command_parameter_expression(params[0], condition)) if (params.size() > 0 && !debug_command_parameter_expression(params[0], condition))
return; return;
@ -2708,7 +2708,7 @@ void debugger_commands::execute_find(int ref, const std::vector<std::string> &pa
for (u64 i = offset; i <= endoffset; i += data_size[0]) for (u64 i = offset; i <= endoffset; i += data_size[0])
{ {
int suboffset = 0; int suboffset = 0;
int match = 1; bool match = true;
/* find the entire string */ /* find the entire string */
for (j = 0; j < data_count && match; j++) for (j = 0; j < data_count && match; j++)
@ -3257,7 +3257,7 @@ void debugger_commands::execute_symlist(int ref, const std::vector<std::string>
} }
else else
{ {
symtable = m_cpu.get_global_symtable(); symtable = &m_cpu.global_symtable();
m_console.printf("Global symbols:\n"); m_console.printf("Global symbols:\n");
} }

10
src/emu/debug/debugcmd.h
View File

@ -81,12 +81,12 @@ private:
u64 cheat_byte_swap(const cheat_system *cheatsys, u64 value); 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 cheat_read_extended(const cheat_system *cheatsys, address_space &space, offs_t address);
u64 execute_min(symbol_table &table, int params, const u64 *param); u64 execute_min(int params, const u64 *param);
u64 execute_max(symbol_table &table, int params, const u64 *param); u64 execute_max(int params, const u64 *param);
u64 execute_if(symbol_table &table, int params, const u64 *param); u64 execute_if(int params, const u64 *param);
u64 global_get(symbol_table &table, global_entry *global); u64 global_get(global_entry *global);
void global_set(symbol_table &table, global_entry *global, u64 value); void global_set(global_entry *global, u64 value);
int mini_printf(char *buffer, const char *format, int params, u64 *param); int mini_printf(char *buffer, const char *format, int params, u64 *param);

3
src/emu/debug/debugcon.cpp
View File

@ -334,8 +334,7 @@ CMDERR debugger_console::internal_parse_command(const std::string &original_comm
{ {
try try
{ {
u64 expresult; parsed_expression(m_machine.debugger().cpu().visible_symtable(), command_start).execute();
parsed_expression expression(m_machine.debugger().cpu().get_visible_symtable(), command_start, &expresult);
} }
catch (expression_error &err) catch (expression_error &err)
{ {

211
src/emu/debug/debugcpu.cpp
View File

@ -53,7 +53,7 @@ debugger_cpu::debugger_cpu(running_machine &machine)
m_tempvar = make_unique_clear<u64[]>(NUM_TEMP_VARIABLES); m_tempvar = make_unique_clear<u64[]>(NUM_TEMP_VARIABLES);
/* create a global symbol table */ /* create a global symbol table */
m_symtable = std::make_unique<symbol_table>(&m_machine); m_symtable = std::make_unique<symbol_table>();
// configure our base memory accessors // configure our base memory accessors
configure_memory(*m_symtable); configure_memory(*m_symtable);
@ -62,8 +62,7 @@ debugger_cpu::debugger_cpu(running_machine &machine)
m_symtable->add("wpaddr", symbol_table::READ_ONLY, &m_wpaddr); m_symtable->add("wpaddr", symbol_table::READ_ONLY, &m_wpaddr);
m_symtable->add("wpdata", symbol_table::READ_ONLY, &m_wpdata); m_symtable->add("wpdata", symbol_table::READ_ONLY, &m_wpdata);
using namespace std::placeholders; m_symtable->add("cpunum", std::bind(&debugger_cpu::get_cpunum, this));
m_symtable->add("cpunum", std::bind(&debugger_cpu::get_cpunum, this, _1));
screen_device_iterator screen_iterator = screen_device_iterator(m_machine.root_device()); screen_device_iterator screen_iterator = screen_device_iterator(m_machine.root_device());
screen_device_iterator::auto_iterator iter = screen_iterator.begin(); screen_device_iterator::auto_iterator iter = screen_iterator.begin();
@ -71,18 +70,20 @@ debugger_cpu::debugger_cpu(running_machine &machine)
if (count == 1) if (count == 1)
{ {
m_symtable->add("beamx", std::bind(&debugger_cpu::get_beamx, this, _1, iter.current())); screen_device &screen = *iter.current();
m_symtable->add("beamy", std::bind(&debugger_cpu::get_beamy, this, _1, iter.current())); m_symtable->add("beamx", [&screen]() { return screen.hpos(); });
m_symtable->add("frame", std::bind(&debugger_cpu::get_frame, this, _1, iter.current())); m_symtable->add("beamy", [&screen]() { return screen.vpos(); });
m_symtable->add("frame", [&screen]() { return screen.frame_number(); });
iter.current()->register_vblank_callback(vblank_state_delegate(&debugger_cpu::on_vblank, this)); iter.current()->register_vblank_callback(vblank_state_delegate(&debugger_cpu::on_vblank, this));
} }
else if (count > 1) else if (count > 1)
{ {
for (uint32_t i = 0; i < count; i++, iter++) for (uint32_t i = 0; i < count; i++, iter++)
{ {
m_symtable->add(string_format("beamx%d", i).c_str(), std::bind(&debugger_cpu::get_beamx, this, _1, iter.current())); screen_device &screen = *iter.current();
m_symtable->add(string_format("beamy%d", i).c_str(), std::bind(&debugger_cpu::get_beamy, this, _1, iter.current())); m_symtable->add(string_format("beamx%d", i).c_str(), [&screen]() { return screen.hpos(); });
m_symtable->add(string_format("frame%d", i).c_str(), std::bind(&debugger_cpu::get_frame, this, _1, iter.current())); m_symtable->add(string_format("beamy%d", i).c_str(), [&screen]() { return screen.vpos(); });
m_symtable->add(string_format("frame%d", i).c_str(), [&screen]() { return screen.frame_number(); });
iter.current()->register_vblank_callback(vblank_state_delegate(&debugger_cpu::on_vblank, this)); iter.current()->register_vblank_callback(vblank_state_delegate(&debugger_cpu::on_vblank, this));
} }
} }
@ -111,10 +112,9 @@ void debugger_cpu::configure_memory(symbol_table &table)
{ {
using namespace std::placeholders; using namespace std::placeholders;
table.configure_memory( table.configure_memory(
&m_machine, std::bind(&debugger_cpu::expression_validate, this, _1, _2),
std::bind(&debugger_cpu::expression_validate, this, _1, _2, _3), std::bind(&debugger_cpu::expression_read_memory, this, _1, _2, _3, _4, _5),
std::bind(&debugger_cpu::expression_read_memory, this, _1, _2, _3, _4, _5, _6), std::bind(&debugger_cpu::expression_write_memory, this, _1, _2, _3, _4, _5, _6));
std::bind(&debugger_cpu::expression_write_memory, this, _1, _2, _3, _4, _5, _6, _7));
} }
/*------------------------------------------------- /*-------------------------------------------------
@ -134,18 +134,18 @@ void debugger_cpu::flush_traces()
/*************************************************************************** //**************************************************************************
SYMBOL TABLE INTERFACES // SYMBOL TABLE INTERFACES
***************************************************************************/ //**************************************************************************
/*------------------------------------------------- //-------------------------------------------------
get_visible_symtable - return the // visible_symtable - return the locally-visible
locally-visible symbol table // symbol table
-------------------------------------------------*/ //-------------------------------------------------
symbol_table* debugger_cpu::get_visible_symtable() symbol_table &debugger_cpu::visible_symtable()
{ {
return &m_visiblecpu->debug()->symtable(); return m_visiblecpu->debug()->symtable();
} }
@ -630,7 +630,7 @@ device_t* debugger_cpu::expression_get_device(const char *tag)
space space
-------------------------------------------------*/ -------------------------------------------------*/
u64 debugger_cpu::expression_read_memory(void *param, const char *name, expression_space spacenum, u32 address, int size, bool disable_se) u64 debugger_cpu::expression_read_memory(const char *name, expression_space spacenum, u32 address, int size, bool disable_se)
{ {
switch (spacenum) switch (spacenum)
{ {
@ -836,7 +836,7 @@ u64 debugger_cpu::expression_read_memory_region(const char *rgntag, offs_t addre
space space
-------------------------------------------------*/ -------------------------------------------------*/
void debugger_cpu::expression_write_memory(void *param, const char *name, expression_space spacenum, u32 address, int size, u64 data, bool disable_se) void debugger_cpu::expression_write_memory(const char *name, expression_space spacenum, u32 address, int size, u64 data, bool disable_se)
{ {
device_t *device = nullptr; device_t *device = nullptr;
device_memory_interface *memory; device_memory_interface *memory;
@ -1040,7 +1040,7 @@ void debugger_cpu::expression_write_memory_region(const char *rgntag, offs_t add
appropriate name appropriate name
-------------------------------------------------*/ -------------------------------------------------*/
expression_error::error_code debugger_cpu::expression_validate(void *param, const char *name, expression_space space) expression_error::error_code debugger_cpu::expression_validate(const char *name, expression_space space)
{ {
device_t *device = nullptr; device_t *device = nullptr;
device_memory_interface *memory; device_memory_interface *memory;
@ -1120,52 +1120,26 @@ expression_error::error_code debugger_cpu::expression_validate(void *param, cons
/*************************************************************************** //**************************************************************************
VARIABLE GETTERS/SETTERS // VARIABLE GETTERS/SETTERS
***************************************************************************/ //**************************************************************************
/*------------------------------------------------- //-------------------------------------------------
get_beamx - get beam horizontal position // get_cpunum - getter callback for the
-------------------------------------------------*/ // 'cpunum' symbol
//-------------------------------------------------
u64 debugger_cpu::get_beamx(symbol_table &table, screen_device *screen) u64 debugger_cpu::get_cpunum()
{
return (screen != nullptr) ? screen->hpos() : 0;
}
/*-------------------------------------------------
get_beamy - get beam vertical position
-------------------------------------------------*/
u64 debugger_cpu::get_beamy(symbol_table &table, screen_device *screen)
{
return (screen != nullptr) ? screen->vpos() : 0;
}
/*-------------------------------------------------
get_frame - get current frame number
-------------------------------------------------*/
u64 debugger_cpu::get_frame(symbol_table &table, screen_device *screen)
{
return (screen != nullptr) ? screen->frame_number() : 0;
}
/*-------------------------------------------------
get_cpunum - getter callback for the
'cpunum' symbol
-------------------------------------------------*/
u64 debugger_cpu::get_cpunum(symbol_table &table)
{ {
execute_interface_iterator iter(m_machine.root_device()); execute_interface_iterator iter(m_machine.root_device());
return iter.indexof(m_visiblecpu->execute()); return iter.indexof(m_visiblecpu->execute());
} }
//**************************************************************************
// EXECUTION HOOKS
//**************************************************************************
void debugger_cpu::start_hook(device_t *device, bool stop_on_vblank) void debugger_cpu::start_hook(device_t *device, bool stop_on_vblank)
{ {
// stash a pointer to the current live CPU // stash a pointer to the current live CPU
@ -1285,7 +1259,7 @@ device_debug::device_debug(device_t &device)
, m_state(nullptr) , m_state(nullptr)
, m_disasm(nullptr) , m_disasm(nullptr)
, m_flags(0) , m_flags(0)
, m_symtable(&device, device.machine().debugger().cpu().get_global_symtable()) , m_symtable(&device.machine().debugger().cpu().global_symtable())
, m_instrhook(nullptr) , m_instrhook(nullptr)
, m_stepaddr(0) , m_stepaddr(0)
, m_stepsleft(0) , m_stepsleft(0)
@ -1338,9 +1312,9 @@ device_debug::device_debug(device_t &device)
// add global symbol for cycles and totalcycles // add global symbol for cycles and totalcycles
if (m_exec != nullptr) if (m_exec != nullptr)
{ {
m_symtable.add("cycles", get_cycles); m_symtable.add("cycles", [this]() { return m_exec->cycles_remaining(); });
m_symtable.add("totalcycles", get_totalcycles); m_symtable.add("totalcycles", symbol_table::READ_ONLY, &m_total_cycles);
m_symtable.add("lastinstructioncycles", get_lastinstructioncycles); m_symtable.add("lastinstructioncycles", [this]() { return m_total_cycles - m_last_total_cycles; });
} }
// add entries to enable/disable unmap reporting for each space // add entries to enable/disable unmap reporting for each space
@ -1349,23 +1323,23 @@ device_debug::device_debug(device_t &device)
if (m_memory->has_space(AS_PROGRAM)) if (m_memory->has_space(AS_PROGRAM))
m_symtable.add( m_symtable.add(
"logunmap", "logunmap",
[&space = m_memory->space(AS_PROGRAM)] (symbol_table &table) { return space.log_unmap(); }, [&space = m_memory->space(AS_PROGRAM)] () { return space.log_unmap(); },
[&space = m_memory->space(AS_PROGRAM)] (symbol_table &table, u64 value) { return space.set_log_unmap(bool(value)); }); [&space = m_memory->space(AS_PROGRAM)] (u64 value) { return space.set_log_unmap(bool(value)); });
if (m_memory->has_space(AS_DATA)) if (m_memory->has_space(AS_DATA))
m_symtable.add( m_symtable.add(
"logunmap", "logunmap",
[&space = m_memory->space(AS_DATA)] (symbol_table &table) { return space.log_unmap(); }, [&space = m_memory->space(AS_DATA)] () { return space.log_unmap(); },
[&space = m_memory->space(AS_DATA)] (symbol_table &table, u64 value) { return space.set_log_unmap(bool(value)); }); [&space = m_memory->space(AS_DATA)] (u64 value) { return space.set_log_unmap(bool(value)); });
if (m_memory->has_space(AS_IO)) if (m_memory->has_space(AS_IO))
m_symtable.add( m_symtable.add(
"logunmap", "logunmap",
[&space = m_memory->space(AS_IO)] (symbol_table &table) { return space.log_unmap(); }, [&space = m_memory->space(AS_IO)] () { return space.log_unmap(); },
[&space = m_memory->space(AS_IO)] (symbol_table &table, u64 value) { return space.set_log_unmap(bool(value)); }); [&space = m_memory->space(AS_IO)] (u64 value) { return space.set_log_unmap(bool(value)); });
if (m_memory->has_space(AS_OPCODES)) if (m_memory->has_space(AS_OPCODES))
m_symtable.add( m_symtable.add(
"logunmap", "logunmap",
[&space = m_memory->space(AS_OPCODES)] (symbol_table &table) { return space.log_unmap(); }, [&space = m_memory->space(AS_OPCODES)] () { return space.log_unmap(); },
[&space = m_memory->space(AS_OPCODES)] (symbol_table &table, u64 value) { return space.set_log_unmap(bool(value)); }); [&space = m_memory->space(AS_OPCODES)] (u64 value) { return space.set_log_unmap(bool(value)); });
} }
// add all registers into it // add all registers into it
@ -1379,8 +1353,8 @@ device_debug::device_debug(device_t &device)
strmakelower(tempstr.assign(entry->symbol())); strmakelower(tempstr.assign(entry->symbol()));
m_symtable.add( m_symtable.add(
tempstr.c_str(), tempstr.c_str(),
std::bind(&device_debug::get_state, _1, entry->index()), std::bind(&device_state_interface::state_int, m_state, entry->index()),
entry->writeable() ? std::bind(&device_debug::set_state, _1, entry->index(), _2) : symbol_table::setter_func(nullptr), entry->writeable() ? std::bind(&device_state_interface::set_state_int, m_state, entry->index(), _1) : symbol_table::setter_func(nullptr),
entry->format_string()); entry->format_string());
} }
} }
@ -1393,7 +1367,7 @@ device_debug::device_debug(device_t &device)
// if no curpc, add one // if no curpc, add one
if (m_state && !m_symtable.find("curpc")) if (m_state && !m_symtable.find("curpc"))
m_symtable.add("curpc", get_current_pc); m_symtable.add("curpc", std::bind(&device_state_interface::pcbase, m_state));
} }
// set up trace // set up trace
@ -1902,7 +1876,7 @@ void device_debug::go_privilege(const char *condition)
{ {
assert(m_exec != nullptr); assert(m_exec != nullptr);
m_device.machine().rewind_invalidate(); m_device.machine().rewind_invalidate();
m_privilege_condition = std::make_unique<parsed_expression>(&m_symtable, condition); m_privilege_condition = std::make_unique<parsed_expression>(m_symtable, condition);
m_flags |= DEBUG_FLAG_STOP_PRIVILEGE; m_flags |= DEBUG_FLAG_STOP_PRIVILEGE;
m_device.machine().debugger().cpu().set_execution_running(); m_device.machine().debugger().cpu().set_execution_running();
} }
@ -2636,79 +2610,6 @@ void device_debug::hotspot_check(address_space &space, offs_t address)
} }
} }
//-------------------------------------------------
// get_current_pc - getter callback for a device's
// current instruction pointer
//-------------------------------------------------
u64 device_debug::get_current_pc(symbol_table &table)
{
device_t *device = reinterpret_cast<device_t *>(table.globalref());
return device->state().pcbase();
}
//-------------------------------------------------
// get_cycles - getter callback for the
// 'cycles' symbol
//-------------------------------------------------
u64 device_debug::get_cycles(symbol_table &table)
{
device_t *device = reinterpret_cast<device_t *>(table.globalref());
return device->debug()->m_exec->cycles_remaining();
}
//-------------------------------------------------
// get_totalcycles - getter callback for the
// 'totalcycles' symbol
//-------------------------------------------------
u64 device_debug::get_totalcycles(symbol_table &table)
{
device_t *device = reinterpret_cast<device_t *>(table.globalref());
return device->debug()->m_total_cycles;
}
//-------------------------------------------------
// get_lastinstructioncycles - getter callback for the
// 'lastinstructioncycles' symbol
//-------------------------------------------------
u64 device_debug::get_lastinstructioncycles(symbol_table &table)
{
device_t *device = reinterpret_cast<device_t *>(table.globalref());
device_debug *debug = device->debug();
return debug->m_total_cycles - debug->m_last_total_cycles;
}
//-------------------------------------------------
// get_state - getter callback for a device's
// state symbols
//-------------------------------------------------
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(index);
}
//-------------------------------------------------
// set_state - setter callback for a device's
// state symbols
//-------------------------------------------------
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(index, value);
}
//************************************************************************** //**************************************************************************
// DEBUG BREAKPOINT // DEBUG BREAKPOINT
@ -2728,7 +2629,7 @@ device_debug::breakpoint::breakpoint(device_debug* debugInterface,
m_index(index), m_index(index),
m_enabled(true), m_enabled(true),
m_address(address), m_address(address),
m_condition(&symbols, (condition != nullptr) ? condition : "1"), m_condition(symbols, (condition != nullptr) ? condition : "1"),
m_action((action != nullptr) ? action : "") m_action((action != nullptr) ? action : "")
{ {
} }
@ -2792,7 +2693,7 @@ device_debug::watchpoint::watchpoint(device_debug* debugInterface,
m_type(type), m_type(type),
m_address(address & space.addrmask()), m_address(address & space.addrmask()),
m_length(length), m_length(length),
m_condition(&symbols, (condition != nullptr) ? condition : "1"), m_condition(symbols, (condition != nullptr) ? condition : "1"),
m_action((action != nullptr) ? action : ""), m_action((action != nullptr) ? action : ""),
m_installing(false) m_installing(false)
{ {
@ -3094,7 +2995,7 @@ void device_debug::watchpoint::triggered(read_or_write type, offs_t address, u64
device_debug::registerpoint::registerpoint(symbol_table &symbols, int index, const char *condition, const char *action) device_debug::registerpoint::registerpoint(symbol_table &symbols, int index, const char *condition, const char *action)
: m_index(index), : m_index(index),
m_enabled(true), m_enabled(true),
m_condition(&symbols, (condition != nullptr) ? condition : "1"), m_condition(symbols, (condition != nullptr) ? condition : "1"),
m_action((action != nullptr) ? action : "") m_action((action != nullptr) ? action : "")
{ {
} }

27
src/emu/debug/debugcpu.h
View File

@ -298,14 +298,6 @@ private:
void reinstall(address_space &space, read_or_write mode); void reinstall(address_space &space, read_or_write mode);
void write_tracking(address_space &space, offs_t address, u64 data); void write_tracking(address_space &space, offs_t address, u64 data);
// symbol get/set callbacks
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 // basic device information
device_t & m_device; // device we are attached to device_t & m_device; // device we are attached to
device_execute_interface * m_exec; // execute interface, if present device_execute_interface * m_exec; // execute interface, if present
@ -507,10 +499,10 @@ public:
/* ----- symbol table interfaces ----- */ /* ----- symbol table interfaces ----- */
/* return the global symbol table */ /* return the global symbol table */
symbol_table *get_global_symtable() { return m_symtable.get(); } symbol_table &global_symtable() { return *m_symtable; }
/* return the locally-visible symbol table */ /* return the locally-visible symbol table */
symbol_table *get_visible_symtable(); symbol_table &visible_symtable();
/* ----- debugger comment helpers ----- */ /* ----- debugger comment helpers ----- */
@ -589,22 +581,19 @@ private:
static const size_t NUM_TEMP_VARIABLES; static const size_t NUM_TEMP_VARIABLES;
/* expression handlers */ /* expression handlers */
u64 expression_read_memory(void *param, const char *name, expression_space space, u32 address, int size, bool disable_se); u64 expression_read_memory(const char *name, expression_space space, u32 address, int size, bool disable_se);
u64 expression_read_program_direct(address_space &space, int opcode, offs_t address, int size); u64 expression_read_program_direct(address_space &space, int opcode, offs_t address, int size);
u64 expression_read_memory_region(const char *rgntag, offs_t address, int size); u64 expression_read_memory_region(const char *rgntag, offs_t address, int size);
void expression_write_memory(void *param, const char *name, expression_space space, u32 address, int size, u64 data, bool disable_se); void expression_write_memory(const char *name, expression_space space, u32 address, int size, u64 data, bool disable_se);
void expression_write_program_direct(address_space &space, int opcode, offs_t address, int size, u64 data); void expression_write_program_direct(address_space &space, int opcode, offs_t address, int size, u64 data);
void expression_write_memory_region(const char *rgntag, offs_t address, int size, u64 data); void expression_write_memory_region(const char *rgntag, offs_t address, int size, u64 data);
expression_error::error_code expression_validate(void *param, const char *name, expression_space space); expression_error::error_code expression_validate(const char *name, expression_space space);
device_t* expression_get_device(const char *tag); device_t* expression_get_device(const char *tag);
/* variable getters/setters */ // variable getters/setters
u64 get_cpunum(symbol_table &table); u64 get_cpunum();
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 */ // internal helpers
void on_vblank(screen_device &device, bool vblank_state); void on_vblank(screen_device &device, bool vblank_state);
running_machine& m_machine; running_machine& m_machine;

7
src/emu/debug/debugvw.cpp
View File

@ -449,7 +449,7 @@ debug_view_expression::debug_view_expression(running_machine &machine)
: m_machine(machine) : m_machine(machine)
, m_dirty(true) , m_dirty(true)
, m_result(0) , m_result(0)
, m_parsed(machine.debugger().cpu().get_global_symtable()) , m_parsed(machine.debugger().cpu().global_symtable())
, m_string("0") , m_string("0")
{ {
} }
@ -471,7 +471,10 @@ debug_view_expression::~debug_view_expression()
void debug_view_expression::set_context(symbol_table *context) void debug_view_expression::set_context(symbol_table *context)
{ {
m_parsed.set_symbols((context != nullptr) ? context : m_machine.debugger().cpu().get_global_symtable()); if (context != nullptr)
m_parsed.set_symbols(*context);
else
m_parsed.set_symbols(m_machine.debugger().cpu().global_symtable());
m_dirty = true; m_dirty = true;
} }

3
src/emu/debug/debugvw.h
View File

@ -267,12 +267,13 @@ public:
u64 last_value() const { return m_result; } u64 last_value() const { return m_result; }
u64 value() { recompute(); return m_result; } u64 value() { recompute(); return m_result; }
const char *string() const { return m_string.c_str(); } const char *string() const { return m_string.c_str(); }
symbol_table *context() const { return m_parsed.symbols(); } symbol_table &context() const { return m_parsed.symbols(); }
// setters // setters
void mark_dirty() { m_dirty = true; } void mark_dirty() { m_dirty = true; }
template <typename... Params> void set_string(Params &&... args) { m_string.assign(std::forward<Params>(args)...); m_dirty = true; } template <typename... Params> void set_string(Params &&... args) { m_string.assign(std::forward<Params>(args)...); m_dirty = true; }
void set_context(symbol_table *context); void set_context(symbol_table *context);
void set_default_base(int base) { m_parsed.set_default_base(base); }
private: private:
// internal helpers // internal helpers

6
src/emu/debug/dvdisasm.cpp
View File

@ -117,7 +117,11 @@ void debug_view_disasm::view_notify(debug_view_notification type)
adjust_visible_y_for_cursor(); adjust_visible_y_for_cursor();
else if(type == VIEW_NOTIFY_SOURCE_CHANGED) else if(type == VIEW_NOTIFY_SOURCE_CHANGED)
m_expression.set_context(&downcast<const debug_view_disasm_source *>(m_source)->device()->debug()->symtable()); {
const debug_view_disasm_source &source = downcast<const debug_view_disasm_source &>(*m_source);
m_expression.set_context(&source.device()->debug()->symtable());
m_expression.set_default_base(source.space().is_octal() ? 8 : 16);
}
} }

87
src/emu/debug/express.cpp
View File

@ -47,11 +47,6 @@
CONSTANTS CONSTANTS
***************************************************************************/ ***************************************************************************/
#ifndef DEFAULT_BASE
#define DEFAULT_BASE 16 // hex unless otherwise specified
#endif
// token.value values if token.is_operator() // token.value values if token.is_operator()
enum enum
{ {
@ -229,13 +224,13 @@ symbol_entry::~symbol_entry()
integer_symbol_entry::integer_symbol_entry(symbol_table &table, const char *name, symbol_table::read_write rw, u64 *ptr) 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, ""), : symbol_entry(table, SMT_INTEGER, name, ""),
m_getter(ptr m_getter(ptr
? symbol_table::getter_func([ptr] (symbol_table &table) { return *ptr; }) ? symbol_table::getter_func([ptr] () { return *ptr; })
: symbol_table::getter_func([this] (symbol_table &table) { return m_value; })), : symbol_table::getter_func([this] () { return m_value; })),
m_setter((rw == symbol_table::READ_ONLY) m_setter((rw == symbol_table::READ_ONLY)
? symbol_table::setter_func(nullptr) ? symbol_table::setter_func(nullptr)
: ptr : ptr
? symbol_table::setter_func([ptr] (symbol_table &table, u64 value) { *ptr = value; }) ? symbol_table::setter_func([ptr] (u64 value) { *ptr = value; })
: symbol_table::setter_func([this] (symbol_table &table, u64 value) { m_value = value; })), : symbol_table::setter_func([this] (u64 value) { m_value = value; })),
m_value(0) m_value(0)
{ {
} }
@ -243,7 +238,7 @@ integer_symbol_entry::integer_symbol_entry(symbol_table &table, const char *name
integer_symbol_entry::integer_symbol_entry(symbol_table &table, const char *name, u64 constval) integer_symbol_entry::integer_symbol_entry(symbol_table &table, const char *name, u64 constval)
: symbol_entry(table, SMT_INTEGER, name, ""), : symbol_entry(table, SMT_INTEGER, name, ""),
m_getter([this] (symbol_table &table) { return m_value; }), m_getter([this] () { return m_value; }),
m_setter(nullptr), m_setter(nullptr),
m_value(constval) m_value(constval)
{ {
@ -275,7 +270,7 @@ bool integer_symbol_entry::is_lval() const
u64 integer_symbol_entry::value() const u64 integer_symbol_entry::value() const
{ {
return m_getter(m_table); return m_getter();
} }
@ -286,7 +281,7 @@ u64 integer_symbol_entry::value() const
void integer_symbol_entry::set_value(u64 newvalue) void integer_symbol_entry::set_value(u64 newvalue)
{ {
if (m_setter != nullptr) if (m_setter != nullptr)
m_setter(m_table, newvalue); m_setter(newvalue);
else else
throw emu_fatalerror("Symbol '%s' is read-only", m_name.c_str()); throw emu_fatalerror("Symbol '%s' is read-only", m_name.c_str());
} }
@ -350,7 +345,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); throw emu_fatalerror("Function '%s' requires at least %d parameters", m_name.c_str(), m_minparams);
if (numparams > m_maxparams) if (numparams > m_maxparams)
throw emu_fatalerror("Function '%s' accepts no more than %d parameters", m_name.c_str(), m_maxparams); throw emu_fatalerror("Function '%s' accepts no more than %d parameters", m_name.c_str(), m_maxparams);
return m_execute(m_table, numparams, paramlist); return m_execute(numparams, paramlist);
} }
@ -363,10 +358,8 @@ u64 function_symbol_entry::execute(int numparams, const u64 *paramlist)
// symbol_table - constructor // symbol_table - constructor
//------------------------------------------------- //-------------------------------------------------
symbol_table::symbol_table(void *globalref, symbol_table *parent) symbol_table::symbol_table(symbol_table *parent)
: m_parent(parent), : m_parent(parent),
m_globalref(globalref),
m_memory_param(nullptr),
m_memory_valid(nullptr), m_memory_valid(nullptr),
m_memory_read(nullptr), m_memory_read(nullptr),
m_memory_write(nullptr) m_memory_write(nullptr)
@ -378,9 +371,8 @@ symbol_table::symbol_table(void *globalref, symbol_table *parent)
// add - add a new u64 pointer symbol // add - add a new u64 pointer symbol
//------------------------------------------------- //-------------------------------------------------
void symbol_table::configure_memory(void *param, valid_func valid, read_func read, write_func write) void symbol_table::configure_memory(valid_func valid, read_func read, write_func write)
{ {
m_memory_param = param;
m_memory_valid = std::move(valid); m_memory_valid = std::move(valid);
m_memory_read = std::move(read); m_memory_read = std::move(read);
m_memory_write = std::move(write); m_memory_write = std::move(write);
@ -483,7 +475,7 @@ expression_error::error_code symbol_table::memory_valid(const char *name, expres
for (symbol_table *symtable = this; symtable != nullptr; symtable = symtable->m_parent) for (symbol_table *symtable = this; symtable != nullptr; symtable = symtable->m_parent)
if (symtable->m_memory_valid != nullptr) if (symtable->m_memory_valid != nullptr)
{ {
expression_error::error_code err = symtable->m_memory_valid(symtable->m_memory_param, name, space); expression_error::error_code err = symtable->m_memory_valid(name, space);
if (err != expression_error::NO_SUCH_MEMORY_SPACE) if (err != expression_error::NO_SUCH_MEMORY_SPACE)
return err; return err;
} }
@ -501,9 +493,9 @@ u64 symbol_table::memory_value(const char *name, expression_space space, u32 off
for (symbol_table *symtable = this; symtable != nullptr; symtable = symtable->m_parent) for (symbol_table *symtable = this; symtable != nullptr; symtable = symtable->m_parent)
if (symtable->m_memory_valid != nullptr) if (symtable->m_memory_valid != nullptr)
{ {
expression_error::error_code err = symtable->m_memory_valid(symtable->m_memory_param, name, space); expression_error::error_code err = symtable->m_memory_valid(name, space);
if (err != expression_error::NO_SUCH_MEMORY_SPACE && symtable->m_memory_read != nullptr) if (err != expression_error::NO_SUCH_MEMORY_SPACE && symtable->m_memory_read != nullptr)
return symtable->m_memory_read(symtable->m_memory_param, name, space, offset, size, disable_se); return symtable->m_memory_read(name, space, offset, size, disable_se);
return 0; return 0;
} }
return 0; return 0;
@ -520,9 +512,9 @@ void symbol_table::set_memory_value(const char *name, expression_space space, u3
for (symbol_table *symtable = this; symtable != nullptr; symtable = symtable->m_parent) for (symbol_table *symtable = this; symtable != nullptr; symtable = symtable->m_parent)
if (symtable->m_memory_valid != nullptr) if (symtable->m_memory_valid != nullptr)
{ {
expression_error::error_code err = symtable->m_memory_valid(symtable->m_memory_param, name, space); expression_error::error_code err = symtable->m_memory_valid(name, space);
if (err != expression_error::NO_SUCH_MEMORY_SPACE && symtable->m_memory_write != nullptr) if (err != expression_error::NO_SUCH_MEMORY_SPACE && symtable->m_memory_write != nullptr)
symtable->m_memory_write(symtable->m_memory_param, name, space, offset, size, value, disable_se); symtable->m_memory_write(name, space, offset, size, value, disable_se);
return; return;
} }
} }
@ -537,16 +529,29 @@ void symbol_table::set_memory_value(const char *name, expression_space space, u3
// parsed_expression - constructor // parsed_expression - constructor
//------------------------------------------------- //-------------------------------------------------
parsed_expression::parsed_expression(symbol_table *symtable, const char *expression, u64 *result) parsed_expression::parsed_expression(symbol_table &symtable, const char *expression, int default_base)
: m_symtable(symtable) : m_symtable(symtable)
, m_default_base(default_base)
{ {
assert(default_base == 8 || default_base == 10 || default_base == 16);
// if we got an expression parse it // if we got an expression parse it
if (expression != nullptr) if (expression != nullptr)
parse(expression); parse(expression);
}
// if we get a result pointer, execute it
if (result != nullptr) //-------------------------------------------------
*result = execute(); // parsed_expression - copy constructor
//-------------------------------------------------
parsed_expression::parsed_expression(const parsed_expression &src)
: m_symtable(src.m_symtable)
, m_default_base(src.m_default_base)
, m_original_string(src.m_original_string)
{
if (!m_original_string.empty())
parse_string_into_tokens();
} }
@ -576,6 +581,7 @@ void parsed_expression::parse(const char *expression)
void parsed_expression::copy(const parsed_expression &src) void parsed_expression::copy(const parsed_expression &src)
{ {
m_symtable = src.m_symtable; m_symtable = src.m_symtable;
m_default_base = src.m_default_base;
m_original_string.assign(src.m_original_string); m_original_string.assign(src.m_original_string);
if (!m_original_string.empty()) if (!m_original_string.empty())
parse_string_into_tokens(); parse_string_into_tokens();
@ -942,13 +948,12 @@ void parsed_expression::parse_symbol_or_number(parse_token &token, const char *&
catch (expression_error const &err) catch (expression_error const &err)
{ {
// this is really a hack, but 0B1234 could also hex depending on default base // this is really a hack, but 0B1234 could also hex depending on default base
if (expression_error::INVALID_NUMBER == err) if (expression_error::INVALID_NUMBER == err && m_default_base == 16)
return parse_number(token, buffer.c_str(), DEFAULT_BASE, expression_error::INVALID_NUMBER); return parse_number(token, buffer.c_str(), m_default_base, expression_error::INVALID_NUMBER);
else else
throw; throw;
} }
// TODO: for octal address spaces, treat 0123 as octal
default: default:
; // fall through ; // fall through
} }
@ -956,7 +961,7 @@ void parsed_expression::parse_symbol_or_number(parse_token &token, const char *&
default: default:
// check for a symbol match // check for a symbol match
symbol_entry *symbol = m_symtable->find_deep(buffer.c_str()); symbol_entry *symbol = m_symtable.get().find_deep(buffer.c_str());
if (symbol != nullptr) if (symbol != nullptr)
{ {
token.configure_symbol(*symbol); token.configure_symbol(*symbol);
@ -971,7 +976,7 @@ void parsed_expression::parse_symbol_or_number(parse_token &token, const char *&
} }
// attempt to parse as a number in the default base // attempt to parse as a number in the default base
parse_number(token, buffer.c_str(), DEFAULT_BASE, expression_error::UNKNOWN_SYMBOL); parse_number(token, buffer.c_str(), m_default_base, expression_error::UNKNOWN_SYMBOL);
} }
} }
@ -1149,12 +1154,9 @@ void parsed_expression::parse_memory_operator(parse_token &token, const char *st
} }
// validate the name // validate the name
if (m_symtable != nullptr) expression_error::error_code err = m_symtable.get().memory_valid(namestring, memspace);
{
expression_error::error_code err = m_symtable->memory_valid(namestring, memspace);
if (err != expression_error::NONE) if (err != expression_error::NONE)
throw expression_error(err, token.offset() + (string - startstring)); throw expression_error(err, token.offset() + (string - startstring));
}
// configure the token // configure the token
token.configure_operator(TVL_MEMORYAT, 2).set_memory_size(memsize).set_memory_space(memspace).set_memory_source(namestring).set_memory_side_effects(disable_se); token.configure_operator(TVL_MEMORYAT, 2).set_memory_size(memsize).set_memory_space(memspace).set_memory_source(namestring).set_memory_side_effects(disable_se);
@ -1679,16 +1681,15 @@ parsed_expression::parse_token::parse_token(int offset)
// for a SYMBOL token // for a SYMBOL token
//------------------------------------------------- //-------------------------------------------------
u64 parsed_expression::parse_token::get_lval_value(symbol_table *table) u64 parsed_expression::parse_token::get_lval_value(symbol_table &table)
{ {
// get the value of a symbol // get the value of a symbol
if (is_symbol()) if (is_symbol())
return m_symbol->value(); return m_symbol->value();
// or get the value from the memory callbacks // or get the value from the memory callbacks
else if (is_memory() && table != nullptr) { else if (is_memory())
return table->memory_value(m_string, memory_space(), address(), 1 << memory_size(), memory_side_effects()); return table.memory_value(m_string, memory_space(), address(), 1 << memory_size(), memory_side_effects());
}
return 0; return 0;
} }
@ -1699,15 +1700,15 @@ u64 parsed_expression::parse_token::get_lval_value(symbol_table *table)
// for a SYMBOL token // for a SYMBOL token
//------------------------------------------------- //-------------------------------------------------
inline void parsed_expression::parse_token::set_lval_value(symbol_table *table, u64 value) inline void parsed_expression::parse_token::set_lval_value(symbol_table &table, u64 value)
{ {
// set the value of a symbol // set the value of a symbol
if (is_symbol()) if (is_symbol())
m_symbol->set_value(value); m_symbol->set_value(value);
// or set the value via the memory callbacks // or set the value via the memory callbacks
else if (is_memory() && table != nullptr) else if (is_memory())
table->set_memory_value(m_string, memory_space(), address(), 1 << memory_size(), value, memory_side_effects()); table.set_memory_value(m_string, memory_space(), address(), 1 << memory_size(), value, memory_side_effects());
} }

37
src/emu/debug/express.h
View File

@ -147,16 +147,16 @@ class symbol_table
{ {
public: public:
// callback functions for getting/setting a symbol value // callback functions for getting/setting a symbol value
typedef std::function<u64(symbol_table &table)> getter_func; typedef std::function<u64()> getter_func;
typedef std::function<void(symbol_table &table, u64 value)> setter_func; typedef std::function<void(u64 value)> setter_func;
// callback functions for function execution // callback functions for function execution
typedef std::function<u64(symbol_table &table, int numparams, const u64 *paramlist)> execute_func; typedef std::function<u64(int numparams, const u64 *paramlist)> execute_func;
// callback functions for memory reads/writes // callback functions for memory reads/writes
typedef std::function<expression_error::error_code(void *cbparam, const char *name, expression_space space)> valid_func; typedef std::function<expression_error::error_code(const char *name, expression_space space)> valid_func;
typedef std::function<u64(void *cbparam, const char *name, expression_space space, u32 offset, int size, bool disable_se)> read_func; typedef std::function<u64(const char *name, expression_space space, u32 offset, int size, bool disable_se)> read_func;
typedef std::function<void(void *cbparam, const char *name, expression_space space, u32 offset, int size, u64 value, bool disable_se)> write_func; typedef std::function<void(const char *name, expression_space space, u32 offset, int size, u64 value, bool disable_se)> write_func;
enum read_write enum read_write
{ {
@ -165,15 +165,14 @@ public:
}; };
// construction/destruction // construction/destruction
symbol_table(void *globalref, symbol_table *parent = nullptr); symbol_table(symbol_table *parent = nullptr);
// getters // getters
const std::unordered_map<std::string, std::unique_ptr<symbol_entry>> &entries() const { return m_symlist; } const std::unordered_map<std::string, std::unique_ptr<symbol_entry>> &entries() const { return m_symlist; }
symbol_table *parent() const { return m_parent; } symbol_table *parent() const { return m_parent; }
void *globalref() const { return m_globalref; }
// setters // setters
void configure_memory(void *param, valid_func valid, read_func read, write_func write); void configure_memory(valid_func valid, read_func read, write_func write);
// symbol access // symbol access
void add(const char *name, read_write rw, u64 *ptr = nullptr); void add(const char *name, read_write rw, u64 *ptr = nullptr);
@ -195,9 +194,7 @@ public:
private: private:
// internal state // internal state
symbol_table * m_parent; // pointer to the parent symbol table symbol_table * m_parent; // pointer to the parent symbol table
void * m_globalref; // global reference parameter
std::unordered_map<std::string,std::unique_ptr<symbol_entry>> m_symlist; // list of symbols std::unordered_map<std::string,std::unique_ptr<symbol_entry>> m_symlist; // list of symbols
void * m_memory_param; // callback parameter for memory
valid_func m_memory_valid; // validation callback valid_func m_memory_valid; // validation callback
read_func m_memory_read; // read callback read_func m_memory_read; // read callback
write_func m_memory_write; // write callback write_func m_memory_write; // write callback
@ -212,19 +209,22 @@ class parsed_expression
{ {
public: public:
// construction/destruction // construction/destruction
parsed_expression(const parsed_expression &src) { copy(src); } parsed_expression(symbol_table &symtable, const char *expression = nullptr, int default_base = 16);
parsed_expression(symbol_table *symtable = nullptr, const char *expression = nullptr, u64 *result = nullptr); parsed_expression(const parsed_expression &src);
parsed_expression(parsed_expression &&src) = default;
// operators // operators
parsed_expression &operator=(const parsed_expression &src) { copy(src); return *this; } parsed_expression &operator=(const parsed_expression &src) { copy(src); return *this; }
parsed_expression &operator=(parsed_expression &&src) = default;
// getters // getters
bool is_empty() const { return (m_tokenlist.count() == 0); } bool is_empty() const { return (m_tokenlist.count() == 0); }
const char *original_string() const { return m_original_string.c_str(); } const char *original_string() const { return m_original_string.c_str(); }
symbol_table *symbols() const { return m_symtable; } symbol_table &symbols() const { return m_symtable.get(); }
// setters // setters
void set_symbols(symbol_table *symtable) { m_symtable = symtable; } void set_symbols(symbol_table &symtable) { m_symtable = std::reference_wrapper<symbol_table>(symtable); }
void set_default_base(int base) { assert(base == 8 || base == 10 || base == 16); m_default_base = base; }
// execution // execution
void parse(const char *string); void parse(const char *string);
@ -312,8 +312,8 @@ private:
parse_token &set_memory_source(const char *string) { assert(m_type == OPERATOR || m_type == MEMORY); m_string = string; return *this; } parse_token &set_memory_source(const char *string) { assert(m_type == OPERATOR || m_type == MEMORY); m_string = string; return *this; }
// access // access
u64 get_lval_value(symbol_table *symtable); u64 get_lval_value(symbol_table &symtable);
void set_lval_value(symbol_table *symtable, u64 value); void set_lval_value(symbol_table &symtable, u64 value);
private: private:
// internal state // internal state
@ -352,7 +352,8 @@ private:
static const int MAX_FUNCTION_PARAMS = 16; static const int MAX_FUNCTION_PARAMS = 16;
// internal state // internal state
symbol_table * m_symtable; // symbol table std::reference_wrapper<symbol_table> m_symtable; // symbol table
int m_default_base; // default base
std::string m_original_string; // original string (prior to parsing) std::string m_original_string; // original string (prior to parsing)
simple_list<parse_token> m_tokenlist; // token list simple_list<parse_token> m_tokenlist; // token list
std::list<std::string> m_stringlist; // string list std::list<std::string> m_stringlist; // string list

14
src/frontend/mame/cheat.cpp
View File

@ -401,8 +401,8 @@ cheat_script::script_entry::script_entry(
std::string const &filename, std::string const &filename,
util::xml::data_node const &entrynode, util::xml::data_node const &entrynode,
bool isaction) bool isaction)
: m_condition(&symbols) : m_condition(symbols)
, m_expression(&symbols) , m_expression(symbols)
{ {
char const *expression(nullptr); char const *expression(nullptr);
try try
@ -610,7 +610,7 @@ cheat_script::script_entry::output_argument::output_argument(
symbol_table &symbols, symbol_table &symbols,
std::string const &filename, std::string const &filename,
util::xml::data_node const &argnode) util::xml::data_node const &argnode)
: m_expression(&symbols) : m_expression(symbols)
, m_count(0) , m_count(0)
{ {
// first extract attributes // first extract attributes
@ -679,7 +679,7 @@ void cheat_script::script_entry::output_argument::save(emu_file &cheatfile) cons
cheat_entry::cheat_entry(cheat_manager &manager, symbol_table &globaltable, std::string const &filename, util::xml::data_node const &cheatnode) cheat_entry::cheat_entry(cheat_manager &manager, symbol_table &globaltable, std::string const &filename, util::xml::data_node const &cheatnode)
: m_manager(manager) : m_manager(manager)
, m_symbols(&manager.machine(), &globaltable) , m_symbols(&globaltable)
, m_state(SCRIPT_STATE_OFF) , m_state(SCRIPT_STATE_OFF)
, m_numtemp(DEFAULT_TEMP_VARIABLES) , m_numtemp(DEFAULT_TEMP_VARIABLES)
, m_argindex(0) , m_argindex(0)
@ -1058,7 +1058,7 @@ constexpr int cheat_manager::CHEAT_VERSION;
cheat_manager::cheat_manager(running_machine &machine) cheat_manager::cheat_manager(running_machine &machine)
: m_machine(machine) : m_machine(machine)
, m_disabled(true) , m_disabled(true)
, m_symtable(&machine) , m_symtable()
{ {
// if the cheat engine is disabled, we're done // if the cheat engine is disabled, we're done
if (!machine.options().cheat()) if (!machine.options().cheat())
@ -1329,7 +1329,7 @@ std::string cheat_manager::quote_expression(const parsed_expression &expression)
// execute_frombcd - convert a value from BCD // execute_frombcd - convert a value from BCD
//------------------------------------------------- //-------------------------------------------------
uint64_t cheat_manager::execute_frombcd(symbol_table &table, int params, const uint64_t *param) uint64_t cheat_manager::execute_frombcd(int params, const uint64_t *param)
{ {
uint64_t value(param[0]); uint64_t value(param[0]);
uint64_t multiplier(1); uint64_t multiplier(1);
@ -1349,7 +1349,7 @@ uint64_t cheat_manager::execute_frombcd(symbol_table &table, int params, const u
// execute_tobcd - convert a value to BCD // execute_tobcd - convert a value to BCD
//------------------------------------------------- //-------------------------------------------------
uint64_t cheat_manager::execute_tobcd(symbol_table &table, int params, const uint64_t *param) uint64_t cheat_manager::execute_tobcd(int params, const uint64_t *param)
{ {
uint64_t value(param[0]); uint64_t value(param[0]);
uint64_t result(0); uint64_t result(0);

4
src/frontend/mame/cheat.h
View File

@ -327,8 +327,8 @@ public:
// global helpers // global helpers
static std::string quote_expression(parsed_expression const &expression); static std::string quote_expression(parsed_expression const &expression);
static uint64_t execute_frombcd(symbol_table &table, int params, uint64_t const *param); static uint64_t execute_frombcd(int params, uint64_t const *param);
static uint64_t execute_tobcd(symbol_table &table, int params, uint64_t const *param); static uint64_t execute_tobcd(int params, uint64_t const *param);
private: private:
// internal helpers // internal helpers