TEST(corestr,strtrimspace)
{
std::string value = " a value for test ";
EXPECT_STREQ("a value for test", strtrimspace(value).c_str());
value = "\r\n\ta value for test\r\n\n\r";
EXPECT_STREQ("a value for test", strtrimspace(value).c_str());
}
bool symbol_manager::parse_map_line(const char *line, FPTR &address, std::string &symbol)
{
#ifdef __GNUC__
/*
32-bit gcc map line:
0x0089cb00 nbmj9195_palette_r(_address_space const*, unsigned int)
64-bit gcc map line:
0x0000000000961afc nbmj9195_palette_r(_address_space const*, unsigned int)
*/
// find a matching start
if (strncmp(line, " 0x", 18) == 0)
{
// make sure we can get an address
void *temp;
if (sscanf(&line[16], "0x%p", &temp) != 1)
return false;
address = reinterpret_cast<FPTR>(temp);
// skip forward until we're past the space
const char *chptr = &line[16];
while (*chptr != 0 && !isspace(*chptr))
chptr++;
// extract the symbol name
strtrimspace(symbol.assign(chptr));
return (symbol.length() > 0);
}
#endif
return false;
}
options::entry::entry(const char *name, const char *description, UINT32 flags, const char *defvalue)
: m_next(NULL),
m_flags(flags),
m_seqid(0),
m_error_reported(false),
m_priority(OPTION_PRIORITY_DEFAULT),
m_description(description)
{
// copy in the name(s) as appropriate
if (name != nullptr)
{
// first extract any range
std::string namestr(name);
int lparen = namestr.find('(');
int dash = namestr.find(lparen + 1, '-');
int rparen = namestr.find(dash + 1, ')');
if (lparen != -1 && dash != -1 && rparen != -1)
{
m_minimum.assign(namestr.substr(lparen + 1, dash - (lparen + 1)));
strtrimspace(m_minimum);
m_maximum.assign(namestr.substr(dash + 1, rparen - (dash + 1)));
strtrimspace(m_maximum);
namestr.erase(lparen, rparen + 1 - lparen);
}
// then chop up any semicolon-separated names
int semi;
int nameindex = 0;
while ((semi = namestr.find(';')) != -1 && nameindex < ARRAY_LENGTH(m_name))
{
m_name[nameindex++].assign(namestr.substr(0, semi));
namestr.erase(0, semi + 1);
}
// finally add the last item
if (nameindex < ARRAY_LENGTH(m_name))
m_name[nameindex++] = namestr;
}
// set the default value
if (defvalue != nullptr)
m_defdata = defvalue;
m_data = m_defdata;
}
std::string input_manager::code_name(input_code code) const
{
// if nothing there, return an empty string
input_device_item *item = item_from_code(code);
if (item == nullptr)
return std::string();
// determine the devclass part
const char *devclass = (*devclass_string_table)[code.device_class()];
// determine the devindex part
std::string devindex = string_format("%d", code.device_index() + 1);
// if we're unifying all devices, don't display a number
if (!m_class[code.device_class()]->multi())
devindex.clear();
// keyboard 0 doesn't show a class or index if it is the only one
input_device_class device_class = item->device().devclass();
if (device_class == DEVICE_CLASS_KEYBOARD && m_class[device_class]->maxindex() == 0)
{
devclass = "";
devindex.clear();
}
// devcode part comes from the item name
const char *devcode = item->name();
// determine the modifier part
const char *modifier = (*modifier_string_table)[code.item_modifier()];
// devcode is redundant with joystick switch left/right/up/down
if (device_class == DEVICE_CLASS_JOYSTICK && code.item_class() == ITEM_CLASS_SWITCH)
if (code.item_modifier() >= ITEM_MODIFIER_LEFT && code.item_modifier() <= ITEM_MODIFIER_DOWN)
devcode = "";
// concatenate the strings
std::string str(devclass);
if (!devindex.empty())
str.append(" ").append(devindex);
if (devcode[0] != 0)
str.append(" ").append(devcode);
if (modifier != nullptr)
str.append(" ").append(modifier);
// delete any leading spaces
strtrimspace(str);
return str;
}
static inline std::string gba_chip_string( uint32_t chip )
{
std::string str;
if (chip == 0) str += "NONE ";
if (chip & GBA_CHIP_EEPROM) str += "EEPROM ";
if (chip & GBA_CHIP_EEPROM_64K) str += "EEPROM_64K ";
if (chip & GBA_CHIP_EEPROM_4K) str += "EEPROM_4K ";
if (chip & GBA_CHIP_FLASH) str += "FLASH ";
if (chip & GBA_CHIP_FLASH_1M) str += "FLASH_1M ";
if (chip & GBA_CHIP_FLASH_512) str += "FLASH_512 ";
if (chip & GBA_CHIP_SRAM) str += "SRAM ";
if (chip & GBA_CHIP_RTC) str += "RTC ";
strtrimspace(str);
return str;
}
bool symbol_manager::parse_sym_line(const char *line, FPTR &address, std::string &symbol)
{
#ifdef __GNUC__
/*
32-bit gcc symbol line:
[271778](sec 1)(fl 0x00)(ty 20)(scl 3) (nx 0) 0x007df675 line_to_symbol(char const*, unsigned int&, bool)
64-bit gcc symbol line:
[271775](sec 1)(fl 0x00)(ty 20)(scl 3) (nx 0) 0x00000000008dd1e9 line_to_symbol(char const*, unsigned long long&, bool)
*/
// first look for a (ty) entry
const char *type = strstr(line, "(ty 20)");
if (type == nullptr)
return false;
// scan forward in the line to find the address
bool in_parens = false;
for (const char *chptr = type; *chptr != 0; chptr++)
{
// track open/close parentheses
if (*chptr == '(')
in_parens = true;
else if (*chptr == ')')
in_parens = false;
// otherwise, look for an 0x address
else if (!in_parens && *chptr == '0' && chptr[1] == 'x')
{
// make sure we can get an address
void *temp;
if (sscanf(chptr, "0x%p", &temp) != 1)
return false;
address = m_text_base + reinterpret_cast<FPTR>(temp);
// skip forward until we're past the space
while (*chptr != 0 && !isspace(*chptr))
chptr++;
// extract the symbol name
strtrimspace(symbol.assign(chptr));
return (symbol.length() > 0);
}
}
#endif
return false;
}
void cheat_entry::menu_text(std::string &description, std::string &state, uint32_t &flags)
{
// description is standard
description.assign(m_description);
state.clear();
flags = 0;
// some cheat entries are just text for display
if (is_text_only())
{
if (!description.empty())
{
strtrimspace(description);
if (description.empty())
description.assign(MENU_SEPARATOR_ITEM);
}
flags = ui::menu::FLAG_DISABLE;
}
// if we have no parameter and no run or off script, it's a oneshot cheat
else if (is_oneshot())
state.assign("Set");
// if we have no parameter, it's just on/off
else if (is_onoff())
{
state.assign((m_state == SCRIPT_STATE_RUN) ? "On" : "Off");
flags = (m_state != 0) ? ui::menu::FLAG_LEFT_ARROW : ui::menu::FLAG_RIGHT_ARROW;
}
// if we have a value parameter, compute it
else if (m_parameter != nullptr)
{
if (m_state == SCRIPT_STATE_OFF)
{
state.assign(is_oneshot_parameter() ? "Set" : "Off");
flags = ui::menu::FLAG_RIGHT_ARROW;
}
else
{
state.assign(m_parameter->text());
flags = ui::menu::FLAG_LEFT_ARROW;
if (!m_parameter->is_maximum())
flags |= ui::menu::FLAG_RIGHT_ARROW;
}
}
}
std::string hash_collection::attribute_string() const
{
std::string buffer;
// handle CRCs
if (m_has_crc32)
buffer.append("crc=\"").append(m_crc32.as_string()).append("\" ");
// handle SHA1s
if (m_has_sha1)
buffer.append("sha1=\"").append(m_sha1.as_string()).append("\" ");
// append flags
if (flag(FLAG_NO_DUMP))
buffer.append("status=\"nodump\"");
if (flag(FLAG_BAD_DUMP))
buffer.append("status=\"baddump\"");
strtrimspace(buffer);
return buffer;
}
std::string hash_collection::macro_string() const
{
std::string buffer;
// handle CRCs
if (m_has_crc32)
buffer.append("CRC(").append(m_crc32.as_string()).append(") ");
// handle SHA1s
if (m_has_sha1)
buffer.append("SHA1(").append(m_sha1.as_string()).append(") ");
// append flags
if (flag(FLAG_NO_DUMP))
buffer.append("NO_DUMP ");
if (flag(FLAG_BAD_DUMP))
buffer.append("BAD_DUMP ");
strtrimspace(buffer);
return buffer;
}
bool core_options::validate_and_set_data(core_options::entry &curentry, const char *newdata, int priority, std::string &error_string)
{
// trim any whitespace
std::string data(newdata);
strtrimspace(data);
// trim quotes
if (data.find_first_of('"') == 0 && data.find_last_of('"') == data.length() - 1)
{
data.erase(0, 1);
data.erase(data.length() - 1, 1);
}
// validate the type of data and optionally the range
float fval;
int ival;
switch (curentry.type())
{
// booleans must be 0 or 1
case OPTION_BOOLEAN:
if (sscanf(data.c_str(), "%d", &ival) != 1 || ival < 0 || ival > 1)
{
strcatprintf(error_string, "Illegal boolean value for %s: \"%s\"; reverting to %s\n", curentry.name(), data.c_str(), curentry.value());
return false;
}
break;
// integers must be integral
case OPTION_INTEGER:
if (sscanf(data.c_str(), "%d", &ival) != 1)
{
strcatprintf(error_string, "Illegal integer value for %s: \"%s\"; reverting to %s\n", curentry.name(), data.c_str(), curentry.value());
return false;
}
if (curentry.has_range() && (ival < atoi(curentry.minimum()) || ival > atoi(curentry.maximum())))
{
strcatprintf(error_string, "Out-of-range integer value for %s: \"%s\" (must be between %s and %s); reverting to %s\n", curentry.name(), data.c_str(), curentry.minimum(), curentry.maximum(), curentry.value());
return false;
}
break;
// floating-point values must be numeric
case OPTION_FLOAT:
if (sscanf(data.c_str(), "%f", &fval) != 1)
{
strcatprintf(error_string, "Illegal float value for %s: \"%s\"; reverting to %s\n", curentry.name(), data.c_str(), curentry.value());
return false;
}
if (curentry.has_range() && ((double) fval < atof(curentry.minimum()) || (double) fval > atof(curentry.maximum())))
{
strcatprintf(error_string, "Out-of-range float value for %s: \"%s\" (must be between %s and %s); reverting to %s\n", curentry.name(), data.c_str(), curentry.minimum(), curentry.maximum(), curentry.value());
return false;
}
break;
// strings can be anything
case OPTION_STRING:
break;
// anything else is invalid
case OPTION_INVALID:
case OPTION_HEADER:
default:
strcatprintf(error_string, "Attempted to set invalid option %s\n", curentry.name());
return false;
}
// set the data
curentry.set_value(data.c_str(), priority);
return true;
}
int find_input_strings(running_machine &machine)
{
for (int i = 0; i < 32; i++)
{
for (int j = 0; j < 16; j++)
{
char tempstr[32];
sprintf(tempstr, "IN%d-%d", i, j);
sc4inputs[i][j].name = tempstr;
sc4inputs[i][j].used = false;
}
}
int foundat = -1;
UINT32 startblock = 0;
UINT32 endblock = 0;
UINT16 *rom = (UINT16*)machine.root_device().memregion( "maincpu" )->base();
UINT8 *rom8 = machine.root_device().memregion( "maincpu" )->base();
for (int i=0;i<(0x100000-0x40)/2;i++)
{
bool found = compare_input_code(machine, i);
if (found==true)
{
startblock = (rom[i + 5] << 16) | rom[i + 6];
endblock = (rom[i + 10] << 16) | rom[i + 11];
sc45helperlog("------------ INPUTS -----------------\n");
sc45helperlog("input strings found at %08x (start of ponter block %08x end of pointer block %08x\n", i*2, startblock, endblock);
foundat = i;
if (endblock > startblock)
{
for (int j = startblock / 2; j < endblock / 2; j+=4)
{
UINT16 portpos = rom[j + 0];
int port = (portpos & 0x1f);
int pos = (portpos >> 5);
UINT16 unk2 = rom[j + 1];
UINT32 stringaddr = (rom[j + 2] << 16) | rom[j + 3];
sc45helperlog("(port %02x position %02x) unk %04x addr %08x ", port,pos, unk2, stringaddr);
std::string tempstring;
for (int k = stringaddr; k < stringaddr + 6; k++)
{
UINT8 chr = rom8[k^1];
if ((chr == 0xff) || (chr == 0x00))
{
k = stringaddr + 6;
}
else
{
tempstring.push_back(chr);
}
}
strtrimspace(tempstring);
strmakelower(tempstring);
//if (pos <= 5)
{
assert(pos >= 0 && pos < ARRAY_LENGTH(sc4inputs[port]));
if (sc4inputs[port][pos].used == false)
{
sc4inputs[port][pos].used = true;
sc4inputs[port][pos].name = tempstring;
}
else
{
printf("position already used?\n");
sc4inputs[port][pos].name.append(" OR ");
sc4inputs[port][pos].name.append(tempstring);
}
}
//else
//{
// printf("invalid port position?\n");
//}
sc45helperlog("%s", tempstring.c_str());
sc45helperlog("\n");
}
}
}
}
