Add API completion signatures

1 files changed, 92 insertions, 5 deletions

diff --git a/src/ecex.c b/src/ecex.c
index 7206b96..a40a792 100644
--- a/src/ecex.c
+++ b/src/ecex.c
@@ -1521,8 +1521,10 @@ static void ecex_completion_provider_clear(ecex_completion_provider_t *provider)
     if (provider->free_fn && provider->userdata) provider->free_fn(provider->userdata);
     for (size_t i = 0; i < provider->word_count; i++) {
         free(provider->words[i]);
+        if (provider->word_details) free(provider->word_details[i]);
     }
     free(provider->words);
+    free(provider->word_details);
     free(provider->detail);
     free(provider->name);
     memset(provider, 0, sizeof(*provider));
@@ -2266,20 +2268,53 @@ int ecex_define_word_completion_provider(ecex_t *ed,
     return ECEX_OK;
 }
 
-int ecex_completion_provider_add_word(ecex_t *ed, const char *name, const char *word) {
+int ecex_completion_provider_add_word_detail(ecex_t *ed,
+                                             const char *name,
+                                             const char *word,
+                                             const char *detail) {
     if (!ed || !name || !word || !word[0]) return ECEX_ERR;
 
     for (size_t i = 0; i < ed->completion_provider_count; i++) {
         ecex_completion_provider_t *provider = &ed->completion_providers[i];
         if (strcmp(provider->name, name) != 0) continue;
 
+        char *word_copy = ecex_strdup(word);
+        if (!word_copy) return ECEX_ERR;
+
+        char *detail_copy = NULL;
+        if (detail && detail[0]) {
+            detail_copy = ecex_strdup(detail);
+            if (!detail_copy) {
+                free(word_copy);
+                return ECEX_ERR;
+            }
+        }
+
         char **grown = realloc(provider->words,
                                (provider->word_count + 1) * sizeof(*provider->words));
-        if (!grown) return ECEX_ERR;
+        if (!grown) {
+            free(word_copy);
+            free(detail_copy);
+            return ECEX_ERR;
+        }
         provider->words = grown;
 
-        provider->words[provider->word_count] = ecex_strdup(word);
-        if (!provider->words[provider->word_count]) return ECEX_ERR;
+        char **grown_details = NULL;
+        if (provider->word_details) {
+            grown_details = realloc(provider->word_details,
+                                    (provider->word_count + 1) * sizeof(*provider->word_details));
+        } else {
+            grown_details = calloc(provider->word_count + 1, sizeof(*provider->word_details));
+        }
+        if (!grown_details) {
+            free(word_copy);
+            free(detail_copy);
+            return ECEX_ERR;
+        }
+        provider->word_details = grown_details;
+
+        provider->words[provider->word_count] = word_copy;
+        provider->word_details[provider->word_count] = detail_copy;
         provider->word_count++;
         return ECEX_OK;
     }
@@ -2287,6 +2322,10 @@ int ecex_completion_provider_add_word(ecex_t *ed, const char *name, const char *
     return ECEX_ERR;
 }
 
+int ecex_completion_provider_add_word(ecex_t *ed, const char *name, const char *word) {
+    return ecex_completion_provider_add_word_detail(ed, name, word, NULL);
+}
+
 int ecex_completion_provider_add_words(ecex_t *ed, const char *name, const char *words) {
     if (!ed || !name || !words) return ECEX_ERR;
 
@@ -2311,6 +2350,48 @@ int ecex_completion_provider_add_words(ecex_t *ed, const char *name, const char
     return ECEX_OK;
 }
 
+int ecex_completion_provider_add_entries(ecex_t *ed, const char *name, const char *entries) {
+    if (!ed || !name || !entries) return ECEX_ERR;
+
+    const char *p = entries;
+    while (*p) {
+        while (*p == '\n' || *p == '\r') p++;
+        if (!*p) break;
+
+        char word[256];
+        char detail[512];
+        size_t word_len = 0;
+        size_t detail_len = 0;
+
+        while (*p && *p != '\t' && *p != '\n' && *p != '\r') {
+            if (word_len + 1 < sizeof(word)) word[word_len++] = *p;
+            p++;
+        }
+        word[word_len] = '\0';
+
+        if (*p == '\t') {
+            p++;
+            while (*p && *p != '\n' && *p != '\r') {
+                if (detail_len + 1 < sizeof(detail)) detail[detail_len++] = *p;
+                p++;
+            }
+        }
+        detail[detail_len] = '\0';
+
+        while (*p == '\n' || *p == '\r') p++;
+
+        if (word_len > 0 &&
+            ecex_completion_provider_add_word_detail(ed,
+                                                     name,
+                                                     word,
+                                                     detail_len > 0 ? detail : NULL) != ECEX_OK) {
+            return ECEX_ERR;
+        }
+    }
+
+    return ECEX_OK;
+}
+
 int ecex_completion_provider_set_detail(ecex_t *ed, const char *name, const char *detail) {
     if (!ed || !name || !name[0]) return ECEX_ERR;
 
@@ -4059,7 +4140,13 @@ static void ecex_completion_collect_from_provider(ecex_t *ed,
         for (size_t i = 0; i < provider->word_count; i++) {
             int score = ecex_fuzzy_score(provider->words[i], prefix);
             if (score < 0) continue;
-            ecex_completion_candidates_add(items, cap, count, provider->words[i], detail, score);
+            const char *word_detail = detail;
+            if (provider->word_details &&
+                provider->word_details[i] &&
+                provider->word_details[i][0]) {
+                word_detail = provider->word_details[i];
+            }
+            ecex_completion_candidates_add(items, cap, count, provider->words[i], word_detail, score);
         }
         return;
     }