LanguageStrings ReadRawLanguageStrings(const std::string &file)

	size_t to_read;

	FILE *fh = FioFOpenFile(file.c_str(), "rb", GAME_DIR, &to_read);

	if (fh == nullptr) return LanguageStrings();

	FileCloser fhClose(fh);

	auto pos = file.rfind(PATHSEPCHAR);

	if (pos == std::string::npos) return LanguageStrings();

	std::string langname = file.substr(pos + 1);

	/* Check for invalid empty filename */

	if (langname.empty() || langname.front() == '.') return LanguageStrings();

	LanguageStrings ret(langname.substr(0, langname.find('.')));

	char buffer[2048];

	while (to_read != 0 && fgets(buffer, sizeof(buffer), fh) != nullptr) {

		size_t len = strlen(buffer);

		/* Remove trailing spaces/newlines from the string. */

		size_t i = len;

		while (i > 0 && (buffer[i - 1] == '\r' || buffer[i - 1] == '\n' || buffer[i - 1] == ' ')) i--;

		buffer[i] = '\0';

		ret.lines.emplace_back(buffer, i);

		if (len > to_read) {

			to_read = 0;

		} else {

			to_read -= len;

	}

	return ret;

			StringReader(data, strings.language.c_str(), master, translation), p(strings.lines.begin()), end(strings.lines.end())

	std::string exclude;

	LanguageScanner(GameStrings *gs, const std::string &exclude) : gs(gs), exclude(exclude) {}

		if (exclude == filename) return true;

		if (!ls.IsValid()) return false;

	std::string basename(info->GetMainScript());

	auto e = basename.rfind(PATHSEPCHAR);

	if (e == std::string::npos) return nullptr;

	basename.erase(e + 1);

	std::string filename = basename + "lang" PATHSEP "english.txt";

	if (!FioCheckFileExists(filename.c_str() , GAME_DIR)) return nullptr;

	if (!ls.IsValid()) return nullptr;

		std::string ldir = basename + "lang" PATHSEP;

				if (tar->first.size() <= ldir.size() || tar->first.compare(0, ldir.size(), ldir) != 0) continue;

			scanner.Scan(ldir.c_str());

	StringListReader master_reader(data, this->raw_strings[0], true, false);

		StringListReader translation_reader(data, p, false, p.language != "english");

		this->compiled_strings.emplace_back(p.language);

		TranslationWriter writer(this->compiled_strings.back().lines);

		if (p.language == language) {

			_current_data->cur_language = &p;

	_current_data->cur_language = &_current_data->compiled_strings[0];

	std::string language; ///< Name of the language (base filename). Empty string if invalid.

	StringList  lines;    ///< The lines of the file to pass into the parser/encoder.

	LanguageStrings() {}

	LanguageStrings(const std::string &lang) : language(lang) {}

	LanguageStrings(const LanguageStrings &other) : language(other.language), lines(other.lines) {}

	LanguageStrings(LanguageStrings &&other) : language(std::move(other.language)), lines(std::move(other.lines)) {}

	bool IsValid() const { return !this->language.empty(); }

	uint version;                  ///< The version of the language strings.

	LanguageStrings *cur_language; ///< The current (compiled) language.

	std::vector<LanguageStrings> raw_strings;      ///< The raw strings per language, first must be English/the master language!.

	std::vector<LanguageStrings> compiled_strings; ///< The compiled strings per language, first must be English/the master language!.

	StringList string_names;                       ///< The names of the compiled strings.

	GameStrings() = default;

	GameStrings(const GameStrings &) = delete;

	GameStrings(GameStrings &&) = delete;

	GameStrings &operator=(const GameStrings &) = delete;

	GameStrings &operator=(GameStrings &&) = delete;

static std::string _game_saveload_string;

	SLEG_SSTR(_game_saveload_string, SLE_STR),

	 SLEG_VAR(_game_saveload_strings, SLE_UINT32),

	  SLE_END()

	SLEG_SSTR(_game_saveload_string, SLE_STR | SLF_ALLOW_CONTROL),

	  SLE_END()

	_game_saveload_string  = ls->language.c_str();

		_game_saveload_string.clear();

		LanguageStrings ls(_game_saveload_string);

			ls.lines.emplace_back(_game_saveload_string);

		SlAutolength((AutolengthProc *)SaveReal_GSTR, &_current_data->raw_strings[i]);

#include <string>

 * Calculate the gross length of the string that it

 * will occupy in the savegame. This includes the real length, returned

 * by SlCalcNetStringLen and the length that the index will occupy.

 * @param ptr Pointer to the \c std::string.

 * @return The gross length of the string.

 */

static inline size_t SlCalcStdStringLen(const void *ptr)

{

	const std::string *str = reinterpret_cast<const std::string *>(ptr);

	size_t len = str->length();

	return len + SlGetArrayLength(len); // also include the length of the index

}

/**

 * Save/Load a \c std::string.

 * @param ptr the string being manipulated

 * @param conv must be SLE_FILE_STRING

 */

static void SlStdString(void *ptr, VarType conv)

{

	std::string *str = reinterpret_cast<std::string *>(ptr);

	switch (_sl.action) {

		case SLA_SAVE: {

			size_t len = str->length();

			SlWriteArrayLength(len);

			SlCopyBytes(const_cast<void *>(static_cast<const void *>(str->c_str())), len);

			break;

		}

		case SLA_LOAD_CHECK:

		case SLA_LOAD: {

			size_t len = SlReadArrayLength();

			char *buf = AllocaM(char, len + 1);

			SlCopyBytes(buf, len);

			buf[len] = '\0'; // properly terminate the string

			StringValidationSettings settings = SVS_REPLACE_WITH_QUESTION_MARK;

			if ((conv & SLF_ALLOW_CONTROL) != 0) {

				settings = settings | SVS_ALLOW_CONTROL_CODE;

				if (IsSavegameVersionBefore(SLV_169)) {

					str_fix_scc_encoded(buf, buf + len);

				}

			}

			if ((conv & SLF_ALLOW_NEWLINE) != 0) {

				settings = settings | SVS_ALLOW_NEWLINE;

			}

			str_validate(buf, buf + len, settings);

			// Store sanitized string.

			str->assign(buf);

		}

		case SLA_PTRS: break;

		case SLA_NULL: break;

		default: NOT_REACHED();

	}

}

/**

		case SL_STDSTR:

				case SL_STDSTR: return SlCalcStdStringLen(GetVariableAddress(object, sld));

		case SL_STDSTR:

			/* These should be all pointers to std::string. */

			return sld->size == sizeof(std::string);

		case SL_STDSTR:

				case SL_STDSTR: SlStdString(ptr, sld->conv); break;

	SL_STDSTR      =  6, ///< Save/load a \c std::string.

 * Storage of a \c std::string in some savegame versions.

 * @param base     Name of the class or struct containing the string.

 * @param variable Name of the variable in the class or struct referenced by \a base.

 * @param type     Storage of the data in memory and in the savegame.

 * @param from     First savegame version that has the string.

 * @param to       Last savegame version that has the string.

 */

#define SLE_CONDSSTR(base, variable, type, from, to) SLE_GENERAL(SL_STDSTR, base, variable, type, 0, from, to)

/**

 * Storage of a \c std::string in every savegame version.

 * @param base     Name of the class or struct containing the string.

 * @param variable Name of the variable in the class or struct referenced by \a base.

 * @param type     Storage of the data in memory and in the savegame.

 */

#define SLE_SSTR(base, variable, type) SLE_CONDSSTR(base, variable, type, SL_MIN_VERSION, SL_MAX_VERSION)

/**

 * Storage of a global \c std::string in some savegame versions.

 * @param variable Name of the global variable.

 * @param type     Storage of the data in memory and in the savegame.

 * @param from     First savegame version that has the string.

 * @param to       Last savegame version that has the string.

 */

#define SLEG_CONDSSTR(variable, type, from, to) SLEG_GENERAL(SL_STDSTR, variable, type, 0, from, to)

/**

 * Storage of a global \c std::string in every savegame version.

 * @param variable Name of the global variable.

 * @param type     Storage of the data in memory and in the savegame.

 */

#define SLEG_SSTR(variable, type) SLEG_CONDSSTR(variable, type, SL_MIN_VERSION, SL_MAX_VERSION)

/**