Initial commit

engines/m4/mem/mem.cpp

@@ -0,0 +1,130 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#include "m4/mem/mem.h"
+#include "m4/mem/memman.h"
+#include "m4/core/errors.h"
+#include "m4/vars.h"
+
+namespace M4 {
+
+#define MAX_REQUESTS 255
+
+void mem_stash_init(int16 num_types) {
+	if (num_types > _MEMTYPE_LIMIT)
+		error_show(FL, 'MSIF', "num_types (%d) _MEMTYPE_LIMIT (%d)", num_types, _MEMTYPE_LIMIT);
+
+	for (int i = 0; i < _MEMTYPE_LIMIT; i++) {
+		_G(memBlock)[i] = nullptr;
+		_G(sizeMem)[i] = 0;
+		_G(requests)[i] = 0;
+	}
+}
+
+void mem_stash_shutdown(void) {
+	for (int i = 0; i < _MEMTYPE_LIMIT; i++) {
+		if (_G(memBlock)[i]) {
+			mem_free(_G(memBlock)[i]);
+			_G(memBlock)[i] = nullptr;
+		}
+	}
+}
+
+bool mem_register_stash_type(int32 *memType, int32 blockSize, int32 maxNumRequests, const Common::String &name) {
+	int32 i = 0;
+	bool found = false;
+
+	while ((i < _MEMTYPE_LIMIT) && (_G(sizeMem)[i] > 0) && (!found)) {
+		i++;
+	}
+	if (i == _MEMTYPE_LIMIT)
+		error_show(FL, 'MSIF', "stash: %s", name.c_str());
+
+	// Found a slot
+	if (found || (i < _MEMTYPE_LIMIT)) {
+		_G(sizeMem)[i] = blockSize;
+		*memType = i;
+
+		if (maxNumRequests > MAX_REQUESTS)
+			maxNumRequests = MAX_REQUESTS;
+
+		_G(requests)[i] = maxNumRequests;
+
+		_G(memBlock)[i] = mem_alloc((blockSize + sizeof(uintptr)) * maxNumRequests, name.c_str());
+		memset(_G(memBlock)[i], 0, (blockSize + sizeof(uintptr)) * maxNumRequests);
+
+		return true;
+	}
+
+	error_show(FL, 'MSIF', "stash: %s", name.c_str());
+	return false;
+}
+
+void mem_free_to_stash(void *mem, int32 memType) {
+	// _G(memBlock)[memType] is block associated with memType
+	int8 *b_ptr = (int8 *)_G(memBlock)[memType];
+	int32 index = ((intptr)mem - (intptr)_G(memBlock)[memType]) / (_G(sizeMem)[memType] + sizeof(uintptr));
+
+	if (index < 0 || index > _G(requests)[memType])
+		error_show(FL, 'MSGF');
+
+	b_ptr += index * (_G(sizeMem)[memType] + sizeof(uintptr));
+	*(uintptr *)b_ptr = 0;
+}
+
+void *mem_get_from_stash(int32 memType, const Common::String &name) {
+	int i;
+	int8 *b_ptr = (int8 *)_G(memBlock)[memType];
+
+	for (i = 0; i < _G(requests)[memType]; i++) {
+		if (!*(uintptr *)b_ptr) {
+			*(uintptr *)b_ptr = 1;
+			void *result = (void *)(b_ptr + sizeof(uintptr));
+			Common::fill((byte *)result, (byte *)result + _G(sizeMem)[memType], 0);
+			return result;
+
+		} else {
+			b_ptr += _G(sizeMem)[memType] + sizeof(uintptr);
+		}
+	}
+
+	error_show(FL, 'OOS!', "stash full %s", name.c_str());
+	return 0;
+}
+
+char *mem_strdup(const char *str) {
+	char *new_str = nullptr;
+
+	if (!str) {
+		new_str = (char *)mem_alloc(1, "string");
+		new_str[0] = '\0';
+		return new_str;
+	}
+
+	new_str = (char *)mem_alloc(strlen(str) + 1, "string");
+	if (!new_str)
+		return nullptr;
+
+	Common::strcpy_s(new_str, 256, str);
+	return new_str;
+}
+
+
+} // namespace M4