mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-15 14:18:37 +00:00
cca744f69a
svn-id: r17975
523 lines
14 KiB
C++
523 lines
14 KiB
C++
/* ScummVM - Scumm Interpreter
|
|
* Copyright (C) 2001 Ludvig Strigeus
|
|
* Copyright (C) 2001-2005 The ScummVM project
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*
|
|
* $Header$
|
|
*
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "common/config-manager.h"
|
|
#include "common/file.h"
|
|
#include "common/util.h"
|
|
|
|
DECLARE_SINGLETON(Common::ConfigManager);
|
|
|
|
#if defined(UNIX)
|
|
#ifdef MACOSX
|
|
#define DEFAULT_CONFIG_FILE "Library/Preferences/ScummVM Preferences"
|
|
#else
|
|
#define DEFAULT_CONFIG_FILE ".scummvmrc"
|
|
#endif
|
|
#else
|
|
#define DEFAULT_CONFIG_FILE "scummvm.ini"
|
|
#endif
|
|
|
|
#define MAXLINELEN 256
|
|
|
|
static char *ltrim(char *t) {
|
|
while (isspace(*t))
|
|
t++;
|
|
return t;
|
|
}
|
|
|
|
static char *rtrim(char *t) {
|
|
int l = strlen(t) - 1;
|
|
while (l >= 0 && isspace(t[l]))
|
|
t[l--] = 0;
|
|
return t;
|
|
}
|
|
|
|
static bool isValidDomainName(const Common::String &domain) {
|
|
const char *p = domain.c_str();
|
|
while (*p && (isalnum(*p) || *p == '-' || *p == '_'))
|
|
p++;
|
|
return *p == 0;
|
|
}
|
|
|
|
namespace Common {
|
|
|
|
const String ConfigManager::kApplicationDomain("scummvm");
|
|
const String ConfigManager::kTransientDomain("__TRANSIENT");
|
|
|
|
const String trueStr("true");
|
|
const String falseStr("false");
|
|
|
|
|
|
#pragma mark -
|
|
|
|
|
|
ConfigManager::ConfigManager() {
|
|
// Ensure the global domain(s) are setup.
|
|
_globalDomains.addKey(kApplicationDomain);
|
|
}
|
|
|
|
|
|
void ConfigManager::loadDefaultConfigFile() {
|
|
char configFile[MAXPATHLEN];
|
|
#if defined(UNIX)
|
|
if (getenv("HOME") != NULL)
|
|
sprintf(configFile,"%s/%s", getenv("HOME"), DEFAULT_CONFIG_FILE);
|
|
else
|
|
strcpy(configFile, DEFAULT_CONFIG_FILE);
|
|
#else
|
|
#if defined (WIN32) && !defined(_WIN32_WCE)
|
|
GetWindowsDirectory(configFile, MAXPATHLEN);
|
|
strcat(configFile, "\\" DEFAULT_CONFIG_FILE);
|
|
#elif defined(__PALM_OS__)
|
|
strcpy(configFile,"/PALM/Programs/ScummVM/" DEFAULT_CONFIG_FILE);
|
|
#elif defined(__PLAYSTATION2__)
|
|
strcpy(configFile, "mc0:ScummVM/" DEFAULT_CONFIG_FILE);
|
|
#else
|
|
strcpy(configFile, DEFAULT_CONFIG_FILE);
|
|
#endif
|
|
#endif
|
|
|
|
loadConfigFile(configFile);
|
|
}
|
|
|
|
void ConfigManager::loadConfigFile(const String &filename) {
|
|
_globalDomains.clear();
|
|
_gameDomains.clear();
|
|
_transientDomain.clear();
|
|
|
|
// Ensure the global domain(s) are setup.
|
|
_globalDomains.addKey(kApplicationDomain);
|
|
|
|
_filename = filename;
|
|
_domainSaveOrder.clear();
|
|
loadFile(_filename);
|
|
debug(1, "Switched to configuration %s", _filename.c_str());
|
|
}
|
|
|
|
void ConfigManager::loadFile(const String &filename) {
|
|
File cfg_file;
|
|
|
|
if (!cfg_file.open(filename.c_str())) {
|
|
warning("Unable to open configuration file: %s", filename.c_str());
|
|
} else {
|
|
char buf[MAXLINELEN];
|
|
String domain;
|
|
String comment;
|
|
int lineno = 0;
|
|
|
|
// TODO: Detect if a domain occurs multiple times (or likewise, if
|
|
// a key occurs multiple times inside one domain).
|
|
|
|
while (!cfg_file.eof()) {
|
|
lineno++;
|
|
if (!cfg_file.readLine(buf, MAXLINELEN))
|
|
break;
|
|
|
|
if (buf[0] == '#') {
|
|
// Accumulate comments here. Once we encounter either the start
|
|
// of a new domain, or a key-value-pair, we associate the value
|
|
// of the 'comment' variable with that entity.
|
|
comment += buf;
|
|
comment += '\n';
|
|
} else if (buf[0] == '[') {
|
|
// It's a new domain which begins here.
|
|
char *p = buf + 1;
|
|
// Get the domain name, and check whether it's valid (that
|
|
// is, verify that it only consists of alphanumerics,
|
|
// dashes and underscores).
|
|
while (*p && (isalnum(*p) || *p == '-' || *p == '_'))
|
|
p++;
|
|
|
|
switch (*p) {
|
|
case '\0':
|
|
error("Config file buggy: missing ] in line %d", lineno);
|
|
break;
|
|
case ']':
|
|
*p = 0;
|
|
domain = buf + 1;
|
|
break;
|
|
default:
|
|
error("Config file buggy: Invalid character '%c' occured in domain name in line %d", *p, lineno);
|
|
}
|
|
|
|
// Store domain comment
|
|
if (_globalDomains.contains(domain)) {
|
|
_globalDomains[domain].setDomainComment(comment);
|
|
} else {
|
|
_gameDomains[domain].setDomainComment(comment);
|
|
}
|
|
comment.clear();
|
|
|
|
_domainSaveOrder.push_back(domain);
|
|
} else {
|
|
// Skip leading & trailing whitespaces
|
|
char *t = rtrim(ltrim(buf));
|
|
|
|
// Skip empty lines
|
|
if (*t == 0)
|
|
continue;
|
|
|
|
// If no domain has been set, this config file is invalid!
|
|
if (domain.isEmpty()) {
|
|
error("Config file buggy: Key/value pair found outside a domain in line %d", lineno);
|
|
}
|
|
|
|
// Split string at '=' into 'key' and 'value'.
|
|
char *p = strchr(t, '=');
|
|
if (!p)
|
|
error("Config file buggy: Junk found in line line %d: '%s'", lineno, t);
|
|
*p = 0;
|
|
String key = rtrim(t);
|
|
String value = ltrim(p + 1);
|
|
set(key, value, domain);
|
|
|
|
// Store comment
|
|
if (_globalDomains.contains(domain)) {
|
|
_globalDomains[domain].setKVComment(key, comment);
|
|
} else {
|
|
_gameDomains[domain].setKVComment(key, comment);
|
|
}
|
|
comment.clear();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ConfigManager::flushToDisk() {
|
|
FILE *cfg_file;
|
|
|
|
// TODO
|
|
// if (!willwrite)
|
|
// return;
|
|
|
|
if (!(cfg_file = fopen(_filename.c_str(), "w"))) {
|
|
warning("Unable to write configuration file: %s", _filename.c_str());
|
|
} else {
|
|
|
|
// First write the domains in _domainSaveOrder, in that order.
|
|
// Note: It's possible for _domainSaveOrder to list domains which
|
|
// are not present anymore.
|
|
StringList::const_iterator i;
|
|
for (i = _domainSaveOrder.begin(); i != _domainSaveOrder.end(); ++i) {
|
|
if (_globalDomains.contains(*i)) {
|
|
writeDomain(cfg_file, *i, _globalDomains[*i]);
|
|
} else if (_gameDomains.contains(*i)) {
|
|
writeDomain(cfg_file, *i, _gameDomains[*i]);
|
|
}
|
|
}
|
|
|
|
DomainMap::const_iterator d;
|
|
|
|
// Now write the global domains which weren't written yet
|
|
for (d = _globalDomains.begin(); d != _globalDomains.end(); ++d) {
|
|
if (!_domainSaveOrder.contains(d->_key))
|
|
writeDomain(cfg_file, d->_key, d->_value);
|
|
}
|
|
|
|
// Finally write the remaining game domains
|
|
for (d = _gameDomains.begin(); d != _gameDomains.end(); ++d) {
|
|
if (!_domainSaveOrder.contains(d->_key))
|
|
writeDomain(cfg_file, d->_key, d->_value);
|
|
}
|
|
|
|
fclose(cfg_file);
|
|
}
|
|
}
|
|
|
|
void ConfigManager::writeDomain(FILE *file, const String &name, const Domain &domain) {
|
|
if (domain.isEmpty())
|
|
return; // Don't bother writing empty domains.
|
|
|
|
String comment;
|
|
|
|
// Write domain comment (if any)
|
|
comment = domain.getDomainComment();
|
|
if (!comment.isEmpty())
|
|
fprintf(file, "%s", comment.c_str());
|
|
|
|
// Write domain start
|
|
fprintf(file, "[%s]\n", name.c_str());
|
|
|
|
// Write all key/value pairs in this domain, including comments
|
|
Domain::const_iterator x;
|
|
for (x = domain.begin(); x != domain.end(); ++x) {
|
|
const String &value = x->_value;
|
|
if (!value.isEmpty()) {
|
|
// Write comment (if any)
|
|
if (domain.hasKVComment(x->_key)) {
|
|
comment = domain.getKVComment(x->_key);
|
|
fprintf(file, "%s", comment.c_str());
|
|
}
|
|
// Write the key/value pair
|
|
fprintf(file, "%s=%s\n", x->_key.c_str(), value.c_str());
|
|
}
|
|
}
|
|
fprintf(file, "\n");
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
|
|
bool ConfigManager::hasKey(const String &key) const {
|
|
// Search the domains in the following order:
|
|
// 1) Transient domain
|
|
// 2) Active game domain (if any)
|
|
// 3) All global domains
|
|
// The defaults domain is explicitly *not* checked.
|
|
|
|
if (_transientDomain.contains(key))
|
|
return true;
|
|
|
|
if (!_activeDomain.isEmpty() && _gameDomains[_activeDomain].contains(key))
|
|
return true;
|
|
|
|
DomainMap::const_iterator iter;
|
|
for (iter = _globalDomains.begin(); iter != _globalDomains.end(); ++iter) {
|
|
if (iter->_value.contains(key))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ConfigManager::hasKey(const String &key, const String &dom) const {
|
|
assert(!dom.isEmpty());
|
|
assert(isValidDomainName(dom));
|
|
|
|
if (dom == kTransientDomain)
|
|
return _transientDomain.contains(key);
|
|
if (_gameDomains.contains(dom))
|
|
return _gameDomains[dom].contains(key);
|
|
if (_globalDomains.contains(dom))
|
|
return _globalDomains[dom].contains(key);
|
|
|
|
return false;
|
|
}
|
|
|
|
void ConfigManager::removeKey(const String &key, const String &dom) {
|
|
assert(!dom.isEmpty());
|
|
assert(isValidDomainName(dom));
|
|
|
|
if (dom == kTransientDomain)
|
|
_transientDomain.remove(key);
|
|
else if (_gameDomains.contains(dom))
|
|
_gameDomains[dom].remove(key);
|
|
else if (_globalDomains.contains(dom))
|
|
_globalDomains[dom].remove(key);
|
|
else
|
|
error("Removing key '%s' from non-existent domain '%s'", key.c_str(), dom.c_str());
|
|
}
|
|
|
|
|
|
#pragma mark -
|
|
|
|
|
|
const String & ConfigManager::get(const String &key, const String &domain) const {
|
|
assert(isValidDomainName(domain));
|
|
|
|
// Search the domains in the following order:
|
|
// 1) Transient domain
|
|
// 2) Active game domain (if any)
|
|
// 3) All global domains
|
|
// 4) The defaults
|
|
|
|
|
|
if ((domain.isEmpty() || domain == kTransientDomain) && _transientDomain.contains(key))
|
|
return _transientDomain[key];
|
|
|
|
const String &dom = domain.isEmpty() ? _activeDomain : domain;
|
|
|
|
if (!dom.isEmpty() && _gameDomains.contains(dom) && _gameDomains[dom].contains(key))
|
|
return _gameDomains[dom][key];
|
|
|
|
DomainMap::const_iterator iter;
|
|
for (iter = _globalDomains.begin(); iter != _globalDomains.end(); ++iter) {
|
|
if (iter->_value.contains(key))
|
|
return iter->_value[key];
|
|
}
|
|
|
|
return _defaultsDomain.get(key);
|
|
}
|
|
|
|
int ConfigManager::getInt(const String &key, const String &dom) const {
|
|
String value(get(key, dom));
|
|
char *errpos;
|
|
|
|
// For now, be tolerant against missing config keys. Strictly spoken, it is
|
|
// a bug in the calling code to retrieve an int for a key which isn't even
|
|
// present... and a default value of 0 seems rather arbitrary.
|
|
if (value.isEmpty())
|
|
return 0;
|
|
|
|
int ivalue = (int)strtol(value.c_str(), &errpos, 10);
|
|
if (value.c_str() == errpos)
|
|
error("Config file buggy: '%s' is not a valid integer", errpos);
|
|
|
|
return ivalue;
|
|
}
|
|
|
|
bool ConfigManager::getBool(const String &key, const String &dom) const {
|
|
String value(get(key, dom));
|
|
|
|
if ((value == trueStr) || (value == "yes") || (value == "1"))
|
|
return true;
|
|
if ((value == falseStr) || (value == "no") || (value == "0"))
|
|
return false;
|
|
|
|
error("Config file buggy: '%s' is not a valid bool", value.c_str());
|
|
}
|
|
|
|
|
|
#pragma mark -
|
|
|
|
|
|
void ConfigManager::set(const String &key, const String &value, const String &dom) {
|
|
assert(isValidDomainName(dom));
|
|
if (dom.isEmpty()) {
|
|
// Remove the transient domain value
|
|
_transientDomain.remove(key);
|
|
|
|
if (_activeDomain.isEmpty())
|
|
_globalDomains[kApplicationDomain][key] = value;
|
|
else
|
|
_gameDomains[_activeDomain][key] = value;
|
|
|
|
} else {
|
|
|
|
if (dom == kTransientDomain)
|
|
_transientDomain[key] = value;
|
|
else {
|
|
if (_globalDomains.contains(dom)) {
|
|
_globalDomains[dom][key] = value;
|
|
if (_activeDomain.isEmpty() || !_gameDomains[_activeDomain].contains(key))
|
|
_transientDomain.remove(key);
|
|
} else {
|
|
_gameDomains[dom][key] = value;
|
|
if (dom == _activeDomain)
|
|
_transientDomain.remove(key);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ConfigManager::set(const String &key, const char *value, const String &dom) {
|
|
set(key, String(value), dom);
|
|
}
|
|
|
|
void ConfigManager::set(const String &key, int value, const String &dom) {
|
|
char tmp[128];
|
|
snprintf(tmp, sizeof(tmp), "%i", value);
|
|
set(key, String(tmp), dom);
|
|
}
|
|
|
|
void ConfigManager::set(const String &key, bool value, const String &dom) {
|
|
set(key, value ? trueStr : falseStr, dom);
|
|
}
|
|
|
|
|
|
#pragma mark -
|
|
|
|
|
|
void ConfigManager::registerDefault(const String &key, const String &value) {
|
|
_defaultsDomain[key] = value;
|
|
}
|
|
|
|
void ConfigManager::registerDefault(const String &key, const char *value) {
|
|
registerDefault(key, String(value));
|
|
}
|
|
|
|
void ConfigManager::registerDefault(const String &key, int value) {
|
|
char tmp[128];
|
|
snprintf(tmp, sizeof(tmp), "%i", value);
|
|
registerDefault(key, tmp);
|
|
}
|
|
|
|
void ConfigManager::registerDefault(const String &key, bool value) {
|
|
registerDefault(key, value ? trueStr : falseStr);
|
|
}
|
|
|
|
|
|
#pragma mark -
|
|
|
|
|
|
void ConfigManager::setActiveDomain(const String &domain) {
|
|
assert(!domain.isEmpty());
|
|
assert(isValidDomainName(domain));
|
|
_activeDomain = domain;
|
|
_gameDomains.addKey(domain);
|
|
}
|
|
|
|
void ConfigManager::removeGameDomain(const String &domain) {
|
|
assert(!domain.isEmpty());
|
|
assert(isValidDomainName(domain));
|
|
_gameDomains.remove(domain);
|
|
}
|
|
|
|
void ConfigManager::renameGameDomain(const String &oldName, const String &newName) {
|
|
if (oldName == newName)
|
|
return;
|
|
|
|
assert(!oldName.isEmpty());
|
|
assert(!newName.isEmpty());
|
|
assert(isValidDomainName(oldName));
|
|
assert(isValidDomainName(newName));
|
|
|
|
_gameDomains[newName].merge(_gameDomains[oldName]);
|
|
|
|
_gameDomains.remove(oldName);
|
|
}
|
|
|
|
bool ConfigManager::hasGameDomain(const String &domain) const {
|
|
assert(!domain.isEmpty());
|
|
return isValidDomainName(domain) && _gameDomains.contains(domain);
|
|
}
|
|
|
|
|
|
#pragma mark -
|
|
|
|
|
|
const String &ConfigManager::Domain::get(const String &key) const {
|
|
Node *node = findNode(_root, key);
|
|
return node ? node->_value : String::emptyString;
|
|
}
|
|
|
|
void ConfigManager::Domain::setDomainComment(const String &comment) {
|
|
_domainComment = comment;
|
|
}
|
|
const String &ConfigManager::Domain::getDomainComment() const {
|
|
return _domainComment;
|
|
}
|
|
|
|
void ConfigManager::Domain::setKVComment(const String &key, const String &comment) {
|
|
_keyValueComments[key] = comment;
|
|
}
|
|
const String &ConfigManager::Domain::getKVComment(const String &key) const {
|
|
return _keyValueComments[key];
|
|
}
|
|
bool ConfigManager::Domain::hasKVComment(const String &key) const {
|
|
return _keyValueComments.contains(key);
|
|
}
|
|
|
|
} // End of namespace Common
|