}

	/* Create a copy of the string, strip if of colours and invalid

	 * characters and (when applicable) assign it to the console buffer */

	str = stredup(string);

	str_strip_colours(str);

	if (_network_dedicated) {

		NetworkAdminConsole("console", str);

		fprintf(stdout, "%s%s\n", GetLogPrefix(), str);

		fflush(stdout);

		IConsoleWriteToLogFile(str);

	const char *t = fios_title;

	if (StrEmpty(fios_title)) {

		auto ps = filename.rfind(PATHSEPCHAR);

		t = filename.c_str() + (ps == std::string::npos ? 0 : ps + 1);

	}

	strecpy(fios->title, t, lastof(fios->title));

	return true;

}

/**

				fios->type = FIOS_TYPE_DIR;

				fios->mtime = 0;

				strecpy(fios->name, d_name, lastof(fios->name));

				std::string dirname = std::string(d_name) + PATHSEP;

				SetDParamStr(0, dirname);

				GetString(fios->title, STR_SAVELOAD_DIRECTORY, lastof(fios->title));

			}

		}

		closedir(dir);

	}

	/* Sort the subdirs always by name, ascending, remember user-sorting order */

	FILE *f = FioFOpenFile(buf, "r", subdir);

	if (f == nullptr) return;

	size_t read = fread(title, 1, last - title, f);

	assert(title + read <= last);

	title[read] = '\0';

	FioFCloseFile(f);

}

/**

 * Callback for FiosGetFileList. It tells if a file is a savegame or not.

 * @param fop Purpose of collecting the list.

						fread(&hs->score, sizeof(hs->score), 1, fp)                        !=  1 ||

						fseek(fp, 2, SEEK_CUR)                                             == -1) { // XXX - placeholder for hs->title, not saved anymore; compatibility

					DEBUG(misc, 1, "Highscore corrupted");

					i = SP_SAVED_HIGHSCORE_END;

					break;

				}

				hs->title = EndGameGetPerformanceTitleFromValue(hs->score);

			}

		}

		fclose(fp);

	}

}

 * Construct a new in-memory item of an Ini file.

 * @param parent the group we belong to

 * @param name   the name of the item

 */

IniItem::IniItem(IniGroup *parent, const std::string &name) : next(nullptr)

{

	*parent->last_item = this;

	parent->last_item = &this->next;

}

/** Free everything we loaded. */

 * Construct a new in-memory group of an Ini file.

 * @param parent the file we belong to

 * @param name   the name of the group

 */

IniGroup::IniGroup(IniLoadFile *parent, const std::string &name) : next(nullptr), type(IGT_VARIABLES), item(nullptr)

{

	this->last_item = &this->item;

	*parent->last_group = this;

	parent->last_group = &this->next;

	if (parent->list_group_names != nullptr) {

			*e = '\0';

			/* If the value was not quoted and empty, it must be nullptr */

			if (!quoted && e == t) {

				item->value.reset();

			} else {

			}

		} else {

			/* it's an orphan item */

			this->ReportFileError("ini: '", buffer, "' outside of group");

		}

	}

	QueryStringWindow(StringID str, StringID caption, uint max_bytes, uint max_chars, WindowDesc *desc, Window *parent, CharSetFilter afilter, QueryStringFlags flags) :

			Window(desc), editbox(max_bytes, max_chars)

	{

		char *last_of = &this->editbox.text.buf[this->editbox.text.max_bytes - 1];

		GetString(this->editbox.text.buf, str, last_of);

		/* Make sure the name isn't too long for the text buffer in the number of

		 * characters (not bytes). max_chars also counts the '\0' characters. */

		while (Utf8StringLength(this->editbox.text.buf) + 1 > this->editbox.text.max_chars) {

			*Utf8PrevChar(this->editbox.text.buf + strlen(this->editbox.text.buf)) = '\0';

		}

		pos++;

	}

	assert(pos <= std::numeric_limits<PacketSize>::max());

	this->pos = static_cast<PacketSize>(pos);

}

/**

 * Reads characters (bytes) from the packet until it finds a '\0', or reaches a

 * maximum of \c length characters.

 * When the '\0' has not been reached in the first \c length read characters,

	if (length == 0) {

		/* The string in the packet was longer. Read until the termination. */

		while (this->Recv_uint8() != '\0') {}

	}

}

/**

 * Get the amount of bytes that are still available for the Transfer functions.

 * @return The number of bytes that still have to be transfered.

 */

 */

static std::string ReadDWordAsString(ByteReader *reader)

{

	char output[5];

	for (int i = 0; i < 4; i++) output[i] = reader->ReadByte();

	output[4] = '\0';

	return std::string(output);

}

