web_engine::web_engine(emu_options &options) : m_options(options), m_machine(NULL), m_ctx(NULL), m_lastupdatetime(0), m_exiting_core(false) { struct mg_callbacks callbacks; // List of options. Last element must be NULL. const char *web_options[] = { "listening_ports", options.http_port(), "document_root", options.http_path(), NULL }; // Prepare callbacks structure. memset(&callbacks, 0, sizeof(callbacks)); callbacks.begin_request = begin_request_handler_static; callbacks.websocket_ready = websocket_ready_handler_static; callbacks.websocket_data = websocket_data_handler_static; callbacks.http_error = begin_http_error_handler_static; // Start the web server. if (m_options.http()) { m_ctx = mg_start(&callbacks, this, web_options); mg_start_thread(websocket_keepalive_static, this); } }
void vector_options::init(emu_options& options) { s_beam_width_min = options.beam_width_min(); s_beam_width_max = options.beam_width_max(); s_beam_intensity_weight = options.beam_intensity_weight(); s_flicker = options.flicker(); }
machine_config::machine_config(const game_driver &gamedrv, emu_options &options) : m_minimum_quantum(attotime::zero), m_watchdog_vblank_count(0), m_watchdog_time(attotime::zero), m_nvram_handler(NULL), m_memcard_handler(NULL), m_default_layout(NULL), m_gamedrv(gamedrv), m_options(options) { // construct the config (*gamedrv.machine_config)(*this, NULL, NULL); bool is_selected_driver = mame_stricmp(gamedrv.name,options.system_name())==0; // intialize slot devices - make sure that any required devices have been allocated slot_interface_iterator slotiter(root_device()); for (device_slot_interface *slot = slotiter.first(); slot != NULL; slot = slotiter.next()) { device_t &owner = slot->device(); astring temp; const char *selval = options.main_value(temp, owner.tag()+1); bool isdefault = (options.priority(owner.tag()+1)==OPTION_PRIORITY_DEFAULT); if (!is_selected_driver || !options.exists(owner.tag()+1)) selval = slot->default_option(); if (selval != NULL && *selval != 0) { const device_slot_option *option = slot->option(selval); if (option && (isdefault || option->selectable())) { device_t *new_dev = device_add(&owner, option->name(), option->devtype(), option->clock()); const char *default_bios = option->default_bios(); if (default_bios != NULL) device_t::static_set_default_bios_tag(*new_dev, default_bios); machine_config_constructor additions = option->machine_config(); if (additions != NULL) (*additions)(const_cast<machine_config &>(*this), new_dev, new_dev); const input_device_default *input_device_defaults = option->input_device_defaults(); if (input_device_defaults) device_t::static_set_input_default(*new_dev, input_device_defaults); } else throw emu_fatalerror("Unknown slot option '%s' in slot '%s'", selval, owner.tag()+1); } } // when finished, set the game driver driver_device::static_set_game(*m_root_device, gamedrv); // then notify all devices that their configuration is complete device_iterator iter(root_device()); for (device_t *device = iter.first(); device != NULL; device = iter.next()) if (!device->configured()) device->config_complete(); }
machine_config::machine_config(const game_driver &gamedrv, emu_options &options) : m_minimum_quantum(attotime::zero), m_perfect_cpu_quantum(NULL), m_watchdog_vblank_count(0), m_watchdog_time(attotime::zero), m_nvram_handler(NULL), m_memcard_handler(NULL), m_video_attributes(0), m_gfxdecodeinfo(NULL), m_total_colors(0), m_default_layout(NULL), m_gamedrv(gamedrv), m_options(options) { // construct the config (*gamedrv.machine_config)(*this, NULL); // intialize slot devices - make sure that any required devices have been allocated device_slot_interface *slot = NULL; for (bool gotone = m_devicelist.first(slot); gotone; gotone = slot->next(slot)) { const slot_interface *intf = slot->get_slot_interfaces(); if (intf != NULL) { device_t &owner = slot->device(); const char *selval = options.value(owner.tag()); if (!options.exists(owner.tag())) selval = slot->get_default_card(devicelist(), options); if (selval != NULL && strlen(selval)!=0) { bool found = false; for (int i = 0; intf[i].name != NULL; i++) { if (strcmp(selval, intf[i].name) == 0) { device_t *new_dev = device_add(&owner, intf[i].name, intf[i].devtype, 0); found = true; if (!options.exists(owner.tag())) device_t::static_set_input_default(*new_dev, slot->input_ports_defaults()); } } if (!found) throw emu_fatalerror("Unknown slot option '%s' in slot '%s'", selval, owner.tag()); } } } // when finished, set the game driver device_t *root = m_devicelist.find("root"); if (root == NULL) throw emu_fatalerror("Machine configuration missing driver_device"); driver_device::static_set_game(*root, gamedrv); // then notify all devices that their configuration is complete for (device_t *device = m_devicelist.first(); device != NULL; device = device->next()) if (!device->configured()) device->config_complete(); }
machine_config::machine_config(const game_driver &gamedrv, emu_options &options) : m_minimum_quantum(attotime::zero), m_default_layout(nullptr), m_gamedrv(gamedrv), m_options(options) { // construct the config (*gamedrv.machine_config)(*this, nullptr, nullptr); bool is_selected_driver = core_stricmp(gamedrv.name,options.system_name())==0; // intialize slot devices - make sure that any required devices have been allocated for (device_slot_interface &slot : slot_interface_iterator(root_device())) { device_t &owner = slot.device(); std::string selval; bool isdefault = (options.priority(owner.tag()+1)==OPTION_PRIORITY_DEFAULT); if (is_selected_driver && options.exists(owner.tag()+1)) selval = options.main_value(owner.tag()+1); else if (slot.default_option() != nullptr) selval.assign(slot.default_option()); if (!selval.empty()) { const device_slot_option *option = slot.option(selval.c_str()); if (option && (isdefault || option->selectable())) { device_t *new_dev = device_add(&owner, option->name(), option->devtype(), option->clock()); const char *default_bios = option->default_bios(); if (default_bios != nullptr) device_t::static_set_default_bios_tag(*new_dev, default_bios); machine_config_constructor additions = option->machine_config(); if (additions != nullptr) (*additions)(const_cast<machine_config &>(*this), new_dev, new_dev); const input_device_default *input_device_defaults = option->input_device_defaults(); if (input_device_defaults) device_t::static_set_input_default(*new_dev, input_device_defaults); } else throw emu_fatalerror("Unknown slot option '%s' in slot '%s'", selval.c_str(), owner.tag()+1); } } // when finished, set the game driver driver_device::static_set_game(*m_root_device, gamedrv); // then notify all devices that their configuration is complete for (device_t &device : device_iterator(root_device())) if (!device.configured()) device.config_complete(); }
web_engine::web_engine(emu_options &options) : m_options(options), m_machine(NULL), m_server(NULL), //m_lastupdatetime(0), m_exiting_core(false), m_http(m_options.http()) { if (m_http) { m_server = mg_create_server(this, ev_handler); mg_set_option(m_server, "listening_port", options.http_port()); mg_set_option(m_server, "document_root", options.http_path()); } }
/*------------------------------------------------- image_battery_save_by_name - stores the battery backed RAM for an image. A filename may be supplied to the function. -------------------------------------------------*/ void image_battery_save_by_name(emu_options &options, const char *filename, const void *buffer, int length) { assert_always(buffer && (length > 0), "Must specify sensical buffer/length"); /* try to open the battery file and write it out, if possible */ emu_file file(options.nvram_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS); file_error filerr = file.open(filename); if (filerr == FILERR_NONE) file.write(buffer, length); }
int image_manager::write_config(emu_options &options, const char *filename, const game_driver *gamedrv) { char buffer[128]; int retval = 1; if (gamedrv != nullptr) { sprintf(buffer, "%s.ini", gamedrv->name); filename = buffer; } emu_file file(options.ini_path(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE); osd_file::error filerr = file.open(filename); if (filerr == osd_file::error::NONE) { std::string inistring = options.output_ini(); file.puts(inistring.c_str()); retval = 0; } return retval; }
static int write_config(emu_options &options, const char *filename, const game_driver *gamedrv) { char buffer[128]; int retval = 1; if (gamedrv != NULL) { sprintf(buffer, "%s.ini", gamedrv->name); filename = buffer; } emu_file file(options.ini_path(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE); file_error filerr = file.open(filename); if (filerr == FILERR_NONE) { astring inistring; options.output_ini(inistring); file.puts(inistring); retval = 0; } return retval; }
bool device_image_interface::open_image_file(emu_options &options) { const char* path = options.value(instance_name()); if (strlen(path)>0) { set_init_phase(); if (load_internal(path, FALSE, 0, NULL, TRUE)==IMAGE_INIT_PASS) { if (software_entry()==NULL) return true; } } return false; }
bool device_image_interface::open_image_file(emu_options &options) { const char* path = options.value(instance_name()); if (*path != 0) { set_init_phase(); if (load_internal(path, false, 0, nullptr, true) == image_init_result::PASS) { if (software_entry()==nullptr) return true; } } return false; }
std::unique_ptr<emu_file> common_process_file(emu_options &options, const char *location, bool has_crc, UINT32 crc, const rom_entry *romp, file_error &filerr) { auto image_file = std::make_unique<emu_file>(options.media_path(), OPEN_FLAG_READ); if (has_crc) filerr = image_file->open(location, PATH_SEPARATOR, ROM_GETNAME(romp), crc); else filerr = image_file->open(location, PATH_SEPARATOR, ROM_GETNAME(romp)); if (filerr != FILERR_NONE) { image_file = nullptr; } return image_file; }
void image_battery_load_by_name(emu_options &options, const char *filename, void *buffer, int length, int fill) { file_error filerr; int bytes_read = 0; assert_always(buffer && (length > 0), "Must specify sensical buffer/length"); /* try to open the battery file and read it in, if possible */ emu_file file(options.nvram_directory(), OPEN_FLAG_READ); filerr = file.open(filename); if (filerr == FILERR_NONE) bytes_read = file.read(buffer, length); /* fill remaining bytes (if necessary) */ memset(((char *) buffer) + bytes_read, fill, length - bytes_read); }
void image_battery_load_by_name(emu_options &options, const char *filename, void *buffer, int length, void *def_buffer) { file_error filerr; int bytes_read = 0; assert_always(buffer && (length > 0), "Must specify sensical buffer/length"); /* try to open the battery file and read it in, if possible */ emu_file file(options.nvram_directory(), OPEN_FLAG_READ); filerr = file.open(filename); if (filerr == FILERR_NONE) bytes_read = file.read(buffer, length); /* if no file was present, copy the default battery */ if (bytes_read == 0 && def_buffer) memcpy((char *) buffer, (char *) def_buffer, length); }
file_error common_process_file(emu_options &options, const char *location, bool has_crc, UINT32 crc, const rom_entry *romp, emu_file **image_file) { *image_file = global_alloc(emu_file(options.media_path(), OPEN_FLAG_READ)); file_error filerr; if (has_crc) filerr = (*image_file)->open(location, PATH_SEPARATOR, ROM_GETNAME(romp), crc); else filerr = (*image_file)->open(location, PATH_SEPARATOR, ROM_GETNAME(romp)); if (filerr != FILERR_NONE) { global_free(*image_file); *image_file = NULL; } return filerr; }
static chd_error open_disk_diff(emu_options &options, const char *name, chd_file &source, chd_file &diff_chd) { std::string fname = std::string(name).append(".dif"); /* try to open the diff */ //printf("Opening differencing image file: %s\n", fname.c_str()); emu_file diff_file(options.diff_directory(), OPEN_FLAG_READ | OPEN_FLAG_WRITE); osd_file::error filerr = diff_file.open(fname.c_str()); if (filerr == osd_file::error::NONE) { std::string fullpath(diff_file.fullpath()); diff_file.close(); //printf("Opening differencing image file: %s\n", fullpath.c_str()); return diff_chd.open(fullpath.c_str(), true, &source); } /* didn't work; try creating it instead */ //printf("Creating differencing image: %s\n", fname.c_str()); diff_file.set_openflags(OPEN_FLAG_READ | OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS); filerr = diff_file.open(fname.c_str()); if (filerr == osd_file::error::NONE) { std::string fullpath(diff_file.fullpath()); diff_file.close(); /* create the CHD */ //printf("Creating differencing image file: %s\n", fupointllpath.c_str()); chd_codec_type compression[4] = { CHD_CODEC_NONE }; chd_error err = diff_chd.create(fullpath.c_str(), source.logical_bytes(), source.hunk_bytes(), compression, source); if (err != CHDERR_NONE) return err; return diff_chd.clone_all_metadata(source); } return CHDERR_FILE_NOT_FOUND; }
static chd_error open_disk_diff(emu_options &options, const rom_entry *romp, chd_file &source, chd_file &diff_chd) { astring fname(ROM_GETNAME(romp), ".dif"); /* try to open the diff */ LOG(("Opening differencing image file: %s\n", fname.cstr())); emu_file diff_file(options.diff_directory(), OPEN_FLAG_READ | OPEN_FLAG_WRITE); file_error filerr = diff_file.open(fname); if (filerr == FILERR_NONE) { astring fullpath(diff_file.fullpath()); diff_file.close(); LOG(("Opening differencing image file: %s\n", fullpath.cstr())); return diff_chd.open(fullpath, true, &source); } /* didn't work; try creating it instead */ LOG(("Creating differencing image: %s\n", fname.cstr())); diff_file.set_openflags(OPEN_FLAG_READ | OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS); filerr = diff_file.open(fname); if (filerr == FILERR_NONE) { astring fullpath(diff_file.fullpath()); diff_file.close(); /* create the CHD */ LOG(("Creating differencing image file: %s\n", fullpath.cstr())); chd_codec_type compression[4] = { CHD_CODEC_NONE }; chd_error err = diff_chd.create(fullpath, source.logical_bytes(), source.hunk_bytes(), compression, source); if (err != CHDERR_NONE) return err; return diff_chd.clone_all_metadata(source); } return CHDERR_FILE_NOT_FOUND; }
int mame_execute(emu_options &options, osd_interface &osd) { bool firstgame = true; bool firstrun = true; // extract the verbose printing option if (options.verbose()) print_verbose = true; // loop across multiple hard resets bool exit_pending = false; int error = MAMERR_NONE; while (error == MAMERR_NONE && !exit_pending) { // if no driver, use the internal empty driver const game_driver *system = options.system(); if (system == NULL) { system = &GAME_NAME(___empty); if (firstgame) started_empty = true; } // otherwise, perform validity checks before anything else else validate_drivers(options, system); firstgame = false; // parse any INI files as the first thing if (options.read_config()) { options.revert(OPTION_PRIORITY_INI); astring errors; options.parse_standard_inis(errors); } // create the machine configuration machine_config config(*system, options); // create the machine structure and driver running_machine machine(config, osd, started_empty); // looooong term: remove this global_machine = &machine; // run the machine error = machine.run(firstrun); firstrun = false; // check the state of the machine if (machine.new_driver_pending()) { options.set_system_name(machine.new_driver_name()); firstrun = true; } if (machine.exit_pending()) exit_pending = true; // machine will go away when we exit scope global_machine = NULL; } // return an error return error; }
int open_disk_image(emu_options &options, const game_driver *gamedrv, const rom_entry *romp, chd_file &image_chd, const char *locationtag) { emu_file image_file(options.media_path(), OPEN_FLAG_READ); const rom_entry *region, *rom; file_error filerr; chd_error err; /* attempt to open the properly named file, scanning up through parent directories */ filerr = FILERR_NOT_FOUND; for (int searchdrv = driver_list::find(*gamedrv); searchdrv != -1 && filerr != FILERR_NONE; searchdrv = driver_list::clone(searchdrv)) filerr = common_process_file(options, driver_list::driver(searchdrv).name, ".chd", romp, image_file); if (filerr != FILERR_NONE) filerr = common_process_file(options, NULL, ".chd", romp, image_file); /* look for the disk in the locationtag too */ if (filerr != FILERR_NONE && locationtag != NULL) { // check if we are dealing with softwarelists. if so, locationtag // is actually a concatenation of: listname + setname + parentname // separated by '%' (parentname being present only for clones) astring tag1(locationtag), tag2, tag3, tag4, tag5; bool is_list = FALSE; bool has_parent = FALSE; int separator1 = tag1.chr(0, '%'); if (separator1 != -1) { is_list = TRUE; // we are loading through softlists, split the listname from the regiontag tag4.cpysubstr(tag1, separator1 + 1, tag1.len() - separator1 + 1); tag1.del(separator1, tag1.len() - separator1); tag1.cat(PATH_SEPARATOR); // check if we are loading a clone (if this is the case also tag1 have a separator '%') int separator2 = tag4.chr(0, '%'); if (separator2 != -1) { has_parent = TRUE; // we are loading a clone through softlists, split the setname from the parentname tag5.cpysubstr(tag4, separator2 + 1, tag4.len() - separator2 + 1); tag4.del(separator2, tag4.len() - separator2); } // prepare locations where we have to load from: list/parentname (if any) & list/clonename astring swlist(tag1.cstr()); tag2.cpy(swlist.cat(tag4)); if (has_parent) { swlist.cpy(tag1); tag3.cpy(swlist.cat(tag5)); } } if (tag5.chr(0, '%') != -1) fatalerror("We do not support clones of clones!\n"); // try to load from the available location(s): // - if we are not using lists, we have locationtag only; // - if we are using lists, we have: list/clonename, list/parentname, clonename, parentname if (!is_list) filerr = common_process_file(options, locationtag, ".chd", romp, image_file); else { // try to load from list/setname if ((filerr != FILERR_NONE) && (tag2.cstr() != NULL)) filerr = common_process_file(options, tag2.cstr(), ".chd", romp, image_file); // try to load from list/parentname (if any) if ((filerr != FILERR_NONE) && has_parent && (tag3.cstr() != NULL)) filerr = common_process_file(options, tag3.cstr(), ".chd", romp, image_file); // try to load from setname if ((filerr != FILERR_NONE) && (tag4.cstr() != NULL)) filerr = common_process_file(options, tag4.cstr(), ".chd", romp, image_file); // try to load from parentname (if any) if ((filerr != FILERR_NONE) && has_parent && (tag5.cstr() != NULL)) filerr = common_process_file(options, tag5.cstr(), ".chd", romp, image_file); // only for CHD we also try to load from list/ if ((filerr != FILERR_NONE) && (tag1.cstr() != NULL)) { tag1.del(tag1.len() - 1, 1); // remove the PATH_SEPARATOR filerr = common_process_file(options, tag1.cstr(), ".chd", romp, image_file); } } } /* did the file open succeed? */ if (filerr == FILERR_NONE) { astring fullpath(image_file.fullpath()); image_file.close(); /* try to open the CHD */ err = image_chd.open(fullpath); if (err == CHDERR_NONE) return err; } else err = CHDERR_FILE_NOT_FOUND; /* otherwise, look at our parents for a CHD with an identical checksum */ /* and try to open that */ hash_collection romphashes(ROM_GETHASHDATA(romp)); for (int drv = driver_list::find(*gamedrv); drv != -1; drv = driver_list::clone(drv)) { machine_config config(driver_list::driver(drv), options); device_iterator deviter(config.root_device()); for (device_t *device = deviter.first(); device != NULL; device = deviter.next()) for (region = rom_first_region(*device); region != NULL; region = rom_next_region(region)) if (ROMREGION_ISDISKDATA(region)) for (rom = rom_first_file(region); rom != NULL; rom = rom_next_file(rom)) /* look for a differing name but with the same hash data */ if (strcmp(ROM_GETNAME(romp), ROM_GETNAME(rom)) != 0 && romphashes == hash_collection(ROM_GETHASHDATA(rom))) { /* attempt to open the properly named file, scanning up through parent directories */ filerr = FILERR_NOT_FOUND; for (int searchdrv = drv; searchdrv != -1 && filerr != FILERR_NONE; searchdrv = driver_list::clone(searchdrv)) filerr = common_process_file(options, driver_list::driver(searchdrv).name, ".chd", rom, image_file); if (filerr != FILERR_NONE) filerr = common_process_file(options, NULL, ".chd", rom, image_file); /* did the file open succeed? */ if (filerr == FILERR_NONE) { astring fullpath(image_file.fullpath()); image_file.close(); /* try to open the CHD */ err = image_chd.open(fullpath); if (err == CHDERR_NONE) return err; } } } return err; }
machine_config::machine_config(const game_driver &gamedrv, emu_options &options) : m_minimum_quantum(attotime::zero) , m_gamedrv(gamedrv) , m_options(options) , m_root_device() , m_default_layouts([] (char const *a, char const *b) { return 0 > std::strcmp(a, b); }) , m_current_device(nullptr) { // add the root device device_add("root", gamedrv.type, 0); // intialize slot devices - make sure that any required devices have been allocated for (device_slot_interface &slot : slot_interface_iterator(root_device())) { device_t &owner = slot.device(); const char *slot_option_name = owner.tag() + 1; // figure out which device goes into this slot bool const has_option = options.has_slot_option(slot_option_name); const char *selval; bool is_default; if (!has_option) { // The only time we should be getting here is when emuopts.cpp is invoking // us to evaluate slot/image options, and the internal state of emuopts.cpp has // not caught up yet selval = slot.default_option(); is_default = true; } else { const slot_option &opt = options.slot_option(slot_option_name); selval = opt.value().c_str(); is_default = !opt.specified(); } if (selval && *selval) { // TODO: make this thing more self-contained so it can apply itself - shouldn't need to know all this here device_slot_interface::slot_option const *option = slot.option(selval); if (option && (is_default || option->selectable())) { // create the device token const tok(begin_configuration(owner)); device_t *const new_dev = device_add(option->name(), option->devtype(), option->clock()); slot.set_card_device(new_dev); char const *const default_bios = option->default_bios(); if (default_bios != nullptr) new_dev->set_default_bios_tag(default_bios); auto additions = option->machine_config(); if (additions) additions(new_dev); input_device_default const *const input_device_defaults = option->input_device_defaults(); if (input_device_defaults) new_dev->set_input_default(input_device_defaults); } else throw emu_fatalerror("Unknown slot option '%s' in slot '%s'", selval, owner.tag()+1); } } // then notify all devices that their configuration is complete for (device_t &device : device_iterator(root_device())) if (!device.configured()) device.config_complete(); }
int mame_execute(emu_options &options, osd_interface &osd) { bool firstgame = true; bool firstrun = true; // extract the verbose printing option if (options.verbose()) print_verbose = true; // loop across multiple hard resets bool exit_pending = false; int error = MAMERR_NONE; // We need to preprocess the config files once to determine the web server's configuration if (options.read_config()) { options.revert(OPTION_PRIORITY_INI); astring errors; options.parse_standard_inis(errors); } web_engine web(options); while (error == MAMERR_NONE && !exit_pending) { // if no driver, use the internal empty driver const game_driver *system = options.system(); if (system == NULL) { system = &GAME_NAME(___empty); if (firstgame) started_empty = true; } firstgame = false; // parse any INI files as the first thing if (options.read_config()) { options.revert(OPTION_PRIORITY_INI); astring errors; options.parse_standard_inis(errors); } // otherwise, perform validity checks before anything else if (system != NULL) { validity_checker valid(options); valid.check_shared_source(*system); } // create the machine configuration machine_config config(*system, options); // create the machine structure and driver running_machine machine(config, osd, started_empty); ui_show_mouse(machine.system().flags & GAME_CLICKABLE_ARTWORK); // looooong term: remove this global_machine = &machine; web.set_machine(machine); web.push_message("update_machine"); // run the machine error = machine.run(firstrun); firstrun = false; // check the state of the machine if (machine.new_driver_pending()) { options.set_system_name(machine.new_driver_name()); firstrun = true; } if (machine.exit_pending()) exit_pending = true; // machine will go away when we exit scope global_machine = NULL; } // return an error return error; }
void driver_switch::assign_drivers(emu_options &opts) { static const struct { const char *name; const game_driver * const *driver; } drivers_table[] = { #ifndef TINY_BUILD { "mame", mamedrivers }, { "plus", mameplusdrivers }, { "homebrew", mamehbdrivers }, { "decrypted", mamedecrypteddrivers }, #ifdef MAMEMESS { "console", messdrivers }, #endif /* MAMEMESS */ #else { "mame", tinydrivers }, #endif /* !TINY_BUILD */ { NULL } }; UINT32 enabled = 0; int i, n; bool mechanical = opts.bool_value(OPTION_DISABLE_MECHANICAL_DRIVER); #ifndef TINY_BUILD const char *drv_option = opts.value(OPTION_DRIVER_CONFIG); if (drv_option) { char *temp = mame_strdup(drv_option); if (temp) { char *p = strtok(temp, ","); while (p) { char *s = core_strtrim(p); //get individual driver name if (s[0]) { if (mame_stricmp(s, "all") == 0) { enabled = (UINT32)-1; break; } for (i = 0; drivers_table[i].name; i++) if (mame_stricmp(s, drivers_table[i].name) == 0) { enabled |= 1 << i; break; } if (!drivers_table[i].name) mame_printf_warning(_("Illegal value for %s = %s\n"), OPTION_DRIVER_CONFIG, s); } osd_free(s); p = strtok(NULL, ","); } osd_free(temp); } } #endif /* !TINY_BUILD */ if (enabled == 0) enabled = 1; // default to mamedrivers n = 0; for (i = 0; drivers_table[i].name; i++) if (enabled & (1 << i)) { for (int c = 0; drivers_table[i].driver[c]; c++) if (mame_stricmp(drivers_table[i].driver[c]->name, "___empty")) if (!mechanical || !(drivers_table[i].driver[c]->flags & GAME_MECHANICAL)) driver_list::s_drivers_sorted[n++] = drivers_table[i].driver[c]; } // ___empty driver add once driver_list::s_drivers_sorted[n++] = &GAME_NAME(___empty); driver_list::s_driver_count = n; qsort(driver_list::s_drivers_sorted, n, sizeof(*driver_list::s_drivers_sorted), driver_list::driver_sort_callback); }
machine_config::machine_config(const game_driver &gamedrv, emu_options &options) : m_minimum_quantum(attotime::zero), m_watchdog_vblank_count(0), m_watchdog_time(attotime::zero), m_nvram_handler(NULL), m_memcard_handler(NULL), m_video_attributes(0), m_gfxdecodeinfo(NULL), m_total_colors(0), m_default_layout(NULL), m_gamedrv(gamedrv), m_options(options), m_root_device(NULL) { // construct the config (*gamedrv.machine_config)(*this, NULL); bool is_selected_driver = strcmp(gamedrv.name,options.system_name())==0; // intialize slot devices - make sure that any required devices have been allocated slot_interface_iterator slotiter(root_device()); for (device_slot_interface *slot = slotiter.first(); slot != NULL; slot = slotiter.next()) { const slot_interface *intf = slot->get_slot_interfaces(); if (intf != NULL) { device_t &owner = slot->device(); astring temp; const char *selval = options.main_value(temp, owner.tag()+1); bool isdefault = (options.priority(owner.tag()+1)==OPTION_PRIORITY_DEFAULT); if (!is_selected_driver || !options.exists(owner.tag()+1)) selval = slot->get_default_card(); if (selval != NULL && *selval != 0) { bool found = false; for (int i = 0; intf[i].name != NULL; i++) { if (strcmp(selval, intf[i].name) == 0) { if ((!intf[i].internal) || (isdefault && intf[i].internal)) { const char *def = slot->get_default_card(); bool is_default = (def != NULL && strcmp(def, selval) == 0); device_t *new_dev = device_add(&owner, intf[i].name, intf[i].devtype, is_default ? slot->default_clock() : 0); found = true; if (is_default) { device_t::static_set_input_default(*new_dev, slot->input_ports_defaults()); if (slot->default_config()) { device_t::static_set_static_config(*new_dev, slot->default_config()); } } } } } if (!found) throw emu_fatalerror("Unknown slot option '%s' in slot '%s'", selval, owner.tag()+1); } } } // when finished, set the game driver driver_device::static_set_game(*m_root_device, gamedrv); // then notify all devices that their configuration is complete device_iterator iter(root_device()); for (device_t *device = iter.first(); device != NULL; device = iter.next()) if (!device->configured()) device->config_complete(); }