static void ide_ctags_completion_provider_populate (GtkSourceCompletionProvider *provider, GtkSourceCompletionContext *context) { IdeCtagsCompletionProvider *self = (IdeCtagsCompletionProvider *)provider; const gchar * const *allowed; g_autofree gchar *casefold = NULL; gint word_len; guint i; guint j; IDE_ENTRY; g_assert (IDE_IS_CTAGS_COMPLETION_PROVIDER (self)); g_assert (GTK_SOURCE_IS_COMPLETION_CONTEXT (context)); g_clear_pointer (&self->current_word, g_free); self->current_word = ide_completion_provider_context_current_word (context); allowed = get_allowed_suffixes (context); if (self->results != NULL) { if (ide_completion_results_replay (self->results, self->current_word)) { ide_completion_results_present (self->results, provider, context); IDE_EXIT; } g_clear_pointer (&self->results, g_object_unref); } word_len = strlen (self->current_word); if (word_len < self->minimum_word_size) IDE_GOTO (word_too_small); casefold = g_utf8_casefold (self->current_word, -1); self->results = ide_completion_results_new (self->current_word); for (i = 0; i < self->indexes->len; i++) { g_autofree gchar *copy = g_strdup (self->current_word); IdeCtagsIndex *index = g_ptr_array_index (self->indexes, i); const IdeCtagsIndexEntry *entries = NULL; const gchar *last_name = NULL; guint tmp_len = word_len; gsize n_entries = 0; while (entries == NULL && *copy) { if (!(entries = ide_ctags_index_lookup_prefix (index, copy, &n_entries))) copy [--tmp_len] = '\0'; } if ((entries == NULL) || (n_entries == 0)) continue; for (j = 0; j < n_entries; j++) { const IdeCtagsIndexEntry *entry = &entries [j]; IdeCtagsCompletionItem *item; if (ide_str_equal0 (entry->name, last_name)) continue; last_name = entry->name; if (!ide_ctags_is_allowed (entry, allowed)) continue; item = ide_ctags_completion_item_new (self, entry); if (!ide_completion_item_match (IDE_COMPLETION_ITEM (item), self->current_word, casefold)) { g_object_unref (item); continue; } ide_completion_results_take_proposal (self->results, IDE_COMPLETION_ITEM (item)); } } ide_completion_results_present (self->results, provider, context); IDE_EXIT; word_too_small: gtk_source_completion_context_add_proposals (context, provider, NULL, TRUE); IDE_EXIT; }
static void ide_ctags_completion_provider_populate (GtkSourceCompletionProvider *provider, GtkSourceCompletionContext *context) { IdeCtagsCompletionProvider *self = (IdeCtagsCompletionProvider *)provider; g_autofree gchar *word = NULL; const IdeCtagsIndexEntry *entries; const gchar * const *allowed; g_autoptr(GPtrArray) ar = NULL; IdeCtagsIndexEntry *last = NULL; GtkSourceBuffer *buffer; gsize n_entries; GtkTextIter iter; GList *list = NULL; gsize i; gsize j; IDE_ENTRY; g_assert (IDE_IS_CTAGS_COMPLETION_PROVIDER (self)); g_assert (GTK_SOURCE_IS_COMPLETION_CONTEXT (context)); if (self->indexes->len == 0) IDE_GOTO (failure); if (!g_settings_get_boolean (self->settings, "ctags-autocompletion")) IDE_GOTO (failure); if (!gtk_source_completion_context_get_iter (context, &iter)) IDE_GOTO (failure); buffer = GTK_SOURCE_BUFFER (gtk_text_iter_get_buffer (&iter)); allowed = get_allowed_suffixes (buffer); word = get_word_to_cursor (&iter); if (ide_str_empty0 (word) || strlen (word) < self->minimum_word_size) IDE_GOTO (failure); if (strlen (word) < 3) IDE_GOTO (failure); ar = g_ptr_array_new (); IDE_TRACE_MSG ("Searching for %s", word); for (j = 0; j < self->indexes->len; j++) { IdeCtagsIndex *index = g_ptr_array_index (self->indexes, j); entries = ide_ctags_index_lookup_prefix (index, word, &n_entries); if ((entries == NULL) || (n_entries == 0)) continue; for (i = 0; i < n_entries; i++) { const IdeCtagsIndexEntry *entry = &entries [i]; if (is_allowed (entry, allowed)) g_ptr_array_add (ar, (gpointer)entry); } } g_ptr_array_sort (ar, sort_wrapper); for (i = ar->len; i > 0; i--) { GtkSourceCompletionProposal *item; IdeCtagsIndexEntry *entry = g_ptr_array_index (ar, i - 1); /* * NOTE: * * We walk backwards in this ptrarray so that we can use g_list_prepend() for O(1) access. * I think everyone agrees that using GList for passing completion data around was not * a great choice, but it is what we have to work with. */ /* * Ignore this item if the previous one looks really similar. * We take the first item instead of the last since the first item (when walking backwards) * tends to be more likely to be the one we care about (based on lexicographical * ordering. For example, something in "gtk-2.0" is less useful than "gtk-3.0". * * This is done here instead of during our initial object creation so that * we can merge items between different indexes. It often happens that the * same headers are included in multiple tags files. */ if ((last != NULL) && too_similar (entry, last)) continue; /* * NOTE: * * Autocompletion is very performance sensitive code. The smallest amount of * extra work has a very negative impact on interactivity. We are trying to * avoid a couple things here based on how completion works. * * 1) Avoiding referencing or copying things. * Since the provider will always outlive the completion item, we use * borrowed references for as much as we can. * 2) We delay the work of looking up icons until they are requested. * No sense in doing that work before hand. */ item = ide_ctags_completion_item_new (entry, self, context); list = g_list_prepend (list, item); last = entry; } failure: gtk_source_completion_context_add_proposals (context, provider, list, TRUE); g_list_free_full (list, g_object_unref); IDE_EXIT; }