settings: Add setting groups and multiline entries

src/settings.cpp

@@ -32,6 +32,14 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <cctype>
 
 
+Settings::~Settings()
+{
+	std::map<std::string, SettingsEntry>::const_iterator it;
+	for (it = m_settings.begin(); it != m_settings.end(); ++it)
+		delete it->second.group;
+}
+
+
 Settings & Settings::operator += (const Settings &other)
 {
 	update(other);
@@ -55,23 +63,62 @@ Settings & Settings::operator = (const Settings &other)
 }
 
 
-bool Settings::parseConfigLines(std::istream &is,
+std::string Settings::getMultiline(std::istream &is)
-		const std::string &end)
+{
+	std::string value;
+	std::string line;
+
+	while (is.good()) {
+		std::getline(is, line);
+		if (line == "\"\"\"")
+			break;
+		value += line;
+		value.push_back('\n');
+	}
+
+	size_t len = value.size();
+	if (len)
+		value.erase(len - 1);
+
+	return value;
+}
+
+
+bool Settings::parseConfigLines(std::istream &is, const std::string &end)
 {
 	JMutexAutoLock lock(m_mutex);
 
-	std::string name, value;
+	std::string line, name, value;
-	bool end_found = false;
 
-	while (is.good() && !end_found) {
+	while (is.good()) {
-		if (parseConfigObject(is, name, value, end, end_found)) {
+		std::getline(is, line);
-			m_settings[name] = value;
+		SettingsParseEvent event = parseConfigObject(line, end, name, value);
+
+		switch (event) {
+		case SPE_NONE:
+		case SPE_INVALID:
+		case SPE_COMMENT:
+			break;
+		case SPE_KVPAIR:
+			m_settings[name] = SettingsEntry(value);
+			break;
+		case SPE_END:
+			return true;
+		case SPE_GROUP: {
+			Settings *branch = new Settings;
+			if (!branch->parseConfigLines(is, "}"))
+				return false;
+
+			m_settings[name] = SettingsEntry(branch);
+			break;
+		}
+		case SPE_MULTILINE:
+			m_settings[name] = SettingsEntry(getMultiline(is));
+			break;
 		}
 	}
-	if (!end.empty() && !end_found) {
+
-		return false;
+	return end.empty();
-	}
-	return true;
 }
 
 
@@ -81,92 +128,146 @@ bool Settings::readConfigFile(const char *filename)
 	if (!is.good())
 		return false;
 
-	JMutexAutoLock lock(m_mutex);
+	return parseConfigLines(is, "");
-
-	std::string name, value;
-
-	while (is.good()) {
-		if (parseConfigObject(is, name, value)) {
-			m_settings[name] = value;
-		}
-	}
-
-	return true;
 }
 
 
-void Settings::writeLines(std::ostream &os) const
+void Settings::writeLines(std::ostream &os, u32 tab_depth) const
 {
 	JMutexAutoLock lock(m_mutex);
 
-	for (std::map<std::string, std::string>::const_iterator
+	for (std::map<std::string, SettingsEntry>::const_iterator
-			i = m_settings.begin();
+			it = m_settings.begin();
-			i != m_settings.end(); ++i) {
+			it != m_settings.end(); ++it) {
-		os << i->first << " = " << i->second << '\n';
+		bool is_multiline = it->second.value.find('\n') != std::string::npos;
+		printValue(os, it->first, it->second, is_multiline, tab_depth);
 	}
 }
 
 
+void Settings::printValue(std::ostream &os, const std::string &name,
+	const SettingsEntry &entry, bool is_value_multiline, u32 tab_depth)
+{
+	for (u32 i = 0; i != tab_depth; i++)
+		os << "\t";
+	os << name << " = ";
+
+	if (is_value_multiline)
+		os << "\"\"\"\n" << entry.value << "\n\"\"\"\n";
+	else
+		os << entry.value << "\n";
+
+	Settings *group = entry.group;
+	if (group) {
+		for (u32 i = 0; i != tab_depth; i++)
+			os << "\t";
+
+		os << name << " = {\n";
+		group->writeLines(os, tab_depth + 1);
+
+		for (u32 i = 0; i != tab_depth; i++)
+			os << "\t";
+
+		os << "}\n";
+	}
+}
+
+
+bool Settings::updateConfigObject(std::istream &is, std::ostream &os,
+	const std::string &end, u32 tab_depth)
+{
+	std::map<std::string, SettingsEntry>::const_iterator it;
+	std::set<std::string> settings_in_config;
+	bool was_modified = false;
+	bool end_found = false;
+	std::string line, name, value;
+
+	// Add any settings that exist in the config file with the current value
+	// in the object if existing
+	while (is.good() && !end_found) {
+		std::getline(is, line);
+		SettingsParseEvent event = parseConfigObject(line, end, name, value);
+
+		switch (event) {
+		case SPE_END:
+			end_found = true;
+			break;
+		case SPE_KVPAIR:
+		case SPE_MULTILINE:
+			it = m_settings.find(name);
+			if (it != m_settings.end()) {
+				if (event == SPE_MULTILINE)
+					value = getMultiline(is);
+
+				if (value != it->second.value) {
+					value = it->second.value;
+					was_modified = true;
+				}
+			}
+
+			settings_in_config.insert(name);
+
+			printValue(os, name, SettingsEntry(value),
+				event == SPE_MULTILINE, tab_depth);
+
+			break;
+		case SPE_GROUP: {
+			Settings *group = NULL;
+			it = m_settings.find(name);
+			if (it != m_settings.end())
+				group = it->second.group;
+
+			settings_in_config.insert(name);
+
+			os << name << " = {\n";
+
+			if (group) {
+				was_modified |= group->updateConfigObject(is, os, "}", tab_depth + 1);
+			} else {
+				Settings dummy_settings;
+				dummy_settings.updateConfigObject(is, os, "}", tab_depth + 1);
+			}
+
+			for (u32 i = 0; i != tab_depth; i++)
+				os << "\t";
+			os << "}\n";
+			break;
+		}
+		default:
+			os << line << (is.eof() ? "" : "\n");
+			break;
+		}
+	}
+
+	// Add any settings in the object that don't exist in the config file yet
+	for (it = m_settings.begin(); it != m_settings.end(); ++it) {
+		if (settings_in_config.find(it->first) != settings_in_config.end())
+			continue;
+
+		was_modified = true;
+
+		bool is_multiline = it->second.value.find('\n') != std::string::npos;
+		printValue(os, it->first, it->second, is_multiline, tab_depth);
+	}
+
+	return was_modified;
+}
+
+
 bool Settings::updateConfigFile(const char *filename)
 {
-	std::list<std::string> objects;
-	std::set<std::string> updated;
-	bool changed = false;
-
 	JMutexAutoLock lock(m_mutex);
 
-	// Read the file and check for differences
+	std::ifstream is(filename);
-	{
+	std::ostringstream os(std::ios_base::binary);
-		std::ifstream is(filename);
-		while (is.good()) {
-			getUpdatedConfigObject(is, objects,
-					updated, changed);
-		}
-	}
 
-	// If something not yet determined to have been changed, check if
+	if (!updateConfigObject(is, os, ""))
-	// any new stuff was added
-	if (!changed) {
-		for (std::map<std::string, std::string>::const_iterator
-				i = m_settings.begin();
-				i != m_settings.end(); ++i) {
-			if (updated.find(i->first) == updated.end()) {
-				changed = true;
-				break;
-			}
-		}
-	}
-
-	// If nothing was actually changed, skip writing the file
-	if (!changed) {
 		return true;
-	}
 
-	// Write stuff back
+	if (!fs::safeWriteToFile(filename, os.str())) {
-	{
+		errorstream << "Error writing configuration file: \""
-		std::ostringstream ss(std::ios_base::binary);
+			<< filename << "\"" << std::endl;
-
+		return false;
-		// Write changes settings
-		for (std::list<std::string>::const_iterator
-				i = objects.begin();
-				i != objects.end(); ++i) {
-			ss << (*i);
-		}
-
-		// Write new settings
-		for (std::map<std::string, std::string>::const_iterator
-				i = m_settings.begin();
-				i != m_settings.end(); ++i) {
-			if (updated.find(i->first) != updated.end())
-				continue;
-			ss << i->first << " = " << i->second << '\n';
-		}
-
-		if (!fs::safeWriteToFile(filename, ss.str())) {
-			errorstream << "Error writing configuration file: \""
-					<< filename << "\"" << std::endl;
-			return false;
-		}
 	}
 
 	return true;
@@ -231,20 +332,31 @@ bool Settings::parseCommandLine(int argc, char *argv[],
  ***********/
 
 
-std::string Settings::get(const std::string &name) const
+const SettingsEntry &Settings::getEntry(const std::string &name) const
 {
 	JMutexAutoLock lock(m_mutex);
 
-	std::map<std::string, std::string>::const_iterator n;
+	std::map<std::string, SettingsEntry>::const_iterator n;
 	if ((n = m_settings.find(name)) == m_settings.end()) {
-		if ((n = m_defaults.find(name)) == m_defaults.end()) {
+		if ((n = m_defaults.find(name)) == m_defaults.end())
 			throw SettingNotFoundException("Setting [" + name + "] not found.");
-		}
 	}
 	return n->second;
 }
 
 
+Settings *Settings::getGroup(const std::string &name) const
+{
+	return getEntry(name).group;
+}
+
+
+std::string Settings::get(const std::string &name) const
+{
+	return getEntry(name).value;
+}
+
+
 bool Settings::getBool(const std::string &name) const
 {
 	return is_yes(get(name));
@@ -309,7 +421,7 @@ v3f Settings::getV3F(const std::string &name) const
 
 
 u32 Settings::getFlagStr(const std::string &name, const FlagDesc *flagdesc,
-		u32 *flagmask) const
+	u32 *flagmask) const
 {
 	std::string val = get(name);
 	return std::isdigit(val[0])
@@ -321,7 +433,7 @@ u32 Settings::getFlagStr(const std::string &name, const FlagDesc *flagdesc,
 // N.B. if getStruct() is used to read a non-POD aggregate type,
 // the behavior is undefined.
 bool Settings::getStruct(const std::string &name, const std::string &format,
-		void *out, size_t olen) const
+	void *out, size_t olen) const
 {
 	std::string valstr;
 
@@ -350,7 +462,7 @@ bool Settings::exists(const std::string &name) const
 std::vector<std::string> Settings::getNames() const
 {
 	std::vector<std::string> names;
-	for (std::map<std::string, std::string>::const_iterator
+	for (std::map<std::string, SettingsEntry>::const_iterator
 			i = m_settings.begin();
 			i != m_settings.end(); ++i) {
 		names.push_back(i->first);
@@ -364,6 +476,27 @@ std::vector<std::string> Settings::getNames() const
  * Getters that don't throw exceptions *
  ***************************************/
 
+bool Settings::getEntryNoEx(const std::string &name, SettingsEntry &val) const
+{
+	try {
+		val = getEntry(name);
+		return true;
+	} catch (SettingNotFoundException &e) {
+		return false;
+	}
+}
+
+
+bool Settings::getGroupNoEx(const std::string &name, Settings *&val) const
+{
+	try {
+		val = getGroup(name);
+		return true;
+	} catch (SettingNotFoundException &e) {
+		return false;
+	}
+}
+
 
 bool Settings::getNoEx(const std::string &name, std::string &val) const
 {
@@ -466,7 +599,8 @@ bool Settings::getV3FNoEx(const std::string &name, v3f &val) const
 // 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 Settings::getFlagStrNoEx(const std::string &name, u32 &val, FlagDesc *flagdesc) const
+bool Settings::getFlagStrNoEx(const std::string &name, u32 &val,
+	FlagDesc *flagdesc) const
 {
 	try {
 		u32 flags, flagmask;
@@ -483,33 +617,42 @@ bool Settings::getFlagStrNoEx(const std::string &name, u32 &val, FlagDesc *flagd
 }
 
 
-	
 /***********
  * Setters *
  ***********/
 
 
-void Settings::set(const std::string &name, std::string value)
+void Settings::set(const std::string &name, const std::string &value)
 {
 	JMutexAutoLock lock(m_mutex);
 
-	m_settings[name] = value;
+	m_settings[name].value = value;
 }
 
 
-void Settings::set(const std::string &name, const char *value)
+void Settings::setGroup(const std::string &name, Settings *group)
 {
 	JMutexAutoLock lock(m_mutex);
 
-	m_settings[name] = value;
+	delete m_settings[name].group;
+	m_settings[name].group = group;
 }
 
 
-void Settings::setDefault(const std::string &name, std::string value)
+void Settings::setDefault(const std::string &name, const std::string &value)
 {
 	JMutexAutoLock lock(m_mutex);
 
-	m_defaults[name] = value;
+	m_defaults[name].value = value;
+}
+
+
+void Settings::setGroupDefault(const std::string &name, Settings *group)
+{
+	JMutexAutoLock lock(m_mutex);
+
+	delete m_defaults[name].group;
+	m_defaults[name].group = group;
 }
 
 
@@ -568,7 +711,8 @@ void Settings::setFlagStr(const std::string &name, u32 flags,
 }
 
 
-bool Settings::setStruct(const std::string &name, const std::string &format, void *value)
+bool Settings::setStruct(const std::string &name, const std::string &format,
+	void *value)
 {
 	std::string structstr;
 	if (!serializeStructToString(&structstr, format, value))
@@ -602,6 +746,7 @@ void Settings::updateValue(const Settings &other, const std::string &name)
 
 	try {
 		std::string val = other.get(name);
+
 		m_settings[name] = val;
 	} catch (SettingNotFoundException &e) {
 	}
@@ -620,78 +765,31 @@ void Settings::update(const Settings &other)
 }
 
 
-void Settings::registerChangedCallback(std::string name,
+SettingsParseEvent Settings::parseConfigObject(const std::string &line,
-		setting_changed_callback cbf)
+	const std::string &end, std::string &name, std::string &value)
 {
-	m_callbacks[name].push_back(cbf);
-}
-
-
-inline bool Settings::parseConfigObject(std::istream &is,
-		std::string &name, std::string &value)
-{
-	bool end_found = false;
-	return parseConfigObject(is, name, value, "", end_found);
-}
-
-
-// NOTE: This function might be expanded to allow multi-line settings.
-bool Settings::parseConfigObject(std::istream &is,
-		std::string &name, std::string &value,
-		const std::string &end, bool &end_found)
-{
-	std::string line;
-	std::getline(is, line);
 	std::string trimmed_line = trim(line);
 
-	// Ignore empty lines and comments
+	if (trimmed_line.empty())
-	if (trimmed_line.empty() || trimmed_line[0] == '#') {
+		return SPE_NONE;
-		value = trimmed_line;
+	if (trimmed_line[0] == '#')
-		return false;
+		return SPE_COMMENT;
-	}
+	if (trimmed_line == end)
-	if (trimmed_line == end) {
+		return SPE_END;
-		end_found = true;
-		return false;
-	}
 
-	Strfnd sf(trimmed_line);
+	size_t pos = trimmed_line.find('=');
+	if (pos == std::string::npos)
+		return SPE_INVALID;
 
-	name = trim(sf.next("="));
+	name  = trim(trimmed_line.substr(0, pos));
-	if (name.empty()) {
+	value = trim(trimmed_line.substr(pos + 1));
-		value = trimmed_line;
-		return false;
-	}
 
-	value = trim(sf.next("\n"));
+	if (value == "{")
+		return SPE_GROUP;
+	if (value == "\"\"\"")
+		return SPE_MULTILINE;
 
-	return true;
+	return SPE_KVPAIR;
-}
-
-
-void Settings::getUpdatedConfigObject(std::istream &is,
-		std::list<std::string> &dst,
-		std::set<std::string> &updated,
-		bool &changed)
-{
-	std::string name, value;
-
-	if (!parseConfigObject(is, name, value)) {
-		dst.push_back(value + (is.eof() ? "" : "\n"));
-		return;
-	}
-
-	if (m_settings.find(name) != m_settings.end()) {
-		std::string new_value = m_settings[name];
-
-		if (new_value != value) {
-			changed = true;
-		}
-
-		dst.push_back(name + " = " + new_value + (is.eof() ? "" : "\n"));
-		updated.insert(name);
-	} else { // File contains a setting which is not in m_settings
-		changed = true;
-	}
 }
 
 
@@ -708,6 +806,14 @@ void Settings::clearNoLock()
 	m_defaults.clear();
 }
 
+
+void Settings::registerChangedCallback(std::string name,
+	setting_changed_callback cbf)
+{
+	m_callbacks[name].push_back(cbf);
+}
+
+
 void Settings::doCallbacks(const std::string name)
 {
 	std::vector<setting_changed_callback> tempvector;

src/settings.h

@@ -28,14 +28,27 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <list>
 #include <set>
 
-enum ValueType
+class Settings;
-{
+
+/** function type to register a changed callback */
+typedef void (*setting_changed_callback)(const std::string);
+
+enum ValueType {
 	VALUETYPE_STRING,
 	VALUETYPE_FLAG // Doesn't take any arguments
 };
 
-struct ValueSpec
+enum SettingsParseEvent {
-{
+	SPE_NONE,
+	SPE_INVALID,
+	SPE_COMMENT,
+	SPE_KVPAIR,
+	SPE_END,
+	SPE_GROUP,
+	SPE_MULTILINE,
+};
+
+struct ValueSpec {
 	ValueSpec(ValueType a_type, const char *a_help=NULL)
 	{
 		type = a_type;
@@ -46,13 +59,39 @@ struct ValueSpec
 };
 
 /** function type to register a changed callback */
-typedef void (*setting_changed_callback)(const std::string);
+
+struct SettingsEntry {
+	SettingsEntry()
+	{
+		group = NULL;
+	}
+
+	SettingsEntry(const std::string &value_)
+	{
+		value = value_;
+		group = NULL;
+	}
+
+	SettingsEntry(Settings *group_)
+	{
+		group = group_;
+	}
+
+	SettingsEntry(const std::string &value_, Settings *group_)
+	{
+		value = value_;
+		group = group_;
+	}
+
+	std::string value;
+	Settings *group;
+};
 
 
-class Settings
+class Settings {
-{
 public:
 	Settings() {}
+	~Settings();
 
 	Settings & operator += (const Settings &other);
 	Settings & operator = (const Settings &other);
@@ -70,13 +109,23 @@ public:
 	bool parseCommandLine(int argc, char *argv[],
 			std::map<std::string, ValueSpec> &allowed_options);
 	bool parseConfigLines(std::istream &is, const std::string &end = "");
-	void writeLines(std::ostream &os) const;
+	void writeLines(std::ostream &os, u32 tab_depth=0) const;
 
+	SettingsParseEvent parseConfigObject(const std::string &line,
+		const std::string &end, std::string &name, std::string &value);
+	bool updateConfigObject(std::istream &is, std::ostream &os,
+		const std::string &end, u32 tab_depth=0);
+
+	static std::string getMultiline(std::istream &is);
+	static void printValue(std::ostream &os, const std::string &name,
+		const SettingsEntry &entry, bool is_value_multiline, u32 tab_depth=0);
 
 	/***********
 	 * Getters *
 	 ***********/
 
+	const SettingsEntry &getEntry(const std::string &name) const;
+	Settings *getGroup(const std::string &name) const;
 	std::string get(const std::string &name) const;
 	bool getBool(const std::string &name) const;
 	u16 getU16(const std::string &name) const;
@@ -102,6 +151,8 @@ public:
 	 * Getters that don't throw exceptions *
 	 ***************************************/
 
+	bool getEntryNoEx(const std::string &name, SettingsEntry &val) const;
+	bool getGroupNoEx(const std::string &name, Settings *&val) const;
 	bool getNoEx(const std::string &name, std::string &val) const;
 	bool getFlag(const std::string &name) const;
 	bool getU16NoEx(const std::string &name, u16 &val) const;
@@ -121,9 +172,12 @@ public:
 	 * Setters *
 	 ***********/
 
-	void set(const std::string &name, std::string value);
+	// N.B. Groups not allocated with new must be set to NULL in the settings
-	void set(const std::string &name, const char *value);
+	// tree before object destruction.
-	void setDefault(const std::string &name, std::string value);
+	void set(const std::string &name, const std::string &value);
+	void setGroup(const std::string &name, Settings *group);
+	void setDefault(const std::string &name, const std::string &value);
+	void setGroupDefault(const std::string &name, Settings *group);
 	void setBool(const std::string &name, bool value);
 	void setS16(const std::string &name, s16 value);
 	void setS32(const std::string &name, s32 value);
@@ -145,34 +199,14 @@ public:
 	void registerChangedCallback(std::string name, setting_changed_callback cbf);
 
 private:
-	/***********************
-	 * Reading and writing *
-	 ***********************/
-
-	bool parseConfigObject(std::istream &is,
-			std::string &name, std::string &value);
-	bool parseConfigObject(std::istream &is,
-			std::string &name, std::string &value,
-			const std::string &end, bool &end_found);
-	/*
-	 * Reads a configuration object from stream (usually a single line)
-	 * and adds it to dst.
-	 * Preserves comments and empty lines.
-	 * Setting names that were added to dst are also added to updated.
-	 */
-	void getUpdatedConfigObject(std::istream &is,
-			std::list<std::string> &dst,
-			std::set<std::string> &updated,
-			bool &changed);
-
 
 	void updateNoLock(const Settings &other);
 	void clearNoLock();
 
 	void doCallbacks(std::string name);
 
-	std::map<std::string, std::string> m_settings;
+	std::map<std::string, SettingsEntry> m_settings;
-	std::map<std::string, std::string> m_defaults;
+	std::map<std::string, SettingsEntry> m_defaults;
 	std::map<std::string, std::vector<setting_changed_callback> > m_callbacks;
 	// All methods that access m_settings/m_defaults directly should lock this.
 	mutable JMutex m_mutex;

src/test.cpp

@@ -418,29 +418,88 @@ struct TestPath: public TestBase
 	}
 };
 
+#define TEST_CONFIG_TEXT_BEFORE               \
+	"leet = 1337\n"                           \
+	"leetleet = 13371337\n"                   \
+	"leetleet_neg = -13371337\n"              \
+	"floaty_thing = 1.1\n"                    \
+	"stringy_thing = asd /( ¤%&(/\" BLÖÄRP\n" \
+	"coord = (1, 2, 4.5)\n"                   \
+	"      # this is just a comment\n"        \
+	"this is an invalid line\n"               \
+	"asdf = {\n"                              \
+	"	a = 5\n"                              \
+	"	b = 2.5\n"                            \
+	"	c = \"\"\"\n"                         \
+	"testy\n"                                 \
+	"   testa   \n"                           \
+	"\"\"\"\n"                                \
+	"\n"                                      \
+	"}\n"                                     \
+	"blarg = \"\"\" \n"                       \
+	"some multiline text\n"                   \
+	"     with leading whitespace!\n"         \
+	"\"\"\"\n"                                \
+	"zoop = true"
+
+#define TEST_CONFIG_TEXT_AFTER                \
+	"leet = 1337\n"                           \
+	"leetleet = 13371337\n"                   \
+	"leetleet_neg = -13371337\n"              \
+	"floaty_thing = 1.1\n"                    \
+	"stringy_thing = asd /( ¤%&(/\" BLÖÄRP\n" \
+	"coord = (1, 2, 4.5)\n"                   \
+	"      # this is just a comment\n"        \
+	"this is an invalid line\n"               \
+	"asdf = {\n"                              \
+	"	a = 5\n"                              \
+	"	b = 2.5\n"                            \
+	"	c = \"\"\"\n"                         \
+	"testy\n"                                 \
+	"   testa   \n"                           \
+	"\"\"\"\n"                                \
+	"\n"                                      \
+	"}\n"                                     \
+	"blarg = \"\"\"\n"                        \
+	"some multiline text\n"                   \
+	"     with leading whitespace!\n"         \
+	"\"\"\"\n"                                \
+	"zoop = true\n"                           \
+	"coord2 = (1,2,3.3)\n"                    \
+	"floaty_thing_2 = 1.2\n"                  \
+	"groupy_thing = \n"                       \
+	"groupy_thing = {\n"                      \
+	"	animals = \n"                         \
+	"	animals = {\n"                        \
+	"		cat = meow\n"                     \
+	"		dog = woof\n"                     \
+	"	}\n"                                  \
+	"	num_apples = 4\n"                     \
+	"	num_oranges = 53\n"                   \
+	"}\n"
+
+
 struct TestSettings: public TestBase
 {
 	void Run()
 	{
 		Settings s;
+
 		// Test reading of settings
-		std::istringstream is(
+		std::istringstream is(TEST_CONFIG_TEXT_BEFORE);
-			"leet = 1337\n"
-			"leetleet = 13371337\n"
-			"leetleet_neg = -13371337\n"
-			"floaty_thing = 1.1\n"
-			"stringy_thing = asd /( ¤%&(/\" BLÖÄRP\n"
-			"coord = (1, 2, 4.5)");
 		s.parseConfigLines(is);
+
 		UASSERT(s.getS32("leet") == 1337);
 		UASSERT(s.getS16("leetleet") == 32767);
 		UASSERT(s.getS16("leetleet_neg") == -32768);
+
 		// Not sure if 1.1 is an exact value as a float, but doesn't matter
 		UASSERT(fabs(s.getFloat("floaty_thing") - 1.1) < 0.001);
 		UASSERT(s.get("stringy_thing") == "asd /( ¤%&(/\" BLÖÄRP");
 		UASSERT(fabs(s.getV3F("coord").X - 1.0) < 0.001);
 		UASSERT(fabs(s.getV3F("coord").Y - 2.0) < 0.001);
 		UASSERT(fabs(s.getV3F("coord").Z - 4.5) < 0.001);
+
 		// Test the setting of settings too
 		s.setFloat("floaty_thing_2", 1.2);
 		s.setV3F("coord2", v3f(1, 2, 3.3));
@@ -449,6 +508,39 @@ struct TestSettings: public TestBase
 		UASSERT(fabs(s.getV3F("coord2").X - 1.0) < 0.001);
 		UASSERT(fabs(s.getV3F("coord2").Y - 2.0) < 0.001);
 		UASSERT(fabs(s.getV3F("coord2").Z - 3.3) < 0.001);
+
+		// Test settings groups
+		Settings *group = s.getGroup("asdf");
+		UASSERT(group != NULL);
+		UASSERT(s.getGroup("zoop") == NULL);
+		UASSERT(group->getS16("a") == 5);
+		UASSERT(fabs(group->getFloat("b") - 2.5) < 0.001);
+
+		Settings *group3 = new Settings;
+		group3->set("cat", "meow");
+		group3->set("dog", "woof");
+
+		Settings *group2 = new Settings;
+		group2->setS16("num_apples", 4);
+		group2->setS16("num_oranges", 53);
+		group2->setGroup("animals", group3);
+		s.setGroup("groupy_thing", group2);
+
+		// Test multiline settings
+		UASSERT(group->get("c") == "testy\n   testa   ");
+		UASSERT(s.get("blarg") ==
+			"some multiline text\n"
+			"     with leading whitespace!");
+
+		// Test writing
+		std::ostringstream os(std::ios_base::binary);
+		is.clear();
+		is.seekg(0);
+
+		UASSERT(s.updateConfigObject(is, os, "", 0) == true);
+		//printf(">>>> expected config:\n%s\n", TEST_CONFIG_TEXT_AFTER);
+		//printf(">>>> actual config:\n%s\n", os.str().c_str());
+		UASSERT(os.str() == TEST_CONFIG_TEXT_AFTER);
 	}
 };
 
@@ -470,7 +562,7 @@ struct TestSerialization: public TestBase
 		UASSERT(serializeWideString(L"") == mkstr("\0\0"));
 		UASSERT(serializeLongString("") == mkstr("\0\0\0\0"));
 		UASSERT(serializeJsonString("") == "\"\"");
-		
+
 		std::string teststring = "Hello world!";
 		UASSERT(serializeString(teststring) ==
 			mkstr("\0\14Hello world!"));
@@ -596,12 +688,12 @@ struct TestCompress: public TestBase
 		fromdata[1]=5;
 		fromdata[2]=5;
 		fromdata[3]=1;
-		
+
 		std::ostringstream os(std::ios_base::binary);
 		compress(fromdata, os, 0);
 
 		std::string str_out = os.str();
-		
+
 		infostream<<"str_out.size()="<<str_out.size()<<std::endl;
 		infostream<<"TestCompress: 1,5,5,1 -> ";
 		for(u32 i=0; i<str_out.size(); i++)
@@ -652,12 +744,12 @@ struct TestCompress: public TestBase
 		fromdata[1]=5;
 		fromdata[2]=5;
 		fromdata[3]=1;
-		
+
 		std::ostringstream os(std::ios_base::binary);
 		compress(fromdata, os, SER_FMT_VER_HIGHEST_READ);
 
 		std::string str_out = os.str();
-		
+
 		infostream<<"str_out.size()="<<str_out.size()<<std::endl;
 		infostream<<"TestCompress: 1,5,5,1 -> ";
 		for(u32 i=0; i<str_out.size(); i++)
@@ -733,7 +825,7 @@ struct TestMapNode: public TestBase
 		UASSERT(n.getContent() == CONTENT_AIR);
 		UASSERT(n.getLight(LIGHTBANK_DAY, nodedef) == 0);
 		UASSERT(n.getLight(LIGHTBANK_NIGHT, nodedef) == 0);
-		
+
 		// Transparency
 		n.setContent(CONTENT_AIR);
 		UASSERT(nodedef->get(n).light_propagates == true);
@@ -753,28 +845,28 @@ struct TestVoxelManipulator: public TestBase
 		VoxelArea a(v3s16(-1,-1,-1), v3s16(1,1,1));
 		UASSERT(a.index(0,0,0) == 1*3*3 + 1*3 + 1);
 		UASSERT(a.index(-1,-1,-1) == 0);
-		
+
 		VoxelArea c(v3s16(-2,-2,-2), v3s16(2,2,2));
 		// An area that is 1 bigger in x+ and z-
 		VoxelArea d(v3s16(-2,-2,-3), v3s16(3,2,2));
-		
+
 		std::list<VoxelArea> aa;
 		d.diff(c, aa);
-		
+
 		// Correct results
 		std::vector<VoxelArea> results;
 		results.push_back(VoxelArea(v3s16(-2,-2,-3),v3s16(3,2,-3)));
 		results.push_back(VoxelArea(v3s16(3,-2,-2),v3s16(3,2,2)));
 
 		UASSERT(aa.size() == results.size());
-		
+
 		infostream<<"Result of diff:"<<std::endl;
 		for(std::list<VoxelArea>::const_iterator
 				i = aa.begin(); i != aa.end(); ++i)
 		{
 			i->print(infostream);
 			infostream<<std::endl;
-			
+
 			std::vector<VoxelArea>::iterator j = std::find(results.begin(), results.end(), *i);
 			UASSERT(j != results.end());
 			results.erase(j);
@@ -784,13 +876,13 @@ struct TestVoxelManipulator: public TestBase
 		/*
 			VoxelManipulator
 		*/
-		
+
 		VoxelManipulator v;
 
 		v.print(infostream, nodedef);
 
 		infostream<<"*** Setting (-1,0,-1)=2 ***"<<std::endl;
-		
+
 		v.setNodeNoRef(v3s16(-1,0,-1), MapNode(CONTENT_GRASS));
 
 		v.print(infostream, nodedef);
@@ -806,7 +898,7 @@ struct TestVoxelManipulator: public TestBase
 		infostream<<"*** Adding area ***"<<std::endl;
 
 		v.addArea(a);
-		
+
 		v.print(infostream, nodedef);
 
 		UASSERT(v.getNode(v3s16(-1,0,-1)).getContent() == CONTENT_GRASS);
@@ -1004,7 +1096,7 @@ struct TestInventory: public TestBase
 		"Empty\n"
 		"EndInventoryList\n"
 		"EndInventory\n";
-		
+
 		std::string serialized_inventory_2 =
 		"List main 32\n"
 		"Width 5\n"
@@ -1042,7 +1134,7 @@ struct TestInventory: public TestBase
 		"Empty\n"
 		"EndInventoryList\n"
 		"EndInventory\n";
-		
+
 		Inventory inv(idef);
 		std::istringstream is(serialized_inventory, std::ios::binary);
 		inv.deSerialize(is);
@@ -1118,7 +1210,7 @@ struct TestMapBlock: public TestBase
 	void Run()
 	{
 		TC parent;
-		
+
 		MapBlock b(&parent, v3s16(1,1,1));
 		v3s16 relpos(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
 
@@ -1130,7 +1222,7 @@ struct TestMapBlock: public TestBase
 		UASSERT(b.getBox().MaxEdge.Y == MAP_BLOCKSIZE*2-1);
 		UASSERT(b.getBox().MinEdge.Z == MAP_BLOCKSIZE);
 		UASSERT(b.getBox().MaxEdge.Z == MAP_BLOCKSIZE*2-1);
-		
+
 		UASSERT(b.isValidPosition(v3s16(0,0,0)) == true);
 		UASSERT(b.isValidPosition(v3s16(-1,0,0)) == false);
 		UASSERT(b.isValidPosition(v3s16(-1,-142,-2341)) == false);
@@ -1144,7 +1236,7 @@ struct TestMapBlock: public TestBase
 		*/
 		/*UASSERT(b.getSizeNodes() == v3s16(MAP_BLOCKSIZE,
 				MAP_BLOCKSIZE, MAP_BLOCKSIZE));*/
-		
+
 		// Changed flag should be initially set
 		UASSERT(b.getModified() == MOD_STATE_WRITE_NEEDED);
 		b.resetModified();
@@ -1161,7 +1253,7 @@ struct TestMapBlock: public TestBase
 			UASSERT(b.getNode(v3s16(x,y,z)).getLight(LIGHTBANK_DAY) == 0);
 			UASSERT(b.getNode(v3s16(x,y,z)).getLight(LIGHTBANK_NIGHT) == 0);
 		}
-		
+
 		{
 			MapNode n(CONTENT_AIR);
 			for(u16 z=0; z<MAP_BLOCKSIZE; z++)
@@ -1171,7 +1263,7 @@ struct TestMapBlock: public TestBase
 				b.setNode(v3s16(x,y,z), n);
 			}
 		}
-			
+
 		/*
 			Parent fetch functions
 		*/
@@ -1179,7 +1271,7 @@ struct TestMapBlock: public TestBase
 		parent.node.setContent(5);
 
 		MapNode n;
-		
+
 		// Positions in the block should still be valid
 		UASSERT(b.isValidPositionParent(v3s16(0,0,0)) == true);
 		UASSERT(b.isValidPositionParent(v3s16(MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1)) == true);
@@ -1190,7 +1282,7 @@ struct TestMapBlock: public TestBase
 		UASSERT(b.isValidPositionParent(v3s16(-121,2341,0)) == false);
 		UASSERT(b.isValidPositionParent(v3s16(-1,0,0)) == false);
 		UASSERT(b.isValidPositionParent(v3s16(MAP_BLOCKSIZE-1,MAP_BLOCKSIZE-1,MAP_BLOCKSIZE)) == false);
-		
+
 		{
 			bool exception_thrown = false;
 			try{
@@ -1222,7 +1314,7 @@ struct TestMapBlock: public TestBase
 		//TODO: Update to new system
 		/*UASSERT(b.getNodeTile(p) == 4);
 		UASSERT(b.getNodeTile(v3s16(-1,-1,0)) == 5);*/
-		
+
 		/*
 			propagateSunlight()
 		*/
@@ -1352,29 +1444,29 @@ struct TestMapSector: public TestBase
 			if(position_valid == false)
 				throw InvalidPositionException();
 		};
-		
+
 		virtual u16 nodeContainerId() const
 		{
 			return 666;
 		}
 	};
-	
+
 	void Run()
 	{
 		TC parent;
 		parent.position_valid = false;
-		
+
 		// Create one with no heightmaps
 		ServerMapSector sector(&parent, v2s16(1,1));
-		
+
 		UASSERT(sector.getBlockNoCreateNoEx(0) == 0);
 		UASSERT(sector.getBlockNoCreateNoEx(1) == 0);
 
 		MapBlock * bref = sector.createBlankBlock(-2);
-		
+
 		UASSERT(sector.getBlockNoCreateNoEx(0) == 0);
 		UASSERT(sector.getBlockNoCreateNoEx(-2) == bref);
-		
+
 		//TODO: Check for AlreadyExistsException
 
 		/*bool exception_thrown = false;
@@ -1645,7 +1737,7 @@ struct TestConnection: public TestBase
 		UASSERT(readU16(&p1.data[4]) == peer_id);
 		UASSERT(readU8(&p1.data[6]) == channel);
 		UASSERT(readU8(&p1.data[7]) == data1[0]);
-		
+
 		//infostream<<"initial data1[0]="<<((u32)data1[0]&0xff)<<std::endl;
 
 		SharedBuffer<u8> p2 = con::makeReliablePacket(data1, seqnum);
@@ -1707,29 +1799,29 @@ struct TestConnection: public TestBase
 
 		Handler hand_server("server");
 		Handler hand_client("client");
-		
+
 		infostream<<"** Creating server Connection"<<std::endl;
 		con::Connection server(proto_id, 512, 5.0, false, &hand_server);
 		Address address(0,0,0,0, 30001);
 		server.Serve(address);
-		
+
 		infostream<<"** Creating client Connection"<<std::endl;
 		con::Connection client(proto_id, 512, 5.0, false, &hand_client);
-		
+
 		UASSERT(hand_server.count == 0);
 		UASSERT(hand_client.count == 0);
-		
+
 		sleep_ms(50);
-		
+
 		Address server_address(127,0,0,1, 30001);
 		infostream<<"** running client.Connect()"<<std::endl;
 		client.Connect(server_address);
 
 		sleep_ms(50);
-		
+
 		// Client should not have added client yet
 		UASSERT(hand_client.count == 0);
-		
+
 		try
 		{
 			u16 peer_id;
@@ -1749,7 +1841,7 @@ struct TestConnection: public TestBase
 		UASSERT(hand_client.last_id == 1);
 		// Server should not have added client yet
 		UASSERT(hand_server.count == 0);
-		
+
 		sleep_ms(100);
 
 		try
@@ -1767,14 +1859,14 @@ struct TestConnection: public TestBase
 			// No actual data received, but the client has
 			// probably been connected
 		}
-		
+
 		// Client should be the same
 		UASSERT(hand_client.count == 1);
 		UASSERT(hand_client.last_id == 1);
 		// Server should have the client
 		UASSERT(hand_server.count == 1);
 		UASSERT(hand_server.last_id == 2);
-		
+
 		//sleep_ms(50);
 
 		while(client.Connected() == false)
@@ -1796,7 +1888,7 @@ struct TestConnection: public TestBase
 		}
 
 		sleep_ms(50);
-		
+
 		try
 		{
 			u16 peer_id;
@@ -1849,10 +1941,10 @@ struct TestConnection: public TestBase
 
 			Address client_address =
 					server.GetPeerAddress(peer_id_client);
-			
+
 			infostream<<"*** Sending packets in wrong order (2,1,2)"
 					<<std::endl;
-			
+
 			u8 chn = 0;
 			con::Channel *ch = &server.getPeer(peer_id_client)->channels[chn];
 			u16 sn = ch->next_outgoing_seqnum;
@@ -1881,7 +1973,7 @@ struct TestConnection: public TestBase
 			UASSERT(size == data1.getSize());
 			UASSERT(memcmp(*data1, *recvdata, data1.getSize()) == 0);
 			UASSERT(peer_id == PEER_ID_SERVER);
-			
+
 			infostream<<"** running client.Receive()"<<std::endl;
 			peer_id = 132;
 			size = client.Receive(peer_id, recvdata);
@@ -1892,7 +1984,7 @@ struct TestConnection: public TestBase
 			UASSERT(size == data2.getSize());
 			UASSERT(memcmp(*data2, *recvdata, data2.getSize()) == 0);
 			UASSERT(peer_id == PEER_ID_SERVER);
-			
+
 			bool got_exception = false;
 			try
 			{
@@ -1926,14 +2018,14 @@ struct TestConnection: public TestBase
 				SharedBuffer<u8> data1(datasize);
 				for(u16 i=0; i<datasize; i++)
 					data1[i] = i/4;
-				
+
 				int sendtimes = myrand_range(1,10);
 				for(int i=0; i<sendtimes; i++){
 					server.Send(peer_id_client, 0, data1, true);
 					sendcount++;
 				}
 				infostream<<"sendcount="<<sendcount<<std::endl;
-				
+
 				//int receivetimes = myrand_range(1,20);
 				int receivetimes = 20;
 				for(int i=0; i<receivetimes; i++){
@@ -1970,11 +2062,11 @@ struct TestConnection: public TestBase
 			if(datasize>20)
 				infostream<<"...";
 			infostream<<std::endl;
-			
+
 			server.Send(peer_id_client, 0, data1, true);
 
 			//sleep_ms(3000);
-			
+
 			SharedBuffer<u8> recvdata;
 			infostream<<"** running client.Receive()"<<std::endl;
 			u16 peer_id = 132;
@@ -2010,13 +2102,13 @@ struct TestConnection: public TestBase
 			UASSERT(memcmp(*data1, *recvdata, data1.getSize()) == 0);
 			UASSERT(peer_id == PEER_ID_SERVER);
 		}
-		
+
 		// Check peer handlers
 		UASSERT(hand_client.count == 1);
 		UASSERT(hand_client.last_id == 1);
 		UASSERT(hand_server.count == 1);
 		UASSERT(hand_server.last_id == 2);
-		
+
 		//assert(0);
 	}
 };
@@ -2043,7 +2135,7 @@ void run_tests()
 
 	int tests_run = 0;
 	int tests_failed = 0;
-	
+
 	// Create item and node definitions
 	IWritableItemDefManager *idef = createItemDefManager();
 	IWritableNodeDefManager *ndef = createNodeDefManager();