mcabber: comparison mcabber/mcabber/compl.c

equal deleted inserted replaced

-:e8f2db654e67
+:0cb8ea02e472
 /*
 * compl.c      -- Completion system
 *
 * Copyright (C) 2005-2010 Mikael Berthe <mikael@lilotux.net>
-* Copyright (C) 2009,2010 Myhailo Danylenko <isbear@ukrpost.net>
+* Copyright (C) 2009-2012 Myhailo Danylenko <isbear@ukrpost.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 guint len_prefix;     // length of text already typed by the user
 guint len_compl;      // length of the last completion
 GSList *next;         // pointer to next completion to try
 } compl;
+typedef GSList *(*compl_handler_t) (void); // XXX userdata? *dynlist?
 // Category structure
 typedef struct {
-guint64 flag;
+guint flags;
 GSList *words;
+compl_handler_t dynamic;
 } category;
-static GSList *Categories;
+#define COMPL_CAT_BUILTIN   0x01
+#define COMPL_CAT_ACTIVE    0x02
+#define COMPL_CAT_DYNAMIC   0x04
+#define COMPL_CAT_REVERSE   0x10
+#define COMPL_CAT_NOSORT    0x20
+#define COMPL_CAT_USERFLAGS 0x30
 static compl *InputCompl;
+static category *Categories;
+static guint num_categories;
+// Dynamic completions callbacks
+static GSList *compl_dyn_group (void)
+{
+return compl_list(ROSTER_TYPE_GROUP);
+}
+static GSList *compl_dyn_user (void)
+{
+return compl_list(ROSTER_TYPE_USER);
+}
+static GSList *compl_dyn_resource (void)
+{
+return buddy_getresources_locale(NULL);
+}
+static GSList *compl_dyn_events (void)
+{
+GSList *compl = evs_geteventslist();
+GSList *cel;
+for (cel = compl; cel; cel = cel->next)
+cel->data = g_strdup(cel->data);
+compl = g_slist_append(compl, g_strdup("list"));
+return compl;
+}
+static inline void register_builtin_cat(guint c, compl_handler_t dynamic) {
+Categories[c-1].flags   = COMPL_CAT_BUILTIN | COMPL_CAT_ACTIVE;
+Categories[c-1].words   = NULL;
+Categories[c-1].dynamic = dynamic;
+if (dynamic != NULL) {
+Categories[c-1].flags |= COMPL_CAT_DYNAMIC;
+}
+}
+void compl_init_system(void)
+{
+num_categories = COMPL_MAX_ID;
 #ifdef MODULES_ENABLE
-static guint64 registered_cats;
+num_categories = ((num_categories / 16) + 1) * 16;
+#endif
-static inline void register_builtin_cat(guint c) {
+Categories = g_new0(category, num_categories);
-registered_cats |= 1UL << (c-1);
-}
-void compl_init_system(void)
-{
 // Builtin completion categories:
-register_builtin_cat(COMPL_CMD);
+register_builtin_cat(COMPL_CMD, NULL);
-register_builtin_cat(COMPL_JID);
+register_builtin_cat(COMPL_JID, compl_dyn_user);
-register_builtin_cat(COMPL_URLJID);
+register_builtin_cat(COMPL_URLJID, NULL);
-register_builtin_cat(COMPL_NAME);
+register_builtin_cat(COMPL_NAME, NULL);
-register_builtin_cat(COMPL_STATUS);
+register_builtin_cat(COMPL_STATUS, NULL);
-register_builtin_cat(COMPL_FILENAME);
+register_builtin_cat(COMPL_FILENAME, NULL);
-register_builtin_cat(COMPL_ROSTER);
+register_builtin_cat(COMPL_ROSTER, NULL);
-register_builtin_cat(COMPL_BUFFER);
+register_builtin_cat(COMPL_BUFFER, NULL);
-register_builtin_cat(COMPL_GROUP);
+register_builtin_cat(COMPL_GROUP, NULL);
-register_builtin_cat(COMPL_GROUPNAME);
+register_builtin_cat(COMPL_GROUPNAME, compl_dyn_group);
-register_builtin_cat(COMPL_MULTILINE);
+register_builtin_cat(COMPL_MULTILINE, NULL);
-register_builtin_cat(COMPL_ROOM);
+register_builtin_cat(COMPL_ROOM, NULL);
-register_builtin_cat(COMPL_RESOURCE);
+register_builtin_cat(COMPL_RESOURCE, compl_dyn_resource);
-register_builtin_cat(COMPL_AUTH);
+register_builtin_cat(COMPL_AUTH, NULL);
-register_builtin_cat(COMPL_REQUEST);
+register_builtin_cat(COMPL_REQUEST, NULL);
-register_builtin_cat(COMPL_EVENTS);
+register_builtin_cat(COMPL_EVENTS, NULL);
-register_builtin_cat(COMPL_EVENTSID);
+register_builtin_cat(COMPL_EVENTSID, compl_dyn_events);
-register_builtin_cat(COMPL_PGP);
+register_builtin_cat(COMPL_PGP, NULL);
-register_builtin_cat(COMPL_COLOR);
+register_builtin_cat(COMPL_COLOR, NULL);
-register_builtin_cat(COMPL_OTR);
+register_builtin_cat(COMPL_OTR, NULL);
-register_builtin_cat(COMPL_OTRPOLICY);
+register_builtin_cat(COMPL_OTRPOLICY, NULL);
-register_builtin_cat(COMPL_MODULE);
+register_builtin_cat(COMPL_MODULE, NULL);
 }
-//  compl_new_category()
+#ifdef MODULES_ENABLE
+//  compl_new_category(flags)
 // Reserves id for new completion category.
+// Flags determine word sorting order.
 // Returns 0, if no more categories can be allocated.
-// Note, that user should not make any assumptions about id nature,
+guint compl_new_category(guint flags)
-// as it is likely to change in future.
+{
-guint compl_new_category(void)
+guint i;
-{
+for (i = 0; i < num_categories; i++)
-const guint maxcat = 8 * sizeof (registered_cats);
+if (!(Categories[i].flags & COMPL_CAT_ACTIVE))
-guint i = 0;
+break;
-while ((registered_cats >> i) & 1 && i < maxcat)
+if (i >= num_categories ) {
-i++;
+guint j;
-if (i >= maxcat)
+if (num_categories > G_MAXUINT - 16) {
-return 0;
+scr_log_print(LPRINT_LOGNORM, "Warning: Too many "
-else {
+"completion categories!");
-guint64 id = 1 << i;
+return 0;
-registered_cats |= id;
+}
-return i+1;
+num_categories += 16;
-}
+Categories = g_renew(category, Categories, num_categories);
+for (j = i+1; j < num_categories; j++)
+Categories[j].flags = 0;
+}
+Categories[i].flags = COMPL_CAT_ACTIVE | (flags & COMPL_CAT_USERFLAGS);
+Categories[i].words = NULL;
+return i+1;
 }
 //  compl_del_category(id)
 // Frees reserved id for category.
 // Note, that for now it not validates its input, so, be careful
 // and specify exactly what you get from compl_new_category.
-void compl_del_category(guint id)
+void compl_del_category(guint compl)
 {
-if (!id) {
+GSList *wel;
-scr_log_print(LPRINT_LOGNORM, "Error: compl_del_category() - "
-"Invalid category.");
+if (!compl) {
-return;
+scr_log_print(LPRINT_DEBUG, "Error: compl_del_category() - "
-}
+"Invalid category (0).");
-id--;
+return;
-registered_cats &= ~(1<<id);
+}
+compl--;
+if ((compl >= num_categories) ||
+(Categories[compl].flags & COMPL_CAT_BUILTIN)) {
+scr_log_print(LPRINT_DEBUG, "Error: compl_del_category() "
+"Invalid category.");
+return;
+}
+Categories[compl].flags = 0;
+for (wel = Categories[compl].words; wel; wel = g_slist_next (wel))
+g_free (wel -> data);
+g_slist_free (Categories[compl].words);
 }
 #endif
 //  new_completion(prefix, compl_cat, suffix)
 // . prefix    = beginning of the word, typed by the user
 // done_completion() must be called when finished.
 // Returns the number of possible completions.
 guint new_completion(const char *prefix, GSList *compl_cat, const gchar *suffix)
 {
 compl *c;
+guint  ret_len = 0;
 GSList *sl_cat;
 gint (*cmp)(const char *s1, const char *s2, size_t n);
 size_t len = strlen(prefix);
 if (InputCompl) { // This should not happen, but hey...
-cancel_completion();
+scr_log_print(LPRINT_DEBUG, "Warning: new_completion() - "
+"Previous completion exists!");
+done_completion();
 }
 if (settings_opt_get_int("completion_ignore_case"))
 cmp = &strncasecmp;
 else
 gchar *compval;
 if (suffix)
 compval = g_strdup_printf("%s%s", word+len, suffix);
 else
 compval = g_strdup(word+len);
-c->list = g_slist_insert_sorted(c->list, compval,
+// for a bit of efficiency, will reverse order afterwards
-(GCompareFunc)g_ascii_strcasecmp);
+c->list = g_slist_prepend(c->list, compval);
+ret_len ++;
 }
 }
 }
-c->next = c->list;
+c->next = c->list = g_slist_reverse (c->list);
 InputCompl = c;
-return g_slist_length(c->list);
+return ret_len;
 }
 //  done_completion();
 void done_completion(void)
 {
 }
 /* Categories functions */
