scheme: Add kptype.h

klish/kcommand.h

@@ -6,6 +6,8 @@
 #ifndef _klish_kcommand_h
 #define _klish_kcommand_h
 
+#include <klish/kparam.h>
+
 typedef struct kcommand_s kcommand_t;
 
 typedef struct kcommand_info_s {
@@ -23,6 +25,8 @@ void kcommand_free(kcommand_t *command);
 const char *kcommand_name(const kcommand_t *command);
 const char *kcommand_help(const kcommand_t *command);
 
+bool_t kcommand_add_param(kcommand_t *command, kparam_t *param);
+
 C_DECL_END
 
 #endif // _klish_kcommand_h

klish/kptype.h

@@ -0,0 +1,28 @@
+/** @file kptype.h
+ *
+ * @brief Klish scheme's "ptype" entry
+ */
+
+#ifndef _klish_kptype_h
+#define _klish_kptype_h
+
+typedef struct kptype_s kptype_t;
+
+typedef struct kptype_info_s {
+	char *name;
+	char *help;
+} kptype_info_t;
+
+
+C_DECL_BEGIN
+
+kptype_t *kptype_new(kptype_info_t info);
+kptype_t *kptype_new_static(kptype_info_t info);
+void kptype_free(kptype_t *ptype);
+
+const char *kptype_name(const kptype_t *ptype);
+const char *kptype_help(const kptype_t *ptype);
+
+C_DECL_END
+
+#endif // _klish_kptype_h

klish/kscheme.h

@@ -7,9 +7,10 @@
 #define _klish_kscheme_h
 
 
-#include <klish/kview.h>
-#include <klish/kcommand.h>
+#include <klish/kptype.h>
 #include <klish/kparam.h>
+#include <klish/kcommand.h>
+#include <klish/kview.h>
 
 typedef struct kscheme_s kscheme_t;
 

klish/kscheme/kcommand.c

@@ -4,15 +4,36 @@
 #include <assert.h>
 
 #include <faux/str.h>
+#include <faux/list.h>
+#include <klish/kparam.h>
 #include <klish/kcommand.h>
 
 
 struct kcommand_s {
 	bool_t is_static;
 	kcommand_info_t info;
+	faux_list_t *params;
 };
 
 
+static int kcommand_param_compare(const void *first, const void *second)
+{
+	const kparam_t *f = (const kparam_t *)first;
+	const kparam_t *s = (const kparam_t *)second;
+
+	return strcmp(kparam_name(f), kparam_name(s));
+}
+
+
+static int kcommand_param_kcompare(const void *key, const void *list_item)
+{
+	const char *f = (const char *)key;
+	const kparam_t *s = (const kparam_t *)list_item;
+
+	return strcmp(f, kparam_name(s));
+}
+
+
 static kcommand_t *kcommand_new_internal(kcommand_info_t info, bool_t is_static)
 {
 	kcommand_t *command = NULL;
@@ -26,6 +47,11 @@ static kcommand_t *kcommand_new_internal(kcommand_info_t info, bool_t is_static)
 	command->is_static = is_static;
 	command->info = info;
 
+	command->params = faux_list_new(FAUX_LIST_UNSORTED, FAUX_LIST_UNIQUE,
+		kcommand_param_compare, kcommand_param_kcompare,
+		(void (*)(void *))kparam_free);
+	assert(command->params);
+
 	return command;
 }
 
@@ -51,6 +77,7 @@ void kcommand_free(kcommand_t *command)
 		faux_str_free(command->info.name);
 		faux_str_free(command->info.help);
 	}
+	faux_list_free(command->params);
 
 	faux_free(command);
 }
@@ -74,3 +101,19 @@ const char *kcommand_help(const kcommand_t *command)
 
 	return command->info.help;
 }
+
+
+bool_t kcommand_add_param(kcommand_t *command, kparam_t *param)
+{
+	assert(command);
+	if (!command)
+		return BOOL_FALSE;
+	assert(param);
+	if (!param)
+		return BOOL_FALSE;
+
+	if (!faux_list_add(command->params, param))
+		return BOOL_FALSE;
+
+	return BOOL_TRUE;
+}

klish/kscheme/kparam.c

@@ -4,14 +4,35 @@
 #include <assert.h>
 
 #include <faux/str.h>
+#include <faux/list.h>
 #include <klish/kparam.h>
 
+
 struct kparam_s {
 	bool_t is_static;
 	kparam_info_t info;
+	faux_list_t *params; // Nested parameters
 };
 
 
+static int kparam_param_compare(const void *first, const void *second)
+{
+	const kparam_t *f = (const kparam_t *)first;
+	const kparam_t *s = (const kparam_t *)second;
+
+	return strcmp(kparam_name(f), kparam_name(s));
+}
+
+
+static int kparam_param_kcompare(const void *key, const void *list_item)
+{
+	const char *f = (const char *)key;
+	const kparam_t *s = (const kparam_t *)list_item;
+
+	return strcmp(f, kparam_name(s));
+}
+
+
 static kparam_t *kparam_new_internal(kparam_info_t info, bool_t is_static)
 {
 	kparam_t *param = NULL;
@@ -25,6 +46,11 @@ static kparam_t *kparam_new_internal(kparam_info_t info, bool_t is_static)
 	param->is_static = is_static;
 	param->info = info;
 
+	param->params = faux_list_new(FAUX_LIST_UNSORTED, FAUX_LIST_UNIQUE,
+		kparam_param_compare, kparam_param_kcompare,
+		(void (*)(void *))kparam_free);
+	assert(param->params);
+
 	return param;
 }
 
@@ -51,6 +77,7 @@ void kparam_free(kparam_t *param)
 		faux_str_free(param->info.help);
 		faux_str_free(param->info.ptype);
 	}
+	faux_list_free(param->params);
 
 	faux_free(param);
 }
@@ -84,3 +111,19 @@ const char *kparam_ptype_str(const kparam_t *param)
 
 	return param->info.ptype;
 }
+
+
+bool_t kparam_add_param(kparam_t *param, kparam_t *nested_param)
+{
+	assert(param);
+	if (!param)
+		return BOOL_FALSE;
+	assert(nested_param);
+	if (!nested_param)
+		return BOOL_FALSE;
+
+	if (!faux_list_add(param->params, nested_param))
+		return BOOL_FALSE;
+
+	return BOOL_TRUE;
+}