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); } } } } } }
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); } } } }
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 void xml_configuration_load(running_machine &machine, int config_type, xml_data_node *parentnode) { // We only care about game files if (config_type != CONFIG_TYPE_GAME) return; // Might not have any data if (parentnode == NULL) return; for (int i = 0; i < xmlConfigurations.size(); i++) delete xmlConfigurations[i]; xmlConfigurations.clear(); // Configuration load xml_data_node* wnode = NULL; for (wnode = xml_get_sibling(parentnode->child, "window"); wnode != NULL; wnode = xml_get_sibling(wnode->next, "window")) { WindowQtConfig::WindowType type = (WindowQtConfig::WindowType)xml_get_attribute_int(wnode, "type", WindowQtConfig::WIN_TYPE_UNKNOWN); switch (type) { case WindowQtConfig::WIN_TYPE_MAIN: xmlConfigurations.push_back(new MainWindowQtConfig()); break; case WindowQtConfig::WIN_TYPE_MEMORY: xmlConfigurations.push_back(new MemoryWindowQtConfig()); break; case WindowQtConfig::WIN_TYPE_DASM: xmlConfigurations.push_back(new DasmWindowQtConfig()); break; case WindowQtConfig::WIN_TYPE_LOG: xmlConfigurations.push_back(new LogWindowQtConfig()); break; case WindowQtConfig::WIN_TYPE_BREAK_POINTS: xmlConfigurations.push_back(new BreakpointsWindowQtConfig()); break; case WindowQtConfig::WIN_TYPE_DEVICES: xmlConfigurations.push_back(new DevicesWindowQtConfig()); break; case WindowQtConfig::WIN_TYPE_DEVICE_INFORMATION: xmlConfigurations.push_back(new DeviceInformationWindowQtConfig()); break; default: continue; } xmlConfigurations.back()->recoverFromXmlNode(wnode); } }
static void counters_load(running_machine &machine, int config_type, xml_data_node *parentnode) { generic_machine_private *state = machine.generic_machine_data; xml_data_node *coinnode, *ticketnode; /* on init, reset the counters */ if (config_type == CONFIG_TYPE_INIT) { memset(state->coin_count, 0, sizeof(state->coin_count)); state->dispensed_tickets = 0; } /* only care about game-specific data */ if (config_type != CONFIG_TYPE_GAME) return; /* might not have any data */ if (parentnode == NULL) return; /* iterate over coins nodes */ for (coinnode = xml_get_sibling(parentnode->child, "coins"); coinnode; coinnode = xml_get_sibling(coinnode->next, "coins")) { int index = xml_get_attribute_int(coinnode, "index", -1); if (index >= 0 && index < COIN_COUNTERS) state->coin_count[index] = xml_get_attribute_int(coinnode, "number", 0); } /* get the single tickets node */ ticketnode = xml_get_sibling(parentnode->child, "tickets"); if (ticketnode != NULL) state->dispensed_tickets = xml_get_attribute_int(ticketnode, "number", 0); }
static int find_pcb_and_resource_nodes(xml_data_node *layout_xml, xml_data_node **pcb_node, xml_data_node **resource_node) { xml_data_node *romset_node; xml_data_node *configuration_node; *pcb_node = NULL; *resource_node = NULL; romset_node = xml_get_sibling(layout_xml->child, "romset"); if (romset_node == NULL) return FALSE; configuration_node = xml_get_sibling(romset_node->child, "configuration"); if (configuration_node == NULL) return FALSE; *pcb_node = xml_get_sibling(configuration_node->child, "pcb"); if (*pcb_node == NULL) return FALSE; *resource_node = xml_get_sibling(romset_node->child, "resources"); if (*resource_node == NULL) return FALSE; return TRUE; }
void emulator_info::layout_file_cb(xml_data_node &layout) { xml_data_node *mamelayout = xml_get_sibling(layout.child, "mamelayout"); if(mamelayout) { xml_data_node *script = xml_get_sibling(mamelayout->child, "script"); if(script) mame_machine_manager::instance()->lua()->call_plugin(script->value, "layout"); } }
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; } }
cheat_parameter::cheat_parameter(cheat_manager &manager, symbol_table &symbols, const char *filename, xml_data_node ¶mnode) : m_value(0) { // read the core attributes m_minval = number_and_format(xml_get_attribute_int(¶mnode, "min", 0), xml_get_attribute_int_format(¶mnode, "min")); m_maxval = number_and_format(xml_get_attribute_int(¶mnode, "max", 0), xml_get_attribute_int_format(¶mnode, "max")); m_stepval = number_and_format(xml_get_attribute_int(¶mnode, "step", 1), xml_get_attribute_int_format(¶mnode, "step")); // iterate over items for (xml_data_node *itemnode = xml_get_sibling(paramnode.child, "item"); itemnode != NULL; itemnode = xml_get_sibling(itemnode->next, "item")) { // check for NULL text if (itemnode->value == NULL || itemnode->value[0] == 0) throw emu_fatalerror("%s.xml(%d): item is missing text\n", filename, itemnode->line); // check for non-existant value if (xml_get_attribute(itemnode, "value") == NULL) throw emu_fatalerror("%s.xml(%d): item is value\n", filename, itemnode->line); // extract the parameters UINT64 value = xml_get_attribute_int(itemnode, "value", 0); int format = xml_get_attribute_int_format(itemnode, "value"); // allocate and append a new item item &curitem = m_itemlist.append(*global_alloc(item(itemnode->value, value, format))); // ensure the maximum expands to suit m_maxval = MAX(m_maxval, curitem.value()); } // add a variable to the symbol table for our value symbols.add("param", symbol_table::READ_ONLY, &m_value); }
static void sound_load(int config_type, xml_data_node *parentnode) { xml_data_node *channelnode; int mixernum; /* we only care about game files */ if (config_type != CONFIG_TYPE_GAME) return; /* might not have any data */ if (parentnode == NULL) return; /* iterate over channel nodes */ for (channelnode = xml_get_sibling(parentnode->child, "channel"); channelnode; channelnode = xml_get_sibling(channelnode->next, "channel")) { mixernum = xml_get_attribute_int(channelnode, "index", -1); if (mixernum >= 0 && mixernum < MAX_MIXER_CHANNELS) { float defvol = xml_get_attribute_float(channelnode, "defvol", -1000.0); float newvol = xml_get_attribute_float(channelnode, "newvol", -1000.0); if (defvol == sound_get_default_gain(mixernum) && newvol != -1000.0) sound_set_user_gain(mixernum, newvol); } } }
static multicart_open_error load_all_sockets(multicart_load_state *state) { multicart_open_error err; xml_data_node *socket_node; for (socket_node = xml_get_sibling(state->pcb_node->child, "socket"); socket_node != NULL; socket_node = xml_get_sibling(socket_node->next, "socket")) { err = load_socket(state, socket_node); if (err != MCERR_NONE) return err; } state->multicart->sockets = state->sockets; return MCERR_NONE; }
xml_data_node *xml_get_or_add_child(xml_data_node *node, const char *name, const char *value) { xml_data_node *child; /* find the child first */ child = xml_get_sibling(node->child, name); if (child) return child; /* if not found, do a standard add child */ return add_child(node, name, value); }
static void configuration_load(running_machine &machine, int config_type, xml_data_node *parentnode) { xml_data_node *wnode; /* we only care about game files */ if (config_type != CONFIG_TYPE_GAME) return; /* might not have any data */ if (parentnode == NULL) return; /* configuration load */ int i = 0; for (wnode = xml_get_sibling(parentnode->child, "window"); wnode != NULL; wnode = xml_get_sibling(wnode->next, "window")) { windowStateArray[i].loadFromXmlDataNode(wnode); i++; } windowStateCount = i; }
void cheat_manager::load_cheats(const char *filename) { xml_data_node *rootnode = NULL; emu_file cheatfile(machine().options().cheat_path(), OPEN_FLAG_READ); try { // open the file with the proper name file_error filerr = cheatfile.open(filename, ".xml"); // loop over all instrances of the files found in our search paths while (filerr == FILERR_NONE) { mame_printf_verbose("Loading cheats file from %s\n", cheatfile.fullpath()); // read the XML file into internal data structures xml_parse_options options = { 0 }; xml_parse_error error; options.error = &error; rootnode = xml_file_read(cheatfile, &options); // if unable to parse the file, just bail if (rootnode == NULL) throw emu_fatalerror("%s.xml(%d): error parsing XML (%s)\n", filename, error.error_line, error.error_message); // find the layout node xml_data_node *mamecheatnode = xml_get_sibling(rootnode->child, "mamecheat"); if (mamecheatnode == NULL) throw emu_fatalerror("%s.xml: missing mamecheatnode node", filename); // validate the config data version int version = xml_get_attribute_int(mamecheatnode, "version", 0); if (version != CHEAT_VERSION) throw emu_fatalerror("%s.xml(%d): Invalid cheat XML file: unsupported version", filename, mamecheatnode->line); // parse all the elements for (xml_data_node *cheatnode = xml_get_sibling(mamecheatnode->child, "cheat"); cheatnode != NULL; cheatnode = xml_get_sibling(cheatnode->next, "cheat")) { // load this entry cheat_entry *curcheat = global_alloc(cheat_entry(*this, m_symtable, filename, *cheatnode)); // make sure we're not a duplicate cheat_entry *scannode = NULL; if (REMOVE_DUPLICATE_CHEATS) for (scannode = m_cheatlist.first(); scannode != NULL; scannode = scannode->next()) if (strcmp(scannode->description(), curcheat->description()) == 0) { mame_printf_verbose("Ignoring duplicate cheat '%s' from file %s\n", curcheat->description(), cheatfile.fullpath()); break; } // add to the end of the list if (scannode == NULL) m_cheatlist.append(*curcheat); else global_free(curcheat); } // free the file and loop for the next one xml_file_free(rootnode); // open the next file in sequence filerr = cheatfile.open_next(); } } // handle errors cleanly catch (emu_fatalerror &err) { mame_printf_error("%s\n", err.string()); m_cheatlist.reset(); if (rootnode != NULL) xml_file_free(rootnode); } }
int messtest(const struct messtest_options *opts, int *test_count, int *failure_count) { char saved_directory[1024]; FILE *file; int result = -1; char *script_directory; xml_parse_options parse_options; xml_parse_error parse_error; xml_data_node *root_node; xml_data_node *tests_node; mess_pile pile; const char *xml; size_t sz; char buf[256]; *test_count = 0; *failure_count = 0; pile_init(&pile); /* open the script file */ file = fopen(opts->script_filename, "r"); if (!file) { fprintf(stderr, "%s: Cannot open file\n", opts->script_filename); goto done; } /* read the file */ while(!feof(file)) { sz = fread(buf, 1, sizeof(buf), file); pile_write(&pile, buf, sz); } pile_writebyte(&pile, '\0', 1); xml = (const char *) pile_getptr(&pile); /* save the current working directory, and change to the test directory */ saved_directory[0] = '\0'; if (!opts->preserve_directory) { script_directory = osd_dirname(opts->script_filename); if (script_directory) { osd_getcurdir(saved_directory, sizeof(saved_directory) / sizeof(saved_directory[0])); osd_setcurdir(script_directory); free(script_directory); } } /* set up parse options */ memset(&parse_options, 0, sizeof(parse_options)); parse_options.init_parser = parse_init; parse_options.flags = XML_PARSE_FLAG_WHITESPACE_SIGNIFICANT; parse_options.error = &parse_error; /* do the parse */ root_node = xml_string_read(xml, &parse_options); if (!root_node) { fprintf(stderr, "%s:%d:%d: %s\n", opts->script_filename, parse_error.error_line, parse_error.error_column, parse_error.error_message); goto done; } /* find the tests node */ tests_node = xml_get_sibling(root_node->child, "tests"); if (!tests_node) goto done; node_tests(tests_node, test_count, failure_count); result = 0; done: /* restore the directory */ if (saved_directory[0]) osd_setcurdir(saved_directory); pile_delete(&pile); return result; }
void cheat_manager::load_cheats(const char *filename) { xml_data_node *rootnode = nullptr; std::string searchstr(machine().options().cheat_path()); path_iterator path(searchstr.c_str()); std::string curpath; while (path.next(curpath)) { searchstr.append(";").append(curpath).append(PATH_SEPARATOR).append("cheat"); } emu_file cheatfile(searchstr.c_str(), OPEN_FLAG_READ); try { // open the file with the proper name osd_file::error filerr = cheatfile.open(filename, ".xml"); // loop over all instrances of the files found in our search paths while (filerr == osd_file::error::NONE) { osd_printf_verbose("Loading cheats file from %s\n", cheatfile.fullpath()); // read the XML file into internal data structures xml_parse_options options = { nullptr }; xml_parse_error error; options.error = &error; rootnode = xml_file_read(cheatfile, &options); // if unable to parse the file, just bail if (rootnode == nullptr) throw emu_fatalerror("%s.xml(%d): error parsing XML (%s)\n", filename, error.error_line, error.error_message); // find the layout node xml_data_node *mamecheatnode = xml_get_sibling(rootnode->child, "mamecheat"); if (mamecheatnode == nullptr) throw emu_fatalerror("%s.xml: missing mamecheatnode node", filename); // validate the config data version int version = xml_get_attribute_int(mamecheatnode, "version", 0); if (version != CHEAT_VERSION) throw emu_fatalerror("%s.xml(%d): Invalid cheat XML file: unsupported version", filename, mamecheatnode->line); // parse all the elements for (xml_data_node *cheatnode = xml_get_sibling(mamecheatnode->child, "cheat"); cheatnode != nullptr; cheatnode = xml_get_sibling(cheatnode->next, "cheat")) { // load this entry auto curcheat = std::make_unique<cheat_entry>(*this, m_symtable, filename, *cheatnode); // make sure we're not a duplicate if (REMOVE_DUPLICATE_CHEATS && curcheat->is_duplicate()) { osd_printf_verbose("Ignoring duplicate cheat '%s' from file %s\n", curcheat->description(), cheatfile.fullpath()); } else // add to the end of the list m_cheatlist.push_back(std::move(curcheat)); } // free the file and loop for the next one xml_file_free(rootnode); // open the next file in sequence filerr = cheatfile.open_next(); } } // handle errors cleanly catch (emu_fatalerror &err) { osd_printf_error("%s\n", err.string()); m_cheatlist.clear(); if (rootnode != nullptr) xml_file_free(rootnode); } }
static void node_createimage(struct imgtooltest_state *state, xml_data_node *node) { imgtoolerr_t err; xml_data_node *child_node; xml_attribute_node *attr_node; option_resolution *opts = NULL; const imgtool_module *module; const char *driver; const char *param_name; const char *param_value; attr_node = xml_get_attribute(node, "driver"); if (!attr_node) { error_missingattribute("driver"); return; } driver = attr_node->value; /* does image creation support options? */ module = imgtool_find_module(attr_node->value); if (module && module->createimage_optguide && module->createimage_optspec) opts = option_resolution_create(module->createimage_optguide, module->createimage_optspec); report_message(MSG_INFO, "Creating image (module '%s')", driver); for (child_node = xml_get_sibling(node->child, "param"); child_node; child_node = xml_get_sibling(child_node->next, "param")) { if (!opts) { report_message(MSG_FAILURE, "Cannot specify creation options with this module"); return; } attr_node = xml_get_attribute(child_node, "name"); if (!attr_node) { error_missingattribute("name"); return; } param_name = attr_node->value; attr_node = xml_get_attribute(child_node, "value"); if (!attr_node) { error_missingattribute("value"); return; } param_value = attr_node->value; option_resolution_add_param(opts, param_name, param_value); } err = imgtool_image_create_byname(driver, tempfile_name(), opts, &state->m_image); if (opts) { option_resolution_close(opts); opts = NULL; } if (err) { state->m_failed = 1; report_imgtoolerr(err); return; } err = imgtool_partition_open(state->m_image, 0, &state->m_partition); if (err) { state->m_failed = 1; report_imgtoolerr(err); return; } }
static void node_checkdirectory(struct imgtooltest_state *state, xml_data_node *node) { imgtoolerr_t err = IMGTOOLERR_SUCCESS; imgtool_directory *imageenum; imgtool_dirent ent; char expected_listing[1024]; char actual_listing[1024]; int i/*, actual_count*/; int mismatch; xml_attribute_node *attr_node; xml_data_node *child_node; const char *filename; expected_dirent *entry; expected_dirent entries[256]; int entry_count; if (!state->m_partition) { state->m_failed = 1; report_message(MSG_FAILURE, "Partition not loaded"); return; } attr_node = xml_get_attribute(node, "path"); filename = attr_node ? attr_node->value : ""; memset(&entries, 0, sizeof(entries)); entry_count = 0; for (child_node = xml_get_sibling(node->child, "entry"); child_node; child_node = xml_get_sibling(child_node->next, "entry")) { if (entry_count >= ARRAY_LENGTH(entries)) { report_message(MSG_FAILURE, "Too many directory entries"); return; } entry = &entries[entry_count++]; attr_node = xml_get_attribute(child_node, "name"); entry->filename = attr_node ? attr_node->value : NULL; attr_node = xml_get_attribute(child_node, "size"); entry->size = attr_node ? atoi(attr_node->value) : -1; } /* build expected listing string */ expected_listing[0] = '\0'; for (i = 0; i < entry_count; i++) { append_to_list(expected_listing, ARRAY_LENGTH(expected_listing), entries[i].filename); } /* now enumerate though listing */ //actual_count = 0; actual_listing[0] = '\0'; mismatch = FALSE; memset(&ent, 0, sizeof(ent)); err = imgtool_directory_open(state->m_partition, filename, &imageenum); if (err) goto done; i = 0; do { err = imgtool_directory_get_next(imageenum, &ent); if (err) goto done; if (!ent.eof) { append_to_list(actual_listing, ARRAY_LENGTH(actual_listing), ent.filename); if (i < entry_count && (strcmp(ent.filename, entries[i].filename))) mismatch = TRUE; i++; } } while(!ent.eof); if (i != entry_count) mismatch = TRUE; if (mismatch) { state->m_failed = 1; report_message(MSG_FAILURE, "File listing mismatch: {%s} expected {%s}", actual_listing, expected_listing); goto done; } done: if (imageenum) imgtool_directory_close(imageenum); if (err) { state->m_failed = 1; report_imgtoolerr(err); } }
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; } }
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()); } }
void node_testzippath(xml_data_node *node) { xml_attribute_node *attr_node; xml_data_node *first_child_node; xml_data_node *child_node; const char *path; const char *plus; astring *apath = NULL; zippath_directory *directory = NULL; const osd_directory_entry *dirent; const char *type_string; file_error err; UINT64 size; mess_pile pile; core_file *file = NULL; pile_init(&pile); /* name the test case */ report_testcase_begin("zippath"); /* retrieve path */ attr_node = xml_get_attribute(node, "path"); path = (attr_node != NULL) ? attr_node->value : ""; /* retrieve 'plus' - for testing zippath_combine */ attr_node = xml_get_attribute(node, "plus"); if (attr_node != NULL) { plus = attr_node->value; apath = zippath_combine(astring_alloc(), path, plus); report_message(MSG_INFO, "Testing ZIP Path '%s' + '%s' ==> '%s'", path, plus, astring_c(apath)); } else { apath = astring_cpyc(astring_alloc(), path); report_message(MSG_INFO, "Testing ZIP Path '%s'", astring_c(apath)); } /* try doing a file compare */ messtest_get_data(node, &pile); if (pile_size(&pile) > 0) { err = zippath_fopen(astring_c(apath), OPEN_FLAG_READ, &file, NULL); if (err != FILERR_NONE) { report_message(MSG_FAILURE, "Error %d opening file", (int) err); goto done; } if (pile_size(&pile) != core_fsize(file)) { report_message(MSG_FAILURE, "Expected file to be of length %d, instead got %d", (int) pile_size(&pile), (int) core_fsize(file)); goto done; } if (memcmp(pile_getptr(&pile), core_fbuffer(file), pile_size(&pile))) { report_message(MSG_FAILURE, "File sizes match, but contents do not"); goto done; } } /* try doing a directory listing */ first_child_node = xml_get_sibling(node->child, "entry"); if (first_child_node != NULL) { err = zippath_opendir(astring_c(apath), &directory); if (err != FILERR_NONE) { report_message(MSG_FAILURE, "Error %d opening directory", (int) err); goto done; } /* read each directory entry */ while((dirent = zippath_readdir(directory)) != NULL) { /* find it in the list */ for (child_node = first_child_node; child_node != NULL; child_node = xml_get_sibling(child_node->next, "entry")) { attr_node = xml_get_attribute(child_node, "name"); if ((attr_node != NULL) && !strcmp(attr_node->value, dirent->name)) break; } /* did we find the node? */ if (child_node != NULL) { /* check dirent type */ attr_node = xml_get_attribute(child_node, "type"); if (attr_node != NULL) { type_string = dir_entry_type_string(dirent->type); if (mame_stricmp(attr_node->value, type_string)) report_message(MSG_FAILURE, "Expected '%s' to be '%s', but instead got '%s'", dirent->name, attr_node->value, type_string); } /* check size */ attr_node = xml_get_attribute(child_node, "size"); if (attr_node != NULL) { size = atoi(attr_node->value); if (size != dirent->size) report_message(MSG_FAILURE, "Expected '%s' to be of size '%ld', but instead got '%ld'", dirent->name, (long) size, (long) dirent->size); } } else { report_message(MSG_FAILURE, "Unexpected directory entry '%s'", dirent->name); } } } done: pile_delete(&pile); if (apath != NULL) astring_free(apath); if (file != NULL) core_fclose(file); if (directory != NULL) zippath_closedir(directory); }
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; }