X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fsettings.h;h=2aa03074b7d6bebec053b5927ad4663dc715442a;hb=83bafbe08b508266d31a6a76f1ffc2cddc662390;hp=9eb2254f06423c742da95fd76a54028ac4736f84;hpb=6ec447a1aa3678371af31aad4e186885ca4b8f27;p=minetest.git diff --git a/src/settings.h b/src/settings.h index 9eb2254f0..2aa03074b 100644 --- a/src/settings.h +++ b/src/settings.h @@ -1,18 +1,18 @@ /* -Minetest-c55 -Copyright (C) 2010-2011 celeron55, Perttu Ahola +Minetest +Copyright (C) 2010-2013 celeron55, Perttu Ahola 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 +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 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. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ @@ -20,18 +20,23 @@ with this program; if not, write to the Free Software Foundation, Inc., #ifndef SETTINGS_HEADER #define SETTINGS_HEADER -#include "common_irrlicht.h" +#include "irrlichttypes_bloated.h" +#include "exceptions.h" #include -#include -#include -#include +#include "jthread/jmutex.h" +#include "jthread/jmutexautolock.h" #include "strfnd.h" #include #include #include #include "debug.h" -#include "utility.h" #include "log.h" +#include "util/string.h" +#include "porting.h" +#include +#include +#include +#include "filesys.h" enum ValueType { @@ -55,29 +60,47 @@ class Settings public: Settings() { - m_mutex.Init(); } void writeLines(std::ostream &os) { JMutexAutoLock lock(m_mutex); - - for(core::map::Iterator - i = m_settings.getIterator(); - i.atEnd() == false; i++) + + for(std::map::iterator + i = m_settings.begin(); + i != m_settings.end(); ++i) { - std::string name = i.getNode()->getKey(); - std::string value = i.getNode()->getValue(); + std::string name = i->first; + std::string value = i->second; os< getNames(){ + std::vector names; + for(std::map::iterator + i = m_settings.begin(); + i != m_settings.end(); ++i) + { + names.push_back(i->first); + } + return names; + } + + // remove a setting + bool remove(const std::string& name) + { + return m_settings.erase(name); + } + bool parseConfigLine(const std::string &line) { JMutexAutoLock lock(m_mutex); - + std::string trimmedline = trim(line); - + // Ignore empty lines and comments if(trimmedline.size() == 0 || trimmedline[0] == '#') return true; @@ -91,15 +114,15 @@ class Settings if(name == "") return true; - + std::string value = sf.next("\n"); value = trim(value); /*infostream<<"Config name=\""< &dst, - core::map &updated, + std::list &dst, + std::set &updated, bool &value_changed) { JMutexAutoLock lock(m_mutex); - + if(is.eof()) return false; - + // NOTE: This function will be expanded to allow multi-line settings std::string line; std::getline(is, line); @@ -185,7 +208,7 @@ class Settings std::string line_end = ""; if(is.eof() == false) line_end = "\n"; - + // Ignore empty lines and comments if(trimmedline.size() == 0 || trimmedline[0] == '#') { @@ -203,14 +226,14 @@ class Settings dst.push_back(line+line_end); return true; } - + std::string value = sf.next("\n"); value = trim(value); - - if(m_settings.find(name)) + + if(m_settings.find(name) != m_settings.end()) { std::string newvalue = m_settings[name]; - + if(newvalue != value) { infostream<<"Changing value of \""< objects; - core::map updated; + + std::list objects; + std::set updated; bool something_actually_changed = false; - + // Read and modify stuff { std::ifstream is(filename); @@ -257,68 +282,68 @@ class Settings something_actually_changed)); } } - + JMutexAutoLock lock(m_mutex); - + // If something not yet determined to have been changed, check if // any new stuff was added if(!something_actually_changed){ - for(core::map::Iterator - i = m_settings.getIterator(); - i.atEnd() == false; i++) + for(std::map::iterator + i = m_settings.begin(); + i != m_settings.end(); ++i) { - if(updated.find(i.getNode()->getKey())) + if(updated.find(i->first) != updated.end()) continue; something_actually_changed = true; break; } } - + // If nothing was actually changed, skip writing the file if(!something_actually_changed){ infostream<<"Skipping writing of "<::Iterator + for(std::list::iterator i = objects.begin(); - i != objects.end(); i++) + i != objects.end(); ++i) { - os<<(*i); + ss<<(*i); } /* Write stuff that was not already in the file */ - for(core::map::Iterator - i = m_settings.getIterator(); - i.atEnd() == false; i++) + for(std::map::iterator + i = m_settings.begin(); + i != m_settings.end(); ++i) { - if(updated.find(i.getNode()->getKey())) + if(updated.find(i->first) != updated.end()) continue; - std::string name = i.getNode()->getKey(); - std::string value = i.getNode()->getValue(); + std::string name = i->first; + std::string value = i->second; infostream<<"Adding \""< &allowed_options) + std::map &allowed_options) { + int nonopt_index = 0; int i=1; for(;;) { @@ -338,6 +364,15 @@ class Settings std::string argname = argv[i]; if(argname.substr(0, 2) != "--") { + // If option doesn't start with -, read it in as nonoptX + if(argname[0] != '-'){ + std::string name = "nonopt"; + name += itos(nonopt_index); + set(name, argname); + nonopt_index++; + i++; + continue; + } errorstream<<"Invalid command-line parameter \"" < expected."<::Node *n; + std::map::iterator n; n = allowed_options.find(name); - if(n == NULL) + if(n == allowed_options.end()) { errorstream<<"Unknown command-line parameter \"" <getValue().type; + ValueType type = n->second.type; std::string value = ""; - + if(type == VALUETYPE_FLAG) { value = "true"; @@ -374,7 +409,7 @@ class Settings value = argv[i]; i++; } - + infostream<<"Valid command-line parameter: \"" <::Node *n; + + std::map::iterator n; n = m_settings.find(name); - if(n == NULL) + if(n == m_settings.end()) { n = m_defaults.find(name); - if(n == NULL) + if(n == m_defaults.end()) { - infostream<<"Settings: Setting not found: \"" - <getValue(); + return n->second; } + //////////// Get setting bool getBool(std::string name) { return is_yes(get(name)); } - + bool getFlag(std::string name) { try @@ -457,7 +491,7 @@ class Settings // If it is in settings if(exists(name)) return getBool(name); - + std::string s; char templine[10]; std::cout< strs_alloced; + std::string *str, valstr; + char *f, *snext; + size_t pos; + + try { + valstr = get(name); + } catch (SettingNotFoundException &e) { + return false; + } + + char *s = &valstr[0]; + char *buf = new char[len]; + char *bufpos = buf; + + char *fmtpos, *fmt = &format[0]; + while ((f = strtok_r(fmt, ",", &fmtpos)) && s) { + fmt = NULL; + + bool is_unsigned = false; + int width = 0; + char valtype = *f; + + width = (int)strtol(f + 1, &f, 10); + if (width && valtype == 's') + valtype = 'i'; + + switch (valtype) { + case 'u': + is_unsigned = true; + /* FALLTHROUGH */ + case 'i': + if (width == 16) { + bufpos += PADDING(bufpos, u16); + if ((bufpos - buf) + sizeof(u16) <= len) { + if (is_unsigned) + *(u16 *)bufpos = (u16)strtoul(s, &s, 10); + else + *(s16 *)bufpos = (s16)strtol(s, &s, 10); + } + bufpos += sizeof(u16); + } else if (width == 32) { + bufpos += PADDING(bufpos, u32); + if ((bufpos - buf) + sizeof(u32) <= len) { + if (is_unsigned) + *(u32 *)bufpos = (u32)strtoul(s, &s, 10); + else + *(s32 *)bufpos = (s32)strtol(s, &s, 10); + } + bufpos += sizeof(u32); + } else if (width == 64) { + bufpos += PADDING(bufpos, u64); + if ((bufpos - buf) + sizeof(u64) <= len) { + if (is_unsigned) + *(u64 *)bufpos = (u64)strtoull(s, &s, 10); + else + *(s64 *)bufpos = (s64)strtoll(s, &s, 10); + } + bufpos += sizeof(u64); + } + s = strchr(s, ','); + break; + case 'b': + snext = strchr(s, ','); + if (snext) + *snext++ = 0; + + bufpos += PADDING(bufpos, bool); + if ((bufpos - buf) + sizeof(bool) <= len) + *(bool *)bufpos = is_yes(std::string(s)); + bufpos += sizeof(bool); + + s = snext; + break; + case 'f': + bufpos += PADDING(bufpos, float); + if ((bufpos - buf) + sizeof(float) <= len) + *(float *)bufpos = strtof(s, &s); + bufpos += sizeof(float); + + s = strchr(s, ','); + break; + case 's': + while (*s == ' ' || *s == '\t') + s++; + if (*s++ != '"') //error, expected string + goto fail; + snext = s; + + while (snext[0] && !(snext[-1] != '\\' && snext[0] == '"')) + snext++; + *snext++ = 0; + + bufpos += PADDING(bufpos, std::string *); + + str = new std::string(s); + pos = 0; + while ((pos = str->find("\\\"", pos)) != std::string::npos) + str->erase(pos, 1); + + if ((bufpos - buf) + sizeof(std::string *) <= len) + *(std::string **)bufpos = str; + bufpos += sizeof(std::string *); + strs_alloced.push_back(str); + + s = *snext ? snext + 1 : NULL; + break; + case 'v': + while (*s == ' ' || *s == '\t') + s++; + if (*s++ != '(') //error, expected vector + goto fail; + + if (width == 2) { + bufpos += PADDING(bufpos, v2f); + + if ((bufpos - buf) + sizeof(v2f) <= len) { + v2f *v = (v2f *)bufpos; + v->X = strtof(s, &s); + s++; + v->Y = strtof(s, &s); + } + + bufpos += sizeof(v2f); + } else if (width == 3) { + bufpos += PADDING(bufpos, v3f); + if ((bufpos - buf) + sizeof(v3f) <= len) { + v3f *v = (v3f *)bufpos; + v->X = strtof(s, &s); + s++; + v->Y = strtof(s, &s); + s++; + v->Z = strtof(s, &s); + } + + bufpos += sizeof(v3f); + } + s = strchr(s, ','); + break; + default: //error, invalid format specifier + goto fail; + } + + if (s && *s == ',') + s++; + + if ((size_t)(bufpos - buf) > len) //error, buffer too small + goto fail; + } + + if (f && *f) { //error, mismatched number of fields and values +fail: + for (size_t i = 0; i != strs_alloced.size(); i++) + delete strs_alloced[i]; + delete[] buf; + return false; + } + + memcpy(out, buf, olen); + delete[] buf; + return true; + } + + //////////// Try to get value, no exception thrown + bool getNoEx(std::string name, std::string &val) + { + try { + val = get(name); + return true; + } catch (SettingNotFoundException &e) { + return false; + } + } + + // N.B. getFlagStrNoEx() does not set val, but merely modifies it. Thus, + // val must be initialized before using getFlagStrNoEx(). The intention of + // this is to simplify modifying a flags field from a default value. + bool getFlagStrNoEx(std::string name, u32 &val, FlagDesc *flagdesc) + { + try { + u32 flags, flagmask; + + flags = getFlagStr(name, flagdesc, &flagmask); + + val &= ~flagmask; + val |= flags; + + return true; + } catch (SettingNotFoundException &e) { + return false; + } + } + + bool getFloatNoEx(std::string name, float &val) + { + try { + val = getFloat(name); + return true; + } catch (SettingNotFoundException &e) { + return false; + } + } + + bool getU16NoEx(std::string name, int &val) + { + try { + val = getU16(name); + return true; + } catch (SettingNotFoundException &e) { + return false; + } + } + + bool getU16NoEx(std::string name, u16 &val) + { + try { + val = getU16(name); + return true; + } catch (SettingNotFoundException &e) { + return false; + } + } + + bool getS16NoEx(std::string name, int &val) + { + try { + val = getU16(name); + return true; + } catch (SettingNotFoundException &e) { + return false; + } + } + + bool getS16NoEx(std::string name, s16 &val) + { + try { + val = getS16(name); + return true; + } catch (SettingNotFoundException &e) { + return false; + } + } + + bool getS32NoEx(std::string name, s32 &val) + { + try { + val = getS32(name); + return true; + } catch (SettingNotFoundException &e) { + return false; + } + } + + bool getV3FNoEx(std::string name, v3f &val) + { + try { + val = getV3F(name); + return true; + } catch (SettingNotFoundException &e) { + return false; + } + } + + bool getV2FNoEx(std::string name, v2f &val) + { + try { + val = getV2F(name); + return true; + } catch (SettingNotFoundException &e) { + return false; + } + } + + bool getU64NoEx(std::string name, u64 &val) + { + try { + val = getU64(name); + return true; + } catch (SettingNotFoundException &e) { + return false; + } + } + + //////////// Set setting + + // N.B. if setStruct() is used to write a non-POD aggregate type, + // the behavior is undefined. + bool setStruct(std::string name, std::string format, void *value) + { + char sbuf[2048]; + int sbuflen = sizeof(sbuf) - 1; + sbuf[sbuflen] = 0; + std::string str; + int pos = 0; + size_t fpos; + char *f; + + char *bufpos = (char *)value; + char *fmtpos, *fmt = &format[0]; + while ((f = strtok_r(fmt, ",", &fmtpos))) { + fmt = NULL; + bool is_unsigned = false; + int width = 0, nprinted = 0; + char valtype = *f; + + width = (int)strtol(f + 1, &f, 10); + if (width && valtype == 's') + valtype = 'i'; + + switch (valtype) { + case 'u': + is_unsigned = true; + /* FALLTHROUGH */ + case 'i': + if (width == 16) { + bufpos += PADDING(bufpos, u16); + nprinted = snprintf(sbuf + pos, sbuflen, + is_unsigned ? "%u, " : "%d, ", + *((u16 *)bufpos)); + bufpos += sizeof(u16); + } else if (width == 32) { + bufpos += PADDING(bufpos, u32); + nprinted = snprintf(sbuf + pos, sbuflen, + is_unsigned ? "%u, " : "%d, ", + *((u32 *)bufpos)); + bufpos += sizeof(u32); + } else if (width == 64) { + bufpos += PADDING(bufpos, u64); + nprinted = snprintf(sbuf + pos, sbuflen, + is_unsigned ? "%llu, " : "%lli, ", + (unsigned long long)*((u64 *)bufpos)); + bufpos += sizeof(u64); + } + break; + case 'b': + bufpos += PADDING(bufpos, bool); + nprinted = snprintf(sbuf + pos, sbuflen, "%s, ", + *((bool *)bufpos) ? "true" : "false"); + bufpos += sizeof(bool); + break; + case 'f': + bufpos += PADDING(bufpos, float); + nprinted = snprintf(sbuf + pos, sbuflen, "%f, ", + *((float *)bufpos)); + bufpos += sizeof(float); + break; + case 's': + bufpos += PADDING(bufpos, std::string *); + str = **((std::string **)bufpos); + + fpos = 0; + while ((fpos = str.find('"', fpos)) != std::string::npos) { + str.insert(fpos, 1, '\\'); + fpos += 2; + } + + nprinted = snprintf(sbuf + pos, sbuflen, "\"%s\", ", + (*((std::string **)bufpos))->c_str()); + bufpos += sizeof(std::string *); + break; + case 'v': + if (width == 2) { + bufpos += PADDING(bufpos, v2f); + v2f *v = (v2f *)bufpos; + nprinted = snprintf(sbuf + pos, sbuflen, + "(%f, %f), ", v->X, v->Y); + bufpos += sizeof(v2f); + } else { + bufpos += PADDING(bufpos, v3f); + v3f *v = (v3f *)bufpos; + nprinted = snprintf(sbuf + pos, sbuflen, + "(%f, %f, %f), ", v->X, v->Y, v->Z); + bufpos += sizeof(v3f); + } + break; + default: + return false; + } + if (nprinted < 0) //error, buffer too small + return false; + pos += nprinted; + sbuflen -= nprinted; + } + + if (pos >= 2) + sbuf[pos - 2] = 0; + + set(name, std::string(sbuf)); + return true; + } + + void setFlagStr(std::string name, u32 flags, + FlagDesc *flagdesc, u32 flagmask) + { + set(name, writeFlagString(flags, flagdesc, flagmask)); + } + void setBool(std::string name, bool value) { if(value) @@ -546,11 +989,6 @@ class Settings set(name, "false"); } - void setS32(std::string name, s32 value) - { - set(name, itos(value)); - } - void setFloat(std::string name, float value) { set(name, ftos(value)); @@ -570,6 +1008,16 @@ class Settings set(name, os.str()); } + void setS16(std::string name, s16 value) + { + set(name, itos(value)); + } + + void setS32(std::string name, s32 value) + { + set(name, itos(value)); + } + void setU64(std::string name, u64 value) { std::ostringstream os; @@ -580,7 +1028,7 @@ class Settings void clear() { JMutexAutoLock lock(m_mutex); - + m_settings.clear(); m_defaults.clear(); } @@ -588,7 +1036,7 @@ class Settings void updateValue(Settings &other, const std::string &name) { JMutexAutoLock lock(m_mutex); - + if(&other == this) return; @@ -605,23 +1053,12 @@ class Settings { JMutexAutoLock lock(m_mutex); JMutexAutoLock lock2(other.m_mutex); - + if(&other == this) return; - for(core::map::Iterator - i = other.m_settings.getIterator(); - i.atEnd() == false; i++) - { - m_settings[i.getNode()->getKey()] = i.getNode()->getValue(); - } - - for(core::map::Iterator - i = other.m_defaults.getIterator(); - i.atEnd() == false; i++) - { - m_defaults[i.getNode()->getKey()] = i.getNode()->getValue(); - } + m_settings.insert(other.m_settings.begin(), other.m_settings.end()); + m_defaults.insert(other.m_defaults.begin(), other.m_defaults.end()); return; } @@ -630,25 +1067,11 @@ class Settings { JMutexAutoLock lock(m_mutex); JMutexAutoLock lock2(other.m_mutex); - + if(&other == this) return *this; - for(core::map::Iterator - i = other.m_settings.getIterator(); - i.atEnd() == false; i++) - { - m_settings.insert(i.getNode()->getKey(), - i.getNode()->getValue()); - } - - for(core::map::Iterator - i = other.m_defaults.getIterator(); - i.atEnd() == false; i++) - { - m_defaults.insert(i.getNode()->getKey(), - i.getNode()->getValue()); - } + update(other); return *this; @@ -658,19 +1081,19 @@ class Settings { JMutexAutoLock lock(m_mutex); JMutexAutoLock lock2(other.m_mutex); - + if(&other == this) return *this; clear(); (*this) += other; - + return *this; } private: - core::map m_settings; - core::map m_defaults; + std::map m_settings; + std::map m_defaults; // All methods that access m_settings/m_defaults directly should lock this. JMutex m_mutex; };