From 4102348817525acc058732da5a5b9e9c4de16d65 Mon Sep 17 00:00:00 2001
From: gimmedonutnow <gimmedonutnow@users.sf.net>
Date: Thu, 10 Aug 2006 05:25:19 +0000
Subject: [PATCH] - added this configuration system for cross-platform testing

---
 src/drivers/common/SConscript    |   1 +
 src/drivers/common/configSys.cpp | 409 +++++++++++++++++++++++++++++++
 src/drivers/common/configSys.h   |  62 +++++
 3 files changed, 472 insertions(+)
 create mode 100644 src/drivers/common/configSys.cpp
 create mode 100644 src/drivers/common/configSys.h

diff --git a/src/drivers/common/SConscript b/src/drivers/common/SConscript
index 94f47a8e..64fadbe7 100644
--- a/src/drivers/common/SConscript
+++ b/src/drivers/common/SConscript
@@ -8,6 +8,7 @@ scale2x.cpp
 scale3x.cpp
 scalebit.cpp
 vidblit.cpp
+configSys.cpp
 """)
 
 for x in range(len(my_list)):
diff --git a/src/drivers/common/configSys.cpp b/src/drivers/common/configSys.cpp
new file mode 100644
index 00000000..a40f12b8
--- /dev/null
+++ b/src/drivers/common/configSys.cpp
@@ -0,0 +1,409 @@
+#include <iostream>
+#include <fstream>
+#include <stdio.h>
+
+#include "configSys.h"
+
+/**
+ * Add a given option.  The option is specified as a short command
+ * line (-f), long command line (--foo), option name (Foo), its type
+ * (integer or string).
+ */
+int
+Config::_addOption(char shortArg,
+                   const std::string &longArg,
+                   const std::string &name,
+                   int type)
+{
+    // make sure we have a valid type
+    if(type != INTEGER && type != STRING) {
+        return -1;
+    }
+
+    // check if the option already exists
+    if(_shortArgMap.find(shortArg) != _shortArgMap.end() ||
+       _longArgMap.find(longArg) != _longArgMap.end() ||
+       (type == INTEGER && _intOptMap.find(name) != _intOptMap.end()) ||
+       (type == STRING  && _strOptMap.find(name) != _strOptMap.end())) {
+        return -1;
+    }
+
+    // add the option
+    switch(type) {
+    case(INTEGER):
+        _intOptMap[name] = 0;
+        break;
+    case(STRING):
+        _strOptMap[name] = "";
+        break;
+    default:
+        break;
+    } 
+    _shortArgMap[shortArg] = name;
+    _longArgMap[longArg] = name;
+
+    return 0;
+}
+
+/**
+ * Add a given option and sets its default value.  The option is
+ * specified as a short command line (-f), long command line (--foo),
+ * option name (Foo), its type (integer or string), and its default
+ * value.
+ */
+int
+Config::addOption(char shortArg,
+                  const std::string &longArg,
+                  const std::string &name,
+                  int type,
+                  int defaultValue)
+{
+    int error;
+
+    // add the option to the config system
+    error = _addOption(shortArg, longArg, name, type);
+    if(error) {
+        return error;
+    }
+
+    // set the option to the default value
+    error = setOption(name, defaultValue);
+    if(error) {
+        return error;
+    }
+
+    return 0;
+}
+
+/**
+ * Add a given option and sets its default value.  The option is
+ * specified as a short command line (-f), long command line (--foo),
+ * option name (Foo), its type (integer or string), and its default
+ * value.
+ */
+int
+Config::addOption(char shortArg,
+                  const std::string &longArg,
+                  const std::string &name,
+                  int type,
+                  const std::string &defaultValue)
+{
+    int error;
+
+    // add the option to the config system
+    error = _addOption(shortArg, longArg, name, type);
+    if(error) {
+        return error;
+    }
+
+    // set the option to the default value
+    error = setOption(name, defaultValue);
+    if(error) {
+        return error;
+    }
+
+    return 0;
+}
+
+/**
+ * Sets the specified option to the given integer value.
+ */
+int
+Config::setOption(const std::string &name,
+                  int value)
+{
+    std::map<std::string, int>::iterator opt_i;
+
+    // confirm that the option exists
+    opt_i = _intOptMap.find(name);
+    if(opt_i == _intOptMap.end()) {
+        return -1;
+    }
+
+    // set the option
+    opt_i->second = value;
+    return 0;
+}
+
+/**
+ * Sets the specified option to the given string value.
+ */
+int
+Config::setOption(const std::string &name,
+                  const std::string &value)
+{
+    std::map<std::string, std::string>::iterator opt_i;
+
+    // confirm that the option exists
+    opt_i = _strOptMap.find(name);
+    if(opt_i == _strOptMap.end()) {
+        return -1;
+    }
+
+    // set the option
+    opt_i->second = value;
+    return 0;
+}
+
+int
+Config::getOption(const std::string &name,
+                  std::string *value)
+{
+    std::map<std::string, std::string>::iterator opt_i;
+
+    // confirm that the option exists
+    opt_i = _strOptMap.find(name);
+    if(opt_i == _strOptMap.end()) {
+        return -1;
+    }
+
+    // get the option
+    (*value) = opt_i->second;
+    return 0;
+}
+
+int
+Config::getOption(const std::string &name,
+                  const char **value)
+{
+    std::map<std::string, std::string>::iterator opt_i;
+
+    // confirm that the option exists
+    opt_i = _strOptMap.find(name);
+    if(opt_i == _strOptMap.end()) {
+        return -1;
+    }
+
+    // get the option
+    (*value) = opt_i->second.c_str();
+    return 0;
+}
+
+int
+Config::getOption(const std::string &name,
+                  int *value)
+{
+    std::map<std::string, int>::iterator opt_i;
+
+    // confirm that the option exists
+    opt_i = _intOptMap.find(name);
+    if(opt_i == _intOptMap.end()) {
+        return -1;
+    }
+
+    // get the option
+    (*value) = opt_i->second;
+    return 0;
+}
+
+
+/**
+ * Parses the command line arguments.  Short args are of the form -f
+ * <opt>, long args are of the form --foo <opt>.  Returns < 0 on error,
+ * or the index of the rom file in argv.
+ */
+int
+Config::_parseArgs(int argc,
+                   char **argv)
+{
+    int retval = 0;
+    std::map<std::string, std::string>::iterator long_i, str_i;
+    std::map<char, std::string>::iterator short_i;
+    std::map<std::string, int>::iterator int_i;
+    std::string arg, opt, value;
+
+    for(int i = 1; i < argc; i++) {
+        arg = argv[i];
+        if(arg[0] != '-') {
+            // must be a rom name?
+            retval = i;
+            continue;
+        }
+
+        if(arg.size() < 2) {
+            // XXX invalid argument
+            return -1;
+        }
+
+        // parse the argument and get the option name
+        if(arg[1] == '-') {
+            // long arg
+            long_i = _longArgMap.find(arg.substr(2));
+            if(long_i == _longArgMap.end()) {
+                // XXX invalid argument
+                return -1;
+            }
+
+            opt = long_i->second;
+        } else {
+            // short arg
+            short_i = _shortArgMap.find(arg[1]);
+            if(short_i == _shortArgMap.end()) {
+                // XXX invalid argument
+                return -1;
+            }
+
+            opt = short_i->second;
+        }
+
+        // make sure we've got a value
+        if(i + 1 >= argc) {
+            // XXX missing value
+            return -1;
+        }
+        i++;
+
+        // now, find the appropriate option entry, and update it
+        str_i = _strOptMap.find(opt);
+        int_i = _intOptMap.find(opt);
+        if(str_i != _strOptMap.end()) {
+            str_i->second = argv[i];
+        } else if(int_i != _intOptMap.end()) {
+            int_i->second = atol(argv[i]);
+        } else {
+            // XXX invalid option?  shouldn't happen
+            return -1;
+        }
+    }
+
+    // if we didn't get a rom-name, return error
+    return (retval) ? retval : -1;
+}
+
+
+/**
+ * Parses first the configuration file, and then overrides with any
+ * command-line options that were specified.
+ */
+int
+Config::parse(int argc,
+              char **argv)
+{
+    int error;
+
+    // read the config file
+    error = _load();
+    if(error) {
+        return error;
+    }
+
+    // parse the arguments
+    error = _parseArgs(argc, argv);
+    if(error) {
+        return error;
+    }
+
+    return 0;
+}
+
+
+/**
+ * Read each line of the config file and put the variables into the
+ * config maps.  Valid configuration lines are of the form:
+ *
+ * <option name> = <option value>
+ *
+ * Lines beginning with # are ignored.
+ */
+int
+Config::_load()
+{
+    int error;
+    unsigned int pos, eqPos;
+    std::fstream config;
+    std::map<std::string, int>::iterator int_i;
+    std::map<std::string, std::string>::iterator str_i;
+    std::string configFile = _dir + "/fceu.cfg";
+    std::string line, name, value;
+    char buf[1024];
+
+    // set the exception handling to catch i/o errors
+    config.exceptions(std::fstream::badbit);
+
+    try {
+        // open the file for reading (create if it doesn't exist)
+        config.open(configFile.c_str(), std::ios::in | std::ios::out);
+
+        while(!config.eof()) {
+            // read a line
+            config.getline(buf, 1024);
+            line = buf;
+
+            // check line validity
+            eqPos = line.find("=");
+            if(line[0] == '#' || eqPos == std::string::npos) {
+                // skip this line
+                continue;
+            }
+
+            // get the name and value for the option
+            pos = line.find(" ");
+            name = line.substr(0, (pos > eqPos) ? eqPos : pos);
+            pos = line.find_first_not_of(" ", eqPos + 1);
+            value = line.substr(pos);
+
+            // check if the option exists, and if so, set it appropriately
+            str_i = _strOptMap.find(name);
+            int_i = _intOptMap.find(name);
+            if(str_i != _strOptMap.end()) {
+                str_i->second = value;
+            } else if(int_i != _intOptMap.end()) {
+                int_i->second = atol(value.c_str());
+            }
+        }
+
+        // close the file
+        config.close();
+    } catch(std::fstream::failure e) {
+        std::cerr << e.what() << std::endl;
+        return -1;
+    }
+
+    return 0;
+}
+
+/**
+ * Writes the configuration file with the current configuration settings.
+ */
+int
+Config::save()
+{
+    int error;
+    std::fstream config;
+    std::map<std::string, int>::iterator int_i;
+    std::map<std::string, std::string>::iterator str_i;
+    std::string configFile = _dir + "/fceu.cfg";
+    char buf[1024];
+
+    // set the exception handling to catch i/o errors
+    config.exceptions(std::ios::failbit | std::ios::badbit);
+
+    try {
+        // open the file, truncate and for write
+        config.open(configFile.c_str(), std::ios::out | std::ios::trunc);
+
+        // write a warning
+        strcpy(buf, "# Auto-generated\n");
+        config.write(buf, strlen(buf));
+
+        // write each configuration setting
+        for(int_i = _intOptMap.begin(); int_i != _intOptMap.end(); int_i++) {
+            snprintf(buf, 1024, "%s = %d\n",
+                     int_i->first.c_str(), int_i->second);
+            config.write(buf, strlen(buf));
+        }
+        for(str_i = _strOptMap.begin(); str_i != _strOptMap.end(); str_i++) {
+            snprintf(buf, 1024, "%s = %s\n",
+                     str_i->first.c_str(), str_i->second.c_str());
+            config.write(buf, strlen(buf));
+        }
+
+        // close the file
+        config.close();
+    } catch(std::fstream::failure e) {
+        std::cerr << e.what() << std::endl;
+        return -1;
+    }
+
+    return 0;
+}
diff --git a/src/drivers/common/configSys.h b/src/drivers/common/configSys.h
new file mode 100644
index 00000000..da72c959
--- /dev/null
+++ b/src/drivers/common/configSys.h
@@ -0,0 +1,62 @@
+#ifndef __CONFIGSYS_H
+#define __CONFIGSYS_H
+
+#include <map>
+#include <string>
+
+class Config {
+private:
+    std::string _dir;
+
+    std::map<std::string, std::string> _strOptMap;
+    std::map<std::string, int>         _intOptMap;
+
+    std::map<char, std::string>        _shortArgMap;
+    std::map<std::string, std::string> _longArgMap;
+
+private:
+    int _addOption(char, const std::string &, const std::string &, int);
+    int _load(void);
+    int _parseArgs(int, char **);
+
+public:
+    const static int STRING  = 1;
+    const static int INTEGER = 2;
+
+public:
+    Config(std::string d) : _dir(d) { }
+    ~Config() { }
+
+    /**
+     * Adds a configuration option.  All options must be added before
+     * parse().
+     */
+    int addOption(char, const std::string &,
+                  const std::string &, int, int);
+    int addOption(char, const std::string &,
+                  const std::string &, int, const std::string &);
+
+    /**
+     * Sets a configuration option.  Can be called at any time.
+     */
+    int setOption(const std::string &, int);
+    int setOption(const std::string &, const std::string &);
+
+    int getOption(const std::string &, std::string *);
+    int getOption(const std::string &, const char **);
+    int getOption(const std::string &, int *);
+
+    /**
+     * Parse the arguments.  Also read in the configuration file and
+     * set the variables accordingly.
+     */
+    int parse(int, char **);
+
+    /**
+     * Save all of the current configuration options to the
+     * configuration file.
+     */
+    int save();
+};
+
+#endif // !__CONFIGSYS_H