/**

 * Define properties for global variables

int CDECL main(int argc, char *argv[])

{

	SetRandomSeed(time(nullptr));

	/* Make sure our arguments contain only valid UTF-8 characters. */

	return openttd_main(argc, argv);

}

bool GetClipboardContents(char *buffer, const char *last)

{

void CocoaReleaseAutoreleasePool();

#endif

int CDECL main(int argc, char *argv[])

{

	/* Make sure our arguments contain only valid UTF-8 characters. */

#ifdef WITH_COCOA

	CocoaSetupAutoreleasePool();

	/* This is passed if we are launched by double-clicking */

	if (argc >= 2 && strncmp(argv[1], "-psn", 4) == 0) {

		argv[1] = nullptr;

	/* setup random seed to something quite random */

	SetRandomSeed(GetTickCount());

	argc = ParseCommandLine(cmdline, argv, lengthof(argv));

	/* Make sure our arguments contain only valid UTF-8 characters. */

	openttd_main(argc, argv);

	/* Restore system timer resolution. */

	timeEndPeriod(1);

		temp[0] = '\0'; // if reading failed, make the name empty

		return false;

	}

	bool ret = VerifyOldNameChecksum(temp, len);

	temp[len - 2] = '\0'; // name is null-terminated in savegame, but it's better to be sure

	return ret;

}

static SavegameType DetermineOldSavegameType(FILE *f, char *title, const char *last)

{

					str_fix_scc_encoded((char *)ptr, (char *)ptr + len);

				}

			}

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

				settings = settings | SVS_ALLOW_NEWLINE;

			}

			break;

		}

		case SLA_PTRS: break;

		case SLA_NULL: break;

		default: NOT_REACHED();

	}

					str_fix_scc_encoded(buf, buf + len);

				}

			}

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

				settings = settings | SVS_ALLOW_NEWLINE;

			}

			// Store sanitized string.

			str->assign(buf);

		}

		case SLA_PTRS: break;

}

/* static */ char *ScriptObject::GetString(StringID string)

{

	char buffer[64];

	::GetString(buffer, string, lastof(buffer));

	return ::stredup(buffer);

}

/* static */ void ScriptObject::SetCallbackVariable(int index, int value)

