void image_manager::config_load(config_type cfg_type, xml_data_node *parentnode)
{
xml_data_node *node;
const char *dev_instance;
const char *working_directory;
if ((cfg_type == config_type::CONFIG_TYPE_GAME) && (parentnode != nullptr))
{
for (node = xml_get_sibling(parentnode->child, "device"); node; node = xml_get_sibling(node->next, "device"))
{
dev_instance = xml_get_attribute_string(node, "instance", nullptr);
if ((dev_instance != nullptr) && (dev_instance[0] != '\0'))
{
for (device_image_interface &image : image_interface_iterator(machine().root_device()))
{
if (!strcmp(dev_instance, image.instance_name())) {
working_directory = xml_get_attribute_string(node, "directory", nullptr);
if (working_directory != nullptr)
image.set_working_directory(working_directory);
}
}
}
}
}
}
static void image_dirs_load(running_machine &machine, int config_type, xml_data_node *parentnode)
{
xml_data_node *node;
const char *dev_instance;
const char *working_directory;
device_image_interface *image = NULL;
if ((config_type == CONFIG_TYPE_GAME) && (parentnode != NULL))
{
for (node = xml_get_sibling(parentnode->child, "device"); node; node = xml_get_sibling(node->next, "device"))
{
dev_instance = xml_get_attribute_string(node, "instance", NULL);
if ((dev_instance != NULL) && (dev_instance[0] != '\0'))
{
for (bool gotone = machine.devicelist().first(image); gotone; gotone = image->next(image))
{
if (!strcmp(dev_instance, image->instance_name())) {
working_directory = xml_get_attribute_string(node, "directory", NULL);
if (working_directory != NULL)
image->set_working_directory(working_directory);
}
}
}
}
}
}
static multicart_open_error load_socket(multicart_load_state *state, xml_data_node *socket_node)
{
const char *id;
const char *uses;
const multicart_resource *resource;
multicart_socket *socket;
multicart_socket **next_socket;
/* get the 'id' and 'uses' attributes; error if not present */
id = xml_get_attribute_string(socket_node, "id", NULL);
uses = xml_get_attribute_string(socket_node, "uses", NULL);
if ((id == NULL) || (uses == NULL))
return MCERR_XML_ERROR;
/* find the resource */
for (resource = state->multicart->resources; resource != NULL; resource = resource->next)
{
if (!strcmp(uses, resource->id))
break;
}
if (resource == NULL)
return MCERR_INVALID_RESOURCE_REF;
/* create the socket */
socket = (multicart_socket *)pool_malloc_lib(state->multicart->data->pool, sizeof(*socket));
if (socket == NULL)
return MCERR_OUT_OF_MEMORY;
memset(socket, 0, sizeof(*socket));
socket->resource = resource;
socket->ptr = resource->ptr;
/* copy id */
socket->id = pool_strdup_lib(state->multicart->data->pool, id);
if (socket->id == NULL)
return MCERR_OUT_OF_MEMORY;
/* which pointer should I use? */
if (resource->ptr != NULL)
{
/* use the resource's ptr */
socket->ptr = resource->ptr;
}
else
{
/* allocate bytes for this socket */
socket->ptr = pool_malloc_lib(state->multicart->data->pool, resource->length);
if (socket->ptr == NULL)
return MCERR_OUT_OF_MEMORY;
/* ...and clear it */
memset(socket->ptr, 0xCD, resource->length);
}
/* append the resource */
for (next_socket = &state->sockets; *next_socket; next_socket = &(*next_socket)->next)
;
*next_socket = socket;
return MCERR_NONE;
}
static multicart_open_error load_rom_resource(multicart_load_state *state, xml_data_node *resource_node,
multicart_resource *resource)
{
const char *file, *crcstr, *sha1;
const zip_file_header *header;
zip_error ziperr;
UINT32 crc;
/* locate the 'file' attribute */
file = xml_get_attribute_string(resource_node, "file", NULL);
if (file == NULL)
return MCERR_XML_ERROR;
if (!(crcstr = xml_get_attribute_string(resource_node, "crc", NULL)))
{
/* locate the file in the ZIP file */
header = find_file(state->zip, file);
}
else /* CRC tag is present, use it */
{
crc = strtoul(crcstr, NULL, 16);
header = find_file_crc(state->zip, file, crc);
}
if (header == NULL)
return MCERR_INVALID_FILE_REF;
resource->length = header->uncompressed_length;
/* allocate bytes for this resource */
resource->ptr = pool_malloc_lib(state->multicart->data->pool, resource->length);
if (resource->ptr == NULL)
return MCERR_OUT_OF_MEMORY;
/* and decompress it */
ziperr = zip_file_decompress(state->zip, resource->ptr, resource->length);
if (ziperr != ZIPERR_NONE)
return MCERR_ZIP_ERROR;
/* check SHA1 now */
if ((sha1 = xml_get_attribute_string(resource_node, "sha1", NULL)))
{
hash_collection actual_hashes;
actual_hashes.compute((const UINT8 *)resource->ptr, resource->length, hash_collection::HASH_TYPES_CRC_SHA1);
hash_collection expected_hashes;
expected_hashes.add_from_string(hash_collection::HASH_SHA1, sha1, strlen(sha1));
if (actual_hashes != expected_hashes)
{
return MCERR_INVALID_FILE_REF;
}
}
return MCERR_NONE;
}
static multicart_open_error load_ram_resource(emu_options &options, multicart_load_state *state, xml_data_node *resource_node,
multicart_resource *resource)
{
const char *length_string;
const char *ram_type;
const char *ram_filename;
astring *ram_pathname;
/* locate the 'length' attribute */
length_string = xml_get_attribute_string(resource_node, "length", NULL);
if (length_string == NULL)
return MCERR_MISSING_RAM_LENGTH;
/* ...and parse it */
resource->length = ram_parse_string(length_string);
if (resource->length <= 0)
return MCERR_INVALID_RAM_SPEC;
/* allocate bytes for this resource */
resource->ptr = pool_malloc_lib(state->multicart->data->pool, resource->length);
if (resource->ptr == NULL)
return MCERR_OUT_OF_MEMORY;
/* Is this a persistent RAM resource? Then try to load it. */
ram_type = xml_get_attribute_string(resource_node, "type", NULL);
if (ram_type != NULL)
{
if (strcmp(ram_type, "persistent")==0)
{
astring tmp;
/* Get the file name. */
ram_filename = xml_get_attribute_string(resource_node, "file", NULL);
if (ram_filename==NULL)
return MCERR_XML_ERROR;
ram_pathname = astring_assemble_3(&tmp, state->multicart->gamedrv_name, PATH_SEPARATOR, ram_filename);
/* Save the file name so that we can write the contents on unloading.
If the RAM resource has no filename, we know that it was volatile only. */
resource->filename = pool_strdup_lib(state->multicart->data->pool, astring_c(ram_pathname));
if (resource->filename == NULL)
return MCERR_OUT_OF_MEMORY;
image_battery_load_by_name(options, resource->filename, resource->ptr, resource->length, 0x00);
}
/* else this type is volatile, in which case we just have
a memory expansion */
}
return MCERR_NONE;
}
cheat_script::cheat_script(cheat_manager &manager, symbol_table &symbols, const char *filename, xml_data_node &scriptnode)
: m_state(SCRIPT_STATE_RUN)
{
// read the core attributes
const char *state = xml_get_attribute_string(&scriptnode, "state", "run");
if (strcmp(state, "on") == 0)
m_state = SCRIPT_STATE_ON;
else if (strcmp(state, "off") == 0)
m_state = SCRIPT_STATE_OFF;
else if (strcmp(state, "change") == 0)
m_state = SCRIPT_STATE_CHANGE;
else if (strcmp(state, "run") != 0)
throw emu_fatalerror("%s.xml(%d): invalid script state '%s'\n", filename, scriptnode.line, state);
// iterate over nodes within the script
for (xml_data_node *entrynode = scriptnode.child; entrynode != NULL; entrynode = entrynode->next)
{
// handle action nodes
if (strcmp(entrynode->name, "action") == 0)
m_entrylist.append(*global_alloc(script_entry(manager, symbols, filename, *entrynode, true)));
// handle output nodes
else if (strcmp(entrynode->name, "output") == 0)
m_entrylist.append(*global_alloc(script_entry(manager, symbols, filename, *entrynode, false)));
// anything else is ignored
else
{
mame_printf_warning("%s.xml(%d): unknown script item '%s' will be lost if saved\n", filename, entrynode->line, entrynode->name);
continue;
}
}
}
void laserdisc_device::config_load(config_type cfg_type, xml_data_node *parentnode)
{
// we only care about game files
if (cfg_type != config_type::CONFIG_TYPE_GAME)
return;
// might not have any data
if (parentnode == nullptr)
return;
// iterate over overlay nodes
for (xml_data_node *ldnode = xml_get_sibling(parentnode->child, "device"); ldnode != nullptr; ldnode = xml_get_sibling(ldnode->next, "device"))
{
const char *devtag = xml_get_attribute_string(ldnode, "tag", "");
if (strcmp(devtag, tag().c_str()) == 0)
{
// handle the overlay node
xml_data_node *overnode = xml_get_sibling(ldnode->child, "overlay");
if (overnode != nullptr)
{
// fetch positioning controls
m_overposx = xml_get_attribute_float(overnode, "hoffset", m_overposx);
m_overscalex = xml_get_attribute_float(overnode, "hstretch", m_overscalex);
m_overposy = xml_get_attribute_float(overnode, "voffset", m_overposy);
m_overscaley = xml_get_attribute_float(overnode, "vstretch", m_overscaley);
}
}
}
}
void MainWindowQtConfig::recoverFromXmlNode(xml_data_node* node)
{
WindowQtConfig::recoverFromXmlNode(node);
const char* state = xml_get_attribute_string(node, "qtwindowstate", "");
m_windowState = QByteArray::fromPercentEncoding(state);
m_rightBar = xml_get_attribute_int(node, "rightbar", m_rightBar);
}
int xml_get_attribute_int(xml_data_node *node, const char *attribute, int defvalue)
{
const char *string = xml_get_attribute_string(node, attribute, NULL);
int value;
if (!string || sscanf(string, "%d", &value) != 1)
return defvalue;
return value;
}
float xml_get_attribute_float(xml_data_node *node, const char *attribute, float defvalue)
{
const char *string = xml_get_attribute_string(node, attribute, NULL);
float value;
if (!string || sscanf(string, "%f", &value) != 1)
return defvalue;
return value;
}
void crosshair_manager::config_load(config_type cfg_type, xml_data_node *parentnode)
{
/* Note: crosshair_load() is only registered if croshairs are used */
xml_data_node *crosshairnode;
int auto_time;
/* we only care about game files */
if (cfg_type != config_type::CONFIG_TYPE_GAME)
return;
/* might not have any data */
if (parentnode == nullptr)
return;
/* loop and get player crosshair info */
for (crosshairnode = xml_get_sibling(parentnode->child, "crosshair"); crosshairnode; crosshairnode = xml_get_sibling(crosshairnode->next, "crosshair"))
{
int player, mode;
player = xml_get_attribute_int(crosshairnode, "player", -1);
// check to make sure we have a valid player
if (player >= 0 && player < MAX_PLAYERS)
{
// check if the player really uses a crosshair
render_crosshair &crosshair = *m_crosshair[player];
if (crosshair.is_used())
{
// get, check, and store visibility mode
mode = xml_get_attribute_int(crosshairnode, "mode", CROSSHAIR_VISIBILITY_DEFAULT);
if (mode >= CROSSHAIR_VISIBILITY_OFF && mode <= CROSSHAIR_VISIBILITY_AUTO)
{
crosshair.set_mode((UINT8)mode);
/* set visibility as specified by mode */
/* auto mode starts with visibility off */
crosshair.set_visible(mode == CROSSHAIR_VISIBILITY_ON);
}
// get and store crosshair pic name
crosshair.set_bitmap_name(xml_get_attribute_string(crosshairnode, "pic", ""));
}
}
}
/* get, check, and store auto visibility time */
crosshairnode = xml_get_sibling(parentnode->child, "autotime");
if (crosshairnode != nullptr)
{
auto_time = xml_get_attribute_int(crosshairnode, "val", CROSSHAIR_VISIBILITY_AUTOTIME_DEFAULT);
if ((auto_time >= CROSSHAIR_VISIBILITY_AUTOTIME_MIN) && (auto_time <= CROSSHAIR_VISIBILITY_AUTOTIME_MAX))
m_auto_time = (UINT8)auto_time;
}
}
static void crosshair_load(running_machine &machine, int config_type, xml_data_node *parentnode)
{
/* Note: crosshair_load() is only registered if croshairs are used */
xml_data_node *crosshairnode;
int auto_time;
/* we only care about game files */
if (config_type != CONFIG_TYPE_GAME)
return;
/* might not have any data */
if (parentnode == NULL)
return;
/* loop and get player crosshair info */
for (crosshairnode = xml_get_sibling(parentnode->child, "crosshair"); crosshairnode; crosshairnode = xml_get_sibling(crosshairnode->next, "crosshair"))
{
int player, mode;
player = xml_get_attribute_int(crosshairnode, "player", -1);
/* check to make sure we have a valid player */
/* also check if the player really uses a crosshair */
if (player >=0 && player < MAX_PLAYERS && global.used[player])
{
/* get, check, and store visibility mode */
mode = xml_get_attribute_int(crosshairnode, "mode", CROSSHAIR_VISIBILITY_DEFAULT);
if (mode >= CROSSHAIR_VISIBILITY_OFF && mode <= CROSSHAIR_VISIBILITY_AUTO)
{
global.mode[player] = (UINT8)mode;
/* set visibility as specified by mode */
/* auto mode starts with visibility off */
global.visible[player] = (mode == CROSSHAIR_VISIBILITY_ON) ? TRUE : FALSE;
}
/* get and store crosshair pic name, truncate name to max length */
strncpy(global.name[player], xml_get_attribute_string(crosshairnode, "pic", ""), CROSSHAIR_PIC_NAME_LENGTH);
/* update bitmap */
create_bitmap(machine, player);
}
}
/* get, check, and store auto visibility time */
crosshairnode = xml_get_sibling(parentnode->child, "autotime");
if (crosshairnode != NULL)
{
auto_time = xml_get_attribute_int(crosshairnode, "val", CROSSHAIR_VISIBILITY_AUTOTIME_DEFAULT);
if ((auto_time >= CROSSHAIR_VISIBILITY_AUTOTIME_MIN) && (auto_time <= CROSSHAIR_VISIBILITY_AUTOTIME_MAX))
global.auto_time = (UINT8)auto_time;
}
}
int xml_get_attribute_int_format(xml_data_node *node, const char *attribute)
{
const char *string = xml_get_attribute_string(node, attribute, nullptr);
if (string == nullptr)
return XML_INT_FORMAT_DECIMAL;
if (string[0] == '$')
return XML_INT_FORMAT_HEX_DOLLAR;
if (string[0] == '0' && string[1] == 'x')
return XML_INT_FORMAT_HEX_C;
if (string[0] == '#')
return XML_INT_FORMAT_DECIMAL_POUND;
return XML_INT_FORMAT_DECIMAL;
}
static multicart_open_error load_resource(emu_options &options, multicart_load_state *state, xml_data_node *resource_node,
multicart_resource_type resource_type)
{
const char *id;
multicart_open_error err;
multicart_resource *resource;
multicart_resource **next_resource;
/* get the 'id' attribute; error if not present */
id = xml_get_attribute_string(resource_node, "id", NULL);
if (id == NULL)
return MCERR_XML_ERROR;
/* allocate memory for the resource */
resource = (multicart_resource *)pool_malloc_lib(state->multicart->data->pool, sizeof(*resource));
if (resource == NULL)
return MCERR_OUT_OF_MEMORY;
memset(resource, 0, sizeof(*resource));
resource->type = resource_type;
/* copy id */
resource->id = pool_strdup_lib(state->multicart->data->pool, id);
if (resource->id == NULL)
return MCERR_OUT_OF_MEMORY;
switch(resource->type)
{
case MULTICART_RESOURCE_TYPE_ROM:
err = load_rom_resource(state, resource_node, resource);
if (err != MCERR_NONE)
return err;
break;
case MULTICART_RESOURCE_TYPE_RAM:
err = load_ram_resource(options, state, resource_node, resource);
if (err != MCERR_NONE)
return err;
break;
default:
return MCERR_UNKNOWN_RESOURCE_TYPE;
}
/* append the resource */
for (next_resource = &state->resources; *next_resource; next_resource = &(*next_resource)->next)
;
*next_resource = resource;
return MCERR_NONE;
}
int xml_get_attribute_int(xml_data_node *node, const char *attribute, int defvalue)
{
const char *string = xml_get_attribute_string(node, attribute, NULL);
int value;
if (string == NULL)
return defvalue;
if (string[0] == '$')
return (sscanf(&string[1], "%X", &value) == 1) ? value : defvalue;
if (string[0] == '0' && string[1] == 'x')
return (sscanf(&string[2], "%X", &value) == 1) ? value : defvalue;
if (string[0] == '#')
return (sscanf(&string[1], "%d", &value) == 1) ? value : defvalue;
return (sscanf(&string[0], "%d", &value) == 1) ? value : defvalue;
}
void DeviceInformationWindowQtConfig::recoverFromXmlNode(xml_data_node* node)
{
WindowQtConfig::recoverFromXmlNode(node);
m_device_tag = xml_get_attribute_string(node, "device-tag", ":");
}
static int debug_comment_load_xml(mame_file *fp)
{
int i, j;
xml_data_node *root, *commentnode, *systemnode, *cpunode, *datanode;
const char *name;
int version;
/* read the file */
root = xml_file_read(fp, NULL);
if (!root)
goto error;
/* find the config node */
commentnode = xml_get_sibling(root->child, "mamecommentfile");
if (!commentnode)
goto error;
/* validate the config data version */
version = xml_get_attribute_int(commentnode, "version", 0);
if (version != COMMENT_VERSION)
goto error;
/* check to make sure the file is applicable */
systemnode = xml_get_sibling(commentnode->child, "system");
name = xml_get_attribute_string(systemnode, "name", "");
if (strcmp(name, Machine->gamedrv->name) != 0)
goto error;
i = 0;
for (cpunode = xml_get_sibling(systemnode->child, "cpu"); cpunode; cpunode = xml_get_sibling(cpunode->next, "cpu"))
{
j = 0;
for (datanode = xml_get_sibling(cpunode->child, "comment"); datanode; datanode = xml_get_sibling(datanode->next, "comment"))
{
/* Malloc the comment */
debug_comments[i].comment_info[j] = (debug_comment*) malloc(sizeof(debug_comment));
debug_comments[i].comment_info[j]->address = xml_get_attribute_int(datanode, "address", 0);
debug_comments[i].comment_info[j]->color = xml_get_attribute_int(datanode, "color", 0);
sscanf(xml_get_attribute_string(datanode, "crc", 0), "%08X", &debug_comments[i].comment_info[j]->crc);
strcpy(debug_comments[i].comment_info[j]->text, datanode->value);
debug_comments[i].comment_info[j]->is_valid = 1;
j++;
}
debug_comments[i].comment_count = j;
i++;
}
/* free the parser */
xml_file_free(root);
return 1;
error:
if (root)
xml_file_free(root);
return 0;
}
multicart_open_error multicart_open(emu_options &options, const char *filename, const char *gamedrv, multicart_load_flags load_flags, multicart_t **cart)
{
multicart_open_error err;
zip_error ziperr;
object_pool *pool;
multicart_load_state state = {0, };
const zip_file_header *header;
const char *pcb_type;
char *layout_text = NULL;
/* allocate an object pool */
pool = pool_alloc_lib(NULL);
if (pool == NULL)
{
err = MCERR_OUT_OF_MEMORY;
goto done;
}
/* allocate the multicart */
state.multicart = (multicart_t*)pool_malloc_lib(pool, sizeof(*state.multicart));
if (state.multicart == NULL)
{
err = MCERR_OUT_OF_MEMORY;
goto done;
}
memset(state.multicart, 0, sizeof(*state.multicart));
/* allocate the multicart's private data */
state.multicart->data = (multicart_private*)pool_malloc_lib(pool, sizeof(*state.multicart->data));
if (state.multicart->data == NULL)
{
err = MCERR_OUT_OF_MEMORY;
goto done;
}
memset(state.multicart->data, 0, sizeof(*state.multicart->data));
state.multicart->data->pool = pool;
pool = NULL;
/* open the ZIP file */
ziperr = zip_file_open(filename, &state.zip);
if (ziperr != ZIPERR_NONE)
{
err = MCERR_NOT_MULTICART;
goto done;
}
/* find the layout.xml file */
header = find_file(state.zip, "layout.xml");
if (header == NULL)
{
err = MCERR_MISSING_LAYOUT;
goto done;
}
/* reserve space for the layout text */
layout_text = (char*)malloc(header->uncompressed_length + 1);
if (layout_text == NULL)
{
err = MCERR_OUT_OF_MEMORY;
goto done;
}
/* uncompress the layout text */
ziperr = zip_file_decompress(state.zip, layout_text, header->uncompressed_length);
if (ziperr != ZIPERR_NONE)
{
err = MCERR_ZIP_ERROR;
goto done;
}
layout_text[header->uncompressed_length] = '\0';
/* parse the layout text */
state.layout_xml = xml_string_read(layout_text, NULL);
if (state.layout_xml == NULL)
{
err = MCERR_XML_ERROR;
goto done;
}
/* locate the PCB node */
if (!find_pcb_and_resource_nodes(state.layout_xml, &state.pcb_node, &state.resources_node))
{
err = MCERR_NO_PCB_OR_RESOURCES;
goto done;
}
/* get the PCB resource_type */
pcb_type = xml_get_attribute_string(state.pcb_node, "type", "");
state.multicart->pcb_type = pool_strdup_lib(state.multicart->data->pool, pcb_type);
if (state.multicart->pcb_type == NULL)
{
err = MCERR_OUT_OF_MEMORY;
goto done;
}
state.multicart->gamedrv_name = pool_strdup_lib(state.multicart->data->pool, gamedrv);
if (state.multicart->gamedrv_name == NULL)
{
err = MCERR_OUT_OF_MEMORY;
goto done;
}
/* do we have to load resources? */
if (load_flags & MULTICART_FLAGS_LOAD_RESOURCES)
{
err = load_all_resources(options, &state);
if (err != MCERR_NONE)
goto done;
err = load_all_sockets(&state);
if (err != MCERR_NONE)
goto done;
}
err = MCERR_NONE;
done:
if (pool != NULL)
pool_free_lib(pool);
if (state.zip != NULL)
zip_file_close(state.zip);
if (layout_text != NULL)
free(layout_text);
if (state.layout_xml != NULL)
xml_file_free(state.layout_xml);
if ((err != MCERR_NONE) && (state.multicart != NULL))
{
multicart_close(options, state.multicart);
state.multicart = NULL;
}
*cart = state.multicart;
return err;
}
cheat_script::script_entry::script_entry(cheat_manager &manager, symbol_table &symbols, const char *filename, xml_data_node &entrynode, bool isaction)
: m_next(NULL),
m_condition(&symbols),
m_expression(&symbols)
{
const char *expression = NULL;
try
{
// read the condition if present
expression = xml_get_attribute_string(&entrynode, "condition", NULL);
if (expression != NULL)
m_condition.parse(expression);
// if this is an action, parse the expression
if (isaction)
{
expression = entrynode.value;
if (expression == NULL || expression[0] == 0)
throw emu_fatalerror("%s.xml(%d): missing expression in action tag\n", filename, entrynode.line);
m_expression.parse(expression);
}
// otherwise, parse the attributes and arguments
else
{
// extract format
const char *format = xml_get_attribute_string(&entrynode, "format", NULL);
if (format == NULL || format[0] == 0)
throw emu_fatalerror("%s.xml(%d): missing format in output tag\n", filename, entrynode.line);
m_format.cpy(format);
// extract other attributes
m_line = xml_get_attribute_int(&entrynode, "line", 0);
m_justify = JUSTIFY_LEFT;
const char *align = xml_get_attribute_string(&entrynode, "align", "left");
if (strcmp(align, "center") == 0)
m_justify = JUSTIFY_CENTER;
else if (strcmp(align, "right") == 0)
m_justify = JUSTIFY_RIGHT;
else if (strcmp(align, "left") != 0)
throw emu_fatalerror("%s.xml(%d): invalid alignment '%s' specified\n", filename, entrynode.line, align);
// then parse arguments
int totalargs = 0;
for (xml_data_node *argnode = xml_get_sibling(entrynode.child, "argument"); argnode != NULL; argnode = xml_get_sibling(argnode->next, "argument"))
{
output_argument &curarg = m_arglist.append(*global_alloc(output_argument(manager, symbols, filename, *argnode)));
// verify we didn't overrun the argument count
totalargs += curarg.count();
if (totalargs > MAX_ARGUMENTS)
throw emu_fatalerror("%s.xml(%d): too many arguments (found %d, max is %d)\n", filename, argnode->line, totalargs, MAX_ARGUMENTS);
}
// validate the format against the arguments
validate_format(filename, entrynode.line);
}
}
catch (expression_error &err)
{
throw emu_fatalerror("%s.xml(%d): error parsing cheat expression \"%s\" (%s)\n", filename, entrynode.line, expression, err.code_string());
}
}
static int config_load_xml(running_machine &machine, emu_file &file, int which_type)
{
xml_data_node *root, *confignode, *systemnode;
config_type *type;
const char *srcfile;
int version, count;
/* read the file */
root = xml_file_read(file, NULL);
if (!root)
goto error;
/* find the config node */
confignode = xml_get_sibling(root->child, "mameconfig");
if (!confignode)
goto error;
/* validate the config data version */
version = xml_get_attribute_int(confignode, "version", 0);
if (version != CONFIG_VERSION)
goto error;
/* strip off all the path crap from the source filename */
srcfile = strrchr(machine.system().source_file, '/');
if (!srcfile)
srcfile = strrchr(machine.system().source_file, '\\');
if (!srcfile)
srcfile = strrchr(machine.system().source_file, ':');
if (!srcfile)
srcfile = machine.system().source_file;
else
srcfile++;
/* loop over all system nodes in the file */
count = 0;
for (systemnode = xml_get_sibling(confignode->child, "system"); systemnode; systemnode = xml_get_sibling(systemnode->next, "system"))
{
/* look up the name of the system here; skip if none */
const char *name = xml_get_attribute_string(systemnode, "name", "");
/* based on the file type, determine whether we have a match */
switch (which_type)
{
case CONFIG_TYPE_GAME:
/* only match on the specific game name */
if (strcmp(name, machine.system().name) != 0)
continue;
break;
case CONFIG_TYPE_DEFAULT:
/* only match on default */
if (strcmp(name, "default") != 0)
continue;
break;
case CONFIG_TYPE_CONTROLLER:
{
int clone_of;
/* match on: default, game name, source file name, parent name, grandparent name */
if (strcmp(name, "default") != 0 &&
strcmp(name, machine.system().name) != 0 &&
strcmp(name, srcfile) != 0 &&
((clone_of = driver_list::clone(machine.system())) == -1 || strcmp(name, driver_list::driver(clone_of).name) != 0) &&
(clone_of == -1 || ((clone_of = driver_list::clone(clone_of)) == -1) || strcmp(name, driver_list::driver(clone_of).name) != 0))
continue;
break;
}
}
/* log that we are processing this entry */
if (DEBUG_CONFIG)
osd_printf_debug("Entry: %s -- processing\n", name);
/* loop over all registrants and call their load function */
for (type = typelist; type; type = type->next)
type->load(which_type, xml_get_sibling(systemnode->child, type->name));
count++;
}
/* error if this isn't a valid game match */
if (count == 0)
goto error;
/* free the parser */
xml_file_free(root);
return 1;
error:
if (root)
xml_file_free(root);
return 0;
}
cheat_entry::cheat_entry(cheat_manager &manager, symbol_table &globaltable, const char *filename, xml_data_node &cheatnode)
: m_manager(manager),
m_next(NULL),
m_on_script(NULL),
m_off_script(NULL),
m_change_script(NULL),
m_run_script(NULL),
m_symbols(&manager.machine(), &globaltable),
m_state(SCRIPT_STATE_OFF),
m_numtemp(DEFAULT_TEMP_VARIABLES),
m_argindex(0)
{
// reset scripts
try
{
// pull the variable count out ahead of things
int tempcount = xml_get_attribute_int(&cheatnode, "tempvariables", DEFAULT_TEMP_VARIABLES);
if (tempcount < 1)
throw emu_fatalerror("%s.xml(%d): invalid tempvariables attribute (%d)\n", filename, cheatnode.line, tempcount);
// allocate memory for the cheat
m_numtemp = tempcount;
// get the description
const char *description = xml_get_attribute_string(&cheatnode, "desc", NULL);
if (description == NULL || description[0] == 0)
throw emu_fatalerror("%s.xml(%d): empty or missing desc attribute on cheat\n", filename, cheatnode.line);
m_description = description;
// create the symbol table
m_symbols.add("argindex", symbol_table::READ_ONLY, &m_argindex);
astring tempname;
for (int curtemp = 0; curtemp < tempcount; curtemp++)
m_symbols.add(tempname.format("temp%d", curtemp), symbol_table::READ_WRITE);
// read the first comment node
xml_data_node *commentnode = xml_get_sibling(cheatnode.child, "comment");
if (commentnode != NULL)
{
// set the value if not NULL
if (commentnode->value != NULL && commentnode->value[0] != 0)
m_comment.cpy(commentnode->value);
// only one comment is kept
commentnode = xml_get_sibling(commentnode->next, "comment");
if (commentnode != NULL)
mame_printf_warning("%s.xml(%d): only one comment node is retained; ignoring additional nodes\n", filename, commentnode->line);
}
// read the first parameter node
xml_data_node *paramnode = xml_get_sibling(cheatnode.child, "parameter");
if (paramnode != NULL)
{
// load this parameter
m_parameter.reset(global_alloc(cheat_parameter(manager, m_symbols, filename, *paramnode)));
// only one parameter allowed
paramnode = xml_get_sibling(paramnode->next, "parameter");
if (paramnode != NULL)
mame_printf_warning("%s.xml(%d): only one parameter node allowed; ignoring additional nodes\n", filename, paramnode->line);
}
// read the script nodes
for (xml_data_node *scriptnode = xml_get_sibling(cheatnode.child, "script"); scriptnode != NULL; scriptnode = xml_get_sibling(scriptnode->next, "script"))
{
// load this entry
cheat_script *curscript = global_alloc(cheat_script(manager, m_symbols, filename, *scriptnode));
// if we have a script already for this slot, it is an error
auto_pointer<cheat_script> &slot = script_for_state(curscript->state());
if (slot != NULL)
mame_printf_warning("%s.xml(%d): only one on script allowed; ignoring additional scripts\n", filename, scriptnode->line);
else
slot.reset(curscript);
}
}
catch (emu_fatalerror &)
{
// call our destructor to clean up and re-throw
this->~cheat_entry();
throw;
}
}