Class breakpoint_recorder

sources/debugger.cpp:149–267

}

class breakpoint_recorder final {
	struct breakpoint final {
		std::size_t id = 0;
		std::variant<std::size_t, std::string, cs::var> data;

		template <typename T>
		breakpoint(std::size_t _id, T &&_data) : id(_id), data(std::forward<T>(_data))
		{
		}
	};

	static std::size_t m_id;
	std::forward_list<breakpoint> m_breakpoints;
	cs::map_t<std::string, std::pair<std::size_t, bool>> m_pending;

public:
	breakpoint_recorder() = default;

	std::size_t add_line(std::size_t line_num)
	{
		m_breakpoints.emplace_front(++m_id, line_num);
		return m_id;
	}

	std::size_t add_func(cs::var function)
	{
		if (function.type() == typeid(cs::object_method))
			function = function.const_val<cs::object_method>().callable;
		else if (function.type() != typeid(cs::callable))
			throw cs::runtime_error("Debugger just can break at specific line or function.");
		const cs::callable::function_type &target = function.const_val<cs::callable>().get_raw_data();
		if (target.target_type() != typeid(cs::function_ptr))
			throw cs::runtime_error("Debugger can not break at CNI function.");
		target.target<cs::function_ptr>()->fptr->set_debugger_state(true);
		m_breakpoints.emplace_front(++m_id, function);
		return m_id;
	}

	std::size_t add_pending(const std::string &func)
	{
		m_breakpoints.emplace_front(++m_id, func);
		m_pending.emplace(func, std::pair<std::size_t, bool>(m_id, true));
		return m_id;
	}

	void replace_pending(const std::string &name, const cs::var &function)
	{
		if (m_pending.count(name) > 0) {
			const cs::callable::function_type &target = function.const_val<cs::callable>().get_raw_data();
			target.target<cs::function_ptr>()->fptr->set_debugger_state(true);
			auto key = m_pending.find(name);
			if (key->second.second) {
				for (auto &it : m_breakpoints) {
					if (it.id == key->second.first) {
						it.data.emplace<cs::var>(function);
						key->second.second = false;
						break;
					}