[#114] feat(DaedalusVm): introduce dynamically growing temporary strings

Author: lmichaelis

include/zenkit/DaedalusScript.hh

@@ -667,6 +667,8 @@ namespace zenkit {
 			return *_m_registered_to;
 		}
 
+		ZKAPI void grow(uint32_t n);
+
 	protected:
 		template <typename T>
 		T const* get_member_ptr(std::uint16_t index, DaedalusInstance const* context) const {

include/zenkit/DaedalusVm.hh

@@ -973,6 +973,12 @@ namespace zenkit {
 			}
 		}
 
+		/// \brief Mark the temporary string at the given index as free.
+		void mark_free_string(uint32_t index);
+
+		/// \brief Obtain a random free temporary string index.
+		uint32_t get_free_string();
+
 	private:
 		std::array<DaedalusStackFrame, stack_size> _m_stack;
 		uint16_t _m_stack_ptr {0};
@@ -993,6 +999,7 @@ namespace zenkit {
 		DaedalusSymbol* _m_item_sym;
 
 		DaedalusSymbol* _m_temporary_strings;
+		std::stack<uint32_t> _m_temporary_strings_free {};
 
 		std::shared_ptr<DaedalusInstance> _m_instance;
 		std::uint32_t _m_pc {0};

src/DaedalusScript.cc

@@ -570,6 +570,39 @@ namespace zenkit {
 		std::get<std::shared_ptr<DaedalusInstance>>(_m_value) = inst;
 	}
 
+	void DaedalusSymbol::grow(uint32_t n) {
+		auto& value = this->_m_value;
+
+		if (std::holds_alternative<std::unique_ptr<std::string[]>>(value)) {
+			auto new_value = std::make_unique<std::string[]>(this->_m_count + n);
+			auto& old_value = std::get<std::unique_ptr<std::string[]>>(value);
+
+			// Move strings from the current value into the new, larger array.
+			for (uint32_t i = 0; i < this->_m_count; ++i) {
+				new_value[i] = std::move(old_value[i]);
+			}
+
+			this->_m_value = std::move(new_value);
+		} else if (std::holds_alternative<std::unique_ptr<std::int32_t[]>>(value)) {
+			auto new_value = std::make_unique<std::int32_t[]>(this->_m_count + n);
+			auto& old_value = std::get<std::unique_ptr<std::int32_t[]>>(value);
+
+			std::copy_n(&old_value[0], this->_m_count, &new_value[0]);
+			this->_m_value = std::move(new_value);
+		} else if (std::holds_alternative<std::unique_ptr<float[]>>(value)) {
+			auto new_value = std::make_unique<float[]>(this->_m_count + n);
+			auto& old_value = std::get<std::unique_ptr<float[]>>(value);
+
+			std::copy_n(&old_value[0], this->_m_count, &new_value[0]);
+			this->_m_value = std::move(new_value);
+		} else {
+			// Cannot grow other symbol types.
+			throw DaedalusIllegalTypeAccess(this, this->type());
+		}
+
+		this->_m_count = this->_m_count + n;
+	}
+
 	void DaedalusSymbol::set_access_trap_enable(bool enable) noexcept {
 		if (enable)
 			_m_flags |= DaedalusSymbolFlag::TRAP_ACCESS;

src/DaedalusVm.cc

@@ -77,6 +77,8 @@ namespace zenkit {
 
 	DaedalusVm::DaedalusVm(DaedalusScript&& scr, std::uint8_t flags) : DaedalusScript(std::move(scr)), _m_flags(flags) {
 		_m_temporary_strings = add_temporary_strings_symbol();
+		_m_temporary_strings_free.push(0);
+
 		_m_self_sym = find_symbol_by_name("SELF");
 		_m_other_sym = find_symbol_by_name("OTHER");
 		_m_victim_sym = find_symbol_by_name("VICTIM");
@@ -508,8 +510,12 @@ namespace zenkit {
 	}
 
 	void DaedalusVm::push_string(std::string_view value) {
-		_m_temporary_strings->set_string(value);
-		push_reference(_m_temporary_strings);
+		// We need to push strings without an explicitly attached variable to a
+		// virtual string container variable.
+		auto index = this->get_free_string();
+
+		_m_temporary_strings->set_string(value, index);
+		push_reference(_m_temporary_strings, index);
 	}
 
 	void DaedalusVm::push_float(float value) {
@@ -584,6 +590,13 @@ namespace zenkit {
 			throw DaedalusVmException {"tried to pop_reference but frame does not contain a reference."};
 		}
 
+		auto sym = std::get<DaedalusSymbol*>(v.value);
+		if (sym->index() == _m_temporary_strings->index()) {
+			// For virtual strings, we'll mark this string as free when it's popped.
+			// This is likely unreliable but until it causes issues, it'll stay as-is.
+			this->mark_free_string(v.index);
+		}
+
 		return {std::get<DaedalusSymbol*>(v.value), v.index, v.context};
 	}
 
@@ -981,4 +994,25 @@ namespace zenkit {
 			ZKLOGE("DaedalusVm", "Accessing member \"%s\" without an instance set", ref->name().c_str());
 		}
 	}
+
+	void DaedalusVm::mark_free_string(uint32_t index) {
+		this->_m_temporary_strings_free.push(index);
+	}
+
+	uint32_t DaedalusVm::get_free_string() {
+		if (_m_temporary_strings_free.size() == 0) {
+			// Like a normal array, we'll grow exponentially.
+			auto prev_size = _m_temporary_strings->count();
+			_m_temporary_strings->grow(prev_size * 2);
+
+			// Mark new strings as unused.
+			for (uint32_t i = prev_size; i < _m_temporary_strings->count(); ++i) {
+				_m_temporary_strings_free.push(i);
+			}
+		}
+
+		auto index = this->_m_temporary_strings_free.top();
+		this->_m_temporary_strings_free.pop();
+		return index;
+	}
 } // namespace zenkit