maint: better parsing of main arguments

Co-authored-by: William Roy <wroy@proton.me>

src/utils/memory.cpp

@@ -0,0 +1,106 @@
+#include <std_include.hpp>
+#include "memory.hpp"
+
+namespace utils
+{
+	memory::allocator memory::mem_allocator_;
+
+	memory::allocator::~allocator()
+	{
+		this->clear();
+	}
+
+	void memory::allocator::clear()
+	{
+		std::lock_guard _(this->mutex_);
+
+		for (const auto& data : this->pool_)
+		{
+			memory::free(data);
+		}
+
+		this->pool_.clear();
+	}
+
+	void memory::allocator::free(void* data)
+	{
+		std::lock_guard _(this->mutex_);
+
+		const auto j = std::find(this->pool_.begin(), this->pool_.end(), data);
+		if (j != this->pool_.end())
+		{
+			memory::free(data);
+			this->pool_.erase(j);
+		}
+	}
+
+	void memory::allocator::free(const void* data)
+	{
+		this->free(const_cast<void*>(data));
+	}
+
+	void* memory::allocator::allocate(const std::size_t length)
+	{
+		std::lock_guard _(this->mutex_);
+
+		const auto data = memory::allocate(length);
+		this->pool_.push_back(data);
+		return data;
+	}
+
+	bool memory::allocator::empty() const
+	{
+		return this->pool_.empty();
+	}
+
+	char* memory::allocator::duplicate_string(const std::string& string)
+	{
+		std::lock_guard _(this->mutex_);
+
+		const auto data = memory::duplicate_string(string);
+		this->pool_.push_back(data);
+		return data;
+	}
+
+	void* memory::allocate(const std::size_t length)
+	{
+		return ::calloc(1, length);
+	}
+
+	char* memory::duplicate_string(const std::string& string)
+	{
+		const auto new_string = allocate_array<char>(string.size() + 1);
+		std::memcpy(new_string, string.data(), string.size());
+		return new_string;
+	}
+
+	void memory::free(void* data)
+	{
+		::free(data);
+	}
+
+	void memory::free(const void* data)
+	{
+		free(const_cast<void*>(data));
+	}
+
+	bool memory::is_set(const void* mem, const char chr, const std::size_t length)
+	{
+		auto* const mem_arr = static_cast<const char*>(mem);
+
+		for (std::size_t i = 0; i < length; ++i)
+		{
+			if (mem_arr[i] != chr)
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	memory::allocator* memory::get_allocator()
+	{
+		return &memory::mem_allocator_;
+	}
+}

src/utils/memory.hpp

@@ -0,0 +1,68 @@
+#pragma once
+
+namespace utils
+{
+	class memory final
+	{
+	public:
+		class allocator final
+		{
+		public:
+			~allocator();
+
+			void clear();
+
+			void free(void* data);
+
+			void free(const void* data);
+
+			void* allocate(std::size_t length);
+
+			template <typename T>
+			T* allocate()
+			{
+				return this->allocate_array<T>(1);
+			}
+
+			template <typename T>
+			T* allocate_array(const std::size_t count = 1)
+			{
+				return static_cast<T*>(this->allocate(count * sizeof(T)));
+			}
+
+			[[nodiscard]] bool empty() const;
+
+			char* duplicate_string(const std::string& string);
+
+		private:
+			std::mutex mutex_;
+			std::vector<void*> pool_;
+		};
+
+		static void* allocate(std::size_t length);
+
+		template <typename T>
+		static T* allocate()
+		{
+			return allocate_array<T>(1);
+		}
+
+		template <typename T>
+		static T* allocate_array(const std::size_t count = 1)
+		{
+			return static_cast<T*>(allocate(count * sizeof(T)));
+		}
+
+		static char* duplicate_string(const std::string& string);
+
+		static void free(void* data);
+		static void free(const void* data);
+
+		static bool is_set(const void* mem, char chr, std::size_t length);
+
+		static allocator* get_allocator();
+
+	private:
+		static allocator mem_allocator_;
+	};
+}

src/utils/string.cpp

@@ -3,6 +3,19 @@
 
 namespace utils::string
 {
+	const char* va(const char* fmt, ...)
+	{
+		static thread_local va_provider<8, 256> provider;
+
+		va_list ap;
+		va_start(ap, fmt);
+
+		const auto* result = provider.get(fmt, ap);
+
+		va_end(ap);
+		return result;
+	}
+
 	std::vector<std::string> split(const std::string& s, const char delim)
 	{
 		std::stringstream ss(s);

src/utils/string.hpp

@@ -1,7 +1,87 @@
 #pragma once
+#include "memory.hpp"
 
 namespace utils::string
 {
+	template <class Type, std::size_t n>
+	constexpr auto ARRAY_COUNT(Type(&)[n]) { return n; }
+
+	template <std::size_t buffers, std::size_t min_buffer_size>
+	class va_provider final
+	{
+	public:
+		static_assert(buffers != 0 && min_buffer_size != 0, "buffers and min_buffer_size mustn't be 0");
+
+		va_provider() : current_buffer_(0)
+		{
+		}
+
+		char* get(const char* format, va_list ap)
+		{
+			++this->current_buffer_ %= ARRAY_COUNT(this->string_pool_);
+			auto entry = &this->string_pool_[this->current_buffer_];
+
+			if (!entry->size_ || !entry->buffer_)
+			{
+				throw std::runtime_error("The string pool is not initialized");
+			}
+
+			while (true)
+			{
+#ifdef _WIN32
+				const auto res = vsnprintf_s(entry->buffer_, entry->size_, _TRUNCATE, format, ap);
+#else
+				const auto res = vsnprintf(entry->buffer_, entry->size_, format, ap);
+#endif
+
+				if (res > 0) break; // Success
+				if (res == 0) return nullptr; // Error
+
+				entry->double_size();
+			}
+
+			return entry->buffer_;
+		}
+
+	private:
+		class entry final
+		{
+		public:
+			explicit entry(const std::size_t size = min_buffer_size) : size_(size), buffer_(nullptr)
+			{
+				if (this->size_ < min_buffer_size) this->size_ = min_buffer_size;
+				this->allocate();
+			}
+
+			~entry()
+			{
+				if (this->buffer_) memory::get_allocator()->free(this->buffer_);
+				this->size_ = 0;
+				this->buffer_ = nullptr;
+			}
+
+			void allocate()
+			{
+				if (this->buffer_) memory::get_allocator()->free(this->buffer_);
+				this->buffer_ = memory::get_allocator()->allocate_array<char>(this->size_ + 1);
+			}
+
+			void double_size()
+			{
+				this->size_ *= 2;
+				this->allocate();
+			}
+
+			std::size_t size_;
+			char* buffer_;
+		};
+
+		std::size_t current_buffer_;
+		entry string_pool_[buffers];
+	};
+
+	const char* va(const char* fmt, ...);
+
 	std::vector<std::string> split(const std::string& s, char delim);
 
 	std::string to_lower(const std::string& text);