?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libanjuta, language-support-*: Introspection from bgo#680466
[anjuta.git] / plugins / parser-cxx / parser-cxx-assist.c
blob3ace1653a1b35dfeebbdf30c47913f4908c80b53
1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
2 /*
3 * parser-cxx-assist.c
4 * Copyright (C) 2007 Naba Kumar <naba@gnome.org>
5 * Johannes Schmid <jhs@gnome.org>
6 *
7 * anjuta is free software.
8 *
9 * You may redistribute it and/or modify it under the terms of the
10 * GNU General Public License, as published by the Free Software
11 * Foundation; either version 2 of the License, or (at your option)
12 * any later version.
13 *
14 * anjuta is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
17 * See the GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with anjuta. If not, write to:
21 * The Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor
23 * Boston, MA 02110-1301, USA.
24 */
25
26 #include <ctype.h>
27 #include <string.h>
28 #include <libanjuta/anjuta-debug.h>
29 #include <libanjuta/anjuta-language-provider.h>
30 #include <libanjuta/anjuta-utils.h>
31 #include <libanjuta/interfaces/ianjuta-file.h>
32 #include <libanjuta/interfaces/ianjuta-editor-cell.h>
33 #include <libanjuta/interfaces/ianjuta-editor-assist.h>
34 #include <libanjuta/interfaces/ianjuta-editor-tip.h>
35 #include <libanjuta/interfaces/ianjuta-language-provider.h>
36 #include <libanjuta/interfaces/ianjuta-symbol-manager.h>
37 #include "parser-cxx-assist.h"
38 #include "cxxparser/engine-parser.h"
39
40 #define BRACE_SEARCH_LIMIT 500
41 #define SCOPE_CONTEXT_CHARACTERS "_.:>-0"
42 #define WORD_CHARACTER "_0"
43
44 static void iprovider_iface_init(IAnjutaProviderIface* iface);
45 static void ilanguage_provider_iface_init(IAnjutaLanguageProviderIface* iface);
46
47 G_DEFINE_TYPE_WITH_CODE (ParserCxxAssist,
48 parser_cxx_assist,
49 G_TYPE_OBJECT,
50 G_IMPLEMENT_INTERFACE (IANJUTA_TYPE_PROVIDER,
51 iprovider_iface_init)
52 G_IMPLEMENT_INTERFACE (IANJUTA_TYPE_LANGUAGE_PROVIDER,
53 ilanguage_provider_iface_init))
54
55 struct _ParserCxxAssistPriv {
56 GSettings* settings;
57 IAnjutaEditorAssist* iassist;
58 IAnjutaEditorTip* itip;
59 AnjutaLanguageProvider* lang_prov;
60
61 const gchar* editor_filename;
62
63 /* Calltips */
64 gchar* calltip_context;
65 IAnjutaIterable* calltip_iter;
66 GList* tips;
67
68 gint async_calltip_file;
69 gint async_calltip_system;
70 gint async_calltip_project;
71
72 IAnjutaSymbolQuery *calltip_query_file;
73 IAnjutaSymbolQuery *calltip_query_system;
74 IAnjutaSymbolQuery *calltip_query_project;
75
76 /* Autocompletion */
77 GCompletion *completion_cache;
78 gchar* pre_word;
79 gboolean member_completion;
80 gboolean autocompletion;
81
82 gint async_file_id;
83 gint async_system_id;
84 gint async_project_id;
85
86 IAnjutaSymbolQuery *ac_query_file;
87 IAnjutaSymbolQuery *ac_query_system;
88 IAnjutaSymbolQuery *ac_query_project;
89
90 /* Member autocompletion */
91 IAnjutaSymbolQuery *query_members;
92
93 /* Sync query */
94 IAnjutaSymbolQuery *sync_query_file;
95 IAnjutaSymbolQuery *sync_query_system;
96 IAnjutaSymbolQuery *sync_query_project;
97 };
98
99 /**
100 * parser_cxx_assist_proposal_new:
101 * @symbol: IAnjutaSymbol to create the proposal for
102 *
103 * Creates a new IAnjutaEditorAssistProposal for symbol
104 *
105 * Returns: a newly allocated IAnjutaEditorAssistProposal
106 */
107 static IAnjutaEditorAssistProposal*
108 parser_cxx_assist_proposal_new (IAnjutaSymbol* symbol)
109 {
110 IAnjutaEditorAssistProposal* proposal = g_new0 (IAnjutaEditorAssistProposal, 1);
111 AnjutaLanguageProposalData* data =
112 anjuta_language_proposal_data_new (g_strdup (ianjuta_symbol_get_string (symbol, IANJUTA_SYMBOL_FIELD_NAME, NULL)));
113 data->type = ianjuta_symbol_get_sym_type (symbol, NULL);
114 switch (data->type)
115 {
116 case IANJUTA_SYMBOL_TYPE_PROTOTYPE:
117 case IANJUTA_SYMBOL_TYPE_FUNCTION:
118 case IANJUTA_SYMBOL_TYPE_METHOD:
119 case IANJUTA_SYMBOL_TYPE_MACRO_WITH_ARG:
120 proposal->label = g_strdup_printf ("%s()", data->name);
121 data->is_func = TRUE;
122 break;
123 default:
124 proposal->label = g_strdup (data->name);
125 data->is_func = FALSE;
126 }
127 data->has_para = FALSE;
128 if (data->is_func)
129 {
130 const gchar* signature = ianjuta_symbol_get_string (symbol,
131 IANJUTA_SYMBOL_FIELD_SIGNATURE,
132 NULL);
133 if (g_strcmp0 (signature, "(void)") || g_strcmp0 (signature, "()"))
134 data->has_para = TRUE;
135
136 }
137
138 proposal->data = data;
139 /* Icons are lifetime object of the symbol-db so we can cast here */
140 proposal->icon = (GdkPixbuf*) ianjuta_symbol_get_icon (symbol, NULL);
141 return proposal;
142 }
143
144 /**
145 * parser_cxx_assist_proposal_free:
146 * @proposal: the proposal to free
147 *
148 * Frees the proposal
149 */
150 static void
151 parser_cxx_assist_proposal_free (IAnjutaEditorAssistProposal* proposal)
152 {
153 AnjutaLanguageProposalData* data = proposal->data;
154 anjuta_language_proposal_data_free (data);
155 g_free (proposal->label);
156 g_free (proposal);
157 }
158
159 /**
160 * anjuta_propsal_completion_func:
161 * @data: an IAnjutaEditorAssistProposal
162 *
163 * Returns: the name of the completion func
164 */
165 static gchar*
166 anjuta_proposal_completion_func (gpointer data)
167 {
168 IAnjutaEditorAssistProposal* proposal = data;
169 AnjutaLanguageProposalData* prop_data = proposal->data;
170
171 return prop_data->name;
172 }
173
174 /**
175 * parser_cxx_assist_create_completion_from_symbols:
176 * @symbols: Symbol iteration
177 *
178 * Create a list of IAnjutaEditorAssistProposals from a list of symbols
179 *
180 * Returns: a newly allocated GList of newly allocated proposals. Free
181 * with cpp_java_assist_proposal_free()
182 */
183 static GList*
184 parser_cxx_assist_create_completion_from_symbols (IAnjutaIterable* symbols)
185 {
186 GList* list = NULL;
187
188 if (!symbols)
189 return NULL;
190 do
191 {
192 IAnjutaSymbol* symbol = IANJUTA_SYMBOL (symbols);
193 IAnjutaEditorAssistProposal* proposal = parser_cxx_assist_proposal_new (symbol);
194
195 list = g_list_append (list, proposal);
196 }
197 while (ianjuta_iterable_next (symbols, NULL));
198
199 return list;
200 }
201
202 /**
203 * parser_cxx_assist_update_pre_word:
204 * @assist: self
205 * @pre_word: new pre_word
206 *
207 * Updates the current pre_word
208 */
209 static void
210 parser_cxx_assist_update_pre_word (ParserCxxAssist* assist,
211 const gchar* pre_word)
212 {
213 g_free (assist->priv->pre_word);
214 if (pre_word == NULL)
215 pre_word = "";
216 assist->priv->pre_word = g_strdup (pre_word);
217 }
218
219 /**
220 * parser_cxx_assist_is_expression_separator:
221 * @c: character to check
222 * @skip_braces: whether to skip closing braces
223 * @iter: current cursor position
224 *
225 * Checks if a character seperates a C/C++ expression. It can skip brances
226 * because they might not really end the expression
227 *
228 * Returns: TRUE if the characters seperates an expression, FALSE otherwise
229 */
230 static gboolean
231 parser_cxx_assist_is_expression_separator (gchar c,
232 gboolean skip_braces,
233 IAnjutaIterable* iter)
234 {
235 IAnjutaEditorAttribute attrib = ianjuta_editor_cell_get_attribute (
236 IANJUTA_EDITOR_CELL(iter), NULL);
237 int i;
238 const gchar separators[] = {',', ';', '\n', '\r', '\t', '(',
239 '{', '}', '=', '<', '\v', '!',
240 '&', '%', '*', '[', ']', '?', '/',
241 '+', 0};
242
243 if (attrib == IANJUTA_EDITOR_STRING ||
244 attrib == IANJUTA_EDITOR_COMMENT)
245 {
246 return FALSE;
247 }
248
249 if (c == ')' && skip_braces)
250 {
251 anjuta_util_jump_to_matching_brace (iter, c, BRACE_SEARCH_LIMIT);
252 return TRUE;
253 }
254 else if (c == ')' && !skip_braces)
255 return FALSE;
256
257 for (i = 0; separators[i] != 0; i++)
258 {
259 if (separators[i] == c)
260 return TRUE;
261 }
262
263 return FALSE;
264 }
265
266 /**
267 * parser_cxx_assist_parse_expression:
268 * @assist: self,
269 * @iter: current cursor position
270 * @start_iter: return location for the start of the completion
271 *
272 * Returns: An iter of a list of IAnjutaSymbols or NULL
273 */
274 static IAnjutaIterable*
275 parser_cxx_assist_parse_expression (ParserCxxAssist* assist, IAnjutaIterable* iter, IAnjutaIterable** start_iter)
276 {
277 IAnjutaEditor* editor = IANJUTA_EDITOR (assist->priv->iassist);
278 IAnjutaIterable* res = NULL;
279 IAnjutaIterable* cur_pos = ianjuta_iterable_clone (iter, NULL);
280 gboolean op_start = FALSE;
281 gboolean ref_start = FALSE;
282 gchar* stmt = NULL;
283
284 /* Cursor points after the current characters, move back */
285 ianjuta_iterable_previous (cur_pos, NULL);
286
287 /* Search for a operator in the current line */
288 do
289 {
290 gchar ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL(cur_pos),
291 0, NULL);
292
293 if (parser_cxx_assist_is_expression_separator(ch, FALSE, iter)) {
294 break;
295 }
296
297 if (ch == '.' || (op_start && ch == '-') || (ref_start && ch == ':'))
298 {
299 /* Found an operator, get the statement and the pre_word */
300 IAnjutaIterable* pre_word_start = ianjuta_iterable_clone (cur_pos,
301 NULL);
302 IAnjutaIterable* pre_word_end = ianjuta_iterable_clone (iter, NULL);
303 IAnjutaIterable* stmt_end = ianjuta_iterable_clone (pre_word_start,
304 NULL);
305
306
307 /* we need to pass to the parser all the statement included the last
308 * operator, being it "." or "->" or "::"
309 * Increase the end bound of the statement.
310 */
311 ianjuta_iterable_next (stmt_end, NULL);
312 if (op_start == TRUE || ref_start == TRUE)
313 ianjuta_iterable_next (stmt_end, NULL);
314
315
316 /* Move one character forward so we have the start of the pre_word
317 * and not the last operator */
318 ianjuta_iterable_next (pre_word_start, NULL);
319 /* If this is a two character operator, skip the second character */
320 if (op_start)
321 {
322 ianjuta_iterable_next (pre_word_start, NULL);
323 }
324
325 parser_cxx_assist_update_pre_word (assist, ianjuta_editor_get_text (
326 editor,
327 pre_word_start,
328 pre_word_end,
329 NULL));
330
331 /* Try to get the name of the variable */
332 while (ianjuta_iterable_previous (cur_pos, NULL))
333 {
334 gchar word_ch = ianjuta_editor_cell_get_char (
335 IANJUTA_EDITOR_CELL(cur_pos), 0, NULL);
336
337 if (parser_cxx_assist_is_expression_separator(word_ch, FALSE,
338 cur_pos))
339 break;
340 }
341 ianjuta_iterable_next (cur_pos, NULL);
342 stmt = ianjuta_editor_get_text (editor,
343 cur_pos, stmt_end, NULL);
344 *start_iter = pre_word_start;
345 g_object_unref (stmt_end);
346 g_object_unref (pre_word_end);
347 break;
348 }
349 else if (ch == '>')
350 op_start = TRUE;
351 else if (ch == ':')
352 ref_start = TRUE;
353 else
354 {
355 op_start = FALSE;
356 ref_start = FALSE;
357 }
358 }
359 while (ianjuta_iterable_previous (cur_pos, NULL));
360
361 if (stmt)
362 {
363 gint lineno;
364 gchar *above_text;
365 IAnjutaIterable* start;
366
367 if (!assist->priv->editor_filename)
368 {
369 g_free (stmt);
370 return NULL;
371 }
372
373 start = ianjuta_editor_get_start_position (editor, NULL);
374 above_text = ianjuta_editor_get_text (editor, start, iter, NULL);
375 g_object_unref (start);
376
377 lineno = ianjuta_editor_get_lineno (editor, NULL);
378
379 /* the parser works even for the "Gtk::" like expressions, so it
380 * shouldn't be created a specific case to handle this.
381 */
382 res = engine_parser_process_expression (stmt,
383 above_text,
384 assist->priv->editor_filename,
385 lineno);
386 g_free (stmt);
387 }
388 g_object_unref (cur_pos);
389 return res;
390 }
391
392 /**
393 * parser_cxx_assist_create_completion_cache:
394 * @assist: self
395 *
396 * Create a new completion_cache object
397 */
398 static void
399 parser_cxx_assist_create_completion_cache (ParserCxxAssist* assist)
400 {
401 g_assert (assist->priv->completion_cache == NULL);
402 assist->priv->completion_cache =
403 g_completion_new (anjuta_proposal_completion_func);
404 }
405
406 /**
407 * parser_cxx_assist_cancel_queries:
408 * @assist: self
409 *
410 * Abort all async operations
411 */
412 static void
413 parser_cxx_assist_cancel_queries (ParserCxxAssist* assist)
414 {
415 ianjuta_symbol_query_cancel (assist->priv->ac_query_file, NULL);
416 ianjuta_symbol_query_cancel (assist->priv->ac_query_project, NULL);
417 ianjuta_symbol_query_cancel (assist->priv->ac_query_system, NULL);
418 assist->priv->async_file_id = 0;
419 assist->priv->async_project_id = 0;
420 assist->priv->async_system_id = 0;
421 }
422
423 /**
424 * parser_cxx_assist_clear_completion_cache:
425 * @assist: self
426 *
427 * Clear the completion cache, aborting all async operations
428 */
429 static void
430 parser_cxx_assist_clear_completion_cache (ParserCxxAssist* assist)
431 {
432 parser_cxx_assist_cancel_queries (assist);
433 if (assist->priv->completion_cache)
434 {
435 g_list_foreach (assist->priv->completion_cache->items,
436 (GFunc) parser_cxx_assist_proposal_free, NULL);
437 g_completion_free (assist->priv->completion_cache);
438 }
439 assist->priv->completion_cache = NULL;
440 assist->priv->member_completion = FALSE;
441 assist->priv->autocompletion = FALSE;
442 }
443
444 /**
445 * parser_cxx_assist_populate_real:
446 * @assist: self
447 * @finished: TRUE if no more proposals are expected, FALSE otherwise
448 *
449 * Really invokes the completion interfaces and adds completions.
450 * Might be called from an async context
451 */
452 static void
453 parser_cxx_assist_populate_real (ParserCxxAssist* assist, gboolean finished)
454 {
455 g_assert (assist->priv->pre_word != NULL);
456 GList* proposals = g_completion_complete (assist->priv->completion_cache,
457 assist->priv->pre_word,
458 NULL);
459 ianjuta_editor_assist_proposals (assist->priv->iassist,
460 IANJUTA_PROVIDER(assist), proposals,
461 assist->priv->pre_word, finished, NULL);
462 }
463
464 /**
465 * parser_cxx_assist_create_member_completion_cache
466 * @assist: self
467 * @cursor: Current cursor position
468 *
469 * Create the completion_cache for member completion if possible
470 *
471 * Returns: the iter where a completion cache was build, NULL otherwise
472 */
473 static IAnjutaIterable*
474 parser_cxx_assist_create_member_completion_cache (ParserCxxAssist* assist,
475 IAnjutaIterable* cursor)
476 {
477 IAnjutaIterable* symbol = NULL;
478 IAnjutaIterable* start_iter = NULL;
479 symbol = parser_cxx_assist_parse_expression (assist, cursor, &start_iter);
480
481 if (symbol)
482 {
483 /* Query symbol children */
484 IAnjutaIterable *children =
485 ianjuta_symbol_query_search_members (assist->priv->query_members,
486 IANJUTA_SYMBOL(symbol),
487 NULL);
488
489 g_object_unref (symbol);
490 if (children)
491 {
492 GList* proposals =
493 parser_cxx_assist_create_completion_from_symbols (children);
494 parser_cxx_assist_create_completion_cache (assist);
495 g_completion_add_items (assist->priv->completion_cache, proposals);
496
497 parser_cxx_assist_populate_real (assist, TRUE);
498 g_list_free (proposals);
499 g_object_unref (children);
500 return start_iter;
501 }
502 }
503 else if (start_iter)
504 g_object_unref (start_iter);
505 return NULL;
506 }
507
508 /**
509 * on_symbol_search_complete:
510 * @search_id: id of this search
511 * @symbols: the returned symbols
512 * @assist: self
513 *
514 * Called by the async search method when it found symbols
515 */
516 static void
517 on_symbol_search_complete (IAnjutaSymbolQuery *query, IAnjutaIterable* symbols,
518 ParserCxxAssist* assist)
519 {
520 GList* proposals;
521 proposals = parser_cxx_assist_create_completion_from_symbols (symbols);
522
523 if (query == assist->priv->ac_query_file)
524 assist->priv->async_file_id = 0;
525 else if (query == assist->priv->ac_query_project)
526 assist->priv->async_project_id = 0;
527 else if (query == assist->priv->ac_query_system)
528 assist->priv->async_system_id = 0;
529 else
530 g_assert_not_reached ();
531
532 g_completion_add_items (assist->priv->completion_cache, proposals);
533 gboolean running = assist->priv->async_system_id
534 || assist->priv->async_file_id
535 || assist->priv->async_project_id;
536 if (!running)
537 parser_cxx_assist_populate_real (assist, TRUE);
538 g_list_free (proposals);
539 }
540
541 /**
542 * parser_cxx_assist_create_autocompletion_cache:
543 * @assist: self
544 * @cursor: Current cursor position
545 *
546 * Create completion cache for autocompletion. This is done async.
547 *
548 * Returns: the iter where a preword was detected, NULL otherwise
549 */
550 static IAnjutaIterable*
551 parser_cxx_assist_create_autocompletion_cache (ParserCxxAssist* assist,
552 IAnjutaIterable* cursor)
553 {
554 IAnjutaIterable* start_iter;
555 gchar* pre_word = anjuta_language_provider_get_pre_word (
556 assist->priv->lang_prov,
557 IANJUTA_EDITOR (assist->priv->iassist),
558 cursor, &start_iter, WORD_CHARACTER);
559 if (!pre_word || strlen (pre_word) <= 3)
560 {
561 if (start_iter)
562 g_object_unref (start_iter);
563 return NULL;
564 }
565 else
566 {
567 gchar *pattern = g_strconcat (pre_word, "%", NULL);
568
569 parser_cxx_assist_create_completion_cache (assist);
570 parser_cxx_assist_update_pre_word (assist, pre_word);
571
572 if (IANJUTA_IS_FILE (assist->priv->iassist))
573 {
574 GFile *file = ianjuta_file_get_file (
575 IANJUTA_FILE (assist->priv->iassist), NULL);
576 if (file != NULL)
577 {
578 assist->priv->async_file_id = 1;
579 ianjuta_symbol_query_search_file (assist->priv->ac_query_file,
580 pattern, file, NULL);
581 g_object_unref (file);
582 }
583 }
584 /* This will avoid duplicates of FUNCTION and PROTOTYPE */
585 assist->priv->async_project_id = 1;
586 ianjuta_symbol_query_search (assist->priv->ac_query_project, pattern,
587 NULL);
588 assist->priv->async_system_id = 1;
589 ianjuta_symbol_query_search (assist->priv->ac_query_system, pattern,
590 NULL);
591 g_free (pre_word);
592 g_free (pattern);
593
594 return start_iter;
595 }
596 }
597
598 /**
599 * parser_cxx_assist_get_calltip_context:
600 * @self: Self
601 * @iter: current cursor position
602 * @e: Error propagation
603 *
604 * Searches for a calltip context
605 *
606 * Returns: name of the method to show a calltip for or NULL
607 */
608 static gchar*
609 parser_cxx_assist_get_calltip_context (IAnjutaLanguageProvider *self,
610 IAnjutaIterable *iter,
611 GError** e)
612 {
613 ParserCxxAssist* assist = PARSER_CXX_ASSIST (self);
614 gchar* calltip_context;
615 calltip_context = anjuta_language_provider_get_calltip_context (
616 assist->priv->lang_prov, assist->priv->itip, iter,
617 SCOPE_CONTEXT_CHARACTERS);
618 return calltip_context;
619 }
620
621 /**
622 * parser_cxx_assist_create_calltips:
623 * @iter: List of symbols
624 * @merge: list of calltips to merge or NULL
625 *
626 * Create a list of Calltips (string) from a list of symbols
627 *
628 * A newly allocated GList* with newly allocated strings
629 */
630 static GList*
631 parser_cxx_assist_create_calltips (IAnjutaIterable* iter, GList* merge)
632 {
633 GList* tips = merge;
634 if (iter)
635 {
636 do
637 {
638 IAnjutaSymbol* symbol = IANJUTA_SYMBOL (iter);
639 const gchar* name = ianjuta_symbol_get_string (
640 symbol,IANJUTA_SYMBOL_FIELD_NAME, NULL);
641 if (name != NULL)
642 {
643 const gchar* args = ianjuta_symbol_get_string (
644 symbol,
645 IANJUTA_SYMBOL_FIELD_SIGNATURE,
646 NULL);
647 const gchar* rettype = ianjuta_symbol_get_string (
648 symbol,
649 IANJUTA_SYMBOL_FIELD_RETURNTYPE,
650 NULL);
651 gchar* print_args;
652 gchar* separator;
653 gchar* white_name;
654 gint white_count = 0;
655
656 if (!rettype)
657 rettype = "";
658 else
659 white_count += strlen(rettype) + 1;
660
661 white_count += strlen(name) + 1;
662
663 white_name = g_strnfill (white_count, ' ');
664 separator = g_strjoin (NULL, ", \n", white_name, NULL);
665 gchar** argv;
666 if (!args)
667 args = "()";
668
669 argv = g_strsplit (args, ",", -1);
670 print_args = g_strjoinv (separator, argv);
671 gchar* tip = g_strdup_printf ("%s %s %s", rettype, name,
672 print_args);
673
674 if (!g_list_find_custom (tips, tip, (GCompareFunc) strcmp))
675 tips = g_list_append (tips, tip);
676
677 g_strfreev (argv);
678 g_free (print_args);
679 g_free (separator);
680 g_free (white_name);
681 }
682 else
683 break;
684 }
685 while (ianjuta_iterable_next (iter, NULL));
686 }
687 return tips;
688 }
689
690 /**
691 * on_calltip_search_complete:
692 * @search_id: id of this search
693 * @symbols: the returned symbols
694 * @assist: self
695 *
696 * Called by the async search method when it found calltips
697 */
698 static void
699 on_calltip_search_complete (IAnjutaSymbolQuery *query, IAnjutaIterable* symbols,
700 ParserCxxAssist* assist)
701 {
702 assist->priv->tips = parser_cxx_assist_create_calltips (symbols,
703 assist->priv->tips);
704 if (query == assist->priv->calltip_query_file)
705 assist->priv->async_calltip_file = 0;
706 else if (query == assist->priv->calltip_query_project)
707 assist->priv->async_calltip_project = 0;
708 else if (query == assist->priv->calltip_query_system)
709 assist->priv->async_calltip_system = 0;
710 else
711 g_assert_not_reached ();
712 gboolean running = assist->priv->async_calltip_system
713 || assist->priv->async_calltip_file
714 || assist->priv->async_calltip_project;
715
716 DEBUG_PRINT ("Calltip search finished with %d items",
717 g_list_length (assist->priv->tips));
718
719 if (!running && assist->priv->tips)
720 {
721 ianjuta_editor_tip_show (IANJUTA_EDITOR_TIP(assist->priv->itip),
722 assist->priv->tips, assist->priv->calltip_iter,
723 NULL);
724 }
725 }
726
727 /**
728 * parser_cxx_assist_query_calltip:
729 * @self: Self
730 * @call_context: name of method/function
731 * e: Error propagation
732 *
733 * Starts an async query for the calltip
734 */
735 static void
736 parser_cxx_assist_query_calltip (ParserCxxAssist* assist,
737 const gchar *call_context,
738 IAnjutaIterable* calltip_iter)
739 {
740 /* Search file */
741 if (IANJUTA_IS_FILE (assist->priv->itip))
742 {
743 GFile *file = ianjuta_file_get_file (IANJUTA_FILE (assist->priv->itip),
744 NULL);
745
746 if (file != NULL)
747 {
748 assist->priv->async_calltip_file = 1;
749 ianjuta_symbol_query_search_file (assist->priv->calltip_query_file,
750 call_context, file, NULL);
751 g_object_unref (file);
752 }
753 }
754
755 /* Search Project */
756 assist->priv->async_calltip_project = 1;
757 ianjuta_symbol_query_search (assist->priv->calltip_query_project,
758 call_context, NULL);
759
760 /* Search system */
761 assist->priv->async_calltip_system = 1;
762 ianjuta_symbol_query_search (assist->priv->calltip_query_system,
763 call_context, NULL);
764 }
765
766 /**
767 * parser_cxx_assist_create_calltip_context:
768 * @assist: self
769 * @call_context: The context (method/function name)
770 * @position: iter where to show calltips
771 *
772 * Create the calltip context
773 */
774 static void
775 parser_cxx_assist_create_calltip_context (ParserCxxAssist* assist,
776 const gchar* call_context,
777 IAnjutaIterable* position)
778 {
779 assist->priv->calltip_context = g_strdup (call_context);
780 assist->priv->calltip_iter = position;
781 }
782
783 /**
784 * parser_cxx_assist_clear_calltip_context:
785 * @self: Self
786 * @e: Error propagation
787 *
788 * Clears the calltip context and brings it back into a save state
789 */
790 static void
791 parser_cxx_assist_clear_calltip_context (ParserCxxAssist* assist)
792 {
793 ianjuta_symbol_query_cancel (assist->priv->calltip_query_file, NULL);
794 ianjuta_symbol_query_cancel (assist->priv->calltip_query_project, NULL);
795 ianjuta_symbol_query_cancel (assist->priv->calltip_query_system, NULL);
796
797 assist->priv->async_calltip_file = 0;
798 assist->priv->async_calltip_project = 0;
799 assist->priv->async_calltip_system = 0;
800
801 g_list_foreach (assist->priv->tips, (GFunc) g_free, NULL);
802 g_list_free (assist->priv->tips);
803 assist->priv->tips = NULL;
804
805 g_free (assist->priv->calltip_context);
806 assist->priv->calltip_context = NULL;
807
808 if (assist->priv->calltip_iter)
809 g_object_unref (assist->priv->calltip_iter);
810 assist->priv->calltip_iter = NULL;
811 }
812
813 /**
814 * parser_cxx_assist_cancelled:
815 * @iassist: IAnjutaEditorAssist that emitted the signal
816 * @assist: ParserCxxAssist object
817 *
818 * Stop any autocompletion queries when the cancelled signal was received
819 */
820 static void
821 parser_cxx_assist_cancelled (IAnjutaEditorAssist* iassist,
822 ParserCxxAssist* assist)
823 {
824 parser_cxx_assist_cancel_queries (assist);
825 }
826
827 static GList*
828 parser_cxx_assist_get_calltip_cache (IAnjutaLanguageProvider* self,
829 gchar* call_context,
830 GError** e)
831 {
832 ParserCxxAssist* assist = PARSER_CXX_ASSIST (self);
833 if (!g_strcmp0 (call_context, assist->priv->calltip_context))
834 {
835 DEBUG_PRINT ("Calltip was found in the cache.");
836 return assist->priv->tips;
837 }
838 else
839 {
840 DEBUG_PRINT ("Calltip is not available in the cache!");
841 return NULL;
842 }
843 }
844
845 static void
846 parser_cxx_assist_new_calltip (IAnjutaLanguageProvider* self,
847 gchar* call_context,
848 IAnjutaIterable* cursor,
849 GError** e)
850 {
851 ParserCxxAssist* assist = PARSER_CXX_ASSIST (self);
852 parser_cxx_assist_clear_calltip_context (assist);
853 parser_cxx_assist_create_calltip_context (assist, call_context, cursor);
854 parser_cxx_assist_query_calltip (assist, call_context, cursor);
855 }
856
857 static IAnjutaIterable*
858 parser_cxx_assist_populate_completions (IAnjutaLanguageProvider* self,
859 IAnjutaIterable* cursor,
860 GError** e)
861 {
862 ParserCxxAssist* assist = PARSER_CXX_ASSIST (self);
863 IAnjutaIterable* start_iter = NULL;
864
865 /* Check if completion was in progress */
866 if (assist->priv->member_completion || assist->priv->autocompletion)
867 {
868 g_assert (assist->priv->completion_cache != NULL);
869 gchar* pre_word = anjuta_language_provider_get_pre_word (
870 assist->priv->lang_prov,
871 IANJUTA_EDITOR (assist->priv->iassist),
872 cursor, &start_iter, WORD_CHARACTER);
873 DEBUG_PRINT ("Preword: %s", pre_word);
874 if (pre_word && g_str_has_prefix (pre_word, assist->priv->pre_word))
875 {
876 DEBUG_PRINT ("Continue autocomplete for %s", pre_word);
877
878 /* Great, we just continue the current completion */
879 parser_cxx_assist_update_pre_word (assist, pre_word);
880 parser_cxx_assist_populate_real (assist, TRUE);
881 g_free (pre_word);
882 return start_iter;
883 }
884 g_free (pre_word);
885 }
886
887 parser_cxx_assist_clear_completion_cache (assist);
888
889 /* Check for member completion */
890 start_iter = parser_cxx_assist_create_member_completion_cache (assist,
891 cursor);
892 if (start_iter)
893 assist->priv->member_completion = TRUE;
894 else
895 {
896 start_iter = parser_cxx_assist_create_autocompletion_cache (assist,
897 cursor);
898 if (start_iter)
899 assist->priv->autocompletion = TRUE;
900 }
901
902 return start_iter;
903 }
904
905 /**
906 * parser_cxx_assist_install:
907 * @assist: ParserCxxAssist object
908 * @ieditor: Editor to install support for
909 * @iparser: Parser to install support for
910 *
911 * Returns: Registers provider for editor
912 */
913 static void
914 parser_cxx_assist_install (ParserCxxAssist *assist,
915 IAnjutaEditor *ieditor)
916 {
917 g_return_if_fail (assist->priv->iassist == NULL);
918
919 if (IANJUTA_IS_EDITOR_ASSIST (ieditor))
920 {
921 assist->priv->iassist = IANJUTA_EDITOR_ASSIST (ieditor);
922 ianjuta_editor_assist_add (IANJUTA_EDITOR_ASSIST (ieditor),
923 IANJUTA_PROVIDER(assist), NULL);
924 g_signal_connect (ieditor, "cancelled",
925 G_CALLBACK (parser_cxx_assist_cancelled), assist);
926 }
927 else
928 assist->priv->iassist = NULL;
929
930 if (IANJUTA_IS_EDITOR_TIP (ieditor))
931 assist->priv->itip = IANJUTA_EDITOR_TIP (ieditor);
932 else
933 assist->priv->itip = NULL;
934
935 if (IANJUTA_IS_FILE (assist->priv->iassist))
936 {
937 GFile *file = ianjuta_file_get_file (
938 IANJUTA_FILE (assist->priv->iassist), NULL);
939 if (file != NULL)
940 {
941 assist->priv->editor_filename = g_file_get_path (file);
942 g_object_unref (file);
943 }
944 }
945 }
946
947 /**
948 * parser_cxx_assist_uninstall:
949 * @self: ParserCxxAssist object
950 *
951 * Returns: Unregisters provider
952 */
953 static void
954 parser_cxx_assist_uninstall (ParserCxxAssist *assist)
955 {
956 g_return_if_fail (assist->priv->iassist != NULL);
957
958 g_signal_handlers_disconnect_by_func (assist->priv->iassist,
959 parser_cxx_assist_cancelled, assist);
960 ianjuta_editor_assist_remove (assist->priv->iassist, IANJUTA_PROVIDER(assist), NULL);
961 assist->priv->iassist = NULL;
962 }
963
964 static void
965 parser_cxx_assist_init (ParserCxxAssist *assist)
966 {
967 assist->priv = g_new0 (ParserCxxAssistPriv, 1);
968 }
969
970 static void
971 parser_cxx_assist_finalize (GObject *object)
972 {
973 ParserCxxAssist *assist = PARSER_CXX_ASSIST (object);
974 ParserCxxAssistPriv* priv = assist->priv;
975
976 parser_cxx_assist_uninstall (assist);
977 parser_cxx_assist_clear_completion_cache (assist);
978 parser_cxx_assist_clear_calltip_context (assist);
979
980
981 if (priv->calltip_query_file)
982 g_object_unref (priv->calltip_query_file);
983 priv->calltip_query_file = NULL;
984
985 if (priv->calltip_query_system)
986 g_object_unref (priv->calltip_query_system);
987 priv->calltip_query_system = NULL;
988
989 if (priv->calltip_query_project)
990 g_object_unref (priv->calltip_query_project);
991 priv->calltip_query_project = NULL;
992
993 if (priv->ac_query_file)
994 g_object_unref (priv->ac_query_file);
995 priv->ac_query_file = NULL;
996
997 if (priv->ac_query_system)
998 g_object_unref (priv->ac_query_system);
999 priv->ac_query_system = NULL;
1000
1001 if (priv->ac_query_project)
1002 g_object_unref (priv->ac_query_project);
1003 priv->ac_query_project = NULL;
1004
1005 if (priv->query_members)
1006 g_object_unref (priv->query_members);
1007 priv->query_members = NULL;
1008
1009 if (priv->sync_query_file)
1010 g_object_unref (priv->sync_query_file);
1011 priv->sync_query_file = NULL;
1012
1013 if (priv->sync_query_system)
1014 g_object_unref (priv->sync_query_system);
1015 priv->sync_query_system = NULL;
1016
1017 if (priv->sync_query_project)
1018 g_object_unref (priv->sync_query_project);
1019 priv->sync_query_project = NULL;
1020
1021 engine_parser_deinit ();
1022
1023 g_free (assist->priv);
1024 G_OBJECT_CLASS (parser_cxx_assist_parent_class)->finalize (object);
1025 }
1026
1027 static void
1028 parser_cxx_assist_class_init (ParserCxxAssistClass *klass)
1029 {
1030 GObjectClass* object_class = G_OBJECT_CLASS (klass);
1031
1032 object_class->finalize = parser_cxx_assist_finalize;
1033 }
1034
1035 ParserCxxAssist *
1036 parser_cxx_assist_new (IAnjutaEditor *ieditor,
1037 IAnjutaSymbolManager *isymbol_manager,
1038 GSettings* settings)
1039 {
1040 ParserCxxAssist *assist;
1041 static IAnjutaSymbolField calltip_fields[] = {
1042 IANJUTA_SYMBOL_FIELD_ID,
1043 IANJUTA_SYMBOL_FIELD_NAME,
1044 IANJUTA_SYMBOL_FIELD_RETURNTYPE,
1045 IANJUTA_SYMBOL_FIELD_SIGNATURE
1046 };
1047 static IAnjutaSymbolField ac_fields[] = {
1048 IANJUTA_SYMBOL_FIELD_ID,
1049 IANJUTA_SYMBOL_FIELD_NAME,
1050 IANJUTA_SYMBOL_FIELD_KIND,
1051 IANJUTA_SYMBOL_FIELD_TYPE,
1052 IANJUTA_SYMBOL_FIELD_ACCESS,
1053 IANJUTA_SYMBOL_FIELD_SIGNATURE
1054 };
1055
1056 if (!IANJUTA_IS_EDITOR_ASSIST (ieditor) && !IANJUTA_IS_EDITOR_TIP (ieditor))
1057 {
1058 /* No assistance is available with the current editor */
1059 return NULL;
1060 }
1061 assist = g_object_new (TYPE_PARSER_CXX_ASSIST, NULL);
1062 assist->priv->settings = settings;
1063
1064 /* Create call tip queries */
1065 /* Calltip in file */
1066 assist->priv->calltip_query_file =
1067 ianjuta_symbol_manager_create_query (isymbol_manager,
1068 IANJUTA_SYMBOL_QUERY_SEARCH_FILE,
1069 IANJUTA_SYMBOL_QUERY_DB_PROJECT,
1070 NULL);
1071 ianjuta_symbol_query_set_fields (assist->priv->calltip_query_file,
1072 G_N_ELEMENTS (calltip_fields),
1073 calltip_fields, NULL);
1074 ianjuta_symbol_query_set_filters (assist->priv->calltip_query_file,
1075 IANJUTA_SYMBOL_TYPE_PROTOTYPE |
1076 IANJUTA_SYMBOL_TYPE_FUNCTION |
1077 IANJUTA_SYMBOL_TYPE_METHOD |
1078 IANJUTA_SYMBOL_TYPE_MACRO_WITH_ARG,
1079 TRUE, NULL);
1080 ianjuta_symbol_query_set_file_scope (assist->priv->calltip_query_file,
1081 IANJUTA_SYMBOL_QUERY_SEARCH_FS_PRIVATE,
1082 NULL);
1083 ianjuta_symbol_query_set_mode (assist->priv->calltip_query_file,
1084 IANJUTA_SYMBOL_QUERY_MODE_ASYNC, NULL);
1085 g_signal_connect (assist->priv->calltip_query_file, "async-result",
1086 G_CALLBACK (on_calltip_search_complete), assist);
1087 /* Calltip in project */
1088 assist->priv->calltip_query_project =
1089 ianjuta_symbol_manager_create_query (isymbol_manager,
1090 IANJUTA_SYMBOL_QUERY_SEARCH,
1091 IANJUTA_SYMBOL_QUERY_DB_PROJECT,
1092 NULL);
1093 ianjuta_symbol_query_set_fields (assist->priv->calltip_query_project,
1094 G_N_ELEMENTS (calltip_fields),
1095 calltip_fields, NULL);
1096 ianjuta_symbol_query_set_filters (assist->priv->calltip_query_project,
1097 IANJUTA_SYMBOL_TYPE_PROTOTYPE |
1098 IANJUTA_SYMBOL_TYPE_METHOD |
1099 IANJUTA_SYMBOL_TYPE_MACRO_WITH_ARG,
1100 TRUE, NULL);
1101 ianjuta_symbol_query_set_file_scope (assist->priv->calltip_query_project,
1102 IANJUTA_SYMBOL_QUERY_SEARCH_FS_PUBLIC,
1103 NULL);
1104 ianjuta_symbol_query_set_mode (assist->priv->calltip_query_project,
1105 IANJUTA_SYMBOL_QUERY_MODE_ASYNC, NULL);
1106 g_signal_connect (assist->priv->calltip_query_project, "async-result",
1107 G_CALLBACK (on_calltip_search_complete), assist);
1108 /* Calltip in system */
1109 assist->priv->calltip_query_system =
1110 ianjuta_symbol_manager_create_query (isymbol_manager,
1111 IANJUTA_SYMBOL_QUERY_SEARCH,
1112 IANJUTA_SYMBOL_QUERY_DB_SYSTEM,
1113 NULL);
1114 ianjuta_symbol_query_set_fields (assist->priv->calltip_query_system,
1115 G_N_ELEMENTS (calltip_fields),
1116 calltip_fields, NULL);
1117 ianjuta_symbol_query_set_filters (assist->priv->calltip_query_system,
1118 IANJUTA_SYMBOL_TYPE_PROTOTYPE |
1119 IANJUTA_SYMBOL_TYPE_METHOD |
1120 IANJUTA_SYMBOL_TYPE_MACRO_WITH_ARG,
1121 TRUE, NULL);
1122 ianjuta_symbol_query_set_file_scope (assist->priv->calltip_query_system,
1123 IANJUTA_SYMBOL_QUERY_SEARCH_FS_PUBLIC,
1124 NULL);
1125 ianjuta_symbol_query_set_mode (assist->priv->calltip_query_system,
1126 IANJUTA_SYMBOL_QUERY_MODE_ASYNC, NULL);
1127 g_signal_connect (assist->priv->calltip_query_system, "async-result",
1128 G_CALLBACK (on_calltip_search_complete), assist);
1129
1130 /* Create autocomplete queries */
1131 /* AC in file */
1132 assist->priv->ac_query_file =
1133 ianjuta_symbol_manager_create_query (isymbol_manager,
1134 IANJUTA_SYMBOL_QUERY_SEARCH_FILE,
1135 IANJUTA_SYMBOL_QUERY_DB_PROJECT,
1136 NULL);
1137 ianjuta_symbol_query_set_group_by (assist->priv->ac_query_file,
1138 IANJUTA_SYMBOL_FIELD_NAME, NULL);
1139 ianjuta_symbol_query_set_fields (assist->priv->ac_query_file,
1140 G_N_ELEMENTS (ac_fields),
1141 ac_fields, NULL);
1142 ianjuta_symbol_query_set_file_scope (assist->priv->ac_query_file,
1143 IANJUTA_SYMBOL_QUERY_SEARCH_FS_PRIVATE,
1144 NULL);
1145 ianjuta_symbol_query_set_mode (assist->priv->ac_query_file,
1146 IANJUTA_SYMBOL_QUERY_MODE_ASYNC, NULL);
1147 g_signal_connect (assist->priv->ac_query_file, "async-result",
1148 G_CALLBACK (on_symbol_search_complete), assist);
1149 /* AC in project */
1150 assist->priv->ac_query_project =
1151 ianjuta_symbol_manager_create_query (isymbol_manager,
1152 IANJUTA_SYMBOL_QUERY_SEARCH,
1153 IANJUTA_SYMBOL_QUERY_DB_PROJECT,
1154 NULL);
1155 ianjuta_symbol_query_set_group_by (assist->priv->ac_query_project,
1156 IANJUTA_SYMBOL_FIELD_NAME, NULL);
1157 ianjuta_symbol_query_set_fields (assist->priv->ac_query_project,
1158 G_N_ELEMENTS (ac_fields),
1159 ac_fields, NULL);
1160 ianjuta_symbol_query_set_file_scope (assist->priv->ac_query_project,
1161 IANJUTA_SYMBOL_QUERY_SEARCH_FS_PUBLIC,
1162 NULL);
1163 ianjuta_symbol_query_set_mode (assist->priv->ac_query_project,
1164 IANJUTA_SYMBOL_QUERY_MODE_ASYNC, NULL);
1165 g_signal_connect (assist->priv->ac_query_project, "async-result",
1166 G_CALLBACK (on_symbol_search_complete), assist);
1167 /* AC in system */
1168 assist->priv->ac_query_system =
1169 ianjuta_symbol_manager_create_query (isymbol_manager,
1170 IANJUTA_SYMBOL_QUERY_SEARCH,
1171 IANJUTA_SYMBOL_QUERY_DB_SYSTEM,
1172 NULL);
1173 ianjuta_symbol_query_set_group_by (assist->priv->ac_query_system,
1174 IANJUTA_SYMBOL_FIELD_NAME, NULL);
1175 ianjuta_symbol_query_set_fields (assist->priv->ac_query_system,
1176 G_N_ELEMENTS (ac_fields),
1177 ac_fields, NULL);
1178 ianjuta_symbol_query_set_file_scope (assist->priv->ac_query_system,
1179 IANJUTA_SYMBOL_QUERY_SEARCH_FS_PUBLIC,
1180 NULL);
1181 ianjuta_symbol_query_set_mode (assist->priv->ac_query_system,
1182 IANJUTA_SYMBOL_QUERY_MODE_ASYNC, NULL);
1183 g_signal_connect (assist->priv->ac_query_system, "async-result",
1184 G_CALLBACK (on_symbol_search_complete), assist);
1185
1186 /* Members autocompletion */
1187 assist->priv->query_members =
1188 ianjuta_symbol_manager_create_query (isymbol_manager,
1189 IANJUTA_SYMBOL_QUERY_SEARCH_MEMBERS,
1190 IANJUTA_SYMBOL_QUERY_DB_PROJECT,
1191 NULL);
1192 ianjuta_symbol_query_set_fields (assist->priv->query_members,
1193 G_N_ELEMENTS (ac_fields),
1194 ac_fields, NULL);
1195
1196 /* Create sync queries */
1197 /* Sync query in file */
1198 assist->priv->sync_query_file =
1199 ianjuta_symbol_manager_create_query (isymbol_manager,
1200 IANJUTA_SYMBOL_QUERY_SEARCH_FILE,
1201 IANJUTA_SYMBOL_QUERY_DB_PROJECT,
1202 NULL);
1203 ianjuta_symbol_query_set_fields (assist->priv->sync_query_file,
1204 G_N_ELEMENTS (calltip_fields),
1205 calltip_fields, NULL);
1206 ianjuta_symbol_query_set_filters (assist->priv->sync_query_file,
1207 IANJUTA_SYMBOL_TYPE_PROTOTYPE |
1208 IANJUTA_SYMBOL_TYPE_FUNCTION |
1209 IANJUTA_SYMBOL_TYPE_METHOD |
1210 IANJUTA_SYMBOL_TYPE_MACRO_WITH_ARG,
1211 TRUE, NULL);
1212 ianjuta_symbol_query_set_file_scope (assist->priv->sync_query_file,
1213 IANJUTA_SYMBOL_QUERY_SEARCH_FS_PRIVATE,
1214 NULL);
1215 /* Sync query in project */
1216 assist->priv->sync_query_project =
1217 ianjuta_symbol_manager_create_query (isymbol_manager,
1218 IANJUTA_SYMBOL_QUERY_SEARCH,
1219 IANJUTA_SYMBOL_QUERY_DB_PROJECT,
1220 NULL);
1221 ianjuta_symbol_query_set_fields (assist->priv->sync_query_project,
1222 G_N_ELEMENTS (calltip_fields),
1223 calltip_fields, NULL);
1224 ianjuta_symbol_query_set_filters (assist->priv->sync_query_project,
1225 IANJUTA_SYMBOL_TYPE_PROTOTYPE |
1226 IANJUTA_SYMBOL_TYPE_METHOD |
1227 IANJUTA_SYMBOL_TYPE_MACRO_WITH_ARG,
1228 TRUE, NULL);
1229 ianjuta_symbol_query_set_file_scope (assist->priv->sync_query_project,
1230 IANJUTA_SYMBOL_QUERY_SEARCH_FS_PUBLIC,
1231 NULL);
1232 /* Sync query in system */
1233 assist->priv->sync_query_system =
1234 ianjuta_symbol_manager_create_query (isymbol_manager,
1235 IANJUTA_SYMBOL_QUERY_SEARCH,
1236 IANJUTA_SYMBOL_QUERY_DB_SYSTEM,
1237 NULL);
1238 ianjuta_symbol_query_set_fields (assist->priv->sync_query_system,
1239 G_N_ELEMENTS (calltip_fields),
1240 calltip_fields, NULL);
1241 ianjuta_symbol_query_set_filters (assist->priv->sync_query_system,
1242 IANJUTA_SYMBOL_TYPE_PROTOTYPE |
1243 IANJUTA_SYMBOL_TYPE_METHOD |
1244 IANJUTA_SYMBOL_TYPE_MACRO_WITH_ARG,
1245 TRUE, NULL);
1246 ianjuta_symbol_query_set_file_scope (assist->priv->sync_query_system,
1247 IANJUTA_SYMBOL_QUERY_SEARCH_FS_PUBLIC,
1248 NULL);
1249
1250 /* Install support */
1251 parser_cxx_assist_install (assist, ieditor);
1252 assist->priv->lang_prov = g_object_new (ANJUTA_TYPE_LANGUAGE_PROVIDER, NULL);
1253 anjuta_language_provider_install (assist->priv->lang_prov, ieditor, settings);
1254 engine_parser_init (isymbol_manager);
1255
1256 return assist;
1257 }
1258
1259 static void
1260 parser_cxx_assist_activate (IAnjutaProvider* self,
1261 IAnjutaIterable* iter,
1262 gpointer data,
1263 GError** e)
1264 {
1265 ParserCxxAssist* assist = PARSER_CXX_ASSIST (self);
1266 anjuta_language_provider_activate (assist->priv->lang_prov, self, iter,
1267 data);
1268 }
1269
1270 static void
1271 parser_cxx_assist_populate (IAnjutaProvider* self,
1272 IAnjutaIterable* cursor,
1273 GError** e)
1274 {
1275 ParserCxxAssist* assist = PARSER_CXX_ASSIST (self);
1276 anjuta_language_provider_populate (assist->priv->lang_prov, self, cursor);
1277 }
1278
1279 static const gchar*
1280 parser_cxx_assist_get_name (IAnjutaProvider* self,
1281 GError** e)
1282 {
1283 return _("C/C++");
1284 }
1285
1286 static IAnjutaIterable*
1287 parser_cxx_assist_get_start_iter (IAnjutaProvider* self,
1288 GError** e)
1289 {
1290 ParserCxxAssist* assist = PARSER_CXX_ASSIST (self);
1291 return anjuta_language_provider_get_start_iter (assist->priv->lang_prov);
1292 }
1293
1294 static void
1295 iprovider_iface_init (IAnjutaProviderIface* iface)
1296 {
1297 iface->activate = parser_cxx_assist_activate;
1298 iface->populate = parser_cxx_assist_populate;
1299 iface->get_name = parser_cxx_assist_get_name;
1300 iface->get_start_iter = parser_cxx_assist_get_start_iter;
1301 }
1302
1303 static void
1304 ilanguage_provider_iface_init (IAnjutaLanguageProviderIface* iface)
1305 {
1306 iface->get_calltip_cache = parser_cxx_assist_get_calltip_cache;
1307 iface->get_calltip_context = parser_cxx_assist_get_calltip_context;
1308 iface->new_calltip = parser_cxx_assist_new_calltip;
1309 iface->populate_completions = parser_cxx_assist_populate_completions;
1310 }
anjuta mirror