| <html lang="en"> |
| <head> |
| <title>Completion - Debugging with GDB</title> |
| <meta http-equiv="Content-Type" content="text/html"> |
| <meta name="description" content="Debugging with GDB"> |
| <meta name="generator" content="makeinfo 4.13"> |
| <link title="Top" rel="start" href="index.html#Top"> |
| <link rel="up" href="Commands.html#Commands" title="Commands"> |
| <link rel="prev" href="Command-Syntax.html#Command-Syntax" title="Command Syntax"> |
| <link rel="next" href="Help.html#Help" title="Help"> |
| <link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage"> |
| <!-- |
| Copyright (C) 1988-2019 Free Software Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.3 or |
| any later version published by the Free Software Foundation; with the |
| Invariant Sections being ``Free Software'' and ``Free Software Needs |
| Free Documentation'', with the Front-Cover Texts being ``A GNU Manual,'' |
| and with the Back-Cover Texts as in (a) below. |
| |
| (a) The FSF's Back-Cover Text is: ``You are free to copy and modify |
| this GNU Manual. Buying copies from GNU Press supports the FSF in |
| developing GNU and promoting software freedom.'' |
| --> |
| <meta http-equiv="Content-Style-Type" content="text/css"> |
| <style type="text/css"><!-- |
| pre.display { font-family:inherit } |
| pre.format { font-family:inherit } |
| pre.smalldisplay { font-family:inherit; font-size:smaller } |
| pre.smallformat { font-family:inherit; font-size:smaller } |
| pre.smallexample { font-size:smaller } |
| pre.smalllisp { font-size:smaller } |
| span.sc { font-variant:small-caps } |
| span.roman { font-family:serif; font-weight:normal; } |
| span.sansserif { font-family:sans-serif; font-weight:normal; } |
| --></style> |
| </head> |
| <body> |
| <div class="node"> |
| <a name="Completion"></a> |
| <p> |
| Next: <a rel="next" accesskey="n" href="Help.html#Help">Help</a>, |
| Previous: <a rel="previous" accesskey="p" href="Command-Syntax.html#Command-Syntax">Command Syntax</a>, |
| Up: <a rel="up" accesskey="u" href="Commands.html#Commands">Commands</a> |
| <hr> |
| </div> |
| |
| <h3 class="section">3.2 Command Completion</h3> |
| |
| <p><a name="index-completion-84"></a><a name="index-word-completion-85"></a><span class="sc">gdb</span> can fill in the rest of a word in a command for you, if there is |
| only one possibility; it can also show you what the valid possibilities |
| are for the next word in a command, at any time. This works for <span class="sc">gdb</span> |
| commands, <span class="sc">gdb</span> subcommands, and the names of symbols in your program. |
| |
| <p>Press the <TAB> key whenever you want <span class="sc">gdb</span> to fill out the rest |
| of a word. If there is only one possibility, <span class="sc">gdb</span> fills in the |
| word, and waits for you to finish the command (or press <RET> to |
| enter it). For example, if you type |
| |
| <!-- FIXME "@key" does not distinguish its argument sufficiently to permit --> |
| <!-- complete accuracy in these examples; space introduced for clarity. --> |
| <!-- If texinfo enhancements make it unnecessary, it would be nice to --> |
| <!-- replace " @key" by "@key" in the following... --> |
| <pre class="smallexample"> (gdb) info bre <TAB> |
| </pre> |
| <p class="noindent"><span class="sc">gdb</span> fills in the rest of the word ‘<samp><span class="samp">breakpoints</span></samp>’, since that is |
| the only <code>info</code> subcommand beginning with ‘<samp><span class="samp">bre</span></samp>’: |
| |
| <pre class="smallexample"> (gdb) info breakpoints |
| </pre> |
| <p class="noindent">You can either press <RET> at this point, to run the <code>info |
| breakpoints</code> command, or backspace and enter something else, if |
| ‘<samp><span class="samp">breakpoints</span></samp>’ does not look like the command you expected. (If you |
| were sure you wanted <code>info breakpoints</code> in the first place, you |
| might as well just type <RET> immediately after ‘<samp><span class="samp">info bre</span></samp>’, |
| to exploit command abbreviations rather than command completion). |
| |
| <p>If there is more than one possibility for the next word when you press |
| <TAB>, <span class="sc">gdb</span> sounds a bell. You can either supply more |
| characters and try again, or just press <TAB> a second time; |
| <span class="sc">gdb</span> displays all the possible completions for that word. For |
| example, you might want to set a breakpoint on a subroutine whose name |
| begins with ‘<samp><span class="samp">make_</span></samp>’, but when you type <kbd>b make_<TAB></kbd> <span class="sc">gdb</span> |
| just sounds the bell. Typing <TAB> again displays all the |
| function names in your program that begin with those characters, for |
| example: |
| |
| <pre class="smallexample"> (gdb) b make_ <TAB> |
| <br><span class="sc">gdb</span> sounds bell; press <TAB> again, to see:<br> |
| make_a_section_from_file make_environ |
| make_abs_section make_function_type |
| make_blockvector make_pointer_type |
| make_cleanup make_reference_type |
| make_command make_symbol_completion_list |
| (gdb) b make_ |
| </pre> |
| <p class="noindent">After displaying the available possibilities, <span class="sc">gdb</span> copies your |
| partial input (‘<samp><span class="samp">b make_</span></samp>’ in the example) so you can finish the |
| command. |
| |
| <p>If you just want to see the list of alternatives in the first place, you |
| can press <kbd>M-?</kbd> rather than pressing <TAB> twice. <kbd>M-?</kbd> |
| means <kbd><META> ?</kbd>. You can type this either by holding down a |
| key designated as the <META> shift on your keyboard (if there is |
| one) while typing <kbd>?</kbd>, or as <ESC> followed by <kbd>?</kbd>. |
| |
| <p>If the number of possible completions is large, <span class="sc">gdb</span> will |
| print as much of the list as it has collected, as well as a message |
| indicating that the list may be truncated. |
| |
| <pre class="smallexample"> (gdb) b m<TAB><TAB> |
| main |
| <... the rest of the possible completions ...> |
| *** List may be truncated, max-completions reached. *** |
| (gdb) b m |
| </pre> |
| <p class="noindent">This behavior can be controlled with the following commands: |
| |
| |
| <a name="index-set-max_002dcompletions-86"></a> |
| <dl><dt><code>set max-completions </code><var>limit</var><dt><code>set max-completions unlimited</code><dd>Set the maximum number of completion candidates. <span class="sc">gdb</span> will |
| stop looking for more completions once it collects this many candidates. |
| This is useful when completing on things like function names as collecting |
| all the possible candidates can be time consuming. |
| The default value is 200. A value of zero disables tab-completion. |
| Note that setting either no limit or a very large limit can make |
| completion slow. |
| <a name="index-show-max_002dcompletions-87"></a><br><dt><code>show max-completions</code><dd>Show the maximum number of candidates that <span class="sc">gdb</span> will collect and show |
| during completion. |
| </dl> |
| |
| <p><a name="index-quotes-in-commands-88"></a><a name="index-completion-of-quoted-strings-89"></a>Sometimes the string you need, while logically a “word”, may contain |
| parentheses or other characters that <span class="sc">gdb</span> normally excludes from |
| its notion of a word. To permit word completion to work in this |
| situation, you may enclose words in <code>'</code> (single quote marks) in |
| <span class="sc">gdb</span> commands. |
| |
| <p>A likely situation where you might need this is in typing an |
| expression that involves a C<tt>++</tt> symbol name with template |
| parameters. This is because when completing expressions, GDB treats |
| the ‘<samp><span class="samp"><</span></samp>’ character as word delimiter, assuming that it's the |
| less-than comparison operator (see <a href="C-Operators.html#C-Operators">C and C<tt>++</tt> Operators</a>). |
| |
| <p>For example, when you want to call a C<tt>++</tt> template function |
| interactively using the <code>print</code> or <code>call</code> commands, you may |
| need to distinguish whether you mean the version of <code>name</code> that |
| was specialized for <code>int</code>, <code>name<int>()</code>, or the version |
| that was specialized for <code>float</code>, <code>name<float>()</code>. To use |
| the word-completion facilities in this situation, type a single quote |
| <code>'</code> at the beginning of the function name. This alerts |
| <span class="sc">gdb</span> that it may need to consider more information than usual |
| when you press <TAB> or <kbd>M-?</kbd> to request word completion: |
| |
| <pre class="smallexample"> (gdb) p 'func< <kbd>M-?</kbd> |
| func<int>() func<float>() |
| (gdb) p 'func< |
| </pre> |
| <p>When setting breakpoints however (see <a href="Specify-Location.html#Specify-Location">Specify Location</a>), you don't |
| usually need to type a quote before the function name, because |
| <span class="sc">gdb</span> understands that you want to set a breakpoint on a |
| function: |
| |
| <pre class="smallexample"> (gdb) b func< <kbd>M-?</kbd> |
| func<int>() func<float>() |
| (gdb) b func< |
| </pre> |
| <p>This is true even in the case of typing the name of C<tt>++</tt> overloaded |
| functions (multiple definitions of the same function, distinguished by |
| argument type). For example, when you want to set a breakpoint you |
| don't need to distinguish whether you mean the version of <code>name</code> |
| that takes an <code>int</code> parameter, <code>name(int)</code>, or the version |
| that takes a <code>float</code> parameter, <code>name(float)</code>. |
| |
| <pre class="smallexample"> (gdb) b bubble( <kbd>M-?</kbd> |
| bubble(int) bubble(double) |
| (gdb) b bubble(dou <kbd>M-?</kbd> |
| bubble(double) |
| </pre> |
| <p>See <a href="quoting-names.html#quoting-names">quoting names</a> for a description of other scenarios that |
| require quoting. |
| |
| <p>For more information about overloaded functions, see <a href="C-Plus-Plus-Expressions.html#C-Plus-Plus-Expressions">C<tt>++</tt> Expressions</a>. You can use the command <code>set |
| overload-resolution off</code> to disable overload resolution; |
| see <a href="Debugging-C-Plus-Plus.html#Debugging-C-Plus-Plus"><span class="sc">gdb</span> Features for C<tt>++</tt></a>. |
| |
| <p><a name="index-completion-of-structure-field-names-90"></a><a name="index-structure-field-name-completion-91"></a><a name="index-completion-of-union-field-names-92"></a><a name="index-union-field-name-completion-93"></a>When completing in an expression which looks up a field in a |
| structure, <span class="sc">gdb</span> also tries<a rel="footnote" href="#fn-1" name="fnd-1"><sup>1</sup></a> to |
| limit completions to the field names available in the type of the |
| left-hand-side: |
| |
| <pre class="smallexample"> (gdb) p gdb_stdout.<kbd>M-?</kbd> |
| magic to_fputs to_rewind |
| to_data to_isatty to_write |
| to_delete to_put to_write_async_safe |
| to_flush to_read |
| </pre> |
| <p class="noindent">This is because the <code>gdb_stdout</code> is a variable of the type |
| <code>struct ui_file</code> that is defined in <span class="sc">gdb</span> sources as |
| follows: |
| |
| <pre class="smallexample"> struct ui_file |
| { |
| int *magic; |
| ui_file_flush_ftype *to_flush; |
| ui_file_write_ftype *to_write; |
| ui_file_write_async_safe_ftype *to_write_async_safe; |
| ui_file_fputs_ftype *to_fputs; |
| ui_file_read_ftype *to_read; |
| ui_file_delete_ftype *to_delete; |
| ui_file_isatty_ftype *to_isatty; |
| ui_file_rewind_ftype *to_rewind; |
| ui_file_put_ftype *to_put; |
| void *to_data; |
| } |
| </pre> |
| <div class="footnote"> |
| <hr> |
| <h4>Footnotes</h4><p class="footnote"><small>[<a name="fn-1" href="#fnd-1">1</a>]</small> The completer can be |
| confused by certain kinds of invalid expressions. Also, it only |
| examines the static type of the expression, not the dynamic type.</p> |
| |
| <hr></div> |
| |
| </body></html> |
| |