From f8c6ec7a18b33deba530b15a5779556233e8057b Mon Sep 17 00:00:00 2001
From: "Claudius \"keldu\" Holeksa" <mail@keldu.de>
Date: Fri, 8 Mar 2024 21:54:31 +0100
Subject: codec,tools: Working on better c iface generation

---
 modules/tools/c++/c_gen_iface.hpp | 474 ++++++++++++--------------------------
 1 file changed, 144 insertions(+), 330 deletions(-)

(limited to 'modules/tools/c++')

diff --git a/modules/tools/c++/c_gen_iface.hpp b/modules/tools/c++/c_gen_iface.hpp
index b55816c..2dfa36f 100644
--- a/modules/tools/c++/c_gen_iface.hpp
+++ b/modules/tools/c++/c_gen_iface.hpp
@@ -12,81 +12,9 @@
 #include <iostream>
 
 namespace saw {
-
-namespace schema {
-
-using CVar = Struct<
-	Member<schema::String, "schema">,
-	Member<schema::UInt32, "crc32">,
-	Member<schema::String, "type">,
-	Member<schema::String, "type_name">,
-	Member<schema::String, "name">,
-	Member<schema::Int8, "is_primitive">
->;
-
-using CStruct = Struct<
-	Member<schema::String, "schema">,
-	Member<schema::UInt32, "crc32">,
-	Member<schema::String, "type">,
-	Member<Array<CVar>, "members">
->;
-
-using CFunction = Struct<
-	Member<schema::String, "schema">,
-	Member<schema::UInt32, "crc32">,
-	Member<schema::String, "name">,
-	Member<Array<CVar>, "params">,
-	Member<CVar, "return">
->;
-
-using CIface = Struct<
-	Member<schema::String, "schema">,
-	Member<schema::UInt32, "crc32">,
-	Member<Array<CStruct>,"structs">,
-	Member<Array<CFunction>,"functions">
->;
-}
-/**
- * Type meant to provide future help if I decide to introduce more maps
- */
-/**
-namespace schema {
-using namespace saw::schema;
-Pseudo flattened
-using Foo = Struct<
-		Member<Array<Int32>, "a">
-		Member<Array<Float32>, "b">
->;
-
-Needs to be flattened to
-
-template<typename InnerSchema>
-using FlattenedSchemaElement = Struct<
-		Member<Array<String>, "path">,
-		Member<InnerSchema, "inner_schema">
->;
-
-// Illegal, but doable with more lines of code
-// Just use typename... T and 
-// "T..." for
-// "Member<FlattenedSchemaElement<Ele>,Names>...>"
-// and specialize somewhere else
-template<typename... Ele, string_literal... Names>
-using FlattenedSchema = Struct<
-		Member<String, "top_schema">,
-		Member<FlattenedSchemaElement<Ele>, Names>...
->;
+namespace binding {
+struct C {};
 }
-*/
-
-template<typename T, typename Res>
-struct schema_flattener {
-		static_assert(always_false<T>, "Not supported");
-};
-
-template<typename T0, string_literal Name0, typename... T, string_literal... Names, typename Res>
-struct schema_flattener<schema::Struct<schema::Member<T0,Name0>,schema::Member<T,Names>...>, Res> {
-};
 
 /**
  * Helper to determine if we are dealing with primitive types
@@ -166,336 +94,222 @@ struct c_primitive_string<schema::Float64> {
 	static constexpr string_literal value = "double";
 };
 
-error_or<data<schema::UInt64>> c_interface_find_struct_by_crc32(const data<schema::CIface>& state, const data<schema::UInt32>& id){
-	const auto& strs = state.template get<"structs">();
-	for(uint64_t i = 0; i < strs.size(); ++i){
-		const auto& str = strs.at(i);
-		if(str.template get<"crc32">() == id){
-			return data<schema::UInt64>{i};
-		}
-	}
-	return make_error<err::not_found>();
-}
-
-error_or<void> c_interface_add_struct(data<schema::CIface>& state, data<schema::CStruct>&& val){
-	auto& strs = state.template get<"structs">();
-	auto eov = strs.add(std::move(val));
-	if(eov.is_error()){
-		return std::move(eov.get_error());
-	}
-	return void_t{};
-}
-
-bool c_interface_function_exists(data<schema::CIface>& state, const std::string_view& name){
-	auto& funcs = state.template get<"functions">();
-	for(uint64_t i = 0; i < funcs.size(); ++i){
-		if(funcs.at(i).get<"name">() == name){
-			return true;
-		}
-	}
-	return false;
-}
+struct language_binding_config {
+	std::string prefix;
+};
 
-template<typename Schema>
-struct c_data_translater {
+namespace impl {
+template<typename Schema, typename Lang>
+struct lang_bind {
 	static_assert(always_false<Schema>, "Not supported");
 };
 
-template<typename T, uint64_t N>
-struct c_data_translater<schema::Primitive<T,N>> {
-	using Schema = schema::Primitive<T,N>;
-	static constexpr string_literal c_type_name = c_primitive_string<Schema>::name;
-	static constexpr string_literal c_type = c_primitive_string<Schema>::value;
-
-	static error_or<void> generate(data<schema::CIface>& state, data<schema::CVar>& prim){
-		try{
-			std::stringstream iss;
-			schema_stringify<Schema>::apply(iss);
-			prim.template get<"schema">().set(iss.str());
-			prim.template get<"crc32">().set(schema_hash<Schema>::apply());
-			prim.template get<"is_primitive">().set(1);
-			prim.template get<"type">().set(std::string{c_primitive_string<Schema>::value.view()});
-		}catch(const std::exception&){
-			return make_error<err::out_of_memory>();
+struct language_binding_state {
+	struct info {
+		std::string type;
+	};
+	std::map<uint32_t, language_binding_state::info> hashes;
+};
+
+struct lang_bind_helper {
+	static error_or<void> append_string(buffer& buff, const std::string_view& str){
+		for(uint64_t i = 0; i < str.size(); ++i){
+			auto err = buff.push(static_cast<uint8_t>(str[i]));
+			if(!err.template is_type<err::no_error>()){
+				return err;
+			}
 		}
+		return void_t{};
+	}
 
+	static error_or<void> append_hashed_type(buffer& buff, const std::string_view& prefix, uint32_t hash){
+		{
+			auto eov = append_string(buff, prefix);
+			if(eov.is_error()){
+				return eov;
+			}
+		}
+		{
+			auto eov = append_string(buff, "_");
+			if(eov.is_error()){
+				return eov;
+			}
+		}
+		{
+			auto eov = append_string(buff, std::to_string(hash));
+			if(eov.is_error()){
+				return eov;
+			}
+		}
+		{
+			auto eov = append_string(buff, "_t");
+			if(eov.is_error()){
+				return eov;
+			}
+		}
 		return void_t{};
 	}
 };
 
-template<typename T, uint64_t N>
-struct c_data_translater<schema::Array<T,N>> {
-	static_assert(N==1, "Doesn't support more than one dimension currently");
-
-	using Schema = schema::Array<T,N>;
-	static constexpr string_literal c_type_name = "array_"_sl + c_data_translater<T>::c_type_name + "_1d"_sl;
-	static constexpr string_literal c_type = c_type_name + "_t"_sl;
-
-	static error_or<void> generate(data<schema::CIface>& state, data<schema::CVar>& arr){
-		try{
-			{
-				std::stringstream iss;
-				schema_stringify<Schema>::apply(iss);
-				arr.template get<"schema">().set(iss.str());
-				arr.template get<"crc32">().set(schema_hash<Schema>::apply());
-				arr.template get<"is_primitive">().set(0);
-			}
+template<typename T, uint64_t L>
+struct lang_bind<schema::Primitive<T,L>, binding::C> {
+	using Schema = schema::Primitive<T,L>;
 
-			/// @todo change this !!!!!
-			{
-				auto eov = c_interface_find_struct_by_crc32(state, arr.template get<"crc32">());
-				if(eov.is_error()){
-					if(false){
-						return std::move(eov.get_error());
+	static error_or<void> generate(buffer& buff, const language_binding_config& cfg, language_binding_state& state){
+		constexpr uint64_t hash = schema_hash<Schema>::apply();
+
+		{
+			std::string hash_type_str = cfg.prefix + "_" + std::to_string(hash) + "_t";
+			auto emp = state.hashes.emplace(std::make_pair(hash, hash_type_str));
+			if(emp.second){
+				{
+					auto eov = lang_bind_helper::append_string(buff, "typedef ");
+					if(eov.is_error()){
+						return eov;
 					}
-					data<schema::CStruct> str;
-					str.template get<"schema">() = arr.template get<"schema">();
-					str.template get<"crc32">() = arr.template get<"crc32">();
-					str.template get<"type">().set(std::string{c_type.view()});
-					auto& membs = str.template get<"members">();
-					{
-						data<schema::CVar> c_var;
-						std::stringstream iss;
-						schema_stringify<T>::apply(iss);
-						c_var.template get<"schema">().set(iss.str());
-						c_var.template get<"crc32">().set(schema_hash<T>::apply());
-						if constexpr (is_primitive<T>::value){
-							c_var.template get<"type">().set(std::string{c_primitive_string<T>::value.view()} + "*");
-							c_var.template get<"name">().set(std::string{"data"});
-							c_var.template get<"is_primitive">().set(1);
-						}else{
-							return make_error<err::not_implemented>();
-						}
-
-						auto eov_add = membs.add(std::move(c_var));
-						if(eov_add.is_error()){
-							return std::move(eov_add.get_error());
-						}
+				}
+				{
+					auto eov = lang_bind_helper::append_string(buff, c_primitive_string<Schema>::value.view());
+					if(eov.is_error()){
+						return eov;
 					}
-					{
-						data<schema::CVar> c_var;
-						std::stringstream iss;
-						schema_stringify<schema::UInt64>::apply(iss);
-						c_var.template get<"schema">().set(iss.str());
-						c_var.template get<"crc32">().set(schema_hash<schema::UInt64>::apply());
-						if constexpr (is_primitive<T>::value){
-							c_var.template get<"type">().set(std::string{c_primitive_string<schema::UInt64>::value.view()});
-							c_var.template get<"name">().set(std::string{"size"});
-							c_var.template get<"is_primitive">().set(1);
-						}else{
-							return make_error<err::not_implemented>();
-						}
-
-						auto eov_add = membs.add(std::move(c_var));
-						if(eov_add.is_error()){
-							return std::move(eov_add.get_error());
-						}
+				}
+				{
+					auto eov = lang_bind_helper::append_string(buff, " ");
+					if(eov.is_error()){
+						return eov;
 					}
-
-					/**
-					 * Add the struct to the struct array
-					 */
-					{
-						auto eov_add = c_interface_add_struct(state, std::move(str));
-						if(eov_add.is_error()){
-							return std::move(eov_add.get_error());
-						}
+				}
+				{
+					auto eov = lang_bind_helper::append_string(buff, hash_type_str);
+					if(eov.is_error()){
+						return eov;
+					}
+				}
+				{
+					auto eov = lang_bind_helper::append_string(buff, ";\n");
+					if(eov.is_error()){
+						return eov;
 					}
 				}
 			}