+static gint compl_sort_forward(gconstpointer a, gconstpointer b)
+{
+return g_ascii_strcasecmp((const gchar *)a, (const gchar *)b);
+}
+static gint compl_sort_reverse(gconstpointer a, gconstpointer b)
+{
+return -g_ascii_strcasecmp((const gchar *)a, (const gchar *)b);
+}
+static gint compl_sort_append(gconstpointer a, gconstpointer b)
+{
+return 1;
+}
+static gint compl_sort_prepend(gconstpointer a, gconstpointer b)
+{
+return -1;
+}
 //  compl_add_category_word(categ, command)
 // Adds a keyword as a possible completion in category categ.
 void compl_add_category_word(guint categ, const gchar *word)
 {
-guint64 catv;
-GSList *sl_cat;
-category *cat;
 char *nword;
 if (!categ) {
-scr_log_print(LPRINT_LOGNORM, "Error: compl_add_category_word() - "
+scr_log_print(LPRINT_DEBUG, "Error: compl_add_category_word() - "
-"Invalid category.");
+"Invalid category (0).");
 return;
 }
 categ--;
-catv = 1UL << categ;
+if ((categ >= num_categories) ||
-// Look for category
+!(Categories[categ].flags & COMPL_CAT_ACTIVE)) {
-for (sl_cat=Categories; sl_cat; sl_cat = g_slist_next(sl_cat)) {
+scr_log_print(LPRINT_DEBUG, "Error: compl_add_category_word() - "
-if (catv == ((category*)sl_cat->data)->flag)
+"Category does not exist.");
-break;
+return;
 }
-if (!sl_cat) {   // Category not found, let's create it
-cat = g_new0(category, 1);
-cat->flag = catv;
-Categories = g_slist_append(Categories, cat);
-} else
-cat = (category*)sl_cat->data;
 // If word is not space-terminated, we add one trailing space
 for (nword = (char*)word; *nword; nword++)
 ;
 if (nword > word) nword--;
 nword = g_strdup_printf("%s ", word);
 } else {              // word is fine
 nword = g_strdup(word);
 }
-if (g_slist_find_custom(cat->words, nword, (GCompareFunc)g_strcmp0) != NULL)
+if (g_slist_find_custom(Categories[categ].words, nword,
-return;
+(GCompareFunc)g_strcmp0) == NULL) {
+guint flags = Categories[categ].flags;
-cat->words = g_slist_insert_sorted(cat->words, nword,
+GCompareFunc comparator = compl_sort_forward;
-(GCompareFunc)g_ascii_strcasecmp);
+if (flags & COMPL_CAT_NOSORT) {
+if (flags & COMPL_CAT_REVERSE)
+comparator = compl_sort_prepend;
+else
+comparator = compl_sort_append;
+} else if (flags & COMPL_CAT_REVERSE)
+comparator = compl_sort_reverse;
+Categories[categ].words = g_slist_insert_sorted
+(Categories[categ].words, nword, comparator);
+}
 }
 //  compl_del_category_word(categ, command)
 // Removes a keyword from category categ in completion list.
 void compl_del_category_word(guint categ, const gchar *word)
 {
-guint64 catv;
+GSList *wel;
-GSList *sl_cat, *sl_elt;
-category *cat;
 char *nword;
 if (!categ) {
-scr_log_print(LPRINT_LOGNORM, "Error: compl_del_category_word() - "
+scr_log_print(LPRINT_DEBUG, "Error: compl_del_category_word() - "
-"Invalid category.");
+"Invalid category (0).");
 return;
 }
 categ--;
-catv = 1UL << categ;
+if ((categ >= num_categories) ||
-// Look for category
+!(Categories[categ].flags & COMPL_CAT_ACTIVE)) {
-for (sl_cat=Categories; sl_cat; sl_cat = g_slist_next(sl_cat)) {
+scr_log_print(LPRINT_DEBUG, "Error: compl_del_category_word() - "
-if (catv == ((category*)sl_cat->data)->flag)
+"Category does not exist.");
-break;
+return;
 }
-if (!sl_cat) return;   // Category not found, finished!
-cat = (category*)sl_cat->data;
 // If word is not space-terminated, we add one trailing space
 for (nword = (char*)word; *nword; nword++)
 ;
 if (nword > word) nword--;
-if (*nword != ' ') {  // Add a space
+if (*nword != ' ')  // Add a space
-nword = g_strdup_printf("%s ", word);
+word = nword = g_strdup_printf("%s ", word);
-} else {              // word is fine
+else
-nword = g_strdup(word);
+nword = NULL;
-}
+for (wel = Categories[categ].words; wel; wel = g_slist_next (wel)) {
-sl_elt = cat->words;
+if (!strcasecmp((char*)wel->data, word)) {
-while (sl_elt) {
+g_free(wel->data);
-if (!strcasecmp((char*)sl_elt->data, nword)) {
+Categories[categ].words = g_slist_delete_link
-g_free(sl_elt->data);
+(Categories[categ].words, wel);
-cat->words = g_slist_delete_link(cat->words, sl_elt);
 break; // Only remove first occurence
 }
-sl_elt = g_slist_next(sl_elt);
+}
-}
+g_free (nword);
 }
 //  compl_get_category_list()
 // Returns a slist of all words in the specified categorie.
 // Iff this function sets *dynlist to TRUE, then the caller must free the
 // whole list after use.
 GSList *compl_get_category_list(guint categ, guint *dynlist)
 {
-guint64 cat_flags;
-GSList *sl_cat;
 if (!categ) {
-scr_log_print(LPRINT_LOGNORM, "Error: compl_get_category_list() - "
+scr_log_print(LPRINT_DEBUG, "Error: compl_get_category_list() - "
-"Invalid category.");
+"Invalid category (0).");
 return NULL;
 }
-*dynlist = FALSE;
+categ --;
-cat_flags = 1UL << (categ - 1);
+if ((categ > num_categories) ||
-// Look for the category
+!(Categories[categ].flags & COMPL_CAT_ACTIVE)) {
-for (sl_cat=Categories; sl_cat; sl_cat = g_slist_next(sl_cat)) {
+scr_log_print(LPRINT_DEBUG, "Error: compl_get_category_list() - "
-if (cat_flags == ((category*)sl_cat->data)->flag)
+"Category does not exist.");
-break;
+return NULL;
 }
-if (sl_cat)       // Category was found, easy...
-return ((category*)sl_cat->data)->words;
+if (Categories[categ].flags & COMPL_CAT_DYNAMIC) {
+*dynlist = TRUE;
-// Handle dynamic SLists
+return (*Categories[categ].dynamic) ();
-*dynlist = TRUE;
+} else {
-if (categ == COMPL_GROUPNAME) {
+*dynlist = FALSE;
-return compl_list(ROSTER_TYPE_GROUP);
+return Categories[categ].words;
 }
-if (categ == COMPL_JID) {
-return compl_list(ROSTER_TYPE_USER);
-}
-if (categ == COMPL_RESOURCE) {
-return buddy_getresources_locale(NULL);
-}
-if (categ == COMPL_EVENTSID) {
-GSList *compl = evs_geteventslist();
-GSList *cel;
-for (cel = compl; cel; cel = cel->next)
-cel->data = g_strdup(cel->data);
-compl = g_slist_append(compl, g_strdup("list"));
-return compl;
-}
-*dynlist = FALSE;
-return NULL;
 }
 /* vim: set expandtab cindent cinoptions=>2\:2(0 sw=2 ts=2:  For Vim users... */

changeset 2042	0cb8ea02e472
parent 2035	dac609275117
child 2107	1bd9978ed5d0