Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-26 02:07:14 +03:00
Code Issues Actions 15 Packages Projects Releases Wiki Activity

disable: reverse polarity (nw)

Browse Source
This commit is contained in:
Olivier Galibert 2017-03-26 14:40:16 +02:00
parent f2aaf2eaa8
commit b39dcdc613
4 changed files with 26 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -929,7 +929,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 with_se) u64 debugger_cpu::expression_read_memory(void *param, const char *name, expression_space spacenum, u32 address, int size, bool disable_se)
{ {
switch (spacenum) switch (spacenum)
{ {
@ -951,7 +951,7 @@ u64 debugger_cpu::expression_read_memory(void *param, const char *name, expressi
if (memory->has_space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_LOGICAL))) if (memory->has_space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_LOGICAL)))
{ {
address_space &space = memory->space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_LOGICAL)); address_space &space = memory->space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_LOGICAL));
if (!with_se) { if (disable_se) {
auto dis = m_machine.disable_side_effect(); auto dis = m_machine.disable_side_effect();
return read_memory(space, space.address_to_byte(address), size, true); return read_memory(space, space.address_to_byte(address), size, true);
} else } else
@ -978,7 +978,7 @@ u64 debugger_cpu::expression_read_memory(void *param, const char *name, expressi
if (memory->has_space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_PHYSICAL))) if (memory->has_space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_PHYSICAL)))
{ {
address_space &space = memory->space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_PHYSICAL)); address_space &space = memory->space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_PHYSICAL));
if (!with_se) { if (disable_se) {
auto dis = m_machine.disable_side_effect(); auto dis = m_machine.disable_side_effect();
return read_memory(space, space.address_to_byte(address), size, false); return read_memory(space, space.address_to_byte(address), size, false);
} else } else
@ -999,7 +999,7 @@ u64 debugger_cpu::expression_read_memory(void *param, const char *name, expressi
device = get_visible_cpu(); device = get_visible_cpu();
memory = &device->memory(); memory = &device->memory();
} }
if (!with_se) { if (disable_se) {
auto dis = m_machine.disable_side_effect(); auto dis = m_machine.disable_side_effect();
return expression_read_program_direct(memory->space(AS_PROGRAM), (spacenum == EXPSPACE_OPCODE), address, size); return expression_read_program_direct(memory->space(AS_PROGRAM), (spacenum == EXPSPACE_OPCODE), address, size);
} else } else
@ -1019,7 +1019,7 @@ u64 debugger_cpu::expression_read_memory(void *param, const char *name, expressi
device = get_visible_cpu(); device = get_visible_cpu();
memory = &device->memory(); memory = &device->memory();
} }
if (!with_se) { if (disable_se) {
auto dis = m_machine.disable_side_effect(); auto dis = m_machine.disable_side_effect();
return expression_read_program_direct(memory->space(AS_DECRYPTED_OPCODES), (spacenum == EXPSPACE_OPCODE), address, size); return expression_read_program_direct(memory->space(AS_DECRYPTED_OPCODES), (spacenum == EXPSPACE_OPCODE), address, size);
} else } else
@ -1147,7 +1147,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 with_se) void debugger_cpu::expression_write_memory(void *param, 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;
@ -1168,7 +1168,7 @@ void debugger_cpu::expression_write_memory(void *param, const char *name, expres
if (memory->has_space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_LOGICAL))) if (memory->has_space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_LOGICAL)))
{ {
address_space &space = memory->space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_LOGICAL)); address_space &space = memory->space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_LOGICAL));
if (!with_se) { if (disable_se) {
auto dis = m_machine.disable_side_effect(); auto dis = m_machine.disable_side_effect();
write_memory(space, space.address_to_byte(address), data, size, true); write_memory(space, space.address_to_byte(address), data, size, true);
} else } else
@ -1190,7 +1190,7 @@ void debugger_cpu::expression_write_memory(void *param, const char *name, expres
if (memory->has_space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_PHYSICAL))) if (memory->has_space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_PHYSICAL)))
{ {
address_space &space = memory->space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_PHYSICAL)); address_space &space = memory->space(AS_PROGRAM + (spacenum - EXPSPACE_PROGRAM_PHYSICAL));
if (!with_se) { if (disable_se) {
auto dis = m_machine.disable_side_effect(); auto dis = m_machine.disable_side_effect();
write_memory(space, space.address_to_byte(address), data, size, false); write_memory(space, space.address_to_byte(address), data, size, false);
} else } else
@ -1206,7 +1206,7 @@ void debugger_cpu::expression_write_memory(void *param, const char *name, expres
device = get_visible_cpu(); device = get_visible_cpu();
memory = &device->memory(); memory = &device->memory();
} }
if (!with_se) { if (disable_se) {
auto dis = m_machine.disable_side_effect(); auto dis = m_machine.disable_side_effect();
expression_write_program_direct(memory->space(AS_PROGRAM), (spacenum == EXPSPACE_OPCODE), address, size, data); expression_write_program_direct(memory->space(AS_PROGRAM), (spacenum == EXPSPACE_OPCODE), address, size, data);
} else } else
@ -1221,7 +1221,7 @@ void debugger_cpu::expression_write_memory(void *param, const char *name, expres
device = get_visible_cpu(); device = get_visible_cpu();
memory = &device->memory(); memory = &device->memory();
} }
if (!with_se) { if (disable_se) {
auto dis = m_machine.disable_side_effect(); auto dis = m_machine.disable_side_effect();
expression_write_program_direct(memory->space(AS_DECRYPTED_OPCODES), (spacenum == EXPSPACE_OPCODE), address, size, data); expression_write_program_direct(memory->space(AS_DECRYPTED_OPCODES), (spacenum == EXPSPACE_OPCODE), address, size, data);
} else } else

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

