summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorGravatarGravatar npwoods <npwoods@alumni.carnegiemellon.edu>2017-05-05 02:17:49 -0400
committerGravatarGravatar Vas Crabb <cuavas@users.noreply.github.com>2017-05-05 16:17:49 +1000
commit536990e77b49ccc50ef275bfbf1018cc29c16154 (patch)
tree86e160cca07995479cd87506732c178b3728e58a
parentcce3369cdeec54494c6d4dc4a781cbba64d027bd (diff)
downloadmame-536990e77b49ccc50ef275bfbf1018cc29c16154.tar.xz
mame-536990e77b49ccc50ef275bfbf1018cc29c16154.zip
Overhaul to how MAME handles options (#2260)
This is an overhaul to how MAME handles options to provide a better foundation for what MAME is already doing in practice. Previously, core_options was designed to provide an input/output facility for reading options from the command line and INI files. However, the current needs (image/slot/get_default_card_software calculus and MewUI) go way beyond that. Broadly, this PR makes the following changes: * core_options now has an extensibility mechanism, so one can register options that behave dramatically differently * With that foundation, emu_options now encapsulates all of the funky image/slot/get_default_card_software calculus that were previously handled by static methods in mameopts.cpp. Changes to emu_options should not automatically cascade in such a way so that it stays in a consistent state * emu_options no longer provides direct access to the slot_options/image_options maps; there are simpler API functions that control these capabilities * Many core_options functions that expose internal data structures (e.g. - priority) that were only really needed because of previous (now obsolete) techniques have been removed. * core_options is now exception based (rather than dumping text to an std::string). The burden is on the caller to catch these, and discern between warnings and errors as needed. Obviously this is a risky change; that's why this is being submitted at the start of the dev cycle.
-rw-r--r--src/devices/machine/ram.cpp4
-rw-r--r--src/emu/diimage.cpp11
-rw-r--r--src/emu/diimage.h6
-rw-r--r--src/emu/dislot.h1
-rw-r--r--src/emu/emuopts.cpp893
-rw-r--r--src/emu/emuopts.h139
-rw-r--r--src/emu/image.cpp31
-rw-r--r--src/emu/mconfig.cpp11
-rw-r--r--src/emu/natkeyboard.cpp4
-rw-r--r--src/emu/romload.cpp18
-rw-r--r--src/frontend/mame/clifront.cpp36
-rw-r--r--src/frontend/mame/info.cpp4
-rw-r--r--src/frontend/mame/luaengine.cpp22
-rw-r--r--src/frontend/mame/mame.cpp45
-rw-r--r--src/frontend/mame/mameopts.cpp612
-rw-r--r--src/frontend/mame/mameopts.h32
-rw-r--r--src/frontend/mame/pluginopts.cpp2
-rw-r--r--src/frontend/mame/ui/custui.cpp38
-rw-r--r--src/frontend/mame/ui/dirmenu.cpp15
-rw-r--r--src/frontend/mame/ui/info.cpp3
-rw-r--r--src/frontend/mame/ui/miscmenu.cpp28
-rw-r--r--src/frontend/mame/ui/selgame.cpp14
-rw-r--r--src/frontend/mame/ui/selsoft.cpp26
-rw-r--r--src/frontend/mame/ui/slotopt.cpp9
-rw-r--r--src/frontend/mame/ui/sndmenu.cpp10
-rw-r--r--src/frontend/mame/ui/submenu.cpp26
-rw-r--r--src/frontend/mame/ui/submenu.h2
-rw-r--r--src/frontend/mame/ui/ui.cpp35
-rw-r--r--src/lib/util/options.cpp968
-rw-r--r--src/lib/util/options.h294
-rw-r--r--src/osd/modules/lib/osdobj_common.h2
-rw-r--r--src/osd/modules/render/drawbgfx.cpp1
-rw-r--r--src/osd/sdl/sdlmain.cpp10
-rw-r--r--src/osd/windows/winmain.cpp15
34 files changed, 1845 insertions, 1522 deletions
diff --git a/src/devices/machine/ram.cpp b/src/devices/machine/ram.cpp
index 49ff027ed0f..1fb1be56043 100644
--- a/src/devices/machine/ram.cpp
+++ b/src/devices/machine/ram.cpp
@@ -163,9 +163,7 @@ void ram_device::device_validity_check(validity_checker &valid) const
osd_printf_error("%s", output.str().c_str());
osd_printf_warning("Setting value to default %s\n",m_default_size);
- std::string error;
- mconfig().options().set_value(OPTION_RAMSIZE, m_default_size, OPTION_PRIORITY_CMDLINE, error);
- assert(error.empty());
+ mconfig().options().set_value(OPTION_RAMSIZE, m_default_size, OPTION_PRIORITY_CMDLINE);
}
}
diff --git a/src/emu/diimage.cpp b/src/emu/diimage.cpp
index 1c256684821..009ea67e42b 100644
--- a/src/emu/diimage.cpp
+++ b/src/emu/diimage.cpp
@@ -1226,7 +1226,7 @@ void device_image_interface::reset_and_load(const std::string &path)
device().machine().schedule_hard_reset();
// and record the new load
- device().machine().options().image_options()[instance_name()] = path;
+ device().machine().options().image_option(instance_name()).specify(path);
}
@@ -1310,9 +1310,10 @@ void device_image_interface::update_names()
if (brief_name == nullptr)
brief_name = device_brieftypename(image_type());
+ m_cannonical_instance_name = string_format("%s%d", inst_name, index + 1);
if (count > 1)
{
- m_instance_name = string_format("%s%d", inst_name, index + 1);
+ m_instance_name = m_cannonical_instance_name;
m_brief_instance_name = string_format("%s%d", brief_name, index + 1);
}
else
@@ -1463,11 +1464,11 @@ std::string device_image_interface::software_get_default_slot(const char *defaul
{
std::string result;
- auto iter = device().mconfig().options().image_options().find(instance_name());
- if (iter != device().mconfig().options().image_options().end() && !iter->second.empty())
+ const std::string &image_name(device().mconfig().options().image_option(instance_name()).value());
+ if (!image_name.empty())
{
result.assign(default_card_slot);
- const software_part *swpart = find_software_item(iter->second, true);
+ const software_part *swpart = find_software_item(image_name, true);
if (swpart != nullptr)
{
const char *slot = swpart->feature("slot");
diff --git a/src/emu/diimage.h b/src/emu/diimage.h
index bf656b6a040..e6fa3ea69e3 100644
--- a/src/emu/diimage.h
+++ b/src/emu/diimage.h
@@ -225,6 +225,7 @@ public:
const std::string &instance_name() const { return m_instance_name; }
const std::string &brief_instance_name() const { return m_brief_instance_name; }
+ const std::string &cannonical_instance_name() const { return m_cannonical_instance_name; }
bool uses_file_extension(const char *file_extension) const;
const formatlist_type &formatlist() const { return m_formatlist; }
@@ -341,8 +342,9 @@ private:
util::hash_collection m_hash;
- std::string m_brief_instance_name;
- std::string m_instance_name;
+ std::string m_instance_name; // e.g. - "cartridge", "floppydisk2"
+ std::string m_brief_instance_name; // e.g. - "cart", "flop2"
+ std::string m_cannonical_instance_name; // e.g. - "cartridge1", "floppydisk2" - only used internally in emuopts.cpp
// in the case of arcade cabinet with fixed carts inserted,
// we want to disable command line cart loading...
diff --git a/src/emu/dislot.h b/src/emu/dislot.h
index a6722a50f70..8f36d70386c 100644
--- a/src/emu/dislot.h
+++ b/src/emu/dislot.h
@@ -145,6 +145,7 @@ public:
virtual std::string get_default_card_software(get_default_card_software_hook &hook) const { return std::string(); }
device_t *get_card_device() { return m_card_device; }
void set_card_device(device_t *dev) { m_card_device = dev; }
+ const char *slot_name() const { return device().tag() + 1; }
private:
// internal state
diff --git a/src/emu/emuopts.cpp b/src/emu/emuopts.cpp
index 2863ef35caf..823fb2e071f 100644
--- a/src/emu/emuopts.cpp
+++ b/src/emu/emuopts.cpp
@@ -10,6 +10,11 @@
#include "emu.h"
#include "emuopts.h"
+#include "drivenum.h"
+#include "softlist_dev.h"
+#include "hashfile.h"
+
+#include <stack>
//**************************************************************************
@@ -213,6 +218,167 @@ const options_entry emu_options::s_option_entries[] =
//**************************************************************************
+// CUSTOM OPTION ENTRIES AND SUPPORT CLASSES
+//**************************************************************************
+
+namespace
+{
+ // custom option entry for the system name
+ class system_name_option_entry : public core_options::entry
+ {
+ public:
+ system_name_option_entry(emu_options &host)
+ : entry(OPTION_SYSTEMNAME)
+ , m_host(host)
+ {
+ }
+
+ virtual const char *value() const override
+ {
+ return m_host.system() ? m_host.system()->name : "";
+ }
+
+ protected:
+ virtual void internal_set_value(std::string &&newvalue) override
+ {
+ m_host.set_system_name(newvalue);
+ }
+
+ private:
+ emu_options &m_host;
+ };
+
+ // custom option entry for the software name
+ class software_name_option_entry : public core_options::entry
+ {
+ public:
+ software_name_option_entry(emu_options &host)
+ : entry(OPTION_SOFTWARENAME)
+ , m_host(host)
+ {
+ }
+
+ protected:
+ virtual void internal_set_value(std::string &&newvalue) override
+ {
+ m_host.set_software(newvalue);
+ }
+
+ private:
+ emu_options &m_host;
+ };
+
+ // custom option entry for slots
+ class slot_option_entry : public core_options::entry
+ {
+ public:
+ slot_option_entry(const char *name, slot_option &host)
+ : entry(name)
+ , m_host(host)
+ {
+ }
+
+ virtual const char *value() const override
+ {
+ const char *result = nullptr;
+ if (m_host.specified())
+ {
+ m_temp = m_host.specified_value();
+ result = m_temp.c_str();
+ }
+ return result;
+ }
+
+ protected:
+ virtual void internal_set_value(std::string &&newvalue) override
+ {
+ m_host.specify(std::move(newvalue));
+ }
+
+ private:
+ slot_option & m_host;
+ mutable std::string m_temp;
+ };
+
+ // custom option entry for images
+ class image_option_entry : public core_options::entry
+ {
+ public:
+ image_option_entry(std::vector<std::string> &&names, image_option &host)
+ : entry(std::move(names))
+ , m_host(host)
+ {
+ }
+
+ virtual const char *value() const override
+ {
+ return m_host.value().c_str();
+ }
+
+ protected:
+ virtual void internal_set_value(std::string &&newvalue) override
+ {
+ m_host.specify(std::move(newvalue));
+ }
+
+ private:
+ image_option &m_host;
+ };
+
+ // existing option tracker class; used by slot/image calculus to identify existing
+ // options for later purging
+ template<typename T>
+ class existing_option_tracker
+ {
+ public:
+ existing_option_tracker(const std::unordered_map<std::string, T> &map)
+ {
+ m_vec.reserve(map.size());
+ for (const auto &entry : map)
+ m_vec.push_back(&entry.first);
+ }
+
+ template<typename TStr>
+ void remove(TStr str)
+ {
+ auto iter = std::find_if(
+ m_vec.begin(),
+ m_vec.end(),
+ [&str](const auto &x) { return *x == str; });
+ if (iter != m_vec.end())
+ m_vec.erase(iter);
+ }
+
+ std::vector<const std::string *>::iterator begin() { return m_vec.begin(); }
+ std::vector<const std::string *>::iterator end() { return m_vec.end(); }
+
+ private:
+ std::vector<const std::string *> m_vec;
+ };
+
+
+ //-------------------------------------------------
+ // get_full_option_names
+ //-------------------------------------------------
+
+ std::vector<std::string> get_full_option_names(const device_image_interface &image)
+ {
+ std::vector<std::string> result;
+
+ result.push_back(image.instance_name());
+ result.push_back(image.brief_instance_name());
+
+ if (strcmp(image.device_typename(image.image_type()), image.instance_name().c_str()) == 0)
+ {
+ result.push_back(image.instance_name() + "1");
+ result.push_back(image.brief_instance_name() + "1");
+ }
+ return result;
+ }
+}
+
+
+//**************************************************************************
// EMU OPTIONS
//**************************************************************************
@@ -220,125 +386,611 @@ const options_entry emu_options::s_option_entries[] =
// emu_options - constructor
//-------------------------------------------------
-emu_options::emu_options()
-: core_options()
-, m_coin_impulse(0)
-, m_joystick_contradictory(false)
-, m_sleep(true)
-, m_refresh_speed(false)
-, m_ui(UI_CABINET)
+emu_options::emu_options(bool general_only)
+ : m_system(nullptr)
+ , m_coin_impulse(0)
+ , m_joystick_contradictory(false)
+ , m_sleep(true)
+ , m_refresh_speed(false)
+ , m_ui(UI_CABINET)
{
+ // add entries
+ if (!general_only)
+ {
+ add_entry(std::make_shared<system_name_option_entry>(*this));
+ add_entry(std::make_shared<software_name_option_entry>(*this));
+ }
add_entries(emu_options::s_option_entries);
+
+ // adding handlers to keep copies of frequently requested options in member variables
+ set_value_changed_handler(OPTION_COIN_IMPULSE, [this](const char *value) { m_coin_impulse = int_value(OPTION_COIN_IMPULSE); });
+ set_value_changed_handler(OPTION_JOYSTICK_CONTRADICTORY, [this](const char *value) { m_joystick_contradictory = bool_value(OPTION_JOYSTICK_CONTRADICTORY); });
+ set_value_changed_handler(OPTION_SLEEP, [this](const char *value) { m_sleep = bool_value(OPTION_SLEEP); });
+ set_value_changed_handler(OPTION_REFRESHSPEED, [this](const char *value) { m_sleep = bool_value(OPTION_REFRESHSPEED); });
+ set_value_changed_handler(OPTION_UI, [this](const std::string &value)
+ {
+ if (value == "simple")
+ m_ui = UI_SIMPLE;
+ else
+ m_ui = UI_CABINET;
+ });
+}
+
+
+//-------------------------------------------------
+// emu_options - destructor
+//-------------------------------------------------
+
+emu_options::~emu_options()
+{
}
//-------------------------------------------------
-// value_changed - to prevent tagmap
-// lookups keep copies of frequently requested
-// options in member variables.
+// system_name
//-------------------------------------------------
-void emu_options::value_changed(const std::string &name, const std::string &value)
+const char *emu_options::system_name() const
{
- if (name == OPTION_COIN_IMPULSE)
+ return m_system ? m_system->name : "";
+}
+
+
+//-------------------------------------------------
+// set_system_name - called to set the system
+// name; will adjust slot/image options as appropriate
+//-------------------------------------------------
+
+void emu_options::set_system_name(const std::string &new_system_name)
+{
+ const game_driver *new_system = nullptr;
+
+ // was a system name specified?
+ if (!new_system_name.empty())
{
- m_coin_impulse = int_value(OPTION_COIN_IMPULSE);
+ // if so, first extract the base name (the reason for this is drag-and-drop on Windows; a side
+ // effect is a command line like 'mame pacman.foo' will work correctly, but so be it)
+ std::string new_system_base_name = core_filename_extract_base(new_system_name, true);
+
+ // perform the lookup (and error if it cannot be found)
+ int index = driver_list::find(new_system_base_name.c_str());
+ if (index < 0)
+ throw options_error_exception("Unknown system '%s'", new_system_name);
+ new_system = &driver_list::driver(index);
}
- else if (name == OPTION_JOYSTICK_CONTRADICTORY)
+
+ // did we change anything?
+ if (new_system != m_system)
{
- m_joystick_contradictory = bool_value(OPTION_JOYSTICK_CONTRADICTORY);
+ // if so, specify the new system and update
+ m_system = new_system;
+ update_slot_and_image_options();
}
- else if (name == OPTION_SLEEP)
+}
+
+
+//-------------------------------------------------
+// update_slot_and_image_options
+//-------------------------------------------------
+
+void emu_options::update_slot_and_image_options()
+{
+ bool changed;
+ do
{
- m_sleep = bool_value(OPTION_SLEEP);
- }
- else if (name == OPTION_REFRESHSPEED)
+ changed = false;
+
+ // first we add and remove slot options depending on what has been configured in the
+ // device, bringing m_slot_options up to a state where it matches machine_config
+ if (add_and_remove_slot_options())
+ changed = true;
+
+ // second, we perform an analgous operation with m_image_options
+ if (add_and_remove_image_options())
+ changed = true;
+
+ // if we changed anything, we should reevaluate existing options
+ if (changed)
+ reevaluate_default_card_software();
+ } while (changed);
+}
+
+
+//-------------------------------------------------
+// add_and_remove_slot_options - add any missing
+// and/or purge extraneous slot options
+//-------------------------------------------------
+
+bool emu_options::add_and_remove_slot_options()
+{
+ bool changed = false;
+
+ // first, create a list of existing slot options; this is so we can purge
+ // any stray slot options that are no longer pertinent when we're done
+ existing_option_tracker<::slot_option> existing(m_slot_options);
+
+ // it is perfectly legal for this to be called without a system; we
+ // need to check for that condition!
+ if (m_system)
{
- m_refresh_speed = bool_value(OPTION_REFRESHSPEED);
+ // create the configuration
+ machine_config config(*m_system, *this);
+
+ for (const device_slot_interface &slot : slot_interface_iterator(config.root_device()))
+ {
+ // come up with the cannonical name of the slot
+ const char *slot_option_name = slot.slot_name();
+
+ // erase this option from existing (so we don't purge it later)
+ existing.remove(slot_option_name);
+
+ // do we need to add this option?
+ if (!has_slot_option(slot_option_name))
+ {
+ // we do - add it to m_slot_options
+ auto pair = std::make_pair(slot_option_name, ::slot_option(*this, slot.default_option()));
+ ::slot_option &new_option(m_slot_options.emplace(std::move(pair)).first->second);
+ changed = true;
+
+ // for non-fixed slots, this slot needs representation in the options collection
+ if (!slot.fixed())
+ {
+ // first device? add the header as to be pretty
+ const char *header = "SLOT DEVICES";
+ if (!header_exists(header))
+ add_header(header);
+
+ // create a new entry in the options
+ auto new_entry = new_option.setup_option_entry(slot_option_name);
+
+ // and add it
+ add_entry(std::move(new_entry), header);
+ }
+ }
+
+ }
}
- else if (name == OPTION_UI)
+
+ // at this point we need to purge stray slot options that may no longer be pertinent
+ for (auto &opt_name : existing)
{
- if (value == "simple")
- m_ui = UI_SIMPLE;
- else
- m_ui = UI_CABINET;
+ auto iter = m_slot_options.find(*opt_name);
+ assert(iter != m_slot_options.end());
+
+ // if this is represented in core_options, remove it
+ if (iter->second.option_entry())
+ remove_entry(*iter->second.option_entry());
+
+ // remove this option
+ m_slot_options.erase(iter);
+ changed = true;
}
+
+ return changed;
}
//-------------------------------------------------
-// override_get_value - when saving to an INI, we
-// need to hook into that process so we can write
-// out image/slot options
+// add_and_remove_slot_options - add any missing
+// and/or purge extraneous slot options
//-------------------------------------------------
-core_options::override_get_value_result emu_options::override_get_value(const char *name, std::string &value) const
+bool emu_options::add_and_remove_image_options()
{
- if (name)
+ // The logic for image options is superficially similar to the logic for slot options, but
+ // there is one larger piece of complexity. The image instance names (returned by the
+ // image_instance() call and surfaced in the UI) may change simply because we've added more
+ // devices. This is because the instance_name() for a singular cartridge device might be
+ // "cartridge" starting out, but become "cartridge1" when another cartridge device is added.
+ //
+ // To get around this behavior, our internal data structures work in terms of what is
+ // returned by cannonical_instance_name(), which will be something like "cartridge1" both
+ // for a singular cartridge device and the first cartridge in a multi cartridge system.
+ //
+ // The need for this behavior was identified by Tafoid when the following command line
+ // regressed:
+ //
+ // mame snes bsxsore -cart2 bszelda
+ //
+ // Before we were accounting for this behavior, 'bsxsore' got stored in "cartridge" and
+ // the association got lost when the second cartridge was added.
+
+ bool changed = false;
+
+ // first, create a list of existing image options; this is so we can purge
+ // any stray slot options that are no longer pertinent when we're done; we
+ // have to do this for both "flavors" of name
+ existing_option_tracker<::image_option> existing(m_image_options_cannonical);
+
+ // wipe the non-cannonical image options; we're going to rebuild it
+ m_image_options.clear();
+
+ // it is perfectly legal for this to be called without a system; we
+ // need to check for that condition!
+ if (m_system)
{
- auto slotiter = m_slot_options.find(name);
- if (slotiter != m_slot_options.end())
+ // create the configuration
+ machine_config config(*m_system, *this);
+
+ // iterate through all image devices
+ for (device_image_interface &image : image_interface_iterator(config.root_device()))
{
- value = slotiter->second.specified_value();
- return slotiter->second.specified()
- ? override_get_value_result::OVERRIDE
- : override_get_value_result::SKIP;
+ const std::string &cannonical_name(image.cannonical_instance_name());
+
+ // erase this option from existing (so we don't purge it later)
+ existing.remove(cannonical_name);
+
+ // do we need to add this option?
+ auto iter = m_image_options_cannonical.find(cannonical_name);
+ ::image_option *this_option = iter != m_image_options_cannonical.end() ? &iter->second : nullptr;
+ if (!this_option)
+ {
+ // we do - add it to both m_image_options_cannonical and m_image_options
+ auto pair = std::make_pair(cannonical_name, ::image_option(*this, image.cannonical_instance_name()));
+ this_option = &m_image_options_cannonical.emplace(std::move(pair)).first->second;
+ changed = true;
+
+ // if this image is user loadable, we have to surface it in the core_options
+ if (image.user_loadable())
+ {
+ // first device? add the header as to be pretty
+ const char *header = "IMAGE DEVICES";
+ if (!header_exists(header))
+ add_header(header);
+
+ // name this options
+ auto names = get_full_option_names(image);
+
+ // create a new entry in the options
+ auto new_entry = this_option->setup_option_entry(std::move(names));
+
+ // and add it
+ add_entry(std::move(new_entry), header);
+ }
+ }
+
+ // whether we added it or we didn't, we have to add it to the m_image_option map
+ m_image_options[image.instance_name()] = this_option;
}
+ }
+
+ // at this point we need to purge stray image options that may no longer be pertinent
+ for (auto &opt_name : existing)
+ {
+ auto iter = m_image_options_cannonical.find(*opt_name);
+ assert(iter != m_image_options_cannonical.end());
+
+ // if this is represented in core_options, remove it
+ if (iter->second.option_entry())
+ remove_entry(*iter->second.option_entry());
+
+ // remove this option
+ m_image_options_cannonical.erase(iter);
+ changed = true;
+ }
+
+ return changed;
+}
+
+
+//-------------------------------------------------
+// reevaluate_default_card_software - based on recent
+// changes in what images are mounted, give drivers
+// a chance to specify new default slot options
+//-------------------------------------------------
- auto imageiter = m_image_options.find(name);
- if (imageiter != m_image_options.end())
+void emu_options::reevaluate_default_card_software()
+{
+ if (m_system)
+ {
+ bool found;
+ do
{
- value = imageiter->second;
- return override_get_value_result::OVERRIDE;
- }
+ // set up the machine_config
+ machine_config config(*m_system, *this);
+ found = false;
+
+ // iterate through all slot devices
+ for (device_slot_interface &slot : slot_interface_iterator(config.root_device()))
+ {
+ // retrieve info about the device instance
+ auto &slot_opt(slot_option(slot.slot_name()));
+
+ // device_slot_interface::get_default_card_software() is essentially a hook
+ // that lets devices provide a feedback loop to force a specified software
+ // list entry to be loaded
+ //
+ // In the repeated cycle of adding slots and slot devices, this gives a chance
+ // for devices to "plug in" default software list items. Of course, the fact
+ // that this is all shuffling options is brittle and roundabout, but such is
+ // the nature of software lists.
+ //
+ // In reality, having some sort of hook into the pipeline of slot/device evaluation
+ // makes sense, but the fact that it is joined at the hip to device_image_interface
+ // and device_slot_interface is unfortunate
+ std::string default_card_software = get_default_card_software(slot);
+ if (slot_opt.default_card_software() != default_card_software)
+ {
+ slot_opt.set_default_card_software(std::move(default_card_software));
+
+ // calling set_default_card_software() can cause a cascade of slot/image
+ // evaluations; we need to bail out of this loop because the iterator
+ // may be bad
+ found = true;
+ break;
+ }
+ }
+ } while (found);
}
+}
- return override_get_value_result::NONE;
+
+//-------------------------------------------------
+// get_default_card_software
+//-------------------------------------------------
+
+std::string emu_options::get_default_card_software(device_slot_interface &slot)
+{
+ std::string image_path;
+ std::function<bool(util::core_file &, std::string&)> get_hashfile_extrainfo;
+
+ // figure out if an image option has been specified, and if so, get the image path out of the options
+ device_image_interface *image = dynamic_cast<device_image_interface *>(&slot);
+ if (image)
+ {
+ image_path = image_option(image->instance_name()).value();
+
+ get_hashfile_extrainfo = [image, this](util::core_file &file, std::string &extrainfo)
+ {
+ util::hash_collection hashes = image->calculate_hash_on_file(file);
+
+ return hashfile_extrainfo(
+ hash_path(),
+ image->device().mconfig().gamedrv(),
+ hashes,
+ extrainfo);
+ };
+ }
+
+ // create the hook
+ get_default_card_software_hook hook(image_path, std::move(get_hashfile_extrainfo));
+
+ // and invoke the slot's implementation of get_default_card_software()
+ return slot.get_default_card_software(hook);
}
//-------------------------------------------------
-// override_set_value - when parsing an INI, we
-// need to hook into into it so we can do the same
-// crazy slot logic done in mameopt
+// set_software - called to load "unqualified"
+// software out of a software list (e.g. - "mame nes 'zelda'")
//-------------------------------------------------
-bool emu_options::override_set_value(const char *name, const std::string &value)
+void emu_options::set_software(const std::string &new_software)
{
- auto slotiter = m_slot_options.find(name);
- if (slotiter != m_slot_options.end())
+ // identify any options as a result of softlists
+ software_options softlist_opts = evaluate_initial_softlist_options(new_software);
+
+ while (!softlist_opts.slot.empty() || !softlist_opts.image.empty())
{
- slotiter->second.specify(std::string(value));
- return true;
+ // track how many options we have
+ size_t before_size = softlist_opts.slot.size() + softlist_opts.image.size();
+
+ // keep a list of deferred options, in case anything is applied
+ // out of order
+ software_options deferred_opts;
+
+ // distribute slot options
+ for (auto &slot_opt : softlist_opts.slot)
+ {
+ auto iter = m_slot_options.find(slot_opt.first);
+ if (iter != m_slot_options.end())
+ iter->second.specify(std::move(slot_opt.second));
+ else
+ deferred_opts.slot[slot_opt.first] = std::move(slot_opt.second);
+ }
+
+ // distribute image options
+ for (auto &image_opt : softlist_opts.image)
+ {
+ auto iter = m_image_options.find(image_opt.first);
+ if (iter != m_image_options.end())
+ iter->second->specify(std::move(image_opt.second));
+ else
+ deferred_opts.image[image_opt.first] = std::move(image_opt.second);
+ }
+
+ // keep any deferred options for the next round
+ softlist_opts = std::move(deferred_opts);
+
+ // do we have any pending options after failing to distribute any?
+ size_t after_size = softlist_opts.slot.size() + softlist_opts.image.size();
+ if ((after_size > 0) && after_size >= before_size)
+ throw options_error_exception("Could not assign software option");
}
+}
+
+
+//-------------------------------------------------
+// evaluate_initial_softlist_options
+//-------------------------------------------------
+
+emu_options::software_options emu_options::evaluate_initial_softlist_options(const std::string &software_identifier)
+{
+ software_options results;
- auto imageiter = m_image_options.find(name);
- if (imageiter != m_image_options.end())
+ // load software specified at the command line (if any of course)
+ if (!software_identifier.empty())
{
- // We've found a potential image slot for this value. However, we're only going to specify it
- // if the current image option is empty. This is because if there is an image option already
- // present, it is almost certain that this was because something was specified at the command
- // line and we're parsing an INI. Because INIs have less priority than the command line, this
- // should be ignored
- //
- // Obviously, this ignores that INIs themselves have their own prioritization, so this should be
- // considered to be a hack. Instead of having image options being just a straight map of std::string
- // it should really be a structure where the priority can be recorded
- if (imageiter->second.empty())
- imageiter->second = value;
- return true;
+ // we have software; first identify the proper game_driver
+ if (!m_system)
+ throw options_error_exception("Cannot specify software without specifying system");
+
+ // and set up a configuration
+ machine_config config(*m_system, *this);
+ software_list_device_iterator iter(config.root_device());
+ if (iter.count() == 0)
+ throw emu_fatalerror(EMU_ERR_FATALERROR, "Error: unknown option: %s\n", software_identifier.c_str());
+
+ // and finally set up the stack
+ std::stack<std::string> software_identifier_stack;
+ software_identifier_stack.push(software_identifier);
+
+ // we need to keep evaluating softlist identifiers until the stack is empty
+ while (!software_identifier_stack.empty())
+ {
+ // pop the identifier
+ std::string current_software_identifier = std::move(software_identifier_stack.top());
+ software_identifier_stack.pop();
+
+ // and parse it
+ std::string list_name, software_name;
+ auto colon_pos = current_software_identifier.find_first_of(':');
+ if (colon_pos != std::string::npos)
+ {
+ list_name = current_software_identifier.substr(0, colon_pos);
+ software_name = current_software_identifier.substr(colon_pos + 1);
+ }
+ else
+ {
+ software_name = current_software_identifier;
+ }
+
+ // loop through all softlist devices, and try to find one capable of handling the requested software
+ bool found = false;
+ bool compatible = false;
+ for (software_list_device &swlistdev : iter)
+ {
+ if (list_name.empty() || (list_name == swlistdev.list_name()))
+ {
+ const software_info *swinfo = swlistdev.find(software_name);
+ if (swinfo != nullptr)
+ {
+ // loop through all parts
+ for (const software_part &swpart : swinfo->parts())
+ {
+ // only load compatible software this way
+ if (swlistdev.is_compatible(swpart) == SOFTWARE_IS_COMPATIBLE)
+ {
+ // we need to find a mountable image slot, but we need to ensure it is a slot
+ // for which we have not already distributed a part to
+ device_image_interface *image = software_list_device::find_mountable_image(
+ config,
+ swpart,
+ [&results](const device_image_interface &candidate) { return results.image.count(candidate.instance_name()) == 0; });
+
+ // did we find a slot to put this part into?
+ if (image != nullptr)
+ {
+ // we've resolved this software
+ results.image[image->instance_name()] = string_format("%s:%s:%s", swlistdev.list_name(), software_name, swpart.name());
+
+ // does this software part have a requirement on another part?
+ const char *requirement = swpart.feature("requirement");
+ if (requirement)
+ software_identifier_stack.push(requirement);
+ }
+ compatible = true;
+ }
+ found = true;
+ }
+
+ // identify other shared features specified as '<<slot name>>_default'
+ //
+ // example from SMS:
+ //
+ // <software name = "alexbmx">
+ // ...
+ // <sharedfeat name = "ctrl1_default" value = "paddle" />
+ // </software>
+ for (const feature_list_item &fi : swinfo->shared_info())
+ {
+ const std::string default_suffix = "_default";
+ if (fi.name().size() > default_suffix.size()
+ && fi.name().compare(fi.name().size() - default_suffix.size(), default_suffix.size(), default_suffix) == 0)
+ {
+ std::string slot_name = fi.name().substr(0, fi.name().size() - default_suffix.size());
+ results.slot[slot_name] = fi.value();
+ }
+ }
+ }
+ }
+ if (compatible)
+ break;
+ }
+
+ if (!compatible)
+ {
+ software_list_device::display_matches(config, nullptr, software_name);
+ if (!found)
+ throw options_error_exception("");
+ else
+ throw options_error_exception("Software '%s' is incompatible with system '%s'\n", software_name, m_system->name);
+ }
+ }
}
+ return results;
+}
+
+
+//-------------------------------------------------
+// slot_option
+//-------------------------------------------------
+
+const slot_option &emu_options::slot_option(const std::string &device_name) const
+{
+ auto iter = m_slot_options.find(device_name);
+ assert(iter != m_slot_options.end() && "Attempt to access non-existent slot option");
+ return iter->second;
+}
+
+slot_option &emu_options::slot_option(const std::string &device_name)
+{
+ auto iter = m_slot_options.find(device_name);
+ assert(iter != m_slot_options.end() && "Attempt to access non-existent slot option");
+ return iter->second;
+}
+
+
+//-------------------------------------------------
+// has_slot_option
+//-------------------------------------------------
- return false;
+bool emu_options::has_slot_option(const std::string &device_name) const
+{
+ return m_slot_options.find(device_name) != m_slot_options.end();
}
//-------------------------------------------------
+// image_option
+//-------------------------------------------------
+
+const image_option &emu_options::image_option(const std::string &device_name) const
+{
+ auto iter = m_image_options.find(device_name);
+ assert(iter != m_image_options.end() && "Attempt to access non-existent image option");
+ return *iter->second;
+}
+
+image_option &emu_options::image_option(const std::string &device_name)
+{
+ auto iter = m_image_options.find(device_name);
+ assert(iter != m_image_options.end() && "Attempt to access non-existent image option");
+ return *iter->second;
+}
+
+
+//**************************************************************************
+// SLOT OPTIONS
+//**************************************************************************
+
+//-------------------------------------------------
// slot_option ctor
//-------------------------------------------------
-slot_option::slot_option(const char *default_value)
- : m_specified(false)
+slot_option::slot_option(emu_options &host, const char *default_value)
+ : m_host(host)
+ , m_specified(false)
, m_default_value(default_value ? default_value : "")
{
}
@@ -396,10 +1048,12 @@ std::string slot_option::specified_value() const
void slot_option::specify(std::string &&text)
{
+ // record the old value; we may need to trigger an update
+ const std::string old_value = value();
+
// we need to do some elementary parsing here
const char *bios_arg = ",bios=";
-
- size_t pos = text.find(bios_arg);
+ const size_t pos = text.find(bios_arg);
if (pos != std::string::npos)
{
m_specified = true;
@@ -412,6 +1066,37 @@ void slot_option::specify(std::string &&text)
m_specified_value = std::move(text);
m_specified_bios = "";
}
+
+ // we may have changed
+ possibly_changed(old_value);
+}
+
+
+//-------------------------------------------------
+// slot_option::set_default_card_software
+//-------------------------------------------------
+
+void slot_option::set_default_card_software(std::string &&s)
+{
+ // record the old value; we may need to trigger an update
+ const std::string old_value = value();
+
+ // update the default card software
+ m_default_card_software = std::move(s);
+
+ // we may have changed
+ possibly_changed(old_value);
+}
+
+
+//-------------------------------------------------
+// slot_option::possibly_changed
+//-------------------------------------------------
+
+void slot_option::possibly_changed(const std::string &old_value)
+{
+ if (value() != old_value)
+ m_host.update_slot_and_image_options();
}
@@ -428,3 +1113,73 @@ void slot_option::set_bios(std::string &&text)
}
m_specified_bios = std::move(text);
}
+
+
+//-------------------------------------------------
+// slot_option::setup_option_entry
+//-------------------------------------------------
+
+core_options::entry::shared_ptr slot_option::setup_option_entry(const char *name)
+{
+ // this should only be called once
+ assert(m_entry.expired());
+
+ // create the entry and return it
+ core_options::entry::shared_ptr entry = std::make_shared<slot_option_entry>(name, *this);
+ m_entry = entry;
+ return entry;
+}
+
+
+//**************************************************************************
+// IMAGE OPTIONS
+//**************************************************************************
+
+//-------------------------------------------------
+// image_option ctor
+//-------------------------------------------------
+
+image_option::image_option(emu_options &host, const std::string &cannonical_instance_name)
+ : m_host(host)
+ , m_cannonical_instance_name(cannonical_instance_name)
+{
+}
+
+
+//-------------------------------------------------
+// image_option::specify
+//-------------------------------------------------
+
+void image_option::specify(const std::string &value)
+{
+ if (value != m_value)
+ {
+ m_value = value;
+ m_host.reevaluate_default_card_software();
+ }
+}
+
+void image_option::specify(std::string &&value)
+{
+ if (value != m_value)
+ {
+ m_value = std::move(value);
+ m_host.reevaluate_default_card_software();
+ }
+}
+
+
+//-------------------------------------------------
+// image_option::setup_option_entry
+//-------------------------------------------------
+
+core_options::entry::shared_ptr image_option::setup_option_entry(std::vector<std::string> &&names)
+{
+ // this should only be called once
+ assert(m_entry.expired());
+
+ // create the entry and return it
+ core_options::entry::shared_ptr entry = std::make_shared<image_option_entry>(std::move(names), *this);
+ m_entry = entry;
+ return entry;
+}
diff --git a/src/emu/emuopts.h b/src/emu/emuopts.h
index e592d04d6e3..44c636182ec 100644
--- a/src/emu/emuopts.h
+++ b/src/emu/emuopts.h
@@ -195,56 +195,77 @@
// TYPE DEFINITIONS
//**************************************************************************
+struct game_driver;
+class device_slot_interface;
+class emu_options;
+
class slot_option
{
public:
- slot_option(const char *default_value = nullptr);
- slot_option(const slot_option &that) = default;
+ slot_option(emu_options &host, const char *default_value);
+ slot_option(const slot_option &that) = delete;
slot_option(slot_option &&that) = default;
- const slot_option &operator=(const slot_option &that)
- {
- m_specified = that.m_specified;
- m_specified_value = that.m_specified_value;
- m_specified_bios = that.m_specified_bios;
- m_default_card_software = that.m_default_card_software;
- m_default_value = that.m_default_value;
- return *this;
- }
-
- const slot_option &operator=(slot_option &&that)
- {
- m_specified = that.m_specified;
- m_specified_value = std::move(that.m_specified_value);
- m_specified_bios = std::move(that.m_specified_bios);
- m_default_card_software = std::move(that.m_default_card_software);
- m_default_value = std::move(that.m_default_value);
- return *this;
- }
-
// accessors
const std::string &value() const;
std::string specified_value() const;
const std::string &bios() const { return m_specified_bios; }
const std::string &default_card_software() const { return m_default_card_software; }
bool specified() const { return m_specified; }
+ core_options::entry::shared_ptr option_entry() const { return m_entry.lock(); }
// seters
void specify(std::string &&text);
void set_bios(std::string &&text);
- void set_default_card_software(std::string &&s) { m_default_card_software = std::move(s); }
+ void set_default_card_software(std::string &&s);
+
+ // instantiates an option entry (don't call outside of emuopts.cpp)
+ core_options::entry::shared_ptr setup_option_entry(const char *name);
private:
- bool m_specified;
- std::string m_specified_value;
- std::string m_specified_bios;
- std::string m_default_card_software;
- std::string m_default_value;
+ void possibly_changed(const std::string &old_value);
+
+ emu_options & m_host;
+ bool m_specified;
+ std::string m_specified_value;
+ std::string m_specified_bios;
+ std::string m_default_card_software;
+ std::string m_default_value;
+ core_options::entry::weak_ptr m_entry;
+};
+
+
+class image_option
+{
+public:
+ image_option(emu_options &host, const std::string &cannonical_instance_name);
+ image_option(const image_option &that) = delete;
+ image_option(image_option &&that) = default;
+
+ // accessors
+ const std::string &cannonical_instance_name() const { return m_cannonical_instance_name; }
+ const std::string &value() const { return m_value; }
+ core_options::entry::shared_ptr option_entry() const { return m_entry.lock(); }
+
+ // mutators
+ void specify(const std::string &value);
+ void specify(std::string &&value);
+
+ // instantiates an option entry (don't call outside of emuopts.cpp)
+ core_options::entry::shared_ptr setup_option_entry(std::vector<std::string> &&names);
+
+private:
+ emu_options & m_host;
+ std::string m_cannonical_instance_name;
+ std::string m_value;
+ core_options::entry::weak_ptr m_entry;
};
class emu_options : public core_options
{
+ friend class slot_option;
+ friend class image_option;
public:
enum ui_option
{
@@ -253,11 +274,16 @@ public:
};
// construction/destruction
- emu_options();
+ emu_options(bool general_only = false);
+ ~emu_options();
+
+ // mutation
+ void set_system_name(const std::string &new_system_name);
+ void set_software(const std::string &new_software);
// core options
- const char *system_name() const { return value(OPTION_SYSTEMNAME); }
- const char *software_name() const { return value(OPTION_SOFTWARENAME); }
+ const game_driver *system() const { return m_system; }
+ const char *system_name() const;
// core configuration options
bool read_config() const { return bool_value(OPTION_READCONFIG); }
@@ -427,36 +453,51 @@ public:
const char *language() const { return value(OPTION_LANGUAGE); }
- // Web server specific optopns
+ // Web server specific options
bool http() const { return bool_value(OPTION_HTTP); }
short http_port() const { return int_value(OPTION_HTTP_PORT); }
const char *http_root() const { return value(OPTION_HTTP_ROOT); }
// slots and devices - the values for these are stored outside of the core_options
// structure
- std::map<std::string, slot_option> &slot_options() { return m_slot_options; }
- const std::map<std::string, slot_option> &slot_options() const { return m_slot_options; }
- std::map<std::string, std::string> &image_options() { return m_image_options; }
- const std::map<std::string, std::string> &image_options() const { return m_image_options; }
-
-protected:
- virtual void value_changed(const std::string &name, const std::string &value) override;
- virtual override_get_value_result override_get_value(const char *name, std::string &value) const override;
- virtual bool override_set_value(const char *name, const std::string &value) override;
+ const ::slot_option &slot_option(const std::string &device_name) const;
+ ::slot_option &slot_option(const std::string &device_name);
+ bool has_slot_option(const std::string &device_name) const;
+ const ::image_option &image_option(const std::string &device_name) const;
+ ::image_option &image_option(const std::string &device_name);
private:
- static const options_entry s_option_entries[];
+ struct software_options
+ {
+ std::unordered_map<std::string, std::string> slot;
+ std::unordered_map<std::string, std::string> image;
+ };
+
+ // slot/image/softlist calculus
+ software_options evaluate_initial_softlist_options(const std::string &software_identifier);
+ void update_slot_and_image_options();
+ bool add_and_remove_slot_options();
+ bool add_and_remove_image_options();
+ void reevaluate_default_card_software();
+ std::string get_default_card_software(device_slot_interface &slot);
+
+ // static list of options entries
+ static const options_entry s_option_entries[];
+
+ // the current driver
+ const game_driver * m_system;
// slots and devices
- std::map<std::string, slot_option> m_slot_options;
- std::map<std::string, std::string> m_image_options;
+ std::unordered_map<std::string, ::slot_option> m_slot_options;
+ std::unordered_map<std::string, ::image_option> m_image_options_cannonical;
+ std::unordered_map<std::string, ::image_option *> m_image_options;
// cached options, for scenarios where parsing core_options is too slow
- int m_coin_impulse;
- bool m_joystick_contradictory;
- bool m_sleep;
- bool m_refresh_speed;
- ui_option m_ui;
+ int m_coin_impulse;
+ bool m_joystick_contradictory;
+ bool m_sleep;
+ bool m_refresh_speed;
+ ui_option m_ui;
};
#endif // MAME_EMU_EMUOPTS_H
diff --git a/src/emu/image.cpp b/src/emu/image.cpp
index 25167db54a2..973c2b57db8 100644
--- a/src/emu/image.cpp
+++ b/src/emu/image.cpp
@@ -38,37 +38,12 @@ image_manager::image_manager(running_machine &machine)
continue;
// find the image option in image_options()
- auto iter = machine.options().image_options().find(image.instance_name());
-
- // GROSS HACK - if we began our journey with a single device configuration (e.g. - a single
- // cartridge system) but later added a device of that type, image.instance_name() will become
- // something different. We're going to try to accomodate that specific scenario here
- //
- // Specific example: 'mame snes -cart1 sufami -cart2 poipoi' - the instance_name() starts out
- // as "cartridge" but at the end becomes "cartridge1"
- if (iter == machine.options().image_options().end()
- && (image.instance_name().rbegin() != image.instance_name().rend())
- && (*image.instance_name().rbegin() == '1'))
- {
- std::string alternate_instance_name = image.instance_name().substr(0, image.instance_name().size() - 1);
- iter = machine.options().image_options().find(alternate_instance_name);
-
- // If we found something, we need to write it back (so later checks work). We also need to redo
- // the find; the act of erasing the old value breaks the iterator
- if (iter != machine.options().image_options().end())
- {
- std::string temp = std::move(iter->second);
- machine.options().image_options()[image.instance_name()] = std::move(temp);
- machine.options().image_options().erase(alternate_instance_name);
- iter = machine.options().image_options().find(image.instance_name());
- }
- }
+ const std::string &startup_image(machine.options().image_option(image.instance_name()).value());
// is an image specified for this image?
- if (iter != machine.options().image_options().end() && !iter->second.empty())
+ if (!startup_image.empty())
{
// we do have a startup image specified - load it
- const std::string &startup_image(iter->second);
image_init_result result = image_init_result::FAIL;
// try as a softlist
@@ -218,7 +193,7 @@ void image_manager::options_extract()
}
// and set the option
- machine().options().image_options()[image.instance_name()] = std::move(image_opt);
+ machine().options().image_option(image.instance_name()).specify(std::move(image_opt));
}
}
diff --git a/src/emu/mconfig.cpp b/src/emu/mconfig.cpp
index 84fc5c70b67..ba52b986fa5 100644
--- a/src/emu/mconfig.cpp
+++ b/src/emu/mconfig.cpp
@@ -39,21 +39,20 @@ machine_config::machine_config(const game_driver &gamedrv, emu_options &options)
const char *slot_option_name = owner.tag() + 1;
// figure out which device goes into this slot
- bool has_option = options.slot_options().count(slot_option_name);
+ bool has_option = options.has_slot_option(slot_option_name);
const char *selval;
bool is_default;
if (!has_option)
{
- // Theoretically we should never get here; in the long run the expectation is that
- // options.slot_options() should be fully qualified and all options should be
- // present. However, we're getting late in the MAME 0.185 development cycle and
- // I don't want to rip this out (yet)
+ // 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_options()[slot_option_name];
+ const slot_option &opt = options.slot_option(slot_option_name);
selval = opt.value().c_str();
is_default = !opt.specified();
}
diff --git a/src/emu/natkeyboard.cpp b/src/emu/natkeyboard.cpp
index e1921b7a21d..1aa8a78ed75 100644
--- a/src/emu/natkeyboard.cpp
+++ b/src/emu/natkeyboard.cpp
@@ -365,9 +365,7 @@ void natural_keyboard::set_in_use(bool usage)
{
// update active usage
m_in_use = usage;
- std::string error;
- machine().options().set_value(OPTION_NATURAL_KEYBOARD, usage, OPTION_PRIORITY_CMDLINE, error);
- assert(error.empty());
+ machine().options().set_value(OPTION_NATURAL_KEYBOARD, usage, OPTION_PRIORITY_CMDLINE);
// lock out (or unlock) all keyboard inputs
for (auto &port : machine().ioport().ports())
diff --git a/src/emu/romload.cpp b/src/emu/romload.cpp
index 118c7fcc0fe..ab2feae3886 100644
--- a/src/emu/romload.cpp
+++ b/src/emu/romload.cpp
@@ -1091,10 +1091,9 @@ int open_disk_image(emu_options &options, const game_driver *gamedrv, const rom_
// will only find CHDs for the default configuration. I believe that this in practice will
// be acceptable.
emu_options driver_specific_options;
- std::string error_string;
- driver_specific_options.set_value(OPTION_SYSTEMNAME, options.system_name(), OPTION_PRIORITY_DEFAULT, error_string);
- driver_specific_options.set_value(OPTION_MEDIAPATH, options.media_path(), OPTION_PRIORITY_DEFAULT, error_string);
- driver_specific_options.set_value(OPTION_DIFF_DIRECTORY, options.diff_directory(), OPTION_PRIORITY_DEFAULT, error_string);
+ driver_specific_options.set_value(OPTION_SYSTEMNAME, options.system_name(), OPTION_PRIORITY_DEFAULT);
+ driver_specific_options.set_value(OPTION_MEDIAPATH, options.media_path(), OPTION_PRIORITY_DEFAULT);
+ driver_specific_options.set_value(OPTION_DIFF_DIRECTORY, options.diff_directory(), OPTION_PRIORITY_DEFAULT);
// Now that we have an emu_options structure properly set up, we can create a machine_config
machine_config config(current_driver, driver_specific_options);
@@ -1496,12 +1495,13 @@ rom_load_manager::rom_load_manager(running_machine &machine)
specbios.assign(machine.options().bios());
else
{
- const char *slot_option_name = device.owner()->tag() + 1;
- const slot_option *opt = machine.options().slot_options().count(slot_option_name)
- ? &machine.options().slot_options()[slot_option_name]
+ const device_slot_interface *slot = dynamic_cast<const device_slot_interface *>(&device);
+ const slot_option *slot_opt = slot
+ ? &machine.options().slot_option(slot->slot_name())
: nullptr;
- specbios = opt && !opt->bios().empty()
- ? opt->bios().c_str()
+
+ specbios = slot_opt && !slot_opt->bios().empty()
+ ? slot_opt->bios().c_str()
: device.default_bios_tag();
}
determine_bios_rom(device, specbios.c_str());
diff --git a/src/frontend/mame/clifront.cpp b/src/frontend/mame/clifront.cpp
index c7a01674f47..8aa5e0c31c2 100644
--- a/src/frontend/mame/clifront.cpp
+++ b/src/frontend/mame/clifront.cpp
@@ -2,7 +2,7 @@
// copyright-holders:Aaron Giles
/***************************************************************************
- clifront.c
+ clifront.cpp
Command-line interface frontend for MAME.
@@ -190,26 +190,26 @@ cli_frontend::cli_frontend(emu_options &options, osd_interface &osd)
cli_frontend::~cli_frontend()
{
- // nuke any device options since they will leak memory
- mame_options::remove_device_options(m_options);
}
void cli_frontend::start_execution(mame_machine_manager *manager, std::vector<std::string> &args)
{
- std::string option_errors;
+ std::ostringstream option_errors;
// parse the command line, adding any system-specific options
- if (!mame_options::parse_command_line(m_options, args, option_errors))
+ try
+ {
+ m_options.parse_command_line(args, OPTION_PRIORITY_CMDLINE);
+ }
+ catch (options_exception &ex)
{
// if we failed, check for no command and a system name first; in that case error on the name
if (m_options.command().empty() && mame_options::system(m_options) == nullptr && *(m_options.system_name()) != 0)
throw emu_fatalerror(EMU_ERR_NO_SUCH_GAME, "Unknown system '%s'", m_options.system_name());
// otherwise, error on the options
- throw emu_fatalerror(EMU_ERR_INVALID_CONFIG, "%s", strtrimspace(option_errors).c_str());
+ throw emu_fatalerror(EMU_ERR_INVALID_CONFIG, "%s", ex.message().c_str());
}
- if (!option_errors.empty())
- osd_printf_error("Error in command line:\n%s\n", strtrimspace(option_errors).c_str());
// determine the base name of the EXE
std::string exename = core_filename_extract_base(args[0], true);
@@ -232,8 +232,11 @@ void cli_frontend::start_execution(mame_machine_manager *manager, std::vector<st
manager->start_luaengine();
- if (!option_errors.empty())
- osd_printf_error("Error in command line:\n%s\n", strtrimspace(option_errors).c_str());
+ if (option_errors.tellp() > 0)
+ {
+ std::string option_errors_string = option_errors.str();
+ osd_printf_error("Error in command line:\n%s\n", strtrimspace(option_errors_string).c_str());
+ }
// if we can't find it, give an appropriate error
const game_driver *system = mame_options::system(m_options);
@@ -779,8 +782,13 @@ void cli_frontend::listmedia(const char *gamename)
//-------------------------------------------------
void cli_frontend::verifyroms(const char *gamename)
{
+ // create our own copy of options for the purposes of ROM validation
+ // so we are not "polluted" with driver-specific slot/image options
+ emu_options options(true);
+ options.copy_from(m_options);
+
// determine which drivers to output;
- driver_enumerator drivlist(m_options, gamename);
+ driver_enumerator drivlist(options, gamename);
unsigned correct = 0;
unsigned incorrect = 0;
@@ -1356,10 +1364,10 @@ void cli_frontend::execute_commands(const char *exename)
}
// other commands need the INIs parsed
- std::string option_errors;
+ std::ostringstream option_errors;
mame_options::parse_standard_inis(m_options,option_errors);
- if (!option_errors.empty())
- osd_printf_error("%s\n", option_errors.c_str());
+ if (option_errors.tellp() > 0)
+ osd_printf_error("%s\n", option_errors.str().c_str());
// createconfig?
if (m_options.command() == CLICOMMAND_CREATECONFIG)
diff --git a/src/frontend/mame/info.cpp b/src/frontend/mame/info.cpp
index fa742dfe2f4..b580bc76a7e 100644
--- a/src/frontend/mame/info.cpp
+++ b/src/frontend/mame/info.cpp
@@ -193,9 +193,9 @@ info_xml_creator::info_xml_creator(driver_enumerator &drivlist, bool filter_devi
: m_output(nullptr)
, m_drivlist(drivlist)
, m_filter_devices(filter_devices)
- , m_lookup_options(m_drivlist.options())
+ , m_lookup_options(true)
{
- mame_options::remove_device_options(m_lookup_options);
+ m_lookup_options.copy_from(m_drivlist.options());
}
diff --git a/src/frontend/mame/luaengine.cpp b/src/frontend/mame/luaengine.cpp
index 7e7d5d78572..add15da55f9 100644
--- a/src/frontend/mame/luaengine.cpp
+++ b/src/frontend/mame/luaengine.cpp
@@ -721,7 +721,6 @@ void lua_engine::initialize()
emu["app_version"] = &emulator_info::get_bare_build_version;
emu["gamename"] = [this](){ return machine().system().description; };
emu["romname"] = [this](){ return machine().basename(); };
- emu["softname"] = [this](){ return machine().options().software_name(); };
emu["keypost"] = [this](const char *keys){ machine().ioport().natkeyboard().post_utf8(keys); };
emu["time"] = [this](){ return machine().time().as_double(); };
emu["start"] = [this](const char *driver) {
@@ -922,9 +921,11 @@ void lua_engine::initialize()
"entries", sol::property([this](core_options &options) {
sol::table table = sol().create_table();
int unadorned_index = 0;
- for(core_options::entry &curentry : options)
+ for (auto &curentry : options.entries())
{
- const char *name = curentry.name();
+ const char *name = curentry->names().size() > 0
+ ? curentry->name().c_str()
+ : nullptr;
bool is_unadorned = false;
// check if it's unadorned
if (name && strlen(name) && !strcmp(name, options.unadorned(unadorned_index)))
@@ -932,8 +933,8 @@ void lua_engine::initialize()
unadorned_index++;
is_unadorned = true;
}
- if (!curentry.is_header() && !curentry.is_command() && !curentry.is_internal() && !is_unadorned)
- table[name] = &curentry;
+ if (curentry->type() != core_options::option_type::HEADER && curentry->type() != core_options::option_type::COMMAND && !is_unadorned)
+ table[name] = &*curentry;
}
return table;
}));
@@ -974,18 +975,19 @@ void lua_engine::initialize()
e.set_value(val, OPTION_PRIORITY_CMDLINE);
},
[this](core_options::entry &e) -> sol::object {
- if(!e.type())
+ if (e.type() == core_options::option_type::INVALID)
return sol::make_object(sol(), sol::nil);
switch(e.type())
{
- case OPTION_BOOLEAN:
+ case core_options::option_type::BOOLEAN:
return sol::make_object(sol(), atoi(e.value()) != 0);
- case OPTION_INTEGER:
+ case core_options::option_type::INTEGER:
return sol::make_object(sol(), atoi(e.value()));
- case OPTION_FLOAT:
+ case core_options::option_type::FLOAT:
return sol::make_object(sol(), atof(e.value()));
+ default:
+ return sol::make_object(sol(), e.value());
}
- return sol::make_object(sol(), e.value());
}),
"description", &core_options::entry::description,
"default_value", &core_options::entry::default_value,
diff --git a/src/frontend/mame/mame.cpp b/src/frontend/mame/mame.cpp
index 0a954906c35..c75d60f5130 100644
--- a/src/frontend/mame/mame.cpp
+++ b/src/frontend/mame/mame.cpp
@@ -124,36 +124,38 @@ void mame_machine_manager::start_luaengine()
std::vector<std::string> exclude = split(options().no_plugin(),',');
{
// parse the file
- std::string error;
// attempt to open the output file
emu_file file(options().ini_path(), OPEN_FLAG_READ);
if (file.open("plugin.ini") == osd_file::error::NONE)
{
- bool result = m_plugins->parse_ini_file((util::core_file&)file, OPTION_PRIORITY_MAME_INI, OPTION_PRIORITY_DRIVER_INI, error);
- if (!result)
+ try
+ {
+ m_plugins->parse_ini_file((util::core_file&)file, OPTION_PRIORITY_MAME_INI, false);
+ }
+ catch (options_exception &)
+ {
osd_printf_error("**Error loading plugin.ini**");
+ }
}
}
- for (auto &curentry : *m_plugins)
+ for (auto &curentry : m_plugins->entries())
{
- if (!curentry.is_header())
+ if (curentry->type() != core_options::option_type::HEADER)
{
- if (std::find(include.begin(), include.end(), curentry.name()) != include.end())
+ if (std::find(include.begin(), include.end(), curentry->name()) != include.end())
{
- std::string error_string;
- m_plugins->set_value(curentry.name(), "1", OPTION_PRIORITY_CMDLINE, error_string);
+ m_plugins->set_value(curentry->name(), "1", OPTION_PRIORITY_CMDLINE);
}
- if (std::find(exclude.begin(), exclude.end(), curentry.name()) != exclude.end())
+ if (std::find(exclude.begin(), exclude.end(), curentry->name()) != exclude.end())
{
- std::string error_string;
- m_plugins->set_value(curentry.name(), "0", OPTION_PRIORITY_CMDLINE, error_string);
+ m_plugins->set_value(curentry->name(), "0", OPTION_PRIORITY_CMDLINE);
}
}
}
}
- if (options().console()) {
- std::string error_string;
- m_plugins->set_value("console", "1", OPTION_PRIORITY_CMDLINE, error_string);
+ if (options().console())
+ {
+ m_plugins->set_value("console", "1", OPTION_PRIORITY_CMDLINE);
}
m_lua->initialize();
@@ -202,9 +204,8 @@ int mame_machine_manager::execute()
// parse any INI files as the first thing
if (m_options.read_config())
{
- m_options.revert(OPTION_PRIORITY_INI);
- std::string errors;
- mame_options::parse_standard_inis(m_options,errors);
+ std::ostringstream errors;
+ mame_options::parse_standard_inis(m_options, errors);
}
// otherwise, perform validity checks before anything else
@@ -216,11 +217,6 @@ int mame_machine_manager::execute()
valid.check_shared_source(*system);
}
- // reevaluate slot options until nothing changes
- while (mame_options::reevaluate_slot_options(m_options))
- {
- }
-
// create the machine configuration
machine_config config(*system, m_options);
@@ -237,12 +233,13 @@ int mame_machine_manager::execute()
if (m_new_driver_pending)
{
// set up new system name and adjust device options accordingly
- mame_options::set_system_name(m_options,m_new_driver_pending->name);
+ m_options.set_system_name(m_new_driver_pending->name);
m_firstrun = true;
}
else
{
- if (machine.exit_pending()) mame_options::set_system_name(m_options,"");
+ if (machine.exit_pending())
+ m_options.set_system_name("");
}
if (machine.exit_pending() && (!started_empty || is_empty))
diff --git a/src/frontend/mame/mameopts.cpp b/src/frontend/mame/mameopts.cpp
index 8cb8cff09fa..04025630a58 100644
--- a/src/frontend/mame/mameopts.cpp
+++ b/src/frontend/mame/mameopts.cpp
@@ -21,491 +21,21 @@
#include <stack>
-int mame_options::m_slot_options = 0;
-int mame_options::m_device_options = 0;
-
-//-------------------------------------------------
-// add_slot_options - add all of the slot
-// options for the configured system
-//-------------------------------------------------
-
-bool mame_options::add_slot_options(emu_options &options, value_specifier_func value_specifier)
-{
- // look up the system configured by name; if no match, do nothing
- const game_driver *cursystem = system(options);
- if (cursystem == nullptr)
- return false;
-
- // create the configuration
- machine_config config(*cursystem, options);
-
- // iterate through all slot devices
- int starting_count = options.options_count();
- for (const device_slot_interface &slot : slot_interface_iterator(config.root_device()))
- {
- // skip fixed slots
- if (slot.fixed())
- continue;
-
- // retrieve info about the device instance
- const char *name = slot.device().tag() + 1;
- if (!options.exists(name))
- {
- // first device? add the header as to be pretty
- if (m_slot_options++ == 0)
- options.add_entry(nullptr, "SLOT DEVICES", OPTION_HEADER | OPTION_FLAG_DEVICE);
-
- // add the option
- options.add_entry(name, nullptr, OPTION_STRING | OPTION_FLAG_DEVICE, slot.default_option(), true);
- options.slot_options()[name] = slot_option(slot.default_option());
-
- // allow opportunity to specify this value
- if (value_specifier)
- {
- std::string specified_value = value_specifier(name);
- if (specified_value != value_specifier_invalid_value())
- options.slot_options()[name].specify(std::move(specified_value));
- }
- }
- }
- return (options.options_count() != starting_count);
-}
-
-
-//-------------------------------------------------
-// update_slot_options - update slot values
-// depending of image mounted
-//-------------------------------------------------
-
-void mame_options::update_slot_options(emu_options &options, const software_part *swpart)
-{
- // look up the system configured by name; if no match, do nothing
- const game_driver *cursystem = system(options);
- if (cursystem == nullptr)
- return;
- machine_config config(*cursystem, options);
-
- // iterate through all slot devices
- for (device_slot_interface &slot : slot_interface_iterator(config.root_device()))
- {
- // retrieve info about the device instance
- const char *name = slot.device().tag() + 1;
- if (options.exists(name) && !slot.option_list().empty())
- {
- std::string defvalue = get_default_card_software(slot, options);
- if (defvalue.empty())
- {
- // keep any non-default setting
- if (options.priority(name) > OPTION_PRIORITY_DEFAULT)
- continue;
-
- // reinstate the actual default value as configured
- if (slot.default_option() != nullptr)
- defvalue.assign(slot.default_option());
- }
-
- // set the value and hide the option if not selectable
- options.set_default_value(name, defvalue.c_str());
- const device_slot_option *option = slot.option(defvalue.c_str());
- options.set_flag(name, ~OPTION_FLAG_INTERNAL, (option != nullptr && !option->selectable()) ? OPTION_FLAG_INTERNAL : 0);
- }
- }
- add_device_options(options);
-}
-
-
-//-------------------------------------------------
-// get_default_card_software
-//-------------------------------------------------
-
-std::string mame_options::get_default_card_software(device_slot_interface &slot, const emu_options &options)
-{
- std::string image_path;
- std::function<bool(util::core_file &, std::string&)> get_hashfile_extrainfo;
-
- // figure out if an image option has been specified, and if so, get the image path out of the options
- device_image_interface *image = dynamic_cast<device_image_interface *>(&slot);
- if (image)
- {
- auto iter = options.image_options().find(image->instance_name());
- if (iter != options.image_options().end())
- image_path = iter->second;
-
- get_hashfile_extrainfo = [image, &options](util::core_file &file, std::string &extrainfo)
- {
- util::hash_collection hashes = image->calculate_hash_on_file(file);
-
- return hashfile_extrainfo(
- options.hash_path(),
- image->device().mconfig().gamedrv(),
- hashes,
- extrainfo);
- };
- }
-
- // create the hook
- get_default_card_software_hook hook(image_path, std::move(get_hashfile_extrainfo));
-
- // and invoke the slot's implementation of get_default_card_software()
- return slot.get_default_card_software(hook);
-}
-
-
-//-------------------------------------------------
-// add_device_options - add all of the device
-// options for the configured system
-//-------------------------------------------------
-
-void mame_options::add_device_options(emu_options &options, value_specifier_func value_specifier)
-{
- // look up the system configured by name; if no match, do nothing
- const game_driver *cursystem = system(options);
- if (cursystem == nullptr)
- return;
- machine_config config(*cursystem, options);
-
- // iterate through all image devices
- for (device_image_interface &image : image_interface_iterator(config.root_device()))
- {
- if (!image.user_loadable())
- continue;
-
- // add the option
- if (!options.exists(image.instance_name().c_str()))
- {
- // first device? add the header as to be pretty
- if (m_device_options++ == 0)
- options.add_entry(nullptr, "IMAGE DEVICES", OPTION_HEADER | OPTION_FLAG_DEVICE);
-
- // add the option
- std::string option_name = get_full_option_name(image);
- options.add_entry(option_name.c_str(), nullptr, OPTION_STRING | OPTION_FLAG_DEVICE, nullptr, true);
- options.image_options()[image.instance_name()] = "";
-
- // allow opportunity to specify this value
- if (value_specifier)
- {
- std::string value = value_specifier(image.instance_name());
- if (value != value_specifier_invalid_value())
- options.image_options()[image.instance_name()] = std::move(value);
- }
- }
- }
-}
-
-
-//-------------------------------------------------
-// remove_device_options - remove device options
-//-------------------------------------------------
-
-std::string mame_options::get_full_option_name(const device_image_interface &image)
-{
- std::ostringstream option_name;
- util::stream_format(option_name, "%s;%s", image.instance_name(), image.brief_instance_name());
- if (strcmp(image.device_typename(image.image_type()), image.instance_name().c_str()) == 0)
- util::stream_format(option_name, ";%s1;%s1", image.instance_name(), image.brief_instance_name());
- return option_name.str();
-}
-
-
-//-------------------------------------------------
-// remove_device_options - remove device options
-//-------------------------------------------------
-
-void mame_options::remove_device_options(emu_options &options)
-{
- // iterate through options and remove interesting ones
- core_options::entry *nextentry;
- for (auto *curentry = options.first(); curentry != nullptr; curentry = nextentry)
- {
- // pre-fetch the next entry in case we delete this one
- nextentry = curentry->next();
-
- // if this is a device option, nuke it
- if ((curentry->flags() & OPTION_FLAG_DEVICE) != 0)
- options.remove_entry(*curentry);
- }
-
- // take also care of ramsize options
- options.set_default_value(OPTION_RAMSIZE, "");
-
- // reset counters
- m_slot_options = 0;
- m_device_options = 0;
-}
-
-
-//-------------------------------------------------
-// parse_slot_devices - parse the command line
-// and update slot and image devices
-//-------------------------------------------------
-
-void mame_options::parse_slot_devices(emu_options &options, value_specifier_func value_specifier)
-{
- bool still_adding = true;
- while (still_adding)
- {
- // keep adding slot options until we stop seeing new stuff
- still_adding = false;
- while (add_slot_options(options, value_specifier))
- still_adding = true;
-
- // add device options
- add_device_options(options, value_specifier);
-
- if (reevaluate_slot_options(options))
- still_adding = true;
- }
-}
-
-
-//-------------------------------------------------
-// reevaluate_slot_options - based on recent changes
-// in what images are mounted, give drivers a chance
-// to specify new default slot options
-//-------------------------------------------------
-
-bool mame_options::reevaluate_slot_options(emu_options &options)
-{
- bool result = false;
-
- // look up the system configured by name; if no match, do nothing
- const game_driver *cursystem = system(options);
- if (cursystem == nullptr)
- return result;
- machine_config config(*cursystem, options);
-
- // iterate through all slot devices
- for (device_slot_interface &slot : slot_interface_iterator(config.root_device()))
- {
- // retrieve info about the device instance
- const char *name = slot.device().tag() + 1;
- if (options.exists(name) && !slot.option_list().empty())
- {
- // device_slot_interface::get_default_card_software() is essentially a hook
- // that lets devices provide a feedback loop to force a specified software
- // list entry to be loaded
- //
- // In the repeated cycle of adding slots and slot devices, this gives a chance
- // for devices to "plug in" default software list items. Of course, the fact
- // that this is all shuffling options is brittle and roundabout, but such is
- // the nature of software lists.
- //
- // In reality, having some sort of hook into the pipeline of slot/device evaluation
- // makes sense, but the fact that it is joined at the hip to device_image_interface
- // and device_slot_interface is unfortunate
- std::string default_card_software = get_default_card_software(slot, options);
- if (!default_card_software.empty())
- {
- // we have default card software - is this resulting in the slot option being mutated?
- if (options.slot_options()[name].default_card_software() != default_card_software)
- {
- options.slot_options()[name].set_default_card_software(std::move(default_card_software));
- result = true;
- }
- }
- }
- }
- return result;
-}
-
-
-//-------------------------------------------------
-// parse_command_line - parse the command line
-// and update the devices
-//-------------------------------------------------
-
-bool mame_options::parse_command_line(emu_options &options, std::vector<std::string> &args, std::string &error_string)
-{
- // parse the command line
- if (!options.parse_command_line(args, OPTION_PRIORITY_CMDLINE, error_string))
- return false;
-
- // identify any options as a result of softlists
- auto softlist_opts = evaluate_initial_softlist_options(options);
-
- // assemble a "value specifier" that will be used to specify options set up as a consequence
- // of slot and device setup
- auto value_specifier = [&options, &softlist_opts, &args, &error_string](const std::string &arg)
- {
- // first find within the command line
- std::string arg_value;
- bool success = options.pluck_from_command_line(args, arg, arg_value);
-
- // next try to find within softlist-specified options
- if (!success)
- {
- auto iter = softlist_opts.find(arg);
- if (iter != softlist_opts.end())
- {
- arg_value = iter->second;
- success = true;
- }
- }
-
- // did we find something?
- return success
- ? arg_value
- : value_specifier_invalid_value();
- };
-
- // parse the slot devices
- parse_slot_devices(options, value_specifier);
-
- // at this point, we should have handled all arguments; the only argument that shouldn't have
- // been handled is the file name
- if (args.size() > 1)
- {
- error_string.append(string_format("Error: unknown option: %s\n", args[1]));
- return false;
- }
-
- return true;
-}
-
-
-//-------------------------------------------------
-// evaluate_initial_softlist_options
-//-------------------------------------------------
-
-std::map<std::string, std::string> mame_options::evaluate_initial_softlist_options(emu_options &options)
-{
- std::map<std::string, std::string> results;
-
- // load software specified at the command line (if any of course)
- std::string software_identifier = options.software_name();
- if (!software_identifier.empty())
- {
- // we have software; first identify the proper game_driver
- const game_driver *system = mame_options::system(options);
- if (system == nullptr && *(options.system_name()) != 0)
- throw emu_fatalerror(EMU_ERR_NO_SUCH_GAME, "Unknown system '%s'", options.system_name());
-
- // and set up a configuration
- machine_config config(*system, options);
- software_list_device_iterator iter(config.root_device());
- if (iter.count() == 0)
- throw emu_fatalerror(EMU_ERR_FATALERROR, "Error: unknown option: %s\n", options.software_name());
-
- // and finally set up the stack
- std::stack<std::string> software_identifier_stack;
- software_identifier_stack.push(software_identifier);
-
- // we need to keep evaluating softlist identifiers until the stack is empty
- while (!software_identifier_stack.empty())
- {
- // pop the identifier
- software_identifier = std::move(software_identifier_stack.top());
- software_identifier_stack.pop();
-
- // and parse it
- std::string list_name, software_name;
- auto colon_pos = software_identifier.find_first_of(':');
- if (colon_pos != std::string::npos)
- {
- list_name = software_identifier.substr(0, colon_pos);
- software_name = software_identifier.substr(colon_pos + 1);
- }
- else
- {
- software_name = software_identifier;
- }
-
- // loop through all softlist devices, and try to find one capable of handling the requested software
- bool found = false;
- bool compatible = false;
- for (software_list_device &swlistdev : iter)
- {
- if (list_name.empty() || (list_name == swlistdev.list_name()))
- {
- const software_info *swinfo = swlistdev.find(software_name);
- if (swinfo != nullptr)
- {
- // loop through all parts
- for (const software_part &swpart : swinfo->parts())
- {
- // only load compatible software this way
- if (swlistdev.is_compatible(swpart) == SOFTWARE_IS_COMPATIBLE)
- {
- // we need to find a mountable image slot, but we need to ensure it is a slot
- // for which we have not already distributed a part to
- device_image_interface *image = software_list_device::find_mountable_image(
- config,
- swpart,
- [&results](const device_image_interface &candidate) { return results.count(candidate.instance_name()) == 0; });
-
- // did we find a slot to put this part into?
- if (image != nullptr)
- {
- // we've resolved this software
- results[image->instance_name()] = string_format("%s:%s:%s", swlistdev.list_name(), software_name, swpart.name());
-
- // does this software part have a requirement on another part?
- const char *requirement = swpart.feature("requirement");
- if (requirement)
- software_identifier_stack.push(requirement);
- }
- compatible = true;
- }
- found = true;
- }
-
- // identify other shared features specified as '<<slot name>>_default'
- //
- // example from SMS:
- //
- // <software name = "alexbmx">
- // ...
- // <sharedfeat name = "ctrl1_default" value = "paddle" />
- // </software>
- for (const feature_list_item &fi : swinfo->shared_info())
- {
- const std::string default_suffix = "_default";
- if (fi.name().size() > default_suffix.size()
- && fi.name().compare(fi.name().size() - default_suffix.size(), default_suffix.size(), default_suffix) == 0)
- {
- std::string slot_name = fi.name().substr(0, fi.name().size() - default_suffix.size());
- results[slot_name] = fi.value();
- }
- }
- }
- }
- if (compatible)
- break;
- }
-
- if (!compatible)
- {
- software_list_device::display_matches(config, nullptr, software_name);
- if (!found)
- throw emu_fatalerror(EMU_ERR_FATALERROR, nullptr);
- else
- throw emu_fatalerror(EMU_ERR_FATALERROR, "Software '%s' is incompatible with system '%s'\n", software_name.c_str(), options.system_name());
- }
- }
- }
- return results;
-}
-
-
//-------------------------------------------------
// parse_standard_inis - parse the standard set
// of INI files
//-------------------------------------------------
-void mame_options::parse_standard_inis(emu_options &options, std::string &error_string, const game_driver *driver)
+void mame_options::parse_standard_inis(emu_options &options, std::ostream &error_stream, const game_driver *driver)
{
- // start with an empty string
- error_string.clear();
-
// parse the INI file defined by the platform (e.g., "mame.ini")
// we do this twice so that the first file can change the INI path
- parse_one_ini(options,emulator_info::get_configname(), OPTION_PRIORITY_MAME_INI);
- parse_one_ini(options,emulator_info::get_configname(), OPTION_PRIORITY_MAME_INI, &error_string);
+ parse_one_ini(options, emulator_info::get_configname(), OPTION_PRIORITY_MAME_INI);
+ parse_one_ini(options, emulator_info::get_configname(), OPTION_PRIORITY_MAME_INI, &error_stream);
// debug mode: parse "debug.ini" as well
if (options.debug())
- parse_one_ini(options,"debug", OPTION_PRIORITY_DEBUG_INI, &error_string);
+ parse_one_ini(options, "debug", OPTION_PRIORITY_DEBUG_INI, &error_stream);
// if we have a valid system driver, parse system-specific INI files
const game_driver *cursystem = (driver == nullptr) ? system(options) : driver;
@@ -514,18 +44,18 @@ void mame_options::parse_standard_inis(emu_options &options, std::string &error_
// parse "vertical.ini" or "horizont.ini"
if (cursystem->flags & ORIENTATION_SWAP_XY)
- parse_one_ini(options,"vertical", OPTION_PRIORITY_ORIENTATION_INI, &error_string);
+ parse_one_ini(options, "vertical", OPTION_PRIORITY_ORIENTATION_INI, &error_stream);
else
- parse_one_ini(options,"horizont", OPTION_PRIORITY_ORIENTATION_INI, &error_string);
+ parse_one_ini(options, "horizont", OPTION_PRIORITY_ORIENTATION_INI, &error_stream);
if (cursystem->flags & MACHINE_TYPE_ARCADE)
- parse_one_ini(options,"arcade", OPTION_PRIORITY_SYSTYPE_INI, &error_string);
+ parse_one_ini(options, "arcade", OPTION_PRIORITY_SYSTYPE_INI, &error_stream);
else if (cursystem->flags & MACHINE_TYPE_CONSOLE)
- parse_one_ini(options,"console", OPTION_PRIORITY_SYSTYPE_INI, &error_string);
+ parse_one_ini(options ,"console", OPTION_PRIORITY_SYSTYPE_INI, &error_stream);
else if (cursystem->flags & MACHINE_TYPE_COMPUTER)
- parse_one_ini(options,"computer", OPTION_PRIORITY_SYSTYPE_INI, &error_string);
+ parse_one_ini(options, "computer", OPTION_PRIORITY_SYSTYPE_INI, &error_stream);
else if (cursystem->flags & MACHINE_TYPE_OTHER)
- parse_one_ini(options,"othersys", OPTION_PRIORITY_SYSTYPE_INI, &error_string);
+ parse_one_ini(options, "othersys", OPTION_PRIORITY_SYSTYPE_INI, &error_stream);
machine_config config(*cursystem, options);
for (const screen_device &device : screen_device_iterator(config.root_device()))
@@ -533,35 +63,35 @@ void mame_options::parse_standard_inis(emu_options &options, std::string &error_
// parse "raster.ini" for raster games
if (device.screen_type() == SCREEN_TYPE_RASTER)
{
- parse_one_ini(options,"raster", OPTION_PRIORITY_SCREEN_INI, &error_string);
+ parse_one_ini(options, "raster", OPTION_PRIORITY_SCREEN_INI, &error_stream);
break;
}
// parse "vector.ini" for vector games
if (device.screen_type() == SCREEN_TYPE_VECTOR)
{
- parse_one_ini(options,"vector", OPTION_PRIORITY_SCREEN_INI, &error_string);
+ parse_one_ini(options, "vector", OPTION_PRIORITY_SCREEN_INI, &error_stream);
break;
}
// parse "lcd.ini" for lcd games
if (device.screen_type() == SCREEN_TYPE_LCD)
{
- parse_one_ini(options,"lcd", OPTION_PRIORITY_SCREEN_INI, &error_string);
+ parse_one_ini(options, "lcd", OPTION_PRIORITY_SCREEN_INI, &error_stream);
break;
}
}
// next parse "source/<sourcefile>.ini"
std::string sourcename = core_filename_extract_base(cursystem->source_file, true).insert(0, "source" PATH_SEPARATOR);
- parse_one_ini(options,sourcename.c_str(), OPTION_PRIORITY_SOURCE_INI, &error_string);
+ parse_one_ini(options, sourcename.c_str(), OPTION_PRIORITY_SOURCE_INI, &error_stream);
// then parse the grandparent, parent, and system-specific INIs
int parent = driver_list::clone(*cursystem);
int gparent = (parent != -1) ? driver_list::clone(parent) : -1;
if (gparent != -1)
- parse_one_ini(options,driver_list::driver(gparent).name, OPTION_PRIORITY_GPARENT_INI, &error_string);
+ parse_one_ini(options, driver_list::driver(gparent).name, OPTION_PRIORITY_GPARENT_INI, &error_stream);
if (parent != -1)
- parse_one_ini(options,driver_list::driver(parent).name, OPTION_PRIORITY_PARENT_INI, &error_string);
- parse_one_ini(options,cursystem->name, OPTION_PRIORITY_DRIVER_INI, &error_string);
+ parse_one_ini(options, driver_list::driver(parent).name, OPTION_PRIORITY_PARENT_INI, &error_stream);
+ parse_one_ini(options, cursystem->name, OPTION_PRIORITY_DRIVER_INI, &error_stream);
}
@@ -578,115 +108,33 @@ const game_driver *mame_options::system(const emu_options &options)
//-------------------------------------------------
-// set_system_name - set a new system name
-//-------------------------------------------------
-
-void mame_options::set_system_name(emu_options &options, const char *name)
-{
- // remember the original system name
- std::string old_system_name(options.system_name());
- bool new_system = old_system_name.compare(name) != 0;
-
- // if the system name changed, fix up the device options
- if (new_system)
- {
- // first set the new name
- std::string error;
- options.set_value(OPTION_SYSTEMNAME, name, OPTION_PRIORITY_CMDLINE, error);
- assert(error.empty());
-
- // remove any existing device options
- remove_device_options(options);
- }
- else
- {
- // revert device options set for the old software
- options.revert(OPTION_PRIORITY_SUBCMD, OPTION_PRIORITY_SUBCMD);
- }
-
- // get the new system
- const game_driver *cursystem = system(options);
- if (cursystem == nullptr)
- return;
-
- if (*options.software_name() != 0)
- {
- std::string sw_load(options.software_name());
- std::string sw_list, sw_name, sw_part, sw_instance, error_string;
- int left = sw_load.find_first_of(':');
- int middle = sw_load.find_first_of(':', left + 1);
- int right = sw_load.find_last_of(':');
-
- sw_list = sw_load.substr(0, left);
- sw_name = sw_load.substr(left + 1, middle - left - 1);
- sw_part = sw_load.substr(middle + 1, right - middle - 1);
- sw_instance = sw_load.substr(right + 1);
- sw_load.assign(sw_load.substr(0, right));
-
- // look up the software part
- machine_config config(*cursystem, options);
- software_list_device *swlist = software_list_device::find_by_name(config, sw_list.c_str());
- const software_info *swinfo = swlist != nullptr ? swlist->find(sw_name.c_str()) : nullptr;
- const software_part *swpart = swinfo != nullptr ? swinfo->find_part(sw_part.c_str()) : nullptr;
- if (swpart == nullptr)
- osd_printf_warning("Could not find %s in software list\n", options.software_name());
-
- // then add the options
- if (new_system)
- {
- while (add_slot_options(options)) {}
- add_device_options(options);
- }
-
- options.set_value(OPTION_SOFTWARENAME, sw_name.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
- if (options.exists(sw_instance.c_str()))
- options.set_value(sw_instance.c_str(), sw_load.c_str(), OPTION_PRIORITY_SUBCMD, error_string);
-
- int num;
- do {
- num = options.options_count();
- update_slot_options(options,swpart);
- } while (num != options.options_count());
- }
- else if (new_system)
- {
- // add the options afresh
- while (add_slot_options(options)) {}
- add_device_options(options);
- int num;
- do {
- num = options.options_count();
- update_slot_options(options);
- } while (num != options.options_count());
- }
-}
-
-//-------------------------------------------------
// parse_one_ini - parse a single INI file
//-------------------------------------------------
-bool mame_options::parse_one_ini(emu_options &options, const char *basename, int priority, std::string *error_string)
+void mame_options::parse_one_ini(emu_options &options, const char *basename, int priority, std::ostream *error_stream)
{
// don't parse if it has been disabled
if (!options.read_config())
- return false;
+ return;
// open the file; if we fail, that's ok
emu_file file(options.ini_path(), OPEN_FLAG_READ);
osd_printf_verbose("Attempting load of %s.ini\n", basename);
osd_file::error filerr = file.open(basename, ".ini");
if (filerr != osd_file::error::NONE)
- return false;
+ return;
// parse the file
osd_printf_verbose("Parsing %s.ini\n", basename);
- std::string error;
- bool result = options.parse_ini_file((util::core_file&)file, priority, OPTION_PRIORITY_DRIVER_INI, error);
-
- // append errors if requested
- if (!error.empty() && error_string)
- error_string->append(string_format("While parsing %s:\n%s\n", file.fullpath(), error));
+ try
+ {
+ options.parse_ini_file((util::core_file&)file, priority, false);
+ }
+ catch (options_exception &ex)
+ {
+ if (error_stream)
+ util::stream_format(*error_stream, "While parsing %s:\n%s\n", ex.message(), file.fullpath(), ex.message());
+ return;
+ }
- return result;
}
-
diff --git a/src/frontend/mame/mameopts.h b/src/frontend/mame/mameopts.h
index 3c543e65c66..68c0d683d0d 100644
--- a/src/frontend/mame/mameopts.h
+++ b/src/frontend/mame/mameopts.h
@@ -50,42 +50,14 @@ class software_part;
class mame_options
{
- static const uint32_t OPTION_FLAG_DEVICE = 0x80000000;
-
public:
- typedef std::function<std::string (const std::string &)> value_specifier_func;
-
// parsing wrappers
- static bool parse_command_line(emu_options &options, std::vector<std::string> &args, std::string &error_string);
- static void parse_standard_inis(emu_options &options, std::string &error_string, const game_driver *driver = nullptr);
- // FIXME: Couriersud: This should be in image_device_exit
- static void remove_device_options(emu_options &options);
-
+ static void parse_standard_inis(emu_options &options, std::ostream &error_stream, const game_driver *driver = nullptr);
static const game_driver *system(const emu_options &options);
- static void set_system_name(emu_options &options, const char *name);
- static bool add_slot_options(emu_options &options, value_specifier_func value_specifier = nullptr);
- static bool reevaluate_slot_options(emu_options &options);
private:
- // device-specific option handling
- static void add_device_options(emu_options &options, value_specifier_func value_specifier = nullptr);
- static void update_slot_options(emu_options &options, const software_part *swpart = nullptr);
- static void parse_slot_devices(emu_options &options, value_specifier_func value_specifier);
- static std::string get_full_option_name(const device_image_interface &image);
- static std::string get_default_card_software(device_slot_interface &slot, const emu_options &options);
-
// INI parsing helper
- static bool parse_one_ini(emu_options &options, const char *basename, int priority, std::string *error_string = nullptr);
-
- // softlist handling
- static std::map<std::string, std::string> evaluate_initial_softlist_options(emu_options &options);
-
- // represents an "invalid" value (an empty string is valid so we can't use that; what I
- // really want to return is std::optional<std::string> but C++17 isn't here yet)
- static std::string value_specifier_invalid_value() { return std::string("\x01\x02\x03"); }
-
- static int m_slot_options;
- static int m_device_options;
+ static void parse_one_ini(emu_options &options, const char *basename, int priority, std::ostream *error_stream = nullptr);
};
#endif /* __MAMEOPTS_H__ */
diff --git a/src/frontend/mame/pluginopts.cpp b/src/frontend/mame/pluginopts.cpp
index 779ac6ff709..b9a9e8d3c3b 100644
--- a/src/frontend/mame/pluginopts.cpp
+++ b/src/frontend/mame/pluginopts.cpp
@@ -75,7 +75,7 @@ void plugin_options::parse_json(std::string path)
if (type=="plugin")
{
- add_entry(core_strdup(plugin_name.c_str()),core_strdup(description.c_str()), OPTION_BOOLEAN, start ? "1" : "0");
+ add_entry({ std::move(plugin_name) }, core_strdup(description.c_str()), option_type::BOOLEAN, start ? "1" : "0");
}
}
diff --git a/src/frontend/mame/ui/custui.cpp b/src/frontend/mame/ui/custui.cpp
index 17a5c22539b..438840f0fc0 100644
--- a/src/frontend/mame/ui/custui.cpp
+++ b/src/frontend/mame/ui/custui.cpp
@@ -64,12 +64,10 @@ menu_custom_ui::menu_custom_ui(mame_ui_manager &mui, render_container &container
menu_custom_ui::~menu_custom_ui()
{
- std::string error_string;
- ui().options().set_value(OPTION_HIDE_PANELS, ui_globals::panels_status, OPTION_PRIORITY_CMDLINE, error_string);
+ ui().options().set_value(OPTION_HIDE_PANELS, ui_globals::panels_status, OPTION_PRIORITY_CMDLINE);
if (!m_lang.empty())
{
- machine().options().set_value(OPTION_LANGUAGE, m_lang[m_currlang].c_str(), OPTION_PRIORITY_CMDLINE, error_string);
- machine().options().mark_changed(OPTION_LANGUAGE);
+ machine().options().set_value(OPTION_LANGUAGE, m_lang[m_currlang].c_str(), OPTION_PRIORITY_CMDLINE);
load_translation(machine().options());
}
ui_globals::reset = true;
@@ -215,22 +213,10 @@ menu_font_ui::menu_font_ui(mame_ui_manager &mui, render_container &container) :
m_info_size = moptions.infos_size();
m_font_size = moptions.font_rows();
-
- for (ui_options::entry &f_entry : moptions)
- {
- const char *entry_name = f_entry.name();
- if (entry_name && strlen(entry_name) && !strcmp(OPTION_INFOS_SIZE, f_entry.name()))
- {
- m_info_max = atof(f_entry.maximum());
- m_info_min = atof(f_entry.minimum());
- }
- else if (entry_name && strlen(entry_name) && !strcmp(OPTION_FONT_ROWS, f_entry.name()))
- {
- m_font_max = atof(f_entry.maximum());
- m_font_min = atof(f_entry.minimum());
- }
- }
-
+ m_info_max = atof(moptions.get_entry(OPTION_INFOS_SIZE)->maximum());
+ m_info_min = atof(moptions.get_entry(OPTION_INFOS_SIZE)->minimum());
+ m_font_max = atof(moptions.get_entry(OPTION_FONT_ROWS)->maximum());
+ m_font_max = atof(moptions.get_entry(OPTION_FONT_ROWS)->minimum());
}
//-------------------------------------------------
@@ -264,11 +250,9 @@ menu_font_ui::~menu_font_ui()
name.insert(0, "[B]");
}
#endif
- machine().options().set_value(OPTION_UI_FONT, name.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
- machine().options().mark_changed(OPTION_UI_FONT);
-
- moptions.set_value(OPTION_INFOS_SIZE, m_info_size, OPTION_PRIORITY_CMDLINE, error_string);
- moptions.set_value(OPTION_FONT_ROWS, m_font_size, OPTION_PRIORITY_CMDLINE, error_string);
+ machine().options().set_value(OPTION_UI_FONT, name, OPTION_PRIORITY_CMDLINE);
+ moptions.set_value(OPTION_INFOS_SIZE, m_info_size, OPTION_PRIORITY_CMDLINE);
+ moptions.set_value(OPTION_FONT_ROWS, m_font_size, OPTION_PRIORITY_CMDLINE);
}
//-------------------------------------------------
@@ -463,11 +447,11 @@ menu_colors_ui::menu_colors_ui(mame_ui_manager &mui, render_container &container
menu_colors_ui::~menu_colors_ui()
{
- std::string error_string, dec_color;
+ std::string dec_color;
for (int index = 1; index < MUI_RESTORE; index++)
{
dec_color = string_format("%x", (uint32_t)m_color_table[index].color);
- ui().options().set_value(m_color_table[index].option, dec_color.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
+ ui().options().set_value(m_color_table[index].option, dec_color.c_str(), OPTION_PRIORITY_CMDLINE);
}
}
diff --git a/src/frontend/mame/ui/dirmenu.cpp b/src/frontend/mame/ui/dirmenu.cpp
index 1ef39925bfd..2d0200ef099 100644
--- a/src/frontend/mame/ui/dirmenu.cpp
+++ b/src/frontend/mame/ui/dirmenu.cpp
@@ -352,11 +352,10 @@ void menu_add_change_folder::handle()
if (m_change)
{
if (ui().options().exists(s_folders[m_ref].option))
- ui().options().set_value(s_folders[m_ref].option, m_current_path.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
+ ui().options().set_value(s_folders[m_ref].option, m_current_path.c_str(), OPTION_PRIORITY_CMDLINE);
else if (strcmp(machine().options().value(s_folders[m_ref].option), m_current_path.c_str()) != 0)
{
- machine().options().set_value(s_folders[m_ref].option, m_current_path.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
- machine().options().mark_changed(s_folders[m_ref].option);
+ machine().options().set_value(s_folders[m_ref].option, m_current_path.c_str(), OPTION_PRIORITY_CMDLINE);
}
}
else
@@ -371,11 +370,10 @@ void menu_add_change_folder::handle()
}
if (ui().options().exists(s_folders[m_ref].option))
- ui().options().set_value(s_folders[m_ref].option, tmppath.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
+ ui().options().set_value(s_folders[m_ref].option, tmppath.c_str(), OPTION_PRIORITY_CMDLINE);
else if (strcmp(machine().options().value(s_folders[m_ref].option), tmppath.c_str()) != 0)
{
- machine().options().set_value(s_folders[m_ref].option, tmppath.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
- machine().options().mark_changed(s_folders[m_ref].option);
+ machine().options().set_value(s_folders[m_ref].option, tmppath.c_str(), OPTION_PRIORITY_CMDLINE);
}
}
@@ -592,11 +590,10 @@ void menu_remove_folder::handle()
}
if (ui().options().exists(s_folders[m_ref].option))
- ui().options().set_value(s_folders[m_ref].option, tmppath.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
+ ui().options().set_value(s_folders[m_ref].option, tmppath.c_str(), OPTION_PRIORITY_CMDLINE);
else if (strcmp(machine().options().value(s_folders[m_ref].option),tmppath.c_str())!=0)
{
- machine().options().set_value(s_folders[m_ref].option, tmppath.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
- machine().options().mark_changed(s_folders[m_ref].option);
+ machine().options().set_value(s_folders[m_ref].option, tmppath.c_str(), OPTION_PRIORITY_CMDLINE);
}
reset_parent(reset_options::REMEMBER_REF);
diff --git a/src/frontend/mame/ui/info.cpp b/src/frontend/mame/ui/info.cpp
index 8101faad3c6..ab0e6d85cd3 100644
--- a/src/frontend/mame/ui/info.cpp
+++ b/src/frontend/mame/ui/info.cpp
@@ -326,8 +326,7 @@ std::string machine_info::mandatory_images()
{
if (image.must_be_loaded())
{
- auto iter = m_machine.options().image_options().find(image.instance_name());
- if (iter == m_machine.options().image_options().end() || iter->second.empty())
+ if (m_machine.options().image_option(image.instance_name()).value().empty())
{
if (is_first)
is_first = false;
diff --git a/src/frontend/mame/ui/miscmenu.cpp b/src/frontend/mame/ui/miscmenu.cpp
index 3ec2bf78cd3..66201951a91 100644
--- a/src/frontend/mame/ui/miscmenu.cpp
+++ b/src/frontend/mame/ui/miscmenu.cpp
@@ -127,12 +127,10 @@ void menu_bios_selection::handle()
if (val>cnt) val=1;
dev->set_system_bios(val);
if (strcmp(dev->tag(),":")==0) {
- std::string error;
- machine().options().set_value("bios", val-1, OPTION_PRIORITY_CMDLINE, error);
- assert(error.empty());
+ machine().options().set_value("bios", val-1, OPTION_PRIORITY_CMDLINE);
} else {
const char *slot_option_name = dev->owner()->tag() + 1;
- machine().options().slot_options()[slot_option_name].set_bios(string_format("%d", val - 1));
+ machine().options().slot_option(slot_option_name).set_bios(string_format("%d", val - 1));
}
reset(reset_options::REMEMBER_REF);
}
@@ -675,15 +673,14 @@ void menu_export::populate(float &customtop, float &custombottom)
menu_machine_configure::menu_machine_configure(mame_ui_manager &mui, render_container &container, const game_driver *prev, float _x0, float _y0)
: menu(mui, container)
, m_drv(prev)
- , m_opts(mui.machine().options())
, x0(_x0)
, y0(_y0)
, m_curbios(0)
, m_fav_reset(false)
{
// parse the INI file
- std::string error;
- mame_options::parse_standard_inis(m_opts,error, m_drv);
+ std::ostringstream error;
+ mame_options::parse_standard_inis(m_opts, error, m_drv);
setup_bios();
}
@@ -754,9 +751,7 @@ void menu_machine_configure::handle()
else if (menu_event->iptkey == IPT_UI_LEFT || menu_event->iptkey == IPT_UI_RIGHT)
{
(menu_event->iptkey == IPT_UI_LEFT) ? --m_curbios : ++m_curbios;
- std::string error;
- m_opts.set_value(OPTION_BIOS, m_bios[m_curbios].second, OPTION_PRIORITY_CMDLINE, error);
- m_opts.mark_changed(OPTION_BIOS);
+ m_opts.set_value(OPTION_BIOS, m_bios[m_curbios].second, OPTION_PRIORITY_CMDLINE);
reset(reset_options::REMEMBER_POSITION);
}
}
@@ -918,8 +913,7 @@ void menu_plugins_configure::handle()
if (menu_event->iptkey == IPT_UI_LEFT || menu_event->iptkey == IPT_UI_RIGHT || menu_event->iptkey == IPT_UI_SELECT)
{
int oldval = plugins.int_value((const char*)menu_event->itemref);
- std::string error_string;
- plugins.set_value((const char*)menu_event->itemref, oldval == 1 ? 0 : 1, OPTION_PRIORITY_CMDLINE, error_string);
+ plugins.set_value((const char*)menu_event->itemref, oldval == 1 ? 0 : 1, OPTION_PRIORITY_CMDLINE);
changed = true;
}
}
@@ -935,13 +929,13 @@ void menu_plugins_configure::populate(float &customtop, float &custombottom)
{
plugin_options& plugins = mame_machine_manager::instance()->plugins();
- for (auto &curentry : plugins)
+ for (auto &curentry : plugins.entries())
{
- if (!curentry.is_header())
+ if (curentry->type() != OPTION_HEADER)
{
- auto enabled = std::string(curentry.value()) == "1";
- item_append(curentry.description(), enabled ? _("On") : _("Off"),
- enabled ? FLAG_RIGHT_ARROW : FLAG_LEFT_ARROW, (void *)(uintptr_t)curentry.name());
+ auto enabled = !strcmp(curentry->value(), "1");
+ item_append(curentry->description(), enabled ? _("On") : _("Off"),
+ enabled ? FLAG_RIGHT_ARROW : FLAG_LEFT_ARROW, (void *)(uintptr_t)curentry->name().c_str());
}
}
item_append(menu_item_type::SEPARATOR);
diff --git a/src/frontend/mame/ui/selgame.cpp b/src/frontend/mame/ui/selgame.cpp
index e2628f63a9b..04d1c2b2350 100644
--- a/src/frontend/mame/ui/selgame.cpp
+++ b/src/frontend/mame/ui/selgame.cpp
@@ -116,8 +116,7 @@ menu_select_game::menu_select_game(mame_ui_manager &mui, render_container &conta
if (!moptions.remember_last())
reselect_last::reset();
- mui.machine().options().set_value(OPTION_SNAPNAME, "%g/%i", OPTION_PRIORITY_CMDLINE, error_string);
- mui.machine().options().set_value(OPTION_SOFTWARENAME, "", OPTION_PRIORITY_CMDLINE, error_string);
+ mui.machine().options().set_value(OPTION_SNAPNAME, "%g/%i", OPTION_PRIORITY_CMDLINE);
ui_globals::curimage_view = FIRST_VIEW;
ui_globals::curdats_view = 0;
@@ -155,9 +154,9 @@ menu_select_game::~menu_select_game()
filter.append(",").append(c_year::ui[c_year::actual]);
ui_options &mopt = ui().options();
- mopt.set_value(OPTION_LAST_USED_FILTER, filter.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
- mopt.set_value(OPTION_LAST_USED_MACHINE, last_driver.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
- mopt.set_value(OPTION_HIDE_PANELS, ui_globals::panels_status, OPTION_PRIORITY_CMDLINE, error_string);
+ mopt.set_value(OPTION_LAST_USED_FILTER, filter.c_str(), OPTION_PRIORITY_CMDLINE);
+ mopt.set_value(OPTION_LAST_USED_MACHINE, last_driver.c_str(), OPTION_PRIORITY_CMDLINE);
+ mopt.set_value(OPTION_HIDE_PANELS, ui_globals::panels_status, OPTION_PRIORITY_CMDLINE);
ui().save_ui_options();
}
@@ -930,11 +929,10 @@ void menu_select_game::inkey_select_favorite(const event *menu_event)
return;
}
- std::string error_string;
std::string string_list = std::string(ui_swinfo->listname).append(":").append(ui_swinfo->shortname).append(":").append(ui_swinfo->part).append(":").append(ui_swinfo->instance);
- mopt.set_value(OPTION_SOFTWARENAME, string_list.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
+ mopt.set_value(OPTION_SOFTWARENAME, string_list.c_str(), OPTION_PRIORITY_CMDLINE);
std::string snap_list = std::string(ui_swinfo->listname).append(PATH_SEPARATOR).append(ui_swinfo->shortname);
- mopt.set_value(OPTION_SNAPNAME, snap_list.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
+ mopt.set_value(OPTION_SNAPNAME, snap_list.c_str(), OPTION_PRIORITY_CMDLINE);
reselect_last::driver = drv.driver().name;
reselect_last::software = ui_swinfo->shortname;
reselect_last::swlist = ui_swinfo->listname;
diff --git a/src/frontend/mame/ui/selsoft.cpp b/src/frontend/mame/ui/selsoft.cpp
index b5eeb36b204..23107e4d992 100644
--- a/src/frontend/mame/ui/selsoft.cpp
+++ b/src/frontend/mame/ui/selsoft.cpp
@@ -144,9 +144,6 @@ menu_select_software::menu_select_software(mame_ui_manager &mui, render_containe
ui_globals::switch_image = true;
ui_globals::cur_sw_dats_view = 0;
ui_globals::cur_sw_dats_total = 1;
-
- std::string error_string;
- mui.machine().options().set_value(OPTION_SOFTWARENAME, "", OPTION_PRIORITY_CMDLINE, error_string);
}
//-------------------------------------------------
@@ -718,11 +715,10 @@ void menu_select_software::inkey_select(const event *menu_event)
return;
}
- std::string error_string;
- std::string string_list = std::string(ui_swinfo->listname).append(":").append(ui_swinfo->shortname).append(":").append(ui_swinfo->part).append(":").append(ui_swinfo->instance);
- machine().options().set_value(OPTION_SOFTWARENAME, string_list.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
+ machine().options().set_system_name(m_driver->name);
+ machine().options().set_value(OPTION_SOFTWARENAME, ui_swinfo->shortname, OPTION_PRIORITY_CMDLINE);
std::string snap_list = std::string(ui_swinfo->listname).append(PATH_SEPARATOR).append(ui_swinfo->shortname);
- machine().options().set_value(OPTION_SNAPNAME, snap_list.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
+ machine().options().set_value(OPTION_SNAPNAME, snap_list.c_str(), OPTION_PRIORITY_CMDLINE);
reselect_last::driver = drivlist.driver().name;
reselect_last::software = ui_swinfo->shortname;
reselect_last::swlist = ui_swinfo->listname;
@@ -1288,9 +1284,8 @@ void software_parts::handle()
{
if ((void*)&elem == menu_event->itemref)
{
- std::string error_string;
std::string string_list = std::string(m_uiinfo->listname).append(":").append(m_uiinfo->shortname).append(":").append(elem.first).append(":").append(m_uiinfo->instance);
- machine().options().set_value(OPTION_SOFTWARENAME, string_list.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
+ machine().options().set_value(OPTION_SOFTWARENAME, string_list.c_str(), OPTION_PRIORITY_CMDLINE);
reselect_last::driver = m_uiinfo->driver->name;
reselect_last::software = m_uiinfo->shortname;
@@ -1298,7 +1293,7 @@ void software_parts::handle()
reselect_last::set(true);
std::string snap_list = std::string(m_uiinfo->listname).append("/").append(m_uiinfo->shortname);
- machine().options().set_value(OPTION_SNAPNAME, snap_list.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
+ machine().options().set_value(OPTION_SNAPNAME, snap_list.c_str(), OPTION_PRIORITY_CMDLINE);
mame_machine_manager::instance()->schedule_new_driver(*m_uiinfo->driver);
machine().schedule_hard_reset();
@@ -1400,8 +1395,7 @@ void bios_selection::handle()
reselect_last::set(true);
}
- std::string error;
- moptions.set_value(OPTION_BIOS, elem.second, OPTION_PRIORITY_CMDLINE, error);
+ moptions.set_value(OPTION_BIOS, elem.second, OPTION_PRIORITY_CMDLINE);
mame_machine_manager::instance()->schedule_new_driver(*s_driver);
machine().schedule_hard_reset();
stack_reset();
@@ -1409,8 +1403,7 @@ void bios_selection::handle()
else
{
ui_software_info *ui_swinfo = (ui_software_info *)m_driver;
- std::string error;
- machine().options().set_value(OPTION_BIOS, elem.second, OPTION_PRIORITY_CMDLINE, error);
+ machine().options().set_value(OPTION_BIOS, elem.second, OPTION_PRIORITY_CMDLINE);
driver_enumerator drivlist(machine().options(), *ui_swinfo->driver);
drivlist.next();
software_list_device *swlist = software_list_device::find_by_name(*drivlist.config(), ui_swinfo->listname.c_str());
@@ -1431,11 +1424,10 @@ void bios_selection::handle()
menu::stack_push<software_parts>(ui(), container(), parts, ui_swinfo);
return;
}
- std::string error_string;
std::string string_list = std::string(ui_swinfo->listname).append(":").append(ui_swinfo->shortname).append(":").append(ui_swinfo->part).append(":").append(ui_swinfo->instance);
- moptions.set_value(OPTION_SOFTWARENAME, string_list.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
+ moptions.set_value(OPTION_SOFTWARENAME, string_list.c_str(), OPTION_PRIORITY_CMDLINE);
std::string snap_list = std::string(ui_swinfo->listname).append(PATH_SEPARATOR).append(ui_swinfo->shortname);
- moptions.set_value(OPTION_SNAPNAME, snap_list.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
+ moptions.set_value(OPTION_SNAPNAME, snap_list.c_str(), OPTION_PRIORITY_CMDLINE);
reselect_last::driver = drivlist.driver().name;
reselect_last::software = ui_swinfo->shortname;
reselect_last::swlist = ui_swinfo->listname;
diff --git a/src/frontend/mame/ui/slotopt.cpp b/src/frontend/mame/ui/slotopt.cpp
index 42ec9e1a896..8434a667899 100644
--- a/src/frontend/mame/ui/slotopt.cpp
+++ b/src/frontend/mame/ui/slotopt.cpp
@@ -27,9 +27,9 @@ device_slot_option *menu_slot_devices::slot_get_current_option(device_slot_inter
std::string current;
const char *slot_option_name = slot.device().tag() + 1;
- if (!slot.fixed() && machine().options().slot_options().count(slot_option_name) > 0)
+ if (!slot.fixed())
{
- current = machine().options().slot_options()[slot_option_name].value();
+ current = machine().options().slot_option(slot_option_name).value();
}
else
{
@@ -140,9 +140,7 @@ const char *menu_slot_devices::slot_get_option(device_slot_interface &slot, int
void menu_slot_devices::set_slot_device(device_slot_interface &slot, const char *val)
{
- std::string error;
- machine().options().set_value(slot.device().tag()+1, val, OPTION_PRIORITY_CMDLINE, error);
- assert(error.empty());
+ machine().options().set_value(slot.device().tag()+1, val, OPTION_PRIORITY_CMDLINE);
}
/*-------------------------------------------------
@@ -200,7 +198,6 @@ void menu_slot_devices::handle()
{
if ((uintptr_t)menu_event->itemref == 1 && menu_event->iptkey == IPT_UI_SELECT)
{
- mame_options::add_slot_options(machine().options());
machine().schedule_hard_reset();
}
else if (menu_event->iptkey == IPT_UI_LEFT || menu_event->iptkey == IPT_UI_RIGHT)
diff --git a/src/frontend/mame/ui/sndmenu.cpp b/src/frontend/mame/ui/sndmenu.cpp
index 0a0d1c019ed..f2304b529ea 100644
--- a/src/frontend/mame/ui/sndmenu.cpp
+++ b/src/frontend/mame/ui/sndmenu.cpp
@@ -45,23 +45,19 @@ menu_sound_options::menu_sound_options(mame_ui_manager &mui, render_container &c
menu_sound_options::~menu_sound_options()
{
- std::string error_string;
emu_options &moptions = machine().options();
if (strcmp(moptions.value(OSDOPTION_SOUND),m_sound ? OSDOPTVAL_AUTO : OSDOPTVAL_NONE)!=0)
{
- moptions.set_value(OSDOPTION_SOUND, m_sound ? OSDOPTVAL_AUTO : OSDOPTVAL_NONE, OPTION_PRIORITY_CMDLINE, error_string);
- machine().options().mark_changed(OSDOPTION_SOUND);
+ moptions.set_value(OSDOPTION_SOUND, m_sound ? OSDOPTVAL_AUTO : OSDOPTVAL_NONE, OPTION_PRIORITY_CMDLINE);
}
if (moptions.int_value(OPTION_SAMPLERATE)!=m_sound_rate[m_cur_rates])
{
- moptions.set_value(OPTION_SAMPLERATE, m_sound_rate[m_cur_rates], OPTION_PRIORITY_CMDLINE, error_string);
- machine().options().mark_changed(OPTION_SAMPLERATE);
+ moptions.set_value(OPTION_SAMPLERATE, m_sound_rate[m_cur_rates], OPTION_PRIORITY_CMDLINE);
}
if (moptions.bool_value(OPTION_SAMPLES)!=m_samples)
{
- moptions.set_value(OPTION_SAMPLES, m_samples, OPTION_PRIORITY_CMDLINE, error_string);
- machine().options().mark_changed(OPTION_SAMPLES);
+ moptions.set_value(OPTION_SAMPLES, m_samples, OPTION_PRIORITY_CMDLINE);
}
}
diff --git a/src/frontend/mame/ui/submenu.cpp b/src/frontend/mame/ui/submenu.cpp
index 5a8cb83cd8b..ab18a5a5a95 100644
--- a/src/frontend/mame/ui/submenu.cpp
+++ b/src/frontend/mame/ui/submenu.cpp
@@ -240,8 +240,7 @@ void submenu::handle()
{
case OPTION_BOOLEAN:
changed = true;
- sm_option.options->set_value(sm_option.name, !strcmp(sm_option.entry->value(),"1") ? "0" : "1", OPTION_PRIORITY_CMDLINE, error_string);
- sm_option.entry->mark_changed();
+ sm_option.options->set_value(sm_option.name, !strcmp(sm_option.entry->value(),"1") ? "0" : "1", OPTION_PRIORITY_CMDLINE);
break;
case OPTION_INTEGER:
if (menu_event->iptkey == IPT_UI_LEFT || menu_event->iptkey == IPT_UI_RIGHT)
@@ -249,8 +248,7 @@ void submenu::handle()
changed = true;
int i_cur = atoi(sm_option.entry->value());
(menu_event->iptkey == IPT_UI_LEFT) ? i_cur-- : i_cur++;
- sm_option.options->set_value(sm_option.name, i_cur, OPTION_PRIORITY_CMDLINE, error_string);
- sm_option.entry->mark_changed();
+ sm_option.options->set_value(sm_option.name, i_cur, OPTION_PRIORITY_CMDLINE);
}
break;
case OPTION_FLOAT:
@@ -260,17 +258,19 @@ void submenu::handle()
f_cur = atof(sm_option.entry->value());
if (sm_option.entry->has_range())
{
- f_step = atof(sm_option.entry->minimum());
+ const char *minimum = sm_option.entry->minimum();
+ const char *maximum = sm_option.entry->maximum();
+ f_step = atof(minimum);
if (f_step <= 0.0f) {
- int pmin = getprecisionchr(sm_option.entry->minimum());
- int pmax = getprecisionchr(sm_option.entry->maximum());
+ int pmin = getprecisionchr(minimum);
+ int pmax = getprecisionchr(maximum);
tmptxt = '1' + std::string((pmin > pmax) ? pmin : pmax, '0');
f_step = 1 / atof(tmptxt.c_str());
}
}
else
{
- int precision = getprecisionchr(sm_option.entry->default_value());
+ int precision = getprecisionchr(sm_option.entry->default_value().c_str());
tmptxt = '1' + std::string(precision, '0');
f_step = 1 / atof(tmptxt.c_str());
}
@@ -279,8 +279,7 @@ void submenu::handle()
else
f_cur += f_step;
tmptxt = string_format("%g", f_cur);
- sm_option.options->set_value(sm_option.name, tmptxt.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
- sm_option.entry->mark_changed();
+ sm_option.options->set_value(sm_option.name, tmptxt.c_str(), OPTION_PRIORITY_CMDLINE);
}
break;
case OPTION_STRING:
@@ -293,10 +292,11 @@ void submenu::handle()
v_cur = sm_option.value[--cur_value];
else
v_cur = sm_option.value[++cur_value];
- sm_option.options->set_value(sm_option.name, v_cur.c_str(), OPTION_PRIORITY_CMDLINE, error_string);
- sm_option.entry->mark_changed();
+ sm_option.options->set_value(sm_option.name, v_cur.c_str(), OPTION_PRIORITY_CMDLINE);
}
break;
+ default:
+ break;
}
break;
default:
@@ -391,7 +391,7 @@ void submenu::populate(float &customtop, float &custombottom)
break;
case OPTION_STRING:
{
- std::string const v_cur(sm_option->entry->value());
+ std::string v_cur(sm_option->entry->value());
int const cur_value = std::distance(sm_option->value.begin(), std::find(sm_option->value.begin(), sm_option->value.end(), v_cur));
arrow_flags = get_arrow_flags(0, int(unsigned(sm_option->value.size() - 1)), cur_value);
item_append(_(sm_option->description),
diff --git a/src/frontend/mame/ui/submenu.h b/src/frontend/mame/ui/submenu.h
index acaf28d90e4..f17b6fe53ff 100644
--- a/src/frontend/mame/ui/submenu.h
+++ b/src/frontend/mame/ui/submenu.h
@@ -48,7 +48,7 @@ public:
option_type type;
const char *description;
const char *name;
- core_options::entry *entry;
+ core_options::entry::shared_ptr entry;
core_options *options;
std::vector<std::string> value;
};
diff --git a/src/frontend/mame/ui/ui.cpp b/src/frontend/mame/ui/ui.cpp
index cf4ea2c9cc5..fc080835893 100644
--- a/src/frontend/mame/ui/ui.cpp
+++ b/src/frontend/mame/ui/ui.cpp
@@ -2228,14 +2228,18 @@ void mame_ui_manager::popup_time_string(int seconds, std::string message)
void mame_ui_manager::load_ui_options()
{
// parse the file
- std::string error;
// attempt to open the output file
emu_file file(machine().options().ini_path(), OPEN_FLAG_READ);
if (file.open("ui.ini") == osd_file::error::NONE)
{
- bool result = options().parse_ini_file((util::core_file&)file, OPTION_PRIORITY_MAME_INI, OPTION_PRIORITY_DRIVER_INI, error);
- if (!result)
+ try
+ {
+ options().parse_ini_file((util::core_file&)file, OPTION_PRIORITY_MAME_INI, true);
+ }
+ catch (options_exception &)
+ {
osd_printf_error("**Error loading ui.ini**");
+ }
}
}
@@ -2266,28 +2270,37 @@ void mame_ui_manager::save_main_option()
{
// parse the file
std::string error;
- emu_options options(machine().options()); // This way we make sure that all OSD parts are in
- std::string error_string;
+ emu_options options(true); // This way we make sure that all OSD parts are in
+
+ options.copy_from(machine().options());
// attempt to open the main ini file
{
emu_file file(machine().options().ini_path(), OPEN_FLAG_READ);
if (file.open(emulator_info::get_configname(), ".ini") == osd_file::error::NONE)
{
- bool result = options.parse_ini_file((util::core_file&)file, OPTION_PRIORITY_MAME_INI, OPTION_PRIORITY_DRIVER_INI, error);
- if (!result)
+ try
+ {
+ options.parse_ini_file((util::core_file&)file, OPTION_PRIORITY_MAME_INI, true);
+ }
+ catch(options_error_exception &ex)
{
- osd_printf_error("**Error loading %s.ini**", emulator_info::get_configname());
+ osd_printf_error("**Error loading %s.ini**: %s\n", emulator_info::get_configname(), ex.message().c_str());
return;
}
+ catch (options_exception &)
+ {
+ // ignore other exceptions
+ }
}
}
- for (emu_options::entry &f_entry : machine().options())
+ for (const auto &f_entry : machine().options().entries())
{
- if (f_entry.is_changed())
+ const char *value = f_entry->value();
+ if (value && strcmp(value, options.value(f_entry->name().c_str())))
{
- options.set_value(f_entry.name(), f_entry.value(), OPTION_PRIORITY_CMDLINE, error_string);
+ options.set_value(f_entry->name(), *f_entry->value(), OPTION_PRIORITY_CMDLINE);
}
}
diff --git a/src/lib/util/options.cpp b/src/lib/util/options.cpp
index 8500eda327d..8889107eba1 100644
--- a/src/lib/util/options.cpp
+++ b/src/lib/util/options.cpp
@@ -2,7 +2,7 @@
// copyright-holders:Aaron Giles
/***************************************************************************
- options.c
+ options.cpp
Core options code code
@@ -44,244 +44,482 @@ const char *const core_options::s_option_unadorned[MAX_UNADORNED_OPTIONS] =
};
+//**************************************************************************
+// OPTIONS EXCEPTION CLASS
+//**************************************************************************
+
+//-------------------------------------------------
+// options_exception - constructor
+//-------------------------------------------------
+
+options_exception::options_exception(std::string &&message)
+ : m_message(std::move(message))
+{
+}
+
+
+//-------------------------------------------------
+// options_warning_exception - constructor
+//-------------------------------------------------
+
+options_warning_exception::options_warning_exception(std::string &&message)
+ : options_exception(std::move(message))
+{
+}
+
+
+//-------------------------------------------------
+// options_error_exception - constructor
+//-------------------------------------------------
+
+options_error_exception::options_error_exception(std::string &&message)
+ : options_exception(std::move(message))
+{
+}
+
//**************************************************************************
-// CORE OPTIONS ENTRY
+// CORE OPTIONS ENTRY BASE CLASS
//**************************************************************************
//-------------------------------------------------
// entry - constructor
//-------------------------------------------------
-core_options::entry::entry(const char *name, const char *description, uint32_t flags, const char *defvalue)
- : m_next(nullptr),
- m_flags(flags),
- m_error_reported(false),
- m_priority(OPTION_PRIORITY_DEFAULT),
- m_description(description),
- m_changed(false)
+core_options::entry::entry(std::vector<std::string> &&names, core_options::option_type type, const char *description)
+ : m_names(std::move(names))
+ , m_priority(OPTION_PRIORITY_DEFAULT)
+ , m_type(type)
+ , m_description(description)
{
- // copy in the name(s) as appropriate
- if (name != nullptr)
+ if (type == option_type::HEADER)
+ assert(m_names.size() == 0);
+ else
+ assert(m_names.size() > 0);
+}
+
+core_options::entry::entry(std::string &&name, core_options::option_type type, const char *description)
+ : entry(std::vector<std::string>({ std::move(name) }), type, description)
+{
+}
+
+
+//-------------------------------------------------
+// entry - destructor
+//-------------------------------------------------
+
+core_options::entry::~entry()
+{
+}
+
+
+//-------------------------------------------------
+// entry::value
+//-------------------------------------------------
+
+const char *core_options::entry::value() const
+{
+ // returning 'nullptr' from here signifies a value entry that is essentially "write only"
+ // and cannot be meaningfully persisted (e.g. - a command or the software name)
+ return nullptr;
+}
+
+
+//-------------------------------------------------
+// entry::set_value
+//-------------------------------------------------
+
+void core_options::entry::set_value(std::string &&newvalue, int priority_value, bool always_override)
+{
+ // it is invalid to set the value on a header
+ assert(type() != option_type::HEADER);
+
+ // only set the value if we have priority
+ if (always_override || priority_value >= priority())
{
- // first extract any range
- std::string namestr(name);
- int lparen = namestr.find_first_of('(',0);
- int dash = namestr.find_first_of('-',lparen + 1);
- int rparen = namestr.find_first_of(')',dash + 1);
- if (lparen != -1 && dash != -1 && rparen != -1)
+ internal_set_value(std::move(newvalue));
+ m_priority = priority_value;
+
+ // invoke the value changed handler, if appropriate
+ if (m_value_changed_handler)
+ m_value_changed_handler(value());
+ }
+}
+
+
+//-------------------------------------------------
+// entry::set_default_value
+//-------------------------------------------------
+
+void core_options::entry::set_default_value(std::string &&newvalue)
+{
+ // set_default_value() is not necessarily supported for all entry types
+ throw false;
+}
+
+
+//-------------------------------------------------
+// entry::validate
+//-------------------------------------------------
+
+void core_options::entry::validate(const std::string &data)
+{
+ float fval;
+ int ival;
+ int minimum_integer, maximum_integer;
+ float minimum_float, maximum_float;
+
+ switch (type())
+ {
+ case option_type::BOOLEAN:
+ // booleans must be 0 or 1
+ if (sscanf(data.c_str(), "%d", &ival) != 1 || ival < 0 || ival > 1)
+ throw options_warning_exception("Illegal boolean value for %s: \"%s\"; reverting to %s\n", name(), data, value());
+ break;
+
+ case option_type::INTEGER:
+ // integers must be integral
+ if (sscanf(data.c_str(), "%d", &ival) != 1)
+ throw options_warning_exception("Illegal integer value for %s: \"%s\"; reverting to %s\n", name(), data, value());
+
+ // range checking
+ if (has_range())
{
- strtrimspace(m_minimum.assign(namestr.substr(lparen + 1, dash - (lparen + 1))));
- strtrimspace(m_maximum.assign(namestr.substr(dash + 1, rparen - (dash + 1))));
- namestr.erase(lparen, rparen + 1 - lparen);
+ minimum_integer = atoi(minimum());
+ maximum_integer = atoi(maximum());
+ if (ival < minimum_integer || ival > maximum_integer)
+ throw options_warning_exception("Out-of-range integer value for %s: \"%s\" (must be between %d and %d); reverting to %s\n", name(), data, minimum_integer, maximum_integer, value());
}
+ break;
- // then chop up any semicolon-separated names
- int semi;
- int nameindex = 0;
- while ((semi = namestr.find_first_of(';')) != -1 && nameindex < ARRAY_LENGTH(m_name))
+ case option_type::FLOAT:
+ if (sscanf(data.c_str(), "%f", &fval) != 1)
+ throw options_warning_exception("Illegal float value for %s: \"%s\"; reverting to %s\n", name(), data, value());
+
+ // range checking
+ if (has_range())
{
- m_name[nameindex++].assign(namestr.substr(0, semi));
- namestr.erase(0, semi + 1);
+ minimum_float = atof(minimum());
+ maximum_float = atof(maximum());
+ if (fval < minimum_float || fval > maximum_float)
+ throw options_warning_exception("Out-of-range float value for %s: \"%s\" (must be between %f and %f); reverting to %s\n", name(), data, minimum_float, maximum_float, value());
}
+ break;
- // finally add the last item
- if (nameindex < ARRAY_LENGTH(m_name))
- m_name[nameindex++] = namestr;
+ case OPTION_STRING:
+ // strings can be anything
+ break;
+
+ case OPTION_INVALID:
+ case OPTION_HEADER:
+ default:
+ // anything else is invalid
+ throw options_error_exception("Attempted to set invalid option %s\n", name());
}
+}
- // set the default value
- if (defvalue != nullptr)
- m_defdata = defvalue;
- m_data = m_defdata;
+
+//-------------------------------------------------
+// entry::minimum
+//-------------------------------------------------
+
+const char *core_options::entry::minimum() const
+{
+ return nullptr;
}
//-------------------------------------------------
-// set_value - update our data value
+// entry::maximum
//-------------------------------------------------
-void core_options::entry::set_value(const char *newdata, int priority)
+const char *core_options::entry::maximum() const
{
- // ignore if we don't have priority
- if (priority < m_priority)
- return;
+ return nullptr;
+}
+
+
+//-------------------------------------------------
+// entry::has_range
+//-------------------------------------------------
- // set the data and priority, then bump the sequence
- m_data = newdata;
- m_priority = priority;
+bool core_options::entry::has_range() const
+{
+ return minimum() && maximum();
}
//-------------------------------------------------
-// set_default_value - set the default value of
-// an option, and reset the current value to it
+// entry::default_value
//-------------------------------------------------
-void core_options::entry::set_default_value(const char *defvalue)
+const std::string &core_options::entry::default_value() const
{
- m_data = defvalue;
- m_defdata = defvalue;
- m_priority = OPTION_PRIORITY_DEFAULT;
+ // I don't really want this generally available, but MewUI seems to need it. Please
+ // do not use
+ throw false;
}
+//**************************************************************************
+// CORE OPTIONS SIMPLE ENTRYCLASS
+//**************************************************************************
+
//-------------------------------------------------
-// set_description - set the description of
-// an option
+// simple_entry - constructor
//-------------------------------------------------
-void core_options::entry::set_description(const char *description)
+core_options::simple_entry::simple_entry(std::vector<std::string> &&names, const char *description, core_options::option_type type, std::string &&defdata, std::string &&minimum, std::string &&maximum)
+ : entry(std::move(names), type, description)
+ , m_defdata(std::move(defdata))
+ , m_minimum(std::move(minimum))
+ , m_maximum(std::move(maximum))
{
- m_description = description;
+ m_data = m_defdata;
}
-void core_options::entry::set_flag(uint32_t mask, uint32_t flag)
+//-------------------------------------------------
+// simple_entry - destructor
+//-------------------------------------------------
+
+core_options::simple_entry::~simple_entry()
{
- m_flags = ( m_flags & mask ) | flag;
}
//-------------------------------------------------
-// revert - revert back to our default if we are
-// within the given priority range
+// simple_entry::value
//-------------------------------------------------
-void core_options::entry::revert(int priority_hi, int priority_lo)
+const char *core_options::simple_entry::value() const
{
- // if our priority is within the range, revert to the default
- if (m_priority <= priority_hi && m_priority >= priority_lo)
+ const char *result;
+ switch (type())
{
- m_data = m_defdata;
- m_priority = OPTION_PRIORITY_DEFAULT;
+ case core_options::option_type::BOOLEAN:
+ case core_options::option_type::INTEGER:
+ case core_options::option_type::FLOAT:
+ case core_options::option_type::STRING:
+ result = m_data.c_str();
+ break;
+
+ default:
+ result = nullptr;
+ break;
}
+ return result;
}
-
-//**************************************************************************
-// CORE OPTIONS
-//**************************************************************************
-
//-------------------------------------------------
-// core_options - constructor
+// simple_entry::default_value
//-------------------------------------------------
-core_options::core_options()
+const std::string &core_options::simple_entry::default_value() const
{
+ // only MewUI seems to need this; please don't use
+ return m_defdata;
}
-core_options::core_options(const options_entry *entrylist)
+
+//-------------------------------------------------
+// internal_set_value
+//-------------------------------------------------
+
+void core_options::simple_entry::internal_set_value(std::string &&newvalue)
{
- add_entries(entrylist);
+ m_data = std::move(newvalue);
}
-core_options::core_options(const options_entry *entrylist1, const options_entry *entrylist2)
+
+//-------------------------------------------------
+// set_default_value
+//-------------------------------------------------
+
+void core_options::simple_entry::set_default_value(std::string &&newvalue)
{
- add_entries(entrylist1);
- add_entries(entrylist2);
+ m_defdata = std::move(newvalue);
}
-core_options::core_options(const options_entry *entrylist1, const options_entry *entrylist2, const options_entry *entrylist3)
+
+//-------------------------------------------------
+// minimum
+//-------------------------------------------------
+
+const char *core_options::simple_entry::minimum() const
{
- add_entries(entrylist1);
- add_entries(entrylist2);
- add_entries(entrylist3);
+ return m_minimum.c_str();
}
-core_options::core_options(const core_options &src)
+
+//-------------------------------------------------
+// maximum
+//-------------------------------------------------
+
+const char *core_options::simple_entry::maximum() const
{
- copyfrom(src);
+ return m_maximum.c_str();
}
+//**************************************************************************
+// CORE OPTIONS
+//**************************************************************************
+
//-------------------------------------------------
-// ~core_options - destructor
+// core_options - constructor
//-------------------------------------------------
-core_options::~core_options()
+core_options::core_options()
{
}
//-------------------------------------------------
-// operator= - assignment operator
+// ~core_options - destructor
//-------------------------------------------------
-core_options &core_options::operator=(const core_options &rhs)
+core_options::~core_options()
{
- // ignore self-assignment
- if (this != &rhs)
- copyfrom(rhs);
- return *this;
}
//-------------------------------------------------
-// operator== - compare two sets of options
+// add_entry - adds an entry
//-------------------------------------------------
-bool core_options::operator==(const core_options &rhs)
+void core_options::add_entry(entry::shared_ptr &&entry, const char *after_header)
{
- // iterate over options in the first list
- for (entry &curentry : m_entrylist)
- if (!curentry.is_header())
- {
- // if the values differ, return false
- if (strcmp(curentry.value(), rhs.value(curentry.name())) != 0)
- return false;
- }
+ // update the entry map
+ for (const std::string &name : entry->names())
+ {
+ // append the entry
+ add_to_entry_map(std::string(name), entry);
- return true;
+ // for booleans, add the "-noXYZ" option as well
+ if (entry->type() == option_type::BOOLEAN)
+ add_to_entry_map(std::string("no") + name, entry);
+ }
+
+ // and add the entry to the vector
+ m_entries.emplace_back(std::move(entry));
}
//-------------------------------------------------
-// operator!= - compare two sets of options
+// add_to_entry_map - adds an entry to the entry
+// map
//-------------------------------------------------
-bool core_options::operator!=(const core_options &rhs)
+void core_options::add_to_entry_map(std::string &&name, entry::shared_ptr &entry)
{
- return !operator==(rhs);
+ // it is illegal to call this method for something that already ex0ists
+ assert(m_entrymap.find(name) == m_entrymap.end());
+
+ // append the entry
+ m_entrymap.emplace(std::make_pair(name, entry::weak_ptr(entry)));
}
//-------------------------------------------------
-// add_entry - add an entry to the current
-// options set
+// add_entry - adds an entry based on an
+// options_entry
//-------------------------------------------------
-void core_options::add_entry(const char *name, const char *description, uint32_t flags, const char *defvalue, bool override_existing)
+void core_options::add_entry(const options_entry &opt, bool override_existing)
{
- // allocate a new entry
- auto newentry = global_alloc(entry(name, description, flags, defvalue));
- if (newentry->name() != nullptr)
+ std::vector<std::string> names;
+ std::string minimum, maximum;
+
+ // copy in the name(s) as appropriate
+ if (opt.name)
{
- // see if we match an existing entry
- auto checkentry = m_entrymap.find(newentry->name());
- if (checkentry != m_entrymap.end())
+ // first extract any range
+ std::string namestr(opt.name);
+ int lparen = namestr.find_first_of('(', 0);
+ int dash = namestr.find_first_of('-', lparen + 1);
+ int rparen = namestr.find_first_of(')', dash + 1);
+ if (lparen != -1 && dash != -1 && rparen != -1)
{
- entry *existing = checkentry->second;
- // if we're overriding existing entries, then remove the old one
- if (override_existing)
- m_entrylist.remove(*existing);
+ strtrimspace(minimum.assign(namestr.substr(lparen + 1, dash - (lparen + 1))));
+ strtrimspace(maximum.assign(namestr.substr(dash + 1, rparen - (dash + 1))));
+ namestr.erase(lparen, rparen + 1 - lparen);
+ }
+
+ // then chop up any semicolon-separated names
+ size_t semi;
+ while ((semi = namestr.find_first_of(';')) != std::string::npos)
+ {
+ names.push_back(namestr.substr(0, semi));
+ namestr.erase(0, semi + 1);
+ }
+
+ // finally add the last item
+ names.push_back(std::move(namestr));
+ }
- // otherwise, just override the default and current values and throw out the new entry
+ // we might be called with an existing entry
+ entry::shared_ptr existing_entry;
+ do
+ {
+ for (const std::string &name : names)
+ {
+ existing_entry = get_entry(name.c_str());
+ if (existing_entry)
+ break;
+ }
+
+ if (existing_entry)
+ {
+ if (override_existing)
+ remove_entry(*existing_entry);
else
- {
- existing->set_default_value(newentry->value());
- global_free(newentry);
return;
- }
}
+ } while (existing_entry);
- // need to call value_changed() with initial value
- value_changed(newentry->name(), newentry->value());
- }
+ // set the default value
+ std::string defdata = opt.defvalue ? opt.defvalue : "";
+
+ // create and add the entry
+ add_entry(
+ std::move(names),
+ opt.description,
+ opt.type,
+ std::move(defdata),
+ std::move(minimum),
+ std::move(maximum));
+}
+
+
+//-------------------------------------------------
+// add_entry
+//-------------------------------------------------
+
+void core_options::add_entry(std::vector<std::string> &&names, const char *description, option_type type, std::string &&default_value, std::string &&minimum, std::string &&maximum)
+{
+ // create the entry
+ entry::shared_ptr new_entry = std::make_shared<simple_entry>(
+ std::move(names),
+ description,
+ type,
+ std::move(default_value),
+ std::move(minimum),
+ std::move(maximum));
+
+ // and add it
+ add_entry(std::move(new_entry));
+}
- // add us to the list and maps
- append_entry(*newentry);
+
+//-------------------------------------------------
+// add_header
+//-------------------------------------------------
+
+void core_options::add_header(const char *description)
+{
+ add_entry(std::vector<std::string>(), description, option_type::HEADER);
}
@@ -293,8 +531,8 @@ void core_options::add_entry(const char *name, const char *description, uint32_t
void core_options::add_entries(const options_entry *entrylist, bool override_existing)
{
// loop over entries until we hit a nullptr name
- for ( ; entrylist->name != nullptr || (entrylist->flags & OPTION_HEADER) != 0; entrylist++)
- add_entry(*entrylist, override_existing);
+ for (int i = 0; entrylist[i].name || entrylist[i].type == option_type::HEADER; i++)
+ add_entry(entrylist[i], override_existing);
}
@@ -305,13 +543,8 @@ void core_options::add_entries(const options_entry *entrylist, bool override_exi
void core_options::set_default_value(const char *name, const char *defvalue)
{
- // find the entry and bail if we can't
- auto curentry = m_entrymap.find(name);
- if (curentry == m_entrymap.end())
- return;
-
// update the data and default data
- curentry->second->set_default_value(defvalue);
+ get_entry(name)->set_default_value(defvalue);
}
@@ -322,13 +555,8 @@ void core_options::set_default_value(const char *name, const char *defvalue)
void core_options::set_description(const char *name, const char *description)
{
- // find the entry and bail if we can't
- auto curentry = m_entrymap.find(name);
- if (curentry == m_entrymap.end())
- return;
-
// update the data and default data
- curentry->second->set_description(description);
+ get_entry(name)->set_description(description);
}
@@ -337,10 +565,12 @@ void core_options::set_description(const char *name, const char *description)
// command line arguments
//-------------------------------------------------
-bool core_options::parse_command_line(std::vector<std::string> &args, int priority, std::string &error_string)
+void core_options::parse_command_line(std::vector<std::string> &args, int priority)
{
+ std::ostringstream error_stream;
+ condition_type condition = condition_type::NONE;
+
// reset the errors and the command
- error_string.clear();
m_command.clear();
// iterate through arguments
@@ -354,8 +584,8 @@ bool core_options::parse_command_line(std::vector<std::string> &args, int priori
const char *optionname = is_unadorned ? core_options::unadorned(unadorned_index++) : &curarg[1];
// find our entry; if not found, continue
- auto curentry = m_entrymap.find(optionname);
- if (curentry == m_entrymap.end())
+ auto curentry = get_entry(optionname);
+ if (!curentry)
{
// we need to relocate this option
if (new_argc != arg)
@@ -376,21 +606,19 @@ bool core_options::parse_command_line(std::vector<std::string> &args, int priori
}
// process commands first
- if (curentry->second->type() == OPTION_COMMAND)
+ if (curentry->type() == option_type::COMMAND)
{
// can only have one command
if (!m_command.empty())
- {
- error_string.append(string_format("Error: multiple commands specified -%s and %s\n", m_command, curarg));
- return false;
- }
- m_command = curentry->second->name();
+ throw options_error_exception("Error: multiple commands specified -%s and %s\n", m_command, curarg);
+
+ m_command = curentry->name();
continue;
}
// get the data for this argument, special casing booleans
std::string newdata;
- if (curentry->second->type() == OPTION_BOOLEAN)
+ if (curentry->type() == option_type::BOOLEAN)
{
newdata = (strncmp(&curarg[1], "no", 2) == 0) ? "0" : "1";
}
@@ -405,17 +633,18 @@ bool core_options::parse_command_line(std::vector<std::string> &args, int priori
}
else
{
- error_string.append(string_format("Error: option %s expected a parameter\n", curarg));
- return false;
+ throw options_error_exception("Error: option %s expected a parameter\n", curarg);
}
args[arg].clear();
// set the new data
- validate_and_set_data(*curentry->second, std::move(newdata), priority, error_string);
+ prettify_and_set_value(*curentry, std::move(newdata), priority, error_stream, condition);
}
args.resize(new_argc);
- return true;
+
+ // did we have any errors that may need to be aggregated?
+ throw_options_exception_if_appropriate(condition, error_stream);
}
@@ -424,8 +653,11 @@ bool core_options::parse_command_line(std::vector<std::string> &args, int priori
// an INI file
//-------------------------------------------------
-bool core_options::parse_ini_file(util::core_file &inifile, int priority, int ignore_priority, std::string &error_string)
+void core_options::parse_ini_file(util::core_file &inifile, int priority, bool always_override)
{
+ std::ostringstream error_stream;
+ condition_type condition = condition_type::NONE;
+
// loop over lines in the file
char buffer[4096];
while (inifile.gets(buffer, ARRAY_LENGTH(buffer)) != nullptr)
@@ -449,7 +681,8 @@ bool core_options::parse_ini_file(util::core_file &inifile, int priority, int ig
// if we hit the end early, print a warning and continue
if (*temp == 0)
{
- error_string.append(string_format("Warning: invalid line in INI: %s", buffer));
+ condition = std::max(condition, condition_type::WARN);
+ util::stream_format(error_stream, "Warning: invalid line in INI: %s", buffer);
continue;
}
@@ -469,77 +702,68 @@ bool core_options::parse_ini_file(util::core_file &inifile, int priority, int ig
*temp = 0;
// find our entry
- auto curentry = m_entrymap.find(optionname);
- if (curentry == m_entrymap.end())
+ entry::shared_ptr curentry = get_entry(optionname);
+ if (!curentry)
{
- if (priority >= ignore_priority)
- error_string.append(string_format("Warning: unknown option in INI: %s\n", optionname));
+ condition = std::max(condition, condition_type::WARN);
+ util::stream_format(error_stream, "Warning: unknown option in INI: %s\n", optionname);
continue;
}
// set the new data
- validate_and_set_data(*curentry->second, optiondata, priority, error_string);
+ prettify_and_set_value(*curentry, optiondata, priority, error_stream, condition);
}
- return true;
+
+ // did we have any errors that may need to be aggregated?
+ throw_options_exception_if_appropriate(condition, error_stream);
}
//-------------------------------------------------
-// pluck_from_command_line - finds a specific
-// value from within a command line
+// throw_options_exception_if_appropriate
//-------------------------------------------------
-bool core_options::pluck_from_command_line(std::vector<std::string> &args, const std::string &optionname, std::string &result)
+void core_options::throw_options_exception_if_appropriate(core_options::condition_type condition, std::ostringstream &error_stream)
{
- // find this entry within the options (it is illegal to call this with a non-existant option
- // so we assert if not present)
- auto curentry = m_entrymap.find(optionname);
- assert(curentry != m_entrymap.end());
-
- // build a vector with potential targets
- std::vector<std::string> targets;
- const char *potential_target;
- int index = 0;
- while ((potential_target = curentry->second->name(index++)) != nullptr)
+ switch(condition)
{
- // not supporting unadorned options for now
- targets.push_back(std::string("-") + potential_target);
- }
+ case condition_type::NONE:
+ // do nothing
+ break;
- // find each of the targets in the argv array
- for (int i = 1; i < args.size() - 1; i++)
- {
- auto const iter = std::find_if(
- targets.begin(),
- targets.end(),
- [&args, i](const std::string &targ) { return targ == args[i]; });
- if (iter != targets.end())
- {
- // get the result
- result = std::move(args[i + 1]);
+ case condition_type::WARN:
+ throw options_warning_exception(error_stream.str());
- // remove this arguments from the list
- auto const pos = std::next(args.begin(), i);
- args.erase(pos, std::next(pos, 2));
- return true;
- }
- }
+ case condition_type::ERR:
+ throw options_warning_exception(error_stream.str());
- result.clear();
- return false;
+ default:
+ // should not get here
+ throw false;
+ }
}
//-------------------------------------------------
-// revert - revert options at or below a certain
-// priority back to their defaults
+// copy_from
//-------------------------------------------------
-void core_options::revert(int priority_hi, int priority_lo)
+void core_options::copy_from(const core_options &that)
{
- // iterate over options and revert to defaults if below the given priority
- for (entry &curentry : m_entrylist)
- curentry.revert(priority_hi, priority_lo);
+ for (auto &dest_entry : m_entries)
+ {
+ if (dest_entry->names().size() > 0)
+ {
+ // identify the source entry
+ const entry::shared_ptr source_entry = that.get_entry(dest_entry->name());
+ if (source_entry)
+ {
+ const char *value = source_entry->value();
+ if (value)
+ dest_entry->set_value(value, source_entry->priority(), true);
+ }
+ }
+ }
}
@@ -560,47 +784,34 @@ std::string core_options::output_ini(const core_options *diff) const
std::string overridden_value;
// loop over all items
- for (entry &curentry : m_entrylist)
+ for (auto &curentry : m_entries)
{
- const char *name = curentry.name();
- const char *value;
- switch (override_get_value(name, overridden_value))
+ if (curentry->type() == option_type::HEADER)
{
- case override_get_value_result::NONE:
- default:
- value = curentry.value();
- break;
-
- case override_get_value_result::SKIP:
- continue;
-
- case override_get_value_result::OVERRIDE:
- value = overridden_value.c_str();
- break;
+ // header: record description
+ last_header = curentry->description();
}
- bool is_unadorned = false;
-
- // check if it's unadorned
- if (name && strlen(name) && !strcmp(name, core_options::unadorned(unadorned_index)))
+ else
{
- unadorned_index++;
- is_unadorned = true;
- }
+ const std::string &name(curentry->name());
+ const char *value(curentry->value());
- // header: record description
- if (curentry.is_header())
- last_header = curentry.description();
+ // check if it's unadorned
+ bool is_unadorned = false;
+ if (name == core_options::unadorned(unadorned_index))
+ {
+ unadorned_index++;
+ is_unadorned = true;
+ }
- // otherwise, output entries for all non-command items
- else if (!curentry.is_command())
- {
- if (!curentry.is_internal())
+ // output entries for all non-command items (items with value)
+ if (value)
{
// look up counterpart in diff, if diff is specified
- if (diff == nullptr || strcmp(value, diff->value(name)) != 0)
+ if (!diff || strcmp(value, diff->value(name.c_str())))
{
// output header, if we have one
- if (last_header != nullptr)
+ if (last_header)
{
if (num_valid_headers++)
buffer << '\n';
@@ -611,7 +822,7 @@ std::string core_options::output_ini(const core_options *diff) const
// and finally output the data, skip if unadorned
if (!is_unadorned)
{
- if (strchr(value, ' ') != nullptr)
+ if (strchr(value, ' '))
util::stream_format(buffer, "%-25s \"%s\"\n", name, value);
else
util::stream_format(buffer, "%-25s %s\n", name, value);
@@ -634,15 +845,15 @@ std::string core_options::output_help() const
std::ostringstream buffer;
// loop over all items
- for (entry &curentry : m_entrylist)
+ for (auto &curentry : m_entries)
{
// header: just print
- if (curentry.is_header())
- util::stream_format(buffer, "\n#\n# %s\n#\n", curentry.description());
+ if (curentry->type() == option_type::HEADER)
+ util::stream_format(buffer, "\n#\n# %s\n#\n", curentry->description());
// otherwise, output entries for all non-deprecated items
- else if (curentry.description() != nullptr)
- util::stream_format(buffer, "-%-20s%s\n", curentry.name(), curentry.description());
+ else if (curentry->description() != nullptr)
+ util::stream_format(buffer, "-%-20s%s\n", curentry->name(), curentry->description());
}
return buffer.str();
}
@@ -652,10 +863,9 @@ std::string core_options::output_help() const
// value - return the raw option value
//-------------------------------------------------
-const char *core_options::value(const char *name) const
+const char *core_options::value(const char *option) const
{
- auto curentry = m_entrymap.find(name);
- return (curentry != m_entrymap.end()) ? curentry->second->value() : "";
+ return get_entry(option)->value();
}
@@ -663,251 +873,143 @@ const char *core_options::value(const char *name) const
// description - return description of option
//-------------------------------------------------
-const char *core_options::description(const char *name) const
+const char *core_options::description(const char *option) const
{
- auto curentry = m_entrymap.find(name);
- return (curentry != m_entrymap.end()) ? curentry->second->description() : "";
+ return get_entry(option)->description();
}
+//**************************************************************************
+// LEGACY
+//**************************************************************************
+
//-------------------------------------------------
-// priority - return the priority of option
+// set_value - set the raw option value
//-------------------------------------------------
-int core_options::priority(const char *name) const
+void core_options::set_value(const std::string &name, const std::string &value, int priority)
{
- auto curentry = m_entrymap.find(name);
- return (curentry != m_entrymap.end()) ? curentry->second->priority() : 0;
+ set_value(name, std::string(value), priority);
}
+void core_options::set_value(const std::string &name, std::string &&value, int priority)
+{
+ get_entry(name)->set_value(std::move(value), priority);
+}
-//-------------------------------------------------
-// exists - return if option exists in list
-//-------------------------------------------------
+void core_options::set_value(const std::string &name, int value, int priority)
+{
+ set_value(name, string_format("%d", value), priority);
+}
-bool core_options::exists(const char *name) const
+void core_options::set_value(const std::string &name, float value, int priority)
{
- return (m_entrymap.find(name) != m_entrymap.end());
+ set_value(name, string_format("%f", value), priority);
}
//-------------------------------------------------
-// set_value - set the raw option value
+// remove_entry - remove an entry from our list
+// and map
//-------------------------------------------------
-bool core_options::set_value(const char *name, const char *value, int priority, std::string &error_string)
+void core_options::remove_entry(core_options::entry &delentry)
{
- // find the entry first
- auto curentry = m_entrymap.find(name);
- if (curentry == m_entrymap.end())
- {
- error_string.append(string_format("Attempted to set unknown option %s\n", name));
- return false;
- }
+ // find this in m_entries
+ auto iter = std::find_if(
+ m_entries.begin(),
+ m_entries.end(),
+ [&delentry](const auto &x) { return &*x == &delentry; });
+ assert(iter != m_entries.end());
- // validate and set the item normally
- return validate_and_set_data(*curentry->second, value, priority, error_string);
-}
+ // erase each of the items out of the entry map
+ for (const std::string &name : delentry.names())
+ m_entrymap.erase(name);
-bool core_options::set_value(const char *name, int value, int priority, std::string &error_string)
-{
- return set_value(name, string_format("%d", value).c_str(), priority, error_string);
+ // finally erase it
+ m_entries.erase(iter);
}
-bool core_options::set_value(const char *name, float value, int priority, std::string &error_string)
-{
- return set_value(name, string_format("%f", value).c_str(), priority, error_string);
-}
+//-------------------------------------------------
+// prettify_and_set_value
+//-------------------------------------------------
-void core_options::set_flag(const char *name, uint32_t mask, uint32_t flag)
+void core_options::prettify_and_set_value(entry &curentry, std::string &&data, int priority, std::ostream &error_stream, condition_type &condition)
{
- // find the entry first
- auto curentry = m_entrymap.find(name);
- if ( curentry == m_entrymap.end())
+ // trim any whitespace
+ strtrimspace(data);
+
+ // trim quotes
+ if (data.find_first_of('"') == 0 && data.find_last_of('"') == data.length() - 1)
{
- return;
+ data.erase(0, 1);
+ data.erase(data.length() - 1, 1);
}
- curentry->second->set_flag(mask, flag);
-}
-void core_options::mark_changed(const char* name)
-{
- // find the entry first
- auto curentry = m_entrymap.find(name);
- if (curentry == m_entrymap.end())
+ // this is called when parsing a command line or an INI - we want to catch the option_exception and write
+ // any exception messages to the error stream
+ try
+ {
+ curentry.set_value(std::move(data), priority);
+ }
+ catch (options_warning_exception &ex)
+ {
+ // we want to aggregate option exceptions
+ error_stream << ex.message();
+ condition = std::max(condition, condition_type::WARN);
+ }
+ catch (options_error_exception &ex)
{
- return;
+ // we want to aggregate option exceptions
+ error_stream << ex.message();
+ condition = std::max(condition, condition_type::ERR);
}
- curentry->second->mark_changed();
}
+
//-------------------------------------------------
-// reset - reset the options state, removing
-// everything
+// get_entry
//-------------------------------------------------
-void core_options::reset()
+const core_options::entry::shared_ptr core_options::get_entry(const std::string &name) const
{
- m_entrylist.reset();
- m_entrymap.clear();
+ auto curentry = m_entrymap.find(name);
+ return (curentry != m_entrymap.end()) ? curentry->second.lock() : nullptr;
}
-
-//-------------------------------------------------
-// append_entry - append an entry to our list
-// and index it in the map
-//-------------------------------------------------
-
-void core_options::append_entry(core_options::entry &newentry)
+core_options::entry::shared_ptr core_options::get_entry(const std::string &name)
{
- m_entrylist.append(newentry);
-
- // if we have names, add them to the map
- for (int name = 0; name < ARRAY_LENGTH(newentry.m_name); name++)
- if (newentry.name(name) != nullptr)
- {
- m_entrymap.insert(std::make_pair(newentry.name(name), &newentry));
- // for boolean options add a "no" variant as well
- if (newentry.type() == OPTION_BOOLEAN)
- m_entrymap.insert(std::make_pair(std::string("no").append(newentry.name(name)), &newentry));
- }
+ auto curentry = m_entrymap.find(name);
+ return (curentry != m_entrymap.end()) ? curentry->second.lock() : nullptr;
}
//-------------------------------------------------
-// remove_entry - remove an entry from our list
-// and map
+// set_value_changed_handler
//-------------------------------------------------
-void core_options::remove_entry(core_options::entry &delentry)
+void core_options::set_value_changed_handler(const std::string &name, std::function<void(const char *)> &&handler)
{
- // remove all names from the map
- for (int name = 0; name < ARRAY_LENGTH(delentry.m_name); name++)
- if (!delentry.m_name[name].empty())
- {
- auto entry = m_entrymap.find(delentry.m_name[name]);
- if (entry!= m_entrymap.end()) m_entrymap.erase(entry);
- }
-
- // remove the entry from the list
- m_entrylist.remove(delentry);
+ get_entry(name)->set_value_changed_handler(std::move(handler));
}
-/**
- * @fn void core_options::copyfrom(const core_options &src)
- *
- * @brief -------------------------------------------------
- * copyfrom - copy options from another set
- * -------------------------------------------------.
- *
- * @param src Source for the.
- */
-
-void core_options::copyfrom(const core_options &src)
-{
- // reset ourselves first
- reset();
-
- // iterate through the src options and make our own
- for (entry &curentry : src.m_entrylist)
- append_entry(*global_alloc(entry(curentry.name(), curentry.description(), curentry.flags(), curentry.default_value())));
-}
-/**
- * @fn bool core_options::validate_and_set_data(core_options::entry &curentry, const char *newdata, int priority, std::string &error_string)
- *
- * @brief -------------------------------------------------
- * validate_and_set_data - make sure the data is of the appropriate type and within
- * range, then set it
- * -------------------------------------------------.
- *
- * @param [in,out] curentry The curentry.
- * @param newdata The newdata.
- * @param priority The priority.
- * @param [in,out] error_string The error string.
- *
- * @return true if it succeeds, false if it fails.
- */
+//-------------------------------------------------
+// header_exists
+//-------------------------------------------------
-bool core_options::validate_and_set_data(core_options::entry &curentry, std::string &&data, int priority, std::string &error_string)
+bool core_options::header_exists(const char *description) const
{
- // trim any whitespace
- strtrimspace(data);
-
- // trim quotes
- if (data.find_first_of('"') == 0 && data.find_last_of('"') == data.length() - 1)
- {
- data.erase(0, 1);
- data.erase(data.length() - 1, 1);
- }
-
- // let derived classes override how we set this data
- if (override_set_value(curentry.name(), data))
- return true;
-
- // validate the type of data and optionally the range
- float fval;
- int ival;
- switch (curentry.type())
- {
- // booleans must be 0 or 1
- case OPTION_BOOLEAN:
- if (sscanf(data.c_str(), "%d", &ival) != 1 || ival < 0 || ival > 1)
- {
- error_string.append(string_format("Illegal boolean value for %s: \"%s\"; reverting to %s\n", curentry.name(), data.c_str(), curentry.value()));
- return false;
- }
- break;
-
- // integers must be integral
- case OPTION_INTEGER:
- if (sscanf(data.c_str(), "%d", &ival) != 1)
- {
- error_string.append(string_format("Illegal integer value for %s: \"%s\"; reverting to %s\n", curentry.name(), data.c_str(), curentry.value()));
- return false;
- }
- if (curentry.has_range() && (ival < atoi(curentry.minimum()) || ival > atoi(curentry.maximum())))
+ auto iter = std::find_if(
+ m_entries.begin(),
+ m_entries.end(),
+ [description](const auto &entry)
{
- error_string.append(string_format("Out-of-range integer value for %s: \"%s\" (must be between %s and %s); reverting to %s\n", curentry.name(), data.c_str(), curentry.minimum(), curentry.maximum(), curentry.value()));
- return false;
- }
- break;
+ return entry->type() == option_type::HEADER
+ && entry->description()
+ && !strcmp(entry->description(), description);
+ });
- // floating-point values must be numeric
- case OPTION_FLOAT:
- if (sscanf(data.c_str(), "%f", &fval) != 1)
- {
- error_string.append(string_format("Illegal float value for %s: \"%s\"; reverting to %s\n", curentry.name(), data.c_str(), curentry.value()));
- return false;
- }
- if (curentry.has_range() && ((double) fval < atof(curentry.minimum()) || (double) fval > atof(curentry.maximum())))
- {
- error_string.append(string_format("Out-of-range float value for %s: \"%s\" (must be between %s and %s); reverting to %s\n", curentry.name(), data.c_str(), curentry.minimum(), curentry.maximum(), curentry.value()));
- return false;
- }
- break;
-
- // strings can be anything
- case OPTION_STRING:
- break;
-
- // anything else is invalid
- case OPTION_INVALID:
- case OPTION_HEADER:
- default:
- error_string.append(string_format("Attempted to set invalid option %s\n", curentry.name()));
- return false;
- }
-
- // set the data
- curentry.set_value(data.c_str(), priority);
- value_changed(curentry.name(), data);
- return true;
-}
-
-core_options::entry *core_options::get_entry(const char *name) const
-{
- auto curentry = m_entrymap.find(name);
- return (curentry != m_entrymap.end()) ? curentry->second : nullptr;
+ return iter != m_entries.end();
}
diff --git a/src/lib/util/options.h b/src/lib/util/options.h
index edf7f8600c8..a36ff95cab6 100644
--- a/src/lib/util/options.h
+++ b/src/lib/util/options.h
@@ -13,26 +13,13 @@
#include "corefile.h"
#include <unordered_map>
-
+#include <sstream>
//**************************************************************************
// CONSTANTS
//**************************************************************************
-// option types
-const uint32_t OPTION_TYPE_MASK = 0x0007; // up to 8 different types
-enum
-{
- OPTION_INVALID, // invalid
- OPTION_HEADER, // a header item
- OPTION_COMMAND, // a command
- OPTION_BOOLEAN, // boolean option
- OPTION_INTEGER, // integer option
- OPTION_FLOAT, // floating-point option
- OPTION_STRING // string option
-};
-
// option priorities
const int OPTION_PRIORITY_DEFAULT = 0; // defaults are at 0 priority
const int OPTION_PRIORITY_LOW = 50; // low priority
@@ -40,20 +27,55 @@ const int OPTION_PRIORITY_NORMAL = 100; // normal priority
const int OPTION_PRIORITY_HIGH = 150; // high priority
const int OPTION_PRIORITY_MAXIMUM = 255; // maximum priority
-const uint32_t OPTION_FLAG_INTERNAL = 0x40000000;
-
//**************************************************************************
// TYPE DEFINITIONS
//**************************************************************************
-// static structure describing a single option with its description and default value
-struct options_entry
+struct options_entry;
+
+// exception thrown by core_options when an illegal request is made
+class options_exception : public std::exception
{
- const char * name; // name on the command line
- const char * defvalue; // default value of this argument
- uint32_t flags; // flags to describe the option
- const char * description; // description for -showusage
+public:
+ const std::string &message() const { return m_message; }
+ virtual const char *what() const noexcept override { return message().c_str(); }
+
+protected:
+ options_exception(std::string &&message);
+
+private:
+ std::string m_message;
+};
+
+class options_warning_exception : public options_exception
+{
+public:
+ template <typename... Params> options_warning_exception(const char *fmt, Params &&...args)
+ : options_warning_exception(util::string_format(fmt, std::forward<Params>(args)...))
+ {
+ }
+
+ options_warning_exception(std::string &&message);
+ options_warning_exception(const options_warning_exception &) = default;
+ options_warning_exception(options_warning_exception &&) = default;
+ options_warning_exception& operator=(const options_warning_exception &) = default;
+ options_warning_exception& operator=(options_warning_exception &&) = default;
+};
+
+class options_error_exception : public options_exception
+{
+public:
+ template <typename... Params> options_error_exception(const char *fmt, Params &&...args)
+ : options_error_exception(util::string_format(fmt, std::forward<Params>(args)...))
+ {
+ }
+
+ options_error_exception(std::string &&message);
+ options_error_exception(const options_error_exception &) = default;
+ options_error_exception(options_error_exception &&) = default;
+ options_error_exception& operator=(const options_error_exception &) = default;
+ options_error_exception& operator=(options_error_exception &&) = default;
};
@@ -63,94 +85,95 @@ class core_options
static const int MAX_UNADORNED_OPTIONS = 16;
public:
+ enum class option_type
+ {
+ INVALID, // invalid
+ HEADER, // a header item
+ COMMAND, // a command
+ BOOLEAN, // boolean option
+ INTEGER, // integer option
+ FLOAT, // floating-point option
+ STRING // string option
+ };
+
// information about a single entry in the options
class entry
{
- friend class core_options;
- friend class simple_list<entry>;
-
- // construction/destruction
- entry(const char *name, const char *description, uint32_t flags = 0, const char *defvalue = nullptr);
-
public:
- // getters
- entry *next() const { return m_next; }
- const char *name(int index = 0) const { return (index < ARRAY_LENGTH(m_name) && !m_name[index].empty()) ? m_name[index].c_str() : nullptr; }
+ typedef std::shared_ptr<entry> shared_ptr;
+ typedef std::weak_ptr<entry> weak_ptr;
+
+ // constructor/destructor
+ entry(std::vector<std::string> &&names, option_type type = option_type::STRING, const char *description = nullptr);
+ entry(std::string &&name, option_type type = option_type::STRING, const char *description = nullptr);
+ entry(const entry &) = delete;
+ entry(entry &&) = delete;
+ entry& operator=(const entry &) = delete;
+ entry& operator=(entry &&) = delete;
+ virtual ~entry();
+
+ // accessors
+ const std::vector<std::string> &names() const { return m_names; }
+ const std::string &name() const { return m_names[0]; }
+ virtual const char *value() const;
+ int priority() const { return m_priority; }
+ option_type type() const { return m_type; }
const char *description() const { return m_description; }
- const char *value() const { return m_data.c_str(); }
- const char *default_value() const { return m_defdata.c_str(); }
- const char *minimum() const { return m_minimum.c_str(); }
- const char *maximum() const { return m_maximum.c_str(); }
- int type() const { return (m_flags & OPTION_TYPE_MASK); }
- uint32_t flags() const { return m_flags; }
- bool is_header() const { return type() == OPTION_HEADER; }
- bool is_command() const { return type() == OPTION_COMMAND; }
- bool is_internal() const { return m_flags & OPTION_FLAG_INTERNAL; }
- bool has_range() const { return (!m_minimum.empty() && !m_maximum.empty()); }
- int priority() const { return m_priority; }
- bool is_changed() const { return m_changed; }
-
- // setters
- void set_value(const char *newvalue, int priority);
- void set_default_value(const char *defvalue);
- void set_description(const char *description);
- void set_flag(uint32_t mask, uint32_t flag);
- void mark_changed() { m_changed = true; }
- void revert(int priority_hi, int priority_lo);
+ virtual const std::string &default_value() const;
+ virtual const char *minimum() const;
+ virtual const char *maximum() const;
+ bool has_range() const;
+
+ // mutators
+ void set_value(std::string &&newvalue, int priority, bool always_override = false);
+ virtual void set_default_value(std::string &&newvalue);
+ void set_description(const char *description) { m_description = description; }
+ void set_value_changed_handler(std::function<void(const char *)> &&handler) { m_value_changed_handler = std::move(handler); }
+
+ protected:
+ virtual void internal_set_value(std::string &&newvalue) = 0;
private:
- // internal state
- entry * m_next; // link to the next data
- uint32_t m_flags; // flags from the entry
- bool m_error_reported; // have we reported an error on this option yet?
- int m_priority; // priority of the data set
- const char * m_description; // description for this item
- std::string m_name[4]; // up to 4 names for the item
- std::string m_data; // data for this item
- std::string m_defdata; // default data for this item
- std::string m_minimum; // minimum value
- std::string m_maximum; // maximum value
- bool m_changed; // changed flag
+ void validate(const std::string &value);
+
+ std::vector<std::string> m_names;
+ int m_priority;
+ core_options::option_type m_type;
+ const char * m_description;
+ std::function<void(const char *)> m_value_changed_handler;
};
// construction/destruction
core_options();
- core_options(const options_entry *entrylist);
- core_options(const options_entry *entrylist1, const options_entry *entrylist2);
- core_options(const options_entry *entrylist1, const options_entry *entrylist2, const options_entry *entrylist3);
- core_options(const core_options &src);
+ core_options(const core_options &) = delete;
+ core_options(core_options &&) = delete;
+ core_options& operator=(const core_options &) = delete;
+ core_options& operator=(core_options &&) = delete;
virtual ~core_options();
- // operators
- core_options &operator=(const core_options &rhs);
- bool operator==(const core_options &rhs);
- bool operator!=(const core_options &rhs);
-
// getters
- entry *first() const { return m_entrylist.first(); }
const std::string &command() const { return m_command; }
- entry *get_entry(const char *name) const;
-
- // range iterators
- using auto_iterator = simple_list<entry>::auto_iterator;
- auto_iterator begin() const { return m_entrylist.begin(); }
- auto_iterator end() const { return m_entrylist.end(); }
+ const entry::shared_ptr get_entry(const std::string &name) const;
+ entry::shared_ptr get_entry(const std::string &name);
+ const std::vector<entry::shared_ptr> &entries() const { return m_entries; }
+ bool exists(const std::string &name) const { return get_entry(name) != nullptr; }
+ bool header_exists(const char *description) const;
// configuration
- void add_entry(const char *name, const char *description, uint32_t flags = 0, const char *defvalue = nullptr, bool override_existing = false);
- void add_entry(const options_entry &data, bool override_existing = false) { add_entry(data.name, data.description, data.flags, data.defvalue, override_existing); }
+ void add_entry(entry::shared_ptr &&entry, const char *after_header = nullptr);
+ void add_entry(const options_entry &entry, bool override_existing = false);
+ void add_entry(std::vector<std::string> &&names, const char *description, option_type type, std::string &&default_value = "", std::string &&minimum = "", std::string &&maximum = "");
+ void add_header(const char *description);
void add_entries(const options_entry *entrylist, bool override_existing = false);
void set_default_value(const char *name, const char *defvalue);
void set_description(const char *name, const char *description);
void remove_entry(entry &delentry);
+ void set_value_changed_handler(const std::string &name, std::function<void(const char *)> &&handler);
// parsing/input
- bool parse_command_line(std::vector<std::string> &args, int priority, std::string &error_string);
- bool parse_ini_file(util::core_file &inifile, int priority, int ignore_priority, std::string &error_string);
- bool pluck_from_command_line(std::vector<std::string> &args, const std::string &name, std::string &result);
-
- // reverting
- void revert(int priority_hi = OPTION_PRIORITY_MAXIMUM, int priority_lo = OPTION_PRIORITY_DEFAULT);
+ void parse_command_line(std::vector<std::string> &args, int priority);
+ void parse_ini_file(util::core_file &inifile, int priority, bool always_override);
+ void copy_from(const core_options &that);
// output
std::string output_ini(const core_options *diff = nullptr) const;
@@ -159,51 +182,88 @@ public:
// reading
const char *value(const char *option) const;
const char *description(const char *option) const;
- int priority(const char *option) const;
- bool bool_value(const char *name) const { return (atoi(value(name)) != 0); }
- int int_value(const char *name) const { return atoi(value(name)); }
- float float_value(const char *name) const { return atof(value(name)); }
- bool exists(const char *name) const;
+ bool bool_value(const char *option) const { return int_value(option) != 0; }
+ int int_value(const char *option) const { return atoi(value(option)); }
+ float float_value(const char *option) const { return atof(value(option)); }
// setting
- bool set_value(const char *name, const char *value, int priority, std::string &error_string);
- bool set_value(const char *name, int value, int priority, std::string &error_string);
- bool set_value(const char *name, float value, int priority, std::string &error_string);
- void set_flag(const char *name, uint32_t mask, uint32_t flags);
- void mark_changed(const char *name);
+ void set_value(const std::string &name, const std::string &value, int priority);
+ void set_value(const std::string &name, std::string &&value, int priority);
+ void set_value(const std::string &name, int value, int priority);
+ void set_value(const std::string &name, float value, int priority);
// misc
static const char *unadorned(int x = 0) { return s_option_unadorned[std::min(x, MAX_UNADORNED_OPTIONS - 1)]; }
- int options_count() const { return m_entrylist.count(); }
-protected:
- // This is a hook to allow option value retrieval to be overridden for various reasons; this is a crude
- // extensibility mechanism that should really be replaced by something better
- enum class override_get_value_result
+private:
+ class simple_entry : public entry
{
- NONE,
- OVERRIDE,
- SKIP
+ public:
+ // construction/destruction
+ simple_entry(std::vector<std::string> &&names, const char *description, core_options::option_type type, std::string &&defdata, std::string &&minimum, std::string &&maximum);
+ simple_entry(const simple_entry &) = delete;
+ simple_entry(simple_entry &&) = delete;
+ simple_entry& operator=(const simple_entry &) = delete;
+ simple_entry& operator=(simple_entry &&) = delete;
+ ~simple_entry();
+
+ // getters
+ virtual const char *value() const override;
+ virtual const char *minimum() const override;
+ virtual const char *maximum() const override;
+ virtual const std::string &default_value() const override;
+
+ virtual void set_default_value(std::string &&newvalue) override;
+
+ protected:
+ virtual void internal_set_value(std::string &&newvalue) override;
+
+ private:
+ // internal state
+ std::string m_data; // data for this item
+ std::string m_defdata; // default data for this item
+ std::string m_minimum; // minimum value
+ std::string m_maximum; // maximum value
};
- virtual void value_changed(const std::string &name, const std::string &value) {}
- virtual override_get_value_result override_get_value(const char *name, std::string &value) const { return override_get_value_result::NONE; }
- virtual bool override_set_value(const char *name, const std::string &value) { return false; }
+ // used internally in core_options
+ enum class condition_type
+ {
+ NONE,
+ WARN,
+ ERR
+ };
-private:
// internal helpers
- void reset();
- void append_entry(entry &newentry);
- void copyfrom(const core_options &src);
- bool validate_and_set_data(entry &curentry, std::string &&newdata, int priority, std::string &error_string);
+ void add_to_entry_map(std::string &&name, entry::shared_ptr &entry);
+ void prettify_and_set_value(entry &curentry, std::string &&data, int priority, std::ostream &error_stream, condition_type &condition);
+ void throw_options_exception_if_appropriate(condition_type condition, std::ostringstream &error_stream);
// internal state
- simple_list<entry> m_entrylist; // head of list of entries
- std::unordered_map<std::string,entry *> m_entrymap; // map for fast lookup
- std::string m_command; // command found
- static const char *const s_option_unadorned[]; // array of unadorned option "names"
+ std::vector<entry::shared_ptr> m_entries; // cannonical list of entries
+ std::unordered_map<std::string, entry::weak_ptr> m_entrymap; // map for fast lookup
+ std::string m_command; // command found
+ static const char *const s_option_unadorned[]; // array of unadorned option "names"
+};
+
+
+// static structure describing a single option with its description and default value
+struct options_entry
+{
+ const char * name; // name on the command line
+ const char * defvalue; // default value of this argument
+ core_options::option_type type; // type of option
+ const char * description; // description for -showusage
};
+// legacy option types
+const core_options::option_type OPTION_INVALID = core_options::option_type::INVALID;
+const core_options::option_type OPTION_HEADER = core_options::option_type::HEADER;
+const core_options::option_type OPTION_COMMAND = core_options::option_type::COMMAND;
+const core_options::option_type OPTION_BOOLEAN = core_options::option_type::BOOLEAN;
+const core_options::option_type OPTION_INTEGER = core_options::option_type::INTEGER;
+const core_options::option_type OPTION_FLOAT = core_options::option_type::FLOAT;
+const core_options::option_type OPTION_STRING = core_options::option_type::STRING;
#endif // MAME_LIB_UTIL_OPTIONS_H
diff --git a/src/osd/modules/lib/osdobj_common.h b/src/osd/modules/lib/osdobj_common.h
index df8096840cf..2c2f750fdbe 100644
--- a/src/osd/modules/lib/osdobj_common.h
+++ b/src/osd/modules/lib/osdobj_common.h
@@ -270,7 +270,7 @@ private:
// FIXME: should be elsewhere
osd_module *select_module_options(const core_options &opts, const std::string &opt_name)
{
- std::string opt_val = opts.value(opt_name.c_str());
+ std::string opt_val = opts.exists(opt_name) ? opts.value(opt_name.c_str()) : "";
if (opt_val.compare("auto")==0)
opt_val = "";
else if (!m_mod_man.type_has_name(opt_name.c_str(), opt_val.c_str()))
diff --git a/src/osd/modules/render/drawbgfx.cpp b/src/osd/modules/render/drawbgfx.cpp
index 2fb0d0b3a1e..31ddc58c145 100644
--- a/src/osd/modules/render/drawbgfx.cpp
+++ b/src/osd/modules/render/drawbgfx.cpp
@@ -85,7 +85,6 @@ renderer_bgfx::renderer_bgfx(std::shared_ptr<osd_window> w)
, m_avi_writer(nullptr)
, m_avi_target(nullptr)
{
- m_options = downcast<osd_options &>(assert_window()->machine().options());
}
//============================================================
diff --git a/src/osd/sdl/sdlmain.cpp b/src/osd/sdl/sdlmain.cpp
index 31f65e2ba66..10e57ec5766 100644
--- a/src/osd/sdl/sdlmain.cpp
+++ b/src/osd/sdl/sdlmain.cpp
@@ -408,14 +408,12 @@ void sdl_osd_interface::init(running_machine &machine)
// determine if we are benchmarking, and adjust options appropriately
int bench = options().bench();
- std::string error_string;
if (bench > 0)
{
- options().set_value(OPTION_THROTTLE, false, OPTION_PRIORITY_MAXIMUM, error_string);
- options().set_value(OSDOPTION_SOUND, "none", OPTION_PRIORITY_MAXIMUM, error_string);
- options().set_value(OSDOPTION_VIDEO, "none", OPTION_PRIORITY_MAXIMUM, error_string);
- options().set_value(OPTION_SECONDS_TO_RUN, bench, OPTION_PRIORITY_MAXIMUM, error_string);
- assert(error_string.c_str()[0] == 0);
+ options().set_value(OPTION_THROTTLE, false, OPTION_PRIORITY_MAXIMUM);
+ options().set_value(OSDOPTION_SOUND, "none", OPTION_PRIORITY_MAXIMUM);
+ options().set_value(OSDOPTION_VIDEO, "none", OPTION_PRIORITY_MAXIMUM);
+ options().set_value(OPTION_SECONDS_TO_RUN, bench, OPTION_PRIORITY_MAXIMUM);
}
// Some driver options - must be before audio init!
diff --git a/src/osd/windows/winmain.cpp b/src/osd/windows/winmain.cpp
index efec6700849..805a769d1b8 100644
--- a/src/osd/windows/winmain.cpp
+++ b/src/osd/windows/winmain.cpp
@@ -515,23 +515,20 @@ void windows_osd_interface::init(running_machine &machine)
// determine if we are benchmarking, and adjust options appropriately
int bench = options.bench();
- std::string error_string;
if (bench > 0)
{
- options.set_value(OPTION_THROTTLE, false, OPTION_PRIORITY_MAXIMUM, error_string);
- options.set_value(OSDOPTION_SOUND, "none", OPTION_PRIORITY_MAXIMUM, error_string);
- options.set_value(OSDOPTION_VIDEO, "none", OPTION_PRIORITY_MAXIMUM, error_string);
- options.set_value(OPTION_SECONDS_TO_RUN, bench, OPTION_PRIORITY_MAXIMUM, error_string);
- assert(error_string.empty());
+ options.set_value(OPTION_THROTTLE, false, OPTION_PRIORITY_MAXIMUM);
+ options.set_value(OSDOPTION_SOUND, "none", OPTION_PRIORITY_MAXIMUM);
+ options.set_value(OSDOPTION_VIDEO, "none", OPTION_PRIORITY_MAXIMUM);
+ options.set_value(OPTION_SECONDS_TO_RUN, bench, OPTION_PRIORITY_MAXIMUM);
}
// determine if we are profiling, and adjust options appropriately
int profile = options.profile();
if (profile > 0)
{
- options.set_value(OPTION_THROTTLE, false, OPTION_PRIORITY_MAXIMUM, error_string);
- options.set_value(OSDOPTION_NUMPROCESSORS, 1, OPTION_PRIORITY_MAXIMUM, error_string);
- assert(error_string.empty());
+ options.set_value(OPTION_THROTTLE, false, OPTION_PRIORITY_MAXIMUM);
+ options.set_value(OSDOPTION_NUMPROCESSORS, 1, OPTION_PRIORITY_MAXIMUM);
}
// thread priority