-			arr.template get<"type">().set(std::string{c_type.view()});
-		}catch(const std::exception&){
-			return make_error<err::out_of_memory>();
 		}
 
 		return void_t{};
 	}
 };
 
-/*
-template<typename... Members>
-struct c_data_translater<schema::Struct<Members...>> {
-	using Schema = schema::Struct<Members...>;
-
-	static error_or<void> generate(data<schema::CIface>& state){
-		return void_t{};
-	}
-};
-*/
-
-template<typename Str>
-struct c_parameter_translater {
-	static_assert(always_false<Str>, "Type not supported");
-};
-
-template<typename... V, string_literal... K>
-struct c_parameter_translater<schema::Struct<schema::Member<V,K>...>> {
-	template<uint64_t i>
-	static error_or<void> generate_ele(data<schema::CIface>& state, data<schema::Array<schema::CVar>>& params){
-		using Type = typename parameter_pack_type<i, V...>::type;
-		constexpr string_literal Literal = parameter_key_pack_type<i,K...>::literal;
+template<typename Input, typename Output>
+struct lang_bind<schema::Function<Input, Output>, binding::C> {
+	static error_or<void> generate(buffer& buff, const language_binding_config& cfg, language_binding_state& state){
+		constexpr uint64_t input_hash = schema_hash<Input>::apply();
+		constexpr uint64_t output_hash = schema_hash<Output>::apply();
 
 		{
-			auto c_var = data<schema::CVar>{};
-			c_var.template get<"name">().set(std::string{Literal.view()});
-			{
-				auto eov = c_data_translater<Type>::generate(state,c_var);
+				auto eov = lang_bind<Input, binding::C>::generate(buff, cfg, state);
 				if(eov.is_error()){
 					return eov;
 				}
-			}
-			{
-				auto eov = params.add(std::move(c_var));
+		}
+		{
+				auto eov = lang_bind<Output, binding::C>::generate(buff, cfg, state);
 				if(eov.is_error()){
 					return eov;
 				}
-			}
 		}
 
-		if constexpr ( (i+1) < sizeof...(V) ) {
-			return generate_ele<i+1>(state, params);
-		}
-		return void_t{};
-	}
-
-	static error_or<void> generate(data<schema::CIface>& state, data<schema::Array<schema::CVar>>& params){
-		if constexpr ( sizeof...(V) > 0){
-			return generate_ele<0>(state, params);
-		}
 		return void_t{};
 	}
 };
 
-template<typename Req, typename Ret>
-struct c_data_translater<schema::Function<Req,Ret>> {
-	using Schema = schema::Function<Req,Ret>;
-
-	static error_or<void> generate_struct_params(data<schema::CIface>& state, data<schema::Array<schema::CVar>>& params){
-		return c_parameter_translater<Req>::generate(state, params);
-	}
+template<typename... M>
+struct lang_bind<schema::Interface<M...>, binding::C> {
+	template<uint64_t i>
+	static error_or<void> generate_element(buffer& buff, const language_binding_config& cfg, language_binding_state& state){
+		using Member = typename parameter_pack_type<i, M...>::type;
+		using MValue = typename Member::ValueType;
+		static constexpr string_literal MKey = Member::KeyLiteral;
 
-	static error_or<void> generate(data<schema::CIface>& state, const std::string_view& func_name){
-		if(c_interface_function_exists(state, func_name)){
-			return make_error<err::invalid_state>("Function already exists");
+		{
+			auto eov = lang_bind<MValue, binding::C>::generate(buff, cfg, state);
+			if(eov.is_error()){
+				return eov;
+			}
 		}
 
-		auto& funcs = state.template get<"functions">();
-		data<schema::CFunction> function;
-		function.template get<"name">().set(std::string{func_name});
-		
-		try{
-			std::stringstream iss;
-			schema_stringify<Schema>::apply(iss);
-			function.template get<"schema">().set(iss.str());
-			function.template get<"crc32">().set(schema_hash<Schema>::apply());
-		}catch(const std::exception&){
-			return make_error<err::out_of_memory>();
+		{
+			auto eov = lang_bind_helper::append_string(buff, cfg.prefix);
+			if(eov.is_error()){
+				return eov;
+			}
 		}
-
-		// Return value
 		{
-			auto& c_var = function.template get<"return">();
-			c_var.template get<"name">().set("ret_val");
-			auto eov = c_data_translater<Ret>::generate(state, c_var);
+			auto eov = lang_bind_helper::append_string(buff, "_");
 			if(eov.is_error()){
 				return eov;
 			}
 		}
-
-		// Request values
-		auto& params = function.template get<"params">();
-		if constexpr (is_primitive<Req>::value){
-			auto c_var = data<schema::CVar>{};
-			c_var.template get<"name">().set("req_val");
-			{
-				auto eov = c_data_translater<Req>::generate(state, c_var);
-				if(eov.is_error()){
-					return eov;
-				}
+		{
+			auto eov = lang_bind_helper::append_string(buff, MKey.view());
+			if(eov.is_error()){
+				return eov;
 			}
-			{
-				auto eov = params.add(std::move(c_var));
-				if(eov.is_error()){
-					return eov;
-				}
+		}
+		{
+			auto eov = lang_bind_helper::append_string(buff, "(");
+			if(eov.is_error()){
+				return eov;
 			}
-		} else {
-			auto eov = generate_struct_params(state, params);
+		}
+		{
+			auto eov = lang_bind_helper::append_hashed_type(buff, cfg.prefix, schema_hash<Member>::apply());
 			if(eov.is_error()){
 				return eov;
 			}
 		}
-
 		{
-			auto eov = funcs.add(std::move(function));
+			auto eov = lang_bind_helper::append_string(buff, ",");
 			if(eov.is_error()){
 				return eov;
 			}
 		}
-
-		return void_t{};
-	}
-};
-
-template<typename... Funcs, string_literal... Names>
-struct c_data_translater<schema::Interface<schema::Member<Funcs,Names>...>> {
-	using Schema = schema::Interface<schema::Member<Funcs, Names>...>;
-
-	template<std::size_t i>
-	static error_or<void> generate_ele(data<schema::CIface>& state){
-		using InnerSchema = typename parameter_pack_type<i, Funcs...>::type;
-		constexpr string_literal Literal = parameter_key_pack_type<i, Names...>::literal;
 		{
-			auto eov = c_data_translater<InnerSchema>::generate(state, Literal.view());
+			auto eov = lang_bind_helper::append_string(buff, ");");
 			if(eov.is_error()){
 				return eov;
 			}
 		}
 
-		/**
-		 * Continue if elements remain or finish
-		 */
-		if constexpr ( (i+1) < sizeof...(Funcs) ){
-			return generate_ele<i+1>(state);
+		if constexpr ((i+1) < sizeof...(M) ){
+			return generate_element<i+1>(buff, cfg, state);
 		}
 		return void_t{};
 	}
 
-	static error_or<void> generate(data<schema::CIface>& state){
-		try{
-			std::stringstream iss;
-			schema_stringify<Schema>::apply(iss);
-			state.template get<"schema">().set(iss.str());
-			state.template get<"crc32">().set(schema_hash<Schema>::apply());
-		}catch(const std::exception&){
-			return make_error<err::out_of_memory>();
+	static error_or<void> generate(buffer& buff, const language_binding_config& cfg){
+		if(cfg.prefix.size() == 0){
+			return make_error<err::invalid_state>("C interfaces need a prefix.");
 		}
-		
-		if constexpr (sizeof...(Funcs) > 0){
-			return generate_ele<0>(state);
+		language_binding_state state;
+
+		if constexpr (sizeof...(M) > 0){
+			return generate_element<0>(buff, cfg, state);
 		}
+
 		return void_t{};
 	}
 };
-
-template<typename Interface>
-error_or<void> generate_c_interface(data<schema::CIface>& state){
-	auto eov = c_data_translater<Interface>::generate(state);
-	return eov;
-}
-/*
-namespace lang {
-struct C {};
 }
 
-template<typename Iface, typename T>
-class binding;
+template<typename IfaceSchema, typename Binding>
+struct language_binding {
+	static_assert(always_false<IfaceSchema, Binding>, "Case not supported.");
+};
 
-template<typename Iface>
-class binding<Iface, lang::C> {
-public:
-	static constexpr string_literal header;
-	static constexpr string_literal source;
+template<typename IfaceSchema>
+struct language_binding<IfaceSchema, binding::C> {
+	static error_or<void> generate(buffer& buff, const language_binding_config& cfg){
+		return impl::lang_bind<IfaceSchema, binding::C>::generate(buff, cfg);
+	}
 };
-*/
 }
-- 
cgit v1.2.3