@ -578,10 +578,10 @@ 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 with_se); u64 expression_read_memory(void *param, 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 with_se); void expression_write_memory(void *param, 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(void *param, const char *name, expression_space space);

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

@ -517,7 +517,7 @@ expression_error::error_code symbol_table::memory_valid(const char *name, expres
// memory_value - return a value read from memory // memory_value - return a value read from memory
//------------------------------------------------- //-------------------------------------------------
u64 symbol_table::memory_value(const char *name, expression_space space, u32 offset, int size, bool with_se) u64 symbol_table::memory_value(const char *name, expression_space space, u32 offset, int size, bool disable_se)
{ {
// walk up the table hierarchy to find the owner // walk up the table hierarchy to find the owner
for (symbol_table *symtable = this; symtable != nullptr; symtable = symtable->m_parent) for (symbol_table *symtable = this; symtable != nullptr; symtable = symtable->m_parent)
@ -525,7 +525,7 @@ u64 symbol_table::memory_value(const char *name, expression_space space, u32 off
{ {
expression_error::error_code err = symtable->m_memory_valid(symtable->m_memory_param, name, space); expression_error::error_code err = symtable->m_memory_valid(symtable->m_memory_param, 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, with_se); return symtable->m_memory_read(symtable->m_memory_param, name, space, offset, size, disable_se);
return 0; return 0;
} }
return 0; return 0;
@ -536,7 +536,7 @@ u64 symbol_table::memory_value(const char *name, expression_space space, u32 off
// set_memory_value - write a value to memory // set_memory_value - write a value to memory
//------------------------------------------------- //-------------------------------------------------
void symbol_table::set_memory_value(const char *name, expression_space space, u32 offset, int size, u64 value, bool with_se) void symbol_table::set_memory_value(const char *name, expression_space space, u32 offset, int size, u64 value, bool disable_se)
{ {
// walk up the table hierarchy to find the owner // walk up the table hierarchy to find the owner
for (symbol_table *symtable = this; symtable != nullptr; symtable = symtable->m_parent) for (symbol_table *symtable = this; symtable != nullptr; symtable = symtable->m_parent)
@ -544,7 +544,7 @@ void symbol_table::set_memory_value(const char *name, expression_space space, u3
{ {
expression_error::error_code err = symtable->m_memory_valid(symtable->m_memory_param, name, space); expression_error::error_code err = symtable->m_memory_valid(symtable->m_memory_param, 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, with_se); symtable->m_memory_write(symtable->m_memory_param, name, space, offset, size, value, disable_se);
return; return;
} }
} }
@ -876,9 +876,9 @@ void parsed_expression::parse_symbol_or_number(parse_token &token, const char *&
// check for memory @ operators // check for memory @ operators
if ((string[0] == '@' || string[0] == '!') && (buffer.back() == 'b' || buffer.back() == 'w' || buffer.back() == 'd' || buffer.back() == 'q')) if ((string[0] == '@' || string[0] == '!') && (buffer.back() == 'b' || buffer.back() == 'w' || buffer.back() == 'd' || buffer.back() == 'q'))
{ {
bool with_se = string[0] == '!'; bool disable_se = string[0] == '@';
string += 1; string += 1;
return parse_memory_operator(token, buffer.c_str(), with_se); return parse_memory_operator(token, buffer.c_str(), disable_se);
} }
// empty string is automatically invalid // empty string is automatically invalid
@ -1098,7 +1098,7 @@ void parsed_expression::parse_quoted_string(parse_token &token, const char *&str
// forms of memory operators // forms of memory operators
//------------------------------------------------- //-------------------------------------------------
void parsed_expression::parse_memory_operator(parse_token &token, const char *string, bool with_se) void parsed_expression::parse_memory_operator(parse_token &token, const char *string, bool disable_se)
{ {
// if there is a '.', it means we have a name // if there is a '.', it means we have a name
const char *startstring = string; const char *startstring = string;
@ -1175,7 +1175,7 @@ void parsed_expression::parse_memory_operator(parse_token &token, const char *st
} }
// 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_effect(with_se); token.configure_operator(TVL_MEMORYAT, 2).set_memory_size(memsize).set_memory_space(memspace).set_memory_source(namestring).set_memory_side_effect(disable_se);
} }

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

@ -161,8 +161,8 @@ public:
// 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(void *cbparam, 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 with_se)> read_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<void(void *cbparam, const char *name, expression_space space, u32 offset, int size, u64 value, bool with_se)> write_func; typedef std::function<void(void *cbparam, const char *name, expression_space space, u32 offset, int size, u64 value, bool disable_se)> write_func;
enum read_write enum read_write
{ {
@ -195,8 +195,8 @@ public:
// memory accessors // memory accessors
expression_error::error_code memory_valid(const char *name, expression_space space); expression_error::error_code memory_valid(const char *name, expression_space space);
u64 memory_value(const char *name, expression_space space, u32 offset, int size, bool with_se); u64 memory_value(const char *name, expression_space space, u32 offset, int size, bool disable_se);
void set_memory_value(const char *name, expression_space space, u32 offset, int size, u64 value, bool with_se); void set_memory_value(const char *name, expression_space space, u32 offset, int size, u64 value, bool disable_se);
private: private:
// internal state // internal state
@ -314,7 +314,7 @@ private:
parse_token &set_right_to_left() { assert(m_type == OPERATOR); m_flags |= TIN_RIGHT_TO_LEFT_MASK; return *this; } parse_token &set_right_to_left() { assert(m_type == OPERATOR); m_flags |= TIN_RIGHT_TO_LEFT_MASK; return *this; }
parse_token &set_memory_space(expression_space space) { assert(m_type == OPERATOR || m_type == MEMORY); m_flags = (m_flags & ~TIN_MEMORY_SPACE_MASK) | ((space << TIN_MEMORY_SPACE_SHIFT) & TIN_MEMORY_SPACE_MASK); return *this; } parse_token &set_memory_space(expression_space space) { assert(m_type == OPERATOR || m_type == MEMORY); m_flags = (m_flags & ~TIN_MEMORY_SPACE_MASK) | ((space << TIN_MEMORY_SPACE_SHIFT) & TIN_MEMORY_SPACE_MASK); return *this; }
parse_token &set_memory_size(int log2ofbits) { assert(m_type == OPERATOR || m_type == MEMORY); m_flags = (m_flags & ~TIN_MEMORY_SIZE_MASK) | ((log2ofbits << TIN_MEMORY_SIZE_SHIFT) & TIN_MEMORY_SIZE_MASK); return *this; } parse_token &set_memory_size(int log2ofbits) { assert(m_type == OPERATOR || m_type == MEMORY); m_flags = (m_flags & ~TIN_MEMORY_SIZE_MASK) | ((log2ofbits << TIN_MEMORY_SIZE_SHIFT) & TIN_MEMORY_SIZE_MASK); return *this; }
parse_token &set_memory_side_effect(bool with_se) { assert(m_type == OPERATOR || m_type == MEMORY); m_flags = with_se ? m_flags | TIN_SIDE_EFFECT_MASK : m_flags & ~TIN_SIDE_EFFECT_MASK; return *this; } parse_token &set_memory_side_effect(bool disable_se) { assert(m_type == OPERATOR || m_type == MEMORY); m_flags = disable_se ? m_flags | TIN_SIDE_EFFECT_MASK : m_flags & ~TIN_SIDE_EFFECT_MASK; return *this; }
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
@ -363,7 +363,7 @@ private:
void parse_number(parse_token &token, const char *string, int base, expression_error::error_code errcode); void parse_number(parse_token &token, const char *string, int base, expression_error::error_code errcode);
void parse_quoted_char(parse_token &token, const char *&string); void parse_quoted_char(parse_token &token, const char *&string);
void parse_quoted_string(parse_token &token, const char *&string); void parse_quoted_string(parse_token &token, const char *&string);
void parse_memory_operator(parse_token &token, const char *string, bool with_se); void parse_memory_operator(parse_token &token, const char *string, bool disable_se);
void normalize_operator(parse_token *prevtoken, parse_token &thistoken); void normalize_operator(parse_token *prevtoken, parse_token &thistoken);
void infix_to_postfix(); void infix_to_postfix();