From da93f0466cdeaf266debe5bacee6779354cf4a34 Mon Sep 17 00:00:00 2001
From: "Claudius \"keldu\" Holeksa" <mail@keldu.de>
Date: Wed, 14 Feb 2024 22:06:14 +0100
Subject: tools: Adding params and other dangling changes

---
 modules/tools/c++/c_gen_iface.hpp        | 94 +++++++++++++++++++++++++++++++-
 modules/tools/python/c_generate_iface.py |  1 +
 modules/tools/tests/c_iface.cpp          | 17 ++++++
 3 files changed, 109 insertions(+), 3 deletions(-)
 create mode 100755 modules/tools/python/c_generate_iface.py

(limited to 'modules')

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;
+			}
 		}
 
 		{
diff --git a/modules/tools/python/c_generate_iface.py b/modules/tools/python/c_generate_iface.py
new file mode 100755
index 0000000..e5a0d9b
--- /dev/null
+++ b/modules/tools/python/c_generate_iface.py
@@ -0,0 +1 @@
+#!/usr/bin/env python3
diff --git a/modules/tools/tests/c_iface.cpp b/modules/tools/tests/c_iface.cpp
index 88899f7..01f1106 100644
--- a/modules/tools/tests/c_iface.cpp
+++ b/modules/tools/tests/c_iface.cpp
@@ -9,11 +9,20 @@ namespace {
 namespace schema {
 using namespace saw::schema;
 
+using TestStruct = Struct<
+	Member<Int32, "a">,
+	Member<Float64, "b">
+>;
+
 using TestEmptyInterface = Interface<>;
 
 using TestOneFunctionInterface = Interface<
 	Member<Function<Int32, Int32>, "one">
 >;
+
+using TestStructFunctionInterface = Interface<
+	Member<Function<TestStruct, Int32>, "two">
+>;
 }
 
 template<typename Schema>
@@ -55,4 +64,12 @@ SAW_TEST("CIface One Function Interface"){
 	test_generate<schema::TestOneFunctionInterface>(res);
 	std::cout<<"\n"<<res<<"\n"<<std::endl;
 }
+
+SAW_TEST("CIface Struct Function Interface"){
+	using namespace saw;
+
+	std::string res;
+	test_generate<schema::TestStructFunctionInterface>(res);
+	std::cout<<"\n"<<res<<"\n"<<std::endl;
+}
 }
-- 
cgit v1.2.3