Commit | Line | Data |
---|---|---|
c5f0f3d0 | 1 | /* Header for GDB line completion. |
b811d2c2 | 2 | Copyright (C) 2000-2020 Free Software Foundation, Inc. |
c5f0f3d0 FN |
3 | |
4 | This program is free software; you can redistribute it and/or modify | |
5 | it under the terms of the GNU General Public License as published by | |
a9762ec7 | 6 | the Free Software Foundation; either version 3 of the License, or |
c5f0f3d0 FN |
7 | (at your option) any later version. |
8 | ||
9 | This program is distributed in the hope that it will be useful, | |
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | GNU General Public License for more details. | |
13 | ||
14 | You should have received a copy of the GNU General Public License | |
a9762ec7 | 15 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
c5f0f3d0 FN |
16 | |
17 | #if !defined (COMPLETER_H) | |
18 | #define COMPLETER_H 1 | |
19 | ||
268a13a5 | 20 | #include "gdbsupport/gdb_vecs.h" |
4de283e4 | 21 | #include "command.h" |
49c4e619 | 22 | |
82083d6d DE |
23 | /* Types of functions in struct match_list_displayer. */ |
24 | ||
25 | struct match_list_displayer; | |
26 | ||
27 | typedef void mld_crlf_ftype (const struct match_list_displayer *); | |
28 | typedef void mld_putch_ftype (const struct match_list_displayer *, int); | |
29 | typedef void mld_puts_ftype (const struct match_list_displayer *, | |
30 | const char *); | |
31 | typedef void mld_flush_ftype (const struct match_list_displayer *); | |
32 | typedef void mld_erase_entire_line_ftype (const struct match_list_displayer *); | |
33 | typedef void mld_beep_ftype (const struct match_list_displayer *); | |
34 | typedef int mld_read_key_ftype (const struct match_list_displayer *); | |
35 | ||
36 | /* Interface between CLI/TUI and gdb_match_list_displayer. */ | |
37 | ||
38 | struct match_list_displayer | |
39 | { | |
40 | /* The screen dimensions to work with when displaying matches. */ | |
41 | int height, width; | |
42 | ||
43 | /* Print cr,lf. */ | |
44 | mld_crlf_ftype *crlf; | |
45 | ||
46 | /* Not "putc" to avoid issues where it is a stdio macro. Sigh. */ | |
47 | mld_putch_ftype *putch; | |
48 | ||
49 | /* Print a string. */ | |
50 | mld_puts_ftype *puts; | |
51 | ||
52 | /* Flush all accumulated output. */ | |
53 | mld_flush_ftype *flush; | |
54 | ||
55 | /* Erase the currently line on the terminal (but don't discard any text the | |
56 | user has entered, readline may shortly re-print it). */ | |
57 | mld_erase_entire_line_ftype *erase_entire_line; | |
58 | ||
59 | /* Ring the bell. */ | |
60 | mld_beep_ftype *beep; | |
61 | ||
62 | /* Read one key. */ | |
63 | mld_read_key_ftype *read_key; | |
64 | }; | |
65 | ||
eb3ff9a5 PA |
66 | /* A list of completion candidates. Each element is a malloc string, |
67 | because ownership of the strings is transferred to readline, which | |
68 | calls free on each element. */ | |
69 | typedef std::vector<gdb::unique_xmalloc_ptr<char>> completion_list; | |
70 | ||
b5ec771e PA |
71 | /* The result of a successful completion match. When doing symbol |
72 | comparison, we use the symbol search name for the symbol name match | |
73 | check, but the matched name that is shown to the user may be | |
74 | different. For example, Ada uses encoded names for lookup, but | |
75 | then wants to decode the symbol name to show to the user, and also | |
76 | in some cases wrap the matched name in "<sym>" (meaning we can't | |
77 | always use the symbol's print name). */ | |
78 | ||
79 | class completion_match | |
80 | { | |
81 | public: | |
82 | /* Get the completion match result. See m_match/m_storage's | |
83 | descriptions. */ | |
84 | const char *match () | |
85 | { return m_match; } | |
86 | ||
87 | /* Set the completion match result. See m_match/m_storage's | |
88 | descriptions. */ | |
89 | void set_match (const char *match) | |
90 | { m_match = match; } | |
91 | ||
92 | /* Get temporary storage for generating a match result, dynamically. | |
93 | The built string is only good until the next clear() call. I.e., | |
94 | good until the next symbol comparison. */ | |
95 | std::string &storage () | |
96 | { return m_storage; } | |
97 | ||
98 | /* Prepare for another completion matching sequence. */ | |
99 | void clear () | |
100 | { | |
101 | m_match = NULL; | |
102 | m_storage.clear (); | |
103 | } | |
104 | ||
105 | private: | |
106 | /* The completion match result. This can either be a pointer into | |
107 | M_STORAGE string, or it can be a pointer into the some other | |
108 | string that outlives the completion matching sequence (usually, a | |
109 | pointer to a symbol's name). */ | |
110 | const char *m_match; | |
111 | ||
112 | /* Storage a symbol comparison routine can use for generating a | |
113 | match result, dynamically. The built string is only good until | |
114 | the next clear() call. I.e., good until the next symbol | |
115 | comparison. */ | |
116 | std::string m_storage; | |
117 | }; | |
118 | ||
a207cff2 PA |
119 | /* The result of a successful completion match, but for least common |
120 | denominator (LCD) computation. Some completers provide matches | |
121 | that don't start with the completion "word". E.g., completing on | |
122 | "b push_ba" on a C++ program usually completes to | |
123 | std::vector<...>::push_back, std::string::push_back etc. In such | |
124 | case, the symbol comparison routine will set the LCD match to point | |
bd69330d PA |
125 | into the "push_back" substring within the symbol's name string. |
126 | Also, in some cases, the symbol comparison routine will want to | |
127 | ignore parts of the symbol name for LCD purposes, such as for | |
128 | example symbols with abi tags in C++. In such cases, the symbol | |
129 | comparison routine will set MARK_IGNORED_RANGE to mark the ignored | |
130 | substrings of the matched string. The resulting LCD string with | |
131 | the ignored parts stripped out is computed at the end of a | |
132 | completion match sequence iff we had a positive match. */ | |
a207cff2 PA |
133 | |
134 | class completion_match_for_lcd | |
135 | { | |
136 | public: | |
bd69330d PA |
137 | /* Get the resulting LCD, after a successful match. */ |
138 | const char *match () | |
139 | { return m_match; } | |
140 | ||
a207cff2 PA |
141 | /* Set the match for LCD. See m_match's description. */ |
142 | void set_match (const char *match) | |
143 | { m_match = match; } | |
144 | ||
bd69330d PA |
145 | /* Mark the range between [BEGIN, END) as ignored. */ |
146 | void mark_ignored_range (const char *begin, const char *end) | |
147 | { m_ignored_ranges.emplace_back (begin, end); } | |
148 | ||
149 | /* Get the resulting LCD, after a successful match. If there are | |
150 | ignored ranges, then this builds a new string with the ignored | |
151 | parts removed (and stores it internally). As such, the result of | |
152 | this call is only good for the current completion match | |
153 | sequence. */ | |
a207cff2 | 154 | const char *finish () |
bd69330d PA |
155 | { |
156 | if (m_ignored_ranges.empty ()) | |
157 | return m_match; | |
158 | else | |
159 | { | |
160 | m_finished_storage.clear (); | |
161 | ||
162 | const char *prev = m_match; | |
163 | for (const auto &range : m_ignored_ranges) | |
164 | { | |
165 | m_finished_storage.append (prev, range.first); | |
166 | prev = range.second; | |
167 | } | |
168 | m_finished_storage.append (prev); | |
169 | ||
170 | return m_finished_storage.c_str (); | |
171 | } | |
172 | } | |
a207cff2 PA |
173 | |
174 | /* Prepare for another completion matching sequence. */ | |
175 | void clear () | |
bd69330d PA |
176 | { |
177 | m_match = NULL; | |
178 | m_ignored_ranges.clear (); | |
179 | } | |
a207cff2 PA |
180 | |
181 | private: | |
182 | /* The completion match result for LCD. This is usually either a | |
183 | pointer into to a substring within a symbol's name, or to the | |
184 | storage of the pairing completion_match object. */ | |
185 | const char *m_match; | |
bd69330d PA |
186 | |
187 | /* The ignored substring ranges within M_MATCH. E.g., if we were | |
188 | looking for completion matches for C++ functions starting with | |
189 | "functio" | |
190 | and successfully match: | |
191 | "function[abi:cxx11](int)" | |
192 | the ignored ranges vector will contain an entry that delimits the | |
193 | "[abi:cxx11]" substring, such that calling finish() results in: | |
194 | "function(int)" | |
195 | */ | |
196 | std::vector<std::pair<const char *, const char *>> m_ignored_ranges; | |
197 | ||
198 | /* Storage used by the finish() method, if it has to compute a new | |
199 | string. */ | |
200 | std::string m_finished_storage; | |
a207cff2 PA |
201 | }; |
202 | ||
b5ec771e PA |
203 | /* Convenience aggregate holding info returned by the symbol name |
204 | matching routines (see symbol_name_matcher_ftype). */ | |
205 | struct completion_match_result | |
206 | { | |
207 | /* The completion match candidate. */ | |
208 | completion_match match; | |
a207cff2 PA |
209 | |
210 | /* The completion match, for LCD computation purposes. */ | |
211 | completion_match_for_lcd match_for_lcd; | |
212 | ||
213 | /* Convenience that sets both MATCH and MATCH_FOR_LCD. M_FOR_LCD is | |
214 | optional. If not specified, defaults to M. */ | |
215 | void set_match (const char *m, const char *m_for_lcd = NULL) | |
216 | { | |
217 | match.set_match (m); | |
218 | if (m_for_lcd == NULL) | |
219 | match_for_lcd.set_match (m); | |
220 | else | |
221 | match_for_lcd.set_match (m_for_lcd); | |
222 | } | |
b5ec771e PA |
223 | }; |
224 | ||
eb3ff9a5 PA |
225 | /* The final result of a completion that is handed over to either |
226 | readline or the "completion" command (which pretends to be | |
227 | readline). Mainly a wrapper for a readline-style match list array, | |
228 | though other bits of info are included too. */ | |
229 | ||
230 | struct completion_result | |
231 | { | |
232 | /* Create an empty result. */ | |
233 | completion_result (); | |
234 | ||
235 | /* Create a result. */ | |
236 | completion_result (char **match_list, size_t number_matches, | |
237 | bool completion_suppress_append); | |
238 | ||
239 | /* Destroy a result. */ | |
240 | ~completion_result (); | |
241 | ||
d6541620 | 242 | DISABLE_COPY_AND_ASSIGN (completion_result); |
eb3ff9a5 PA |
243 | |
244 | /* Move a result. */ | |
0fa7617d | 245 | completion_result (completion_result &&rhs) noexcept; |
eb3ff9a5 PA |
246 | |
247 | /* Release ownership of the match list array. */ | |
248 | char **release_match_list (); | |
249 | ||
250 | /* Sort the match list. */ | |
251 | void sort_match_list (); | |
252 | ||
253 | private: | |
254 | /* Destroy the match list array and its contents. */ | |
255 | void reset_match_list (); | |
256 | ||
257 | public: | |
258 | /* (There's no point in making these fields private, since the whole | |
259 | point of this wrapper is to build data in the layout expected by | |
260 | readline. Making them private would require adding getters for | |
261 | the "complete" command, which would expose the same | |
262 | implementation details anyway.) */ | |
263 | ||
264 | /* The match list array, in the format that readline expects. | |
265 | match_list[0] contains the common prefix. The real match list | |
266 | starts at index 1. The list is NULL terminated. If there's only | |
267 | one match, then match_list[1] is NULL. If there are no matches, | |
268 | then this is NULL. */ | |
269 | char **match_list; | |
270 | /* The number of matched completions in MATCH_LIST. Does not | |
271 | include the NULL terminator or the common prefix. */ | |
272 | size_t number_matches; | |
273 | ||
274 | /* Whether readline should suppress appending a whitespace, when | |
275 | there's only one possible completion. */ | |
276 | bool completion_suppress_append; | |
277 | }; | |
278 | ||
279 | /* Object used by completers to build a completion match list to hand | |
280 | over to readline. It tracks: | |
281 | ||
282 | - How many unique completions have been generated, to terminate | |
283 | completion list generation early if the list has grown to a size | |
284 | so large as to be useless. This helps avoid GDB seeming to lock | |
285 | up in the event the user requests to complete on something vague | |
286 | that necessitates the time consuming expansion of many symbol | |
287 | tables. | |
c6756f62 | 288 | |
a207cff2 PA |
289 | - The completer's idea of least common denominator (aka the common |
290 | prefix) between all completion matches to hand over to readline. | |
291 | Some completers provide matches that don't start with the | |
292 | completion "word". E.g., completing on "b push_ba" on a C++ | |
293 | program usually completes to std::vector<...>::push_back, | |
294 | std::string::push_back etc. If all matches happen to start with | |
295 | "std::", then readline would figure out that the lowest common | |
296 | denominator is "std::", and thus would do a partial completion | |
297 | with that. I.e., it would replace "push_ba" in the input buffer | |
298 | with "std::", losing the original "push_ba", which is obviously | |
299 | undesirable. To avoid that, such completers pass the substring | |
300 | of the match that matters for common denominator computation as | |
301 | MATCH_FOR_LCD argument to add_completion. The end result is | |
302 | passed to readline in gdb_rl_attempted_completion_function. | |
303 | ||
c6756f62 PA |
304 | - The custom word point to hand over to readline, for completers |
305 | that parse the input string in order to dynamically adjust | |
306 | themselves depending on exactly what they're completing. E.g., | |
307 | the linespec completer needs to bypass readline's too-simple word | |
308 | breaking algorithm. | |
eb3ff9a5 PA |
309 | */ |
310 | class completion_tracker | |
311 | { | |
312 | public: | |
313 | completion_tracker (); | |
314 | ~completion_tracker (); | |
315 | ||
d6541620 | 316 | DISABLE_COPY_AND_ASSIGN (completion_tracker); |
eb3ff9a5 PA |
317 | |
318 | /* Add the completion NAME to the list of generated completions if | |
319 | it is not there already. If too many completions were already | |
320 | found, this throws an error. */ | |
a207cff2 | 321 | void add_completion (gdb::unique_xmalloc_ptr<char> name, |
a22ecf70 PA |
322 | completion_match_for_lcd *match_for_lcd = NULL, |
323 | const char *text = NULL, const char *word = NULL); | |
eb3ff9a5 PA |
324 | |
325 | /* Add all completions matches in LIST. Elements are moved out of | |
326 | LIST. */ | |
327 | void add_completions (completion_list &&list); | |
328 | ||
19a2740f AB |
329 | /* Remove completion matching NAME from the completion list, does nothing |
330 | if NAME is not already in the completion list. */ | |
331 | void remove_completion (const char *name); | |
332 | ||
c6756f62 PA |
333 | /* Set the quote char to be appended after a unique completion is |
334 | added to the input line. Set to '\0' to clear. See | |
335 | m_quote_char's description. */ | |
336 | void set_quote_char (int quote_char) | |
337 | { m_quote_char = quote_char; } | |
338 | ||
339 | /* The quote char to be appended after a unique completion is added | |
340 | to the input line. Returns '\0' if no quote char has been set. | |
341 | See m_quote_char's description. */ | |
342 | int quote_char () { return m_quote_char; } | |
343 | ||
344 | /* Tell the tracker that the current completer wants to provide a | |
345 | custom word point instead of a list of a break chars, in the | |
346 | handle_brkchars phase. Such completers must also compute their | |
347 | completions then. */ | |
348 | void set_use_custom_word_point (bool enable) | |
349 | { m_use_custom_word_point = enable; } | |
350 | ||
351 | /* Whether the current completer computes a custom word point. */ | |
352 | bool use_custom_word_point () const | |
353 | { return m_use_custom_word_point; } | |
354 | ||
355 | /* The custom word point. */ | |
356 | int custom_word_point () const | |
357 | { return m_custom_word_point; } | |
358 | ||
359 | /* Set the custom word point to POINT. */ | |
360 | void set_custom_word_point (int point) | |
361 | { m_custom_word_point = point; } | |
362 | ||
363 | /* Advance the custom word point by LEN. */ | |
3844e605 | 364 | void advance_custom_word_point_by (int len); |
c6756f62 | 365 | |
c45ec17c PA |
366 | /* Whether to tell readline to skip appending a whitespace after the |
367 | completion. See m_suppress_append_ws. */ | |
368 | bool suppress_append_ws () const | |
369 | { return m_suppress_append_ws; } | |
370 | ||
371 | /* Set whether to tell readline to skip appending a whitespace after | |
372 | the completion. See m_suppress_append_ws. */ | |
373 | void set_suppress_append_ws (bool suppress) | |
374 | { m_suppress_append_ws = suppress; } | |
375 | ||
c6756f62 PA |
376 | /* Return true if we only have one completion, and it matches |
377 | exactly the completion word. I.e., completing results in what we | |
378 | already have. */ | |
379 | bool completes_to_completion_word (const char *word); | |
380 | ||
b5ec771e PA |
381 | /* Get a reference to the shared (between all the multiple symbol |
382 | name comparison calls) completion_match_result object, ready for | |
383 | another symbol name match sequence. */ | |
384 | completion_match_result &reset_completion_match_result () | |
385 | { | |
386 | completion_match_result &res = m_completion_match_result; | |
387 | ||
388 | /* Clear any previous match. */ | |
389 | res.match.clear (); | |
a207cff2 | 390 | res.match_for_lcd.clear (); |
b5ec771e PA |
391 | return m_completion_match_result; |
392 | } | |
393 | ||
eb3ff9a5 PA |
394 | /* True if we have any completion match recorded. */ |
395 | bool have_completions () const | |
724fd9ba | 396 | { return htab_elements (m_entries_hash) > 0; } |
eb3ff9a5 | 397 | |
c6756f62 PA |
398 | /* Discard the current completion match list and the current |
399 | LCD. */ | |
400 | void discard_completions (); | |
401 | ||
eb3ff9a5 PA |
402 | /* Build a completion_result containing the list of completion |
403 | matches to hand over to readline. The parameters are as in | |
404 | rl_attempted_completion_function. */ | |
405 | completion_result build_completion_result (const char *text, | |
406 | int start, int end); | |
407 | ||
408 | private: | |
409 | ||
724fd9ba AB |
410 | /* The type that we place into the m_entries_hash hash table. */ |
411 | class completion_hash_entry; | |
412 | ||
eb3ff9a5 PA |
413 | /* Add the completion NAME to the list of generated completions if |
414 | it is not there already. If false is returned, too many | |
415 | completions were found. */ | |
a207cff2 | 416 | bool maybe_add_completion (gdb::unique_xmalloc_ptr<char> name, |
a22ecf70 PA |
417 | completion_match_for_lcd *match_for_lcd, |
418 | const char *text, const char *word); | |
eb3ff9a5 | 419 | |
724fd9ba AB |
420 | /* Ensure that the lowest common denominator held in the member variable |
421 | M_LOWEST_COMMON_DENOMINATOR is valid. This method must be called if | |
422 | there is any chance that new completions have been added to the | |
423 | tracker before the lowest common denominator is read. */ | |
424 | void recompute_lowest_common_denominator (); | |
425 | ||
426 | /* Callback used from recompute_lowest_common_denominator, called for | |
427 | every entry in m_entries_hash. */ | |
428 | void recompute_lcd_visitor (completion_hash_entry *entry); | |
eb3ff9a5 | 429 | |
b5ec771e PA |
430 | /* Completion match outputs returned by the symbol name matching |
431 | routines (see symbol_name_matcher_ftype). These results are only | |
432 | valid for a single match call. This is here in order to be able | |
433 | to conveniently share the same storage among all the calls to the | |
434 | symbol name matching routines. */ | |
435 | completion_match_result m_completion_match_result; | |
436 | ||
eb3ff9a5 PA |
437 | /* The completion matches found so far, in a hash table, for |
438 | duplicate elimination as entries are added. Otherwise the user | |
439 | is left scratching his/her head: readline and complete_command | |
440 | will remove duplicates, and if removal of duplicates there brings | |
441 | the total under max_completions the user may think gdb quit | |
442 | searching too early. */ | |
724fd9ba | 443 | htab_t m_entries_hash = NULL; |
eb3ff9a5 | 444 | |
c6756f62 PA |
445 | /* If non-zero, then this is the quote char that needs to be |
446 | appended after completion (iff we have a unique completion). We | |
447 | don't rely on readline appending the quote char as delimiter as | |
448 | then readline wouldn't append the ' ' after the completion. | |
449 | I.e., we want this: | |
450 | ||
451 | before tab: "b 'function(" | |
452 | after tab: "b 'function()' " | |
453 | */ | |
454 | int m_quote_char = '\0'; | |
455 | ||
456 | /* If true, the completer has its own idea of "word" point, and | |
457 | doesn't want to rely on readline computing it based on brkchars. | |
458 | Set in the handle_brkchars phase. */ | |
459 | bool m_use_custom_word_point = false; | |
460 | ||
461 | /* The completer's idea of where the "word" we were looking at is | |
462 | relative to RL_LINE_BUFFER. This is advanced in the | |
463 | handle_brkchars phase as the completer discovers potential | |
464 | completable words. */ | |
465 | int m_custom_word_point = 0; | |
466 | ||
c45ec17c PA |
467 | /* If true, tell readline to skip appending a whitespace after the |
468 | completion. Automatically set if we have a unique completion | |
469 | that already has a space at the end. A completer may also | |
470 | explicitly set this. E.g., the linespec completer sets this when | |
471 | the completion ends with the ":" separator between filename and | |
472 | function name. */ | |
473 | bool m_suppress_append_ws = false; | |
474 | ||
c6756f62 PA |
475 | /* Our idea of lowest common denominator to hand over to readline. |
476 | See intro. */ | |
eb3ff9a5 PA |
477 | char *m_lowest_common_denominator = NULL; |
478 | ||
a207cff2 PA |
479 | /* If true, the LCD is unique. I.e., all completions had the same |
480 | MATCH_FOR_LCD substring, even if the completions were different. | |
481 | For example, if "break function<tab>" found "a::function()" and | |
482 | "b::function()", the LCD will be "function()" in both cases and | |
483 | so we want to tell readline to complete the line with | |
484 | "function()", instead of showing all the possible | |
485 | completions. */ | |
eb3ff9a5 | 486 | bool m_lowest_common_denominator_unique = false; |
724fd9ba AB |
487 | |
488 | /* True if the value in M_LOWEST_COMMON_DENOMINATOR is correct. This is | |
489 | set to true each time RECOMPUTE_LOWEST_COMMON_DENOMINATOR is called, | |
490 | and reset to false whenever a new completion is added. */ | |
491 | bool m_lowest_common_denominator_valid = false; | |
492 | ||
493 | /* To avoid calls to xrealloc in RECOMPUTE_LOWEST_COMMON_DENOMINATOR, we | |
494 | track the maximum possible size of the lowest common denominator, | |
495 | which we know as each completion is added. */ | |
496 | size_t m_lowest_common_denominator_max_length = 0; | |
eb3ff9a5 PA |
497 | }; |
498 | ||
60a20c19 PA |
499 | /* Return a string to hand off to readline as a completion match |
500 | candidate, potentially composed of parts of MATCH_NAME and of | |
501 | TEXT/WORD. For a description of TEXT/WORD see completer_ftype. */ | |
502 | ||
503 | extern gdb::unique_xmalloc_ptr<char> | |
504 | make_completion_match_str (const char *match_name, | |
505 | const char *text, const char *word); | |
506 | ||
507 | /* Like above, but takes ownership of MATCH_NAME (i.e., can | |
508 | reuse/return it). */ | |
509 | ||
510 | extern gdb::unique_xmalloc_ptr<char> | |
511 | make_completion_match_str (gdb::unique_xmalloc_ptr<char> &&match_name, | |
512 | const char *text, const char *word); | |
513 | ||
82083d6d DE |
514 | extern void gdb_display_match_list (char **matches, int len, int max, |
515 | const struct match_list_displayer *); | |
516 | ||
ef0b411a GB |
517 | extern const char *get_max_completions_reached_message (void); |
518 | ||
eb3ff9a5 PA |
519 | extern void complete_line (completion_tracker &tracker, |
520 | const char *text, | |
521 | const char *line_buffer, | |
522 | int point); | |
83d31a92 | 523 | |
6e035501 JV |
524 | /* Complete LINE and return completion results. For completion purposes, |
525 | cursor position is assumed to be at the end of LINE. WORD is set to | |
526 | the end of word to complete. QUOTE_CHAR is set to the opening quote | |
527 | character if we found an unclosed quoted substring, '\0' otherwise. */ | |
528 | extern completion_result | |
529 | complete (const char *line, char const **word, int *quote_char); | |
530 | ||
6a2c1b87 PA |
531 | /* Find the bounds of the word in TEXT for completion purposes, and |
532 | return a pointer to the end of the word. Calls the completion | |
533 | machinery for a handle_brkchars phase (using TRACKER) to figure out | |
534 | the right work break characters for the command in TEXT. | |
535 | QUOTE_CHAR, if non-null, is set to the opening quote character if | |
536 | we found an unclosed quoted substring, '\0' otherwise. */ | |
537 | extern const char *completion_find_completion_word (completion_tracker &tracker, | |
538 | const char *text, | |
539 | int *quote_char); | |
540 | ||
c6756f62 PA |
541 | |
542 | /* Assuming TEXT is an expression in the current language, find the | |
543 | completion word point for TEXT, emulating the algorithm readline | |
544 | uses to find the word point, using the current language's word | |
545 | break characters. */ | |
c6756f62 PA |
546 | const char *advance_to_expression_complete_word_point |
547 | (completion_tracker &tracker, const char *text); | |
548 | ||
e6ed716c PA |
549 | /* Assuming TEXT is an filename, find the completion word point for |
550 | TEXT, emulating the algorithm readline uses to find the word | |
551 | point. */ | |
552 | extern const char *advance_to_filename_complete_word_point | |
553 | (completion_tracker &tracker, const char *text); | |
554 | ||
eb3ff9a5 PA |
555 | extern char **gdb_rl_attempted_completion_function (const char *text, |
556 | int start, int end); | |
d75b5104 | 557 | |
eb3ff9a5 PA |
558 | extern void noop_completer (struct cmd_list_element *, |
559 | completion_tracker &tracker, | |
560 | const char *, const char *); | |
d75b5104 | 561 | |
eb3ff9a5 PA |
562 | extern void filename_completer (struct cmd_list_element *, |
563 | completion_tracker &tracker, | |
564 | const char *, const char *); | |
c5f0f3d0 | 565 | |
eb3ff9a5 PA |
566 | extern void expression_completer (struct cmd_list_element *, |
567 | completion_tracker &tracker, | |
568 | const char *, const char *); | |
65d12d83 | 569 | |
eb3ff9a5 PA |
570 | extern void location_completer (struct cmd_list_element *, |
571 | completion_tracker &tracker, | |
572 | const char *, const char *); | |
c94fdfd0 | 573 | |
eb3ff9a5 PA |
574 | extern void symbol_completer (struct cmd_list_element *, |
575 | completion_tracker &tracker, | |
576 | const char *, const char *); | |
78b13106 | 577 | |
eb3ff9a5 PA |
578 | extern void command_completer (struct cmd_list_element *, |
579 | completion_tracker &tracker, | |
580 | const char *, const char *); | |
db60ec62 | 581 | |
eb3ff9a5 PA |
582 | extern void signal_completer (struct cmd_list_element *, |
583 | completion_tracker &tracker, | |
584 | const char *, const char *); | |
de0bea00 | 585 | |
eb3ff9a5 PA |
586 | extern void reg_or_group_completer (struct cmd_list_element *, |
587 | completion_tracker &tracker, | |
588 | const char *, const char *); | |
71c24708 | 589 | |
eb3ff9a5 PA |
590 | extern void reggroup_completer (struct cmd_list_element *, |
591 | completion_tracker &tracker, | |
592 | const char *, const char *); | |
51f0e40d | 593 | |
67cb5b2d | 594 | extern const char *get_gdb_completer_quote_characters (void); |
c5f0f3d0 | 595 | |
67c296a2 PM |
596 | extern char *gdb_completion_word_break_characters (void); |
597 | ||
67cb5b2d PA |
598 | /* Set the word break characters array to BREAK_CHARS. This function |
599 | is useful as const-correct alternative to direct assignment to | |
600 | rl_completer_word_break_characters, which is "char *", | |
601 | not "const char *". */ | |
602 | extern void set_rl_completer_word_break_characters (const char *break_chars); | |
603 | ||
6e1dbf8c PA |
604 | /* Get the matching completer_handle_brkchars_ftype function for FN. |
605 | FN is one of the core completer functions above (filename, | |
606 | location, symbol, etc.). This function is useful for cases when | |
607 | the completer doesn't know the type of the completion until some | |
7d793aa9 SDJ |
608 | calculation is done (e.g., for Python functions). */ |
609 | ||
6e1dbf8c PA |
610 | extern completer_handle_brkchars_ftype * |
611 | completer_handle_brkchars_func_for_completer (completer_ftype *fn); | |
7d793aa9 | 612 | |
c5f0f3d0 FN |
613 | /* Exported to linespec.c */ |
614 | ||
c45ec17c PA |
615 | /* Return a list of all source files whose names begin with matching |
616 | TEXT. */ | |
617 | extern completion_list complete_source_filenames (const char *text); | |
618 | ||
619 | /* Complete on expressions. Often this means completing on symbol | |
620 | names, but some language parsers also have support for completing | |
621 | field names. */ | |
622 | extern void complete_expression (completion_tracker &tracker, | |
623 | const char *text, const char *word); | |
624 | ||
272d4594 PA |
625 | /* Called by custom word point completers that want to recurse into |
626 | the completion machinery to complete a command. Used to complete | |
627 | COMMAND in "thread apply all COMMAND", for example. Note that | |
628 | unlike command_completer, this fully recurses into the proper | |
629 | completer for COMMAND, so that e.g., | |
630 | ||
631 | (gdb) thread apply all print -[TAB] | |
632 | ||
633 | does the right thing and show the print options. */ | |
634 | extern void complete_nested_command_line (completion_tracker &tracker, | |
635 | const char *text); | |
636 | ||
d7561cbb KS |
637 | extern const char *skip_quoted_chars (const char *, const char *, |
638 | const char *); | |
4e87b832 | 639 | |
d7561cbb | 640 | extern const char *skip_quoted (const char *); |
c5f0f3d0 | 641 | |
ef0b411a GB |
642 | /* Maximum number of candidates to consider before the completer |
643 | bails by throwing MAX_COMPLETIONS_REACHED_ERROR. Negative values | |
644 | disable limiting. */ | |
645 | ||
646 | extern int max_completions; | |
647 | ||
c5f0f3d0 | 648 | #endif /* defined (COMPLETER_H) */ |