tools: Adding params and other dangling changes

1 files changed, 91 insertions, 3 deletions

diff --git a/modules/tools/c++/c_gen_iface.hpp b/modules/tools/c++/c_gen_iface.hpp
index cdacc34..1b1e14d 100644
--- a/modules/tools/c++/c_gen_iface.hpp
+++ b/modules/tools/c++/c_gen_iface.hpp
@@ -17,7 +17,8 @@ namespace schema {
 using CVar = Struct<
 	Member<schema::String, "schema">,
 	Member<schema::String, "type">,
-	Member<schema::String, "name">
+	Member<schema::String, "name">,
+	Member<schema::Int8, "is_primitive">
 >;
 
 using CStruct = Struct<
@@ -168,11 +169,12 @@ struct c_data_translater<schema::Primitive<T,N>> {
 	using Schema = schema::Primitive<T,N>;
 
 	static error_or<void> generate(data<schema::CIface>& state, data<schema::CVar>& prim){
-		/// @TODO Check if exists in CVars already
 		try{
 			std::stringstream iss;
 			schema_stringify<Schema>::apply(iss);
 			prim.template get<"schema">().set(iss.str());
+			prim.template get<"is_primitive">().set(1);
+			prim.template get<"type">().set(std::string{c_primitive_string<Schema>::value});
 		}catch(const std::exception&){
 			return make_error<err::out_of_memory>();
 		}
@@ -181,10 +183,76 @@ struct c_data_translater<schema::Primitive<T,N>> {
 	}
 };
 
+template<typename T, uint64_t N>
+struct c_data_translater<schema::Array<T,N>> {
+	using Schema = schema::Array<T,N>;
+
+	static error_or<void> generate(data<schema::CIface>& state){
+
+		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;
+
+		{
+			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);
+				if(eov.is_error()){
+					return eov;
+				}
+			}
+			{
+				auto eov = params.add(std::move(c_var));
+				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);
+	}
+
 	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");
@@ -213,7 +281,27 @@ struct c_data_translater<schema::Function<Req,Ret>> {
 		}
 
 		// 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 = params.add(std::move(c_var));
+				if(eov.is_error()){
+					return eov;
+				}
+			}
+		} else {
+			auto eov = generate_struct_params(state, params);
+			if(eov.is_error()){
+				return eov;
+			}
 		}
 
 		{