summaryrefslogtreecommitdiffstats
path: root/src/emu/debug/express.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/emu/debug/express.cpp')
-rw-r--r--src/emu/debug/express.cpp91
1 files changed, 46 insertions, 45 deletions
diff --git a/src/emu/debug/express.cpp b/src/emu/debug/express.cpp
index 114ec589951..bb1f17e05f3 100644
--- a/src/emu/debug/express.cpp
+++ b/src/emu/debug/express.cpp
@@ -47,11 +47,6 @@
CONSTANTS
***************************************************************************/
-#ifndef DEFAULT_BASE
-#define DEFAULT_BASE 16 // hex unless otherwise specified
-#endif
-
-
// token.value values if token.is_operator()
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)
: 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; })),
+ ? symbol_table::getter_func([ptr] () { return *ptr; })
+ : symbol_table::getter_func([this] () { 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; })),
+ ? symbol_table::setter_func([ptr] (u64 value) { *ptr = value; })
+ : symbol_table::setter_func([this] (u64 value) { m_value = value; })),
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)
: 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_value(constval)
{
@@ -275,7 +270,7 @@ bool integer_symbol_entry::is_lval() 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)
{
if (m_setter != nullptr)
- m_setter(m_table, newvalue);
+ m_setter(newvalue);
else
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);
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, 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::symbol_table(void *globalref, symbol_table *parent)
+symbol_table::symbol_table(symbol_table *parent)
: m_parent(parent),
- m_globalref(globalref),
- m_memory_param(nullptr),
m_memory_valid(nullptr),
m_memory_read(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
//-------------------------------------------------
-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_read = std::move(read);
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)
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)
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)
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)
- 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;
@@ -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)
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)
- 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;
}
}
@@ -537,16 +529,29 @@ void symbol_table::set_memory_value(const char *name, expression_space space, u3
// 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_default_base(default_base)
{
+ assert(default_base == 8 || default_base == 10 || default_base == 16);
+
// if we got an expression parse it
if (expression != nullptr)
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)
{
m_symtable = src.m_symtable;
+ m_default_base = src.m_default_base;
m_original_string.assign(src.m_original_string);
if (!m_original_string.empty())
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)
{
// this is really a hack, but 0B1234 could also hex depending on default base
- if (expression_error::INVALID_NUMBER == err)
- return parse_number(token, buffer.c_str(), DEFAULT_BASE, expression_error::INVALID_NUMBER);
+ if (expression_error::INVALID_NUMBER == err && m_default_base == 16)
+ return parse_number(token, buffer.c_str(), m_default_base, expression_error::INVALID_NUMBER);
else
throw;
}
- // TODO: for octal address spaces, treat 0123 as octal
default:
; // fall through
}
@@ -956,7 +961,7 @@ void parsed_expression::parse_symbol_or_number(parse_token &token, const char *&
default:
// 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)
{
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
- 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
- if (m_symtable != nullptr)
- {
- expression_error::error_code err = m_symtable->memory_valid(namestring, memspace);
- if (err != expression_error::NONE)
- throw expression_error(err, token.offset() + (string - startstring));
- }
+ expression_error::error_code err = m_symtable.get().memory_valid(namestring, memspace);
+ if (err != expression_error::NONE)
+ throw expression_error(err, token.offset() + (string - startstring));
// 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);
@@ -1679,16 +1681,15 @@ parsed_expression::parse_token::parse_token(int offset)
// 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
if (is_symbol())
return m_symbol->value();
// or get the value from the memory callbacks
- else if (is_memory() && table != nullptr) {
- return table->memory_value(m_string, memory_space(), address(), 1 << memory_size(), memory_side_effects());
- }
+ else if (is_memory())
+ return table.memory_value(m_string, memory_space(), address(), 1 << memory_size(), memory_side_effects());
return 0;
}
@@ -1699,15 +1700,15 @@ u64 parsed_expression::parse_token::get_lval_value(symbol_table *table)
// 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
if (is_symbol())
m_symbol->set_value(value);
// or set the value via the memory callbacks
- else if (is_memory() && table != nullptr)
- table->set_memory_value(m_string, memory_space(), address(), 1 << memory_size(), value, memory_side_effects());
+ else if (is_memory())
+ table.set_memory_value(m_string, memory_space(), address(), 1 << memory_size(), value, memory_side_effects());
}