{

	if ((size_t)index >= GetStorage()->callback_value.size()) GetStorage()->callback_value.resize(index + 1);

		return false;

	}

	if (!StrEmpty(text) && (GetCommandFlags(cmd) & CMD_STR_CTRL) == 0) {

		/* The string must be valid, i.e. not contain special codes. Since some

		 * can be made with GSText, make sure the control codes are removed. */

	}

	/* Set the default callback to return a true/false result of the DoCommand */

	if (callback == nullptr) callback = &ScriptInstance::DoCommandReturn;

	/* Are we only interested in the estimate costs? */

	switch (sq_gettype(vm, -1)) {

		case OT_STRING: {

			const SQChar *value;

			sq_getstring(vm, -1, &value);

			this->params[parameter] = stredup(value);

			break;

		}

		case OT_INTEGER: {

			SQInteger value;

			sq_getinteger(vm, -1, &value);

{

	int32 k;

	if (sq_gettype(vm, 2) == OT_STRING) {

		const SQChar *key_string;

		sq_getstring(vm, 2, &key_string);

		if (strncmp(key_string, "param_", 6) != 0 || strlen(key_string) > 8) return SQ_ERROR;

		k = atoi(key_string + 6);

	} else if (sq_gettype(vm, 2) == OT_INTEGER) {

		SQInteger key;

		sq_getinteger(vm, 2, &key);

	/* Read the table, and find all properties we care about */

	sq_pushnull(vm);

	while (SQ_SUCCEEDED(sq_next(vm, -2))) {

		const SQChar *key;

		if (SQ_FAILED(sq_getstring(vm, -2, &key))) return SQ_ERROR;

		if (strcmp(key, "name") == 0) {

			const SQChar *sqvalue;

			if (SQ_FAILED(sq_getstring(vm, -1, &sqvalue))) return SQ_ERROR;

			char *name = stredup(sqvalue);

			char *s;

			/* Don't allow '=' and ',' in configure setting names, as we need those

			 *  2 chars to nicely store the settings as a string. */

			while ((s = strchr(name, '=')) != nullptr) *s = '_';

			while ((s = strchr(name, ',')) != nullptr) *s = '_';

			config.name = name;

			items |= 0x001;

		} else if (strcmp(key, "description") == 0) {

			const SQChar *sqdescription;

			if (SQ_FAILED(sq_getstring(vm, -1, &sqdescription))) return SQ_ERROR;

			config.description = stredup(sqdescription);

			items |= 0x002;

		} else if (strcmp(key, "min_value") == 0) {

			SQInteger res;

			if (SQ_FAILED(sq_getinteger(vm, -1, &res))) return SQ_ERROR;

			config.min_value = res;

			items |= 0x004;

}

SQInteger ScriptInfo::AddLabels(HSQUIRRELVM vm)

{

	const SQChar *setting_name;

	if (SQ_FAILED(sq_getstring(vm, -2, &setting_name))) return SQ_ERROR;

	ScriptConfigItem *config = nullptr;

	for (auto &item : this->config_list) {

		if (strcmp(item.name, setting_name) == 0) config = &item;

	}

		const SQChar *label;

		if (SQ_FAILED(sq_getstring(vm, -2, &key_string))) return SQ_ERROR;

		if (SQ_FAILED(sq_getstring(vm, -1, &label))) return SQ_ERROR;

		/* Because squirrel doesn't support identifiers starting with a digit,

		 * we skip the first character. */

		int key = atoi(key_string + 1);

		/* !Contains() prevents stredup from leaking. */

		if (!config->labels->Contains(key)) config->labels->Insert(key, stredup(label));

		sq_pop(vm, 2);

	}

bool Squirrel::CallStringMethodStrdup(HSQOBJECT instance, const char *method_name, const char **res, int suspend)

{

	HSQOBJECT ret;

	if (!this->CallMethod(instance, method_name, &ret, suspend)) return false;

	if (ret._type != OT_STRING) return false;

	*res = stredup(ObjectToString(&ret));

	return true;

}

bool Squirrel::CallIntegerMethod(HSQOBJECT instance, const char *method_name, int *res, int suspend)

{

	HSQOBJECT ret;

		const SQChar *tmp;

		sq_getstring(vm, -1, &tmp);

		char *tmp_str = stredup(tmp);

		sq_poptop(vm);

		ptr->push_back((void *)tmp_str);

		return tmp_str;

	}

	template <> inline Array      *GetParam(ForceType<Array *>,      HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr)

	{

		/* Sanity check of the size. */

	if (this->max_length == 0 || str.size() < this->max_length) return;

	/* In case a maximum length is imposed by the setting, the length

	 * includes the '\0' termination for network transfer purposes.

	 * Also ensure the string is valid after chopping of some bytes. */

	std::string stdstr(str, this->max_length - 1);

}

/**

 * Write a string to the actual setting.

 * @param object The object the setting is to be saved in.

 * @param str The string to save.

	}

	*str = '\0';

}

template <class T>

{

	/* Assume the ABSOLUTE WORST to be in str as it comes from the outside. */

	while (str <= last && *str != '\0') {

		size_t len = Utf8EncodedCharLen(*str);

		WChar c;

	}

	/* String termination, if needed, is left to the caller of this function. */

}

/**

 */

{

	char *dst = str;

	*dst = '\0';

}

/**

 */

{

	auto buf = str.data();

	auto last = buf + str.size();

	std::ostringstream dst;

	std::ostreambuf_iterator<char> dst_iter(dst);

	return dst.str();

}

/**

 * Checks whether the given string is valid, i.e. contains only

 * valid (printable) characters and is properly terminated.

 * @param str  The string to validate.

 * @param last The last character of the string, i.e. the string

 *             must be terminated here or earlier.

 */

int CDECL seprintf(char *str, const char *last, const char *format, ...) WARN_FORMAT(3, 4) NOACCESS(2);

int CDECL vseprintf(char *str, const char *last, const char *format, va_list ap) WARN_FORMAT(3, 0) NOACCESS(2);

char *CDECL str_fmt(const char *str, ...) WARN_FORMAT(1, 2);

void str_fix_scc_encoded(char *str, const char *last) NOACCESS(2);

void str_strip_colours(char *str);

bool strtolower(char *str);

bool strtolower(std::string &str, std::string::size_type offs = 0);

	if (!this->text) return;

	/* Add space for trailing \0 */

	this->text = ReallocT(this->text, filesize + 1);

	this->text[filesize] = '\0';

	for (char *p = this->text; *p != '\0'; p++) {

		if (*p == '\t' || *p == '\r') *p = ' ';

	}

	/* Check for the byte-order-mark, and skip it if needed. */

	char *p = this->text + (strncmp(u8"\ufeff", this->text, 3) == 0 ? 3 : 0);

	/* Make sure the string is a valid UTF-8 sequence. */

	/* Split the string on newlines. */

	int row = 0;

	this->lines.emplace_back(row, p);

	for (; *p != '\0'; p++) {

		if (*p == '\n') {

	for (char *c = input_line; *c != '\0'; c++) {

		if (*c == '\n' || *c == '\r' || c == lastof(input_line)) {

			*c = '\0';

			break;

		}

	}

	IConsoleCmdExec(input_line); // execute command

}

void VideoDriver_Dedicated::MainLoop()

{