| <html lang="en"> |
| <head> |
| <title>Print Settings - 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="Data.html#Data" title="Data"> |
| <link rel="prev" href="Auto-Display.html#Auto-Display" title="Auto Display"> |
| <link rel="next" href="Pretty-Printing.html#Pretty-Printing" title="Pretty Printing"> |
| <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="Print-Settings"></a> |
| <p> |
| Next: <a rel="next" accesskey="n" href="Pretty-Printing.html#Pretty-Printing">Pretty Printing</a>, |
| Previous: <a rel="previous" accesskey="p" href="Auto-Display.html#Auto-Display">Auto Display</a>, |
| Up: <a rel="up" accesskey="u" href="Data.html#Data">Data</a> |
| <hr> |
| </div> |
| |
| <h3 class="section">10.8 Print Settings</h3> |
| |
| <p><a name="index-format-options-674"></a><a name="index-print-settings-675"></a><span class="sc">gdb</span> provides the following ways to control how arrays, structures, |
| and symbols are printed. |
| |
| <p class="noindent">These settings are useful for debugging programs in any language: |
| |
| |
| <a name="index-set-print-676"></a> |
| <dl><dt><code>set print address</code><dt><code>set print address on</code><dd><a name="index-print_002fdon_0027t-print-memory-addresses-677"></a><span class="sc">gdb</span> prints memory addresses showing the location of stack |
| traces, structure values, pointer values, breakpoints, and so forth, |
| even when it also displays the contents of those addresses. The default |
| is <code>on</code>. For example, this is what a stack frame display looks like with |
| <code>set print address on</code>: |
| |
| <pre class="smallexample"> (gdb) f |
| #0 set_quotes (lq=0x34c78 "<<", rq=0x34c88 ">>") |
| at input.c:530 |
| 530 if (lquote != def_lquote) |
| </pre> |
| <br><dt><code>set print address off</code><dd>Do not print addresses when displaying their contents. For example, |
| this is the same stack frame displayed with <code>set print address off</code>: |
| |
| <pre class="smallexample"> (gdb) set print addr off |
| (gdb) f |
| #0 set_quotes (lq="<<", rq=">>") at input.c:530 |
| 530 if (lquote != def_lquote) |
| </pre> |
| <p>You can use ‘<samp><span class="samp">set print address off</span></samp>’ to eliminate all machine |
| dependent displays from the <span class="sc">gdb</span> interface. For example, with |
| <code>print address off</code>, you should get the same text for backtraces on |
| all machines—whether or not they involve pointer arguments. |
| |
| <p><a name="index-show-print-678"></a><br><dt><code>show print address</code><dd>Show whether or not addresses are to be printed. |
| </dl> |
| |
| <p>When <span class="sc">gdb</span> prints a symbolic address, it normally prints the |
| closest earlier symbol plus an offset. If that symbol does not uniquely |
| identify the address (for example, it is a name whose scope is a single |
| source file), you may need to clarify. One way to do this is with |
| <code>info line</code>, for example ‘<samp><span class="samp">info line *0x4537</span></samp>’. Alternately, |
| you can set <span class="sc">gdb</span> to print the source file and line number when |
| it prints a symbolic address: |
| |
| <dl> |
| <dt><code>set print symbol-filename on</code><dd><a name="index-source-file-and-line-of-a-symbol-679"></a><a name="index-symbol_002c-source-file-and-line-680"></a>Tell <span class="sc">gdb</span> to print the source file name and line number of a |
| symbol in the symbolic form of an address. |
| |
| <br><dt><code>set print symbol-filename off</code><dd>Do not print source file name and line number of a symbol. This is the |
| default. |
| |
| <br><dt><code>show print symbol-filename</code><dd>Show whether or not <span class="sc">gdb</span> will print the source file name and |
| line number of a symbol in the symbolic form of an address. |
| </dl> |
| |
| <p>Another situation where it is helpful to show symbol filenames and line |
| numbers is when disassembling code; <span class="sc">gdb</span> shows you the line |
| number and source file that corresponds to each instruction. |
| |
| <p>Also, you may wish to see the symbolic form only if the address being |
| printed is reasonably close to the closest earlier symbol: |
| |
| <dl> |
| <dt><code>set print max-symbolic-offset </code><var>max-offset</var><dt><code>set print max-symbolic-offset unlimited</code><dd><a name="index-maximum-value-for-offset-of-closest-symbol-681"></a>Tell <span class="sc">gdb</span> to only display the symbolic form of an address if the |
| offset between the closest earlier symbol and the address is less than |
| <var>max-offset</var>. The default is <code>unlimited</code>, which tells <span class="sc">gdb</span> |
| to always print the symbolic form of an address if any symbol precedes |
| it. Zero is equivalent to <code>unlimited</code>. |
| |
| <br><dt><code>show print max-symbolic-offset</code><dd>Ask how large the maximum offset is that <span class="sc">gdb</span> prints in a |
| symbolic address. |
| </dl> |
| |
| <p><a name="index-wild-pointer_002c-interpreting-682"></a><a name="index-pointer_002c-finding-referent-683"></a>If you have a pointer and you are not sure where it points, try |
| ‘<samp><span class="samp">set print symbol-filename on</span></samp>’. Then you can determine the name |
| and source file location of the variable where it points, using |
| ‘<samp><span class="samp">p/a </span><var>pointer</var></samp>’. This interprets the address in symbolic form. |
| For example, here <span class="sc">gdb</span> shows that a variable <code>ptt</code> points |
| at another variable <code>t</code>, defined in <samp><span class="file">hi2.c</span></samp>: |
| |
| <pre class="smallexample"> (gdb) set print symbol-filename on |
| (gdb) p/a ptt |
| $4 = 0xe008 <t in hi2.c> |
| </pre> |
| <blockquote> |
| <em>Warning:</em> For pointers that point to a local variable, ‘<samp><span class="samp">p/a</span></samp>’ |
| does not show the symbol name and filename of the referent, even with |
| the appropriate <code>set print</code> options turned on. |
| </blockquote> |
| |
| <p>You can also enable ‘<samp><span class="samp">/a</span></samp>’-like formatting all the time using |
| ‘<samp><span class="samp">set print symbol on</span></samp>’: |
| |
| <dl> |
| <dt><code>set print symbol on</code><dd>Tell <span class="sc">gdb</span> to print the symbol corresponding to an address, if |
| one exists. |
| |
| <br><dt><code>set print symbol off</code><dd>Tell <span class="sc">gdb</span> not to print the symbol corresponding to an |
| address. In this mode, <span class="sc">gdb</span> will still print the symbol |
| corresponding to pointers to functions. This is the default. |
| |
| <br><dt><code>show print symbol</code><dd>Show whether <span class="sc">gdb</span> will display the symbol corresponding to an |
| address. |
| </dl> |
| |
| <p>Other settings control how different kinds of objects are printed: |
| |
| <dl> |
| <dt><code>set print array</code><dt><code>set print array on</code><dd><a name="index-pretty-print-arrays-684"></a>Pretty print arrays. This format is more convenient to read, |
| but uses more space. The default is off. |
| |
| <br><dt><code>set print array off</code><dd>Return to compressed format for arrays. |
| |
| <br><dt><code>show print array</code><dd>Show whether compressed or pretty format is selected for displaying |
| arrays. |
| |
| <p><a name="index-print-array-indexes-685"></a><br><dt><code>set print array-indexes</code><dt><code>set print array-indexes on</code><dd>Print the index of each element when displaying arrays. May be more |
| convenient to locate a given element in the array or quickly find the |
| index of a given element in that printed array. The default is off. |
| |
| <br><dt><code>set print array-indexes off</code><dd>Stop printing element indexes when displaying arrays. |
| |
| <br><dt><code>show print array-indexes</code><dd>Show whether the index of each element is printed when displaying |
| arrays. |
| |
| <br><dt><code>set print elements </code><var>number-of-elements</var><dt><code>set print elements unlimited</code><dd><a name="index-number-of-array-elements-to-print-686"></a><a name="index-limit-on-number-of-printed-array-elements-687"></a>Set a limit on how many elements of an array <span class="sc">gdb</span> will print. |
| If <span class="sc">gdb</span> is printing a large array, it stops printing after it has |
| printed the number of elements set by the <code>set print elements</code> command. |
| This limit also applies to the display of strings. |
| When <span class="sc">gdb</span> starts, this limit is set to 200. |
| Setting <var>number-of-elements</var> to <code>unlimited</code> or zero means |
| that the number of elements to print is unlimited. |
| |
| <br><dt><code>show print elements</code><dd>Display the number of elements of a large array that <span class="sc">gdb</span> will print. |
| If the number is 0, then the printing is unlimited. |
| |
| <br><dt><code>set print frame-arguments </code><var>value</var><dd><a name="index-set-print-frame_002darguments-688"></a><a name="index-printing-frame-argument-values-689"></a><a name="index-print-all-frame-argument-values-690"></a><a name="index-print-frame-argument-values-for-scalars-only-691"></a><a name="index-do-not-print-frame-argument-values-692"></a>This command allows to control how the values of arguments are printed |
| when the debugger prints a frame (see <a href="Frames.html#Frames">Frames</a>). The possible |
| values are: |
| |
| <dl> |
| <dt><code>all</code><dd>The values of all arguments are printed. |
| |
| <br><dt><code>scalars</code><dd>Print the value of an argument only if it is a scalar. The value of more |
| complex arguments such as arrays, structures, unions, etc, is replaced |
| by <code>...</code>. This is the default. Here is an example where |
| only scalar arguments are shown: |
| |
| <pre class="smallexample"> #1 0x08048361 in call_me (i=3, s=..., ss=0xbf8d508c, u=..., e=green) |
| at frame-args.c:23 |
| </pre> |
| <br><dt><code>none</code><dd>None of the argument values are printed. Instead, the value of each argument |
| is replaced by <code>...</code>. In this case, the example above now becomes: |
| |
| <pre class="smallexample"> #1 0x08048361 in call_me (i=..., s=..., ss=..., u=..., e=...) |
| at frame-args.c:23 |
| </pre> |
| </dl> |
| |
| <p>By default, only scalar arguments are printed. This command can be used |
| to configure the debugger to print the value of all arguments, regardless |
| of their type. However, it is often advantageous to not print the value |
| of more complex parameters. For instance, it reduces the amount of |
| information printed in each frame, making the backtrace more readable. |
| Also, it improves performance when displaying Ada frames, because |
| the computation of large arguments can sometimes be CPU-intensive, |
| especially in large applications. Setting <code>print frame-arguments</code> |
| to <code>scalars</code> (the default) or <code>none</code> avoids this computation, |
| thus speeding up the display of each Ada frame. |
| |
| <br><dt><code>show print frame-arguments</code><dd>Show how the value of arguments should be displayed when printing a frame. |
| |
| <br><dt><code>set print raw frame-arguments on</code><dd>Print frame arguments in raw, non pretty-printed, form. |
| |
| <br><dt><code>set print raw frame-arguments off</code><dd>Print frame arguments in pretty-printed form, if there is a pretty-printer |
| for the value (see <a href="Pretty-Printing.html#Pretty-Printing">Pretty Printing</a>), |
| otherwise print the value in raw form. |
| This is the default. |
| |
| <br><dt><code>show print raw frame-arguments</code><dd>Show whether to print frame arguments in raw form. |
| |
| <p><a name="set-print-entry_002dvalues"></a><br><dt><code>set print entry-values </code><var>value</var><dd><a name="index-set-print-entry_002dvalues-693"></a>Set printing of frame argument values at function entry. In some cases |
| <span class="sc">gdb</span> can determine the value of function argument which was passed by |
| the function caller, even if the value was modified inside the called function |
| and therefore is different. With optimized code, the current value could be |
| unavailable, but the entry value may still be known. |
| |
| <p>The default value is <code>default</code> (see below for its description). Older |
| <span class="sc">gdb</span> behaved as with the setting <code>no</code>. Compilers not supporting |
| this feature will behave in the <code>default</code> setting the same way as with the |
| <code>no</code> setting. |
| |
| <p>This functionality is currently supported only by DWARF 2 debugging format and |
| the compiler has to produce ‘<samp><span class="samp">DW_TAG_call_site</span></samp>’ tags. With |
| <span class="sc">gcc</span>, you need to specify <samp><span class="option">-O -g</span></samp> during compilation, to get |
| this information. |
| |
| <p>The <var>value</var> parameter can be one of the following: |
| |
| <dl> |
| <dt><code>no</code><dd>Print only actual parameter values, never print values from function entry |
| point. |
| <pre class="smallexample"> #0 equal (val=5) |
| #0 different (val=6) |
| #0 lost (val=<optimized out>) |
| #0 born (val=10) |
| #0 invalid (val=<optimized out>) |
| </pre> |
| <br><dt><code>only</code><dd>Print only parameter values from function entry point. The actual parameter |
| values are never printed. |
| <pre class="smallexample"> #0 equal (val@entry=5) |
| #0 different (val@entry=5) |
| #0 lost (val@entry=5) |
| #0 born (val@entry=<optimized out>) |
| #0 invalid (val@entry=<optimized out>) |
| </pre> |
| <br><dt><code>preferred</code><dd>Print only parameter values from function entry point. If value from function |
| entry point is not known while the actual value is known, print the actual |
| value for such parameter. |
| <pre class="smallexample"> #0 equal (val@entry=5) |
| #0 different (val@entry=5) |
| #0 lost (val@entry=5) |
| #0 born (val=10) |
| #0 invalid (val@entry=<optimized out>) |
| </pre> |
| <br><dt><code>if-needed</code><dd>Print actual parameter values. If actual parameter value is not known while |
| value from function entry point is known, print the entry point value for such |
| parameter. |
| <pre class="smallexample"> #0 equal (val=5) |
| #0 different (val=6) |
| #0 lost (val@entry=5) |
| #0 born (val=10) |
| #0 invalid (val=<optimized out>) |
| </pre> |
| <br><dt><code>both</code><dd>Always print both the actual parameter value and its value from function entry |
| point, even if values of one or both are not available due to compiler |
| optimizations. |
| <pre class="smallexample"> #0 equal (val=5, val@entry=5) |
| #0 different (val=6, val@entry=5) |
| #0 lost (val=<optimized out>, val@entry=5) |
| #0 born (val=10, val@entry=<optimized out>) |
| #0 invalid (val=<optimized out>, val@entry=<optimized out>) |
| </pre> |
| <br><dt><code>compact</code><dd>Print the actual parameter value if it is known and also its value from |
| function entry point if it is known. If neither is known, print for the actual |
| value <code><optimized out></code>. If not in MI mode (see <a href="GDB_002fMI.html#GDB_002fMI">GDB/MI</a>) and if both |
| values are known and identical, print the shortened |
| <code>param=param@entry=VALUE</code> notation. |
| <pre class="smallexample"> #0 equal (val=val@entry=5) |
| #0 different (val=6, val@entry=5) |
| #0 lost (val@entry=5) |
| #0 born (val=10) |
| #0 invalid (val=<optimized out>) |
| </pre> |
| <br><dt><code>default</code><dd>Always print the actual parameter value. Print also its value from function |
| entry point, but only if it is known. If not in MI mode (see <a href="GDB_002fMI.html#GDB_002fMI">GDB/MI</a>) and |
| if both values are known and identical, print the shortened |
| <code>param=param@entry=VALUE</code> notation. |
| <pre class="smallexample"> #0 equal (val=val@entry=5) |
| #0 different (val=6, val@entry=5) |
| #0 lost (val=<optimized out>, val@entry=5) |
| #0 born (val=10) |
| #0 invalid (val=<optimized out>) |
| </pre> |
| </dl> |
| |
| <p>For analysis messages on possible failures of frame argument values at function |
| entry resolution see <a href="set-debug-entry_002dvalues.html#set-debug-entry_002dvalues">set debug entry-values</a>. |
| |
| <br><dt><code>show print entry-values</code><dd>Show the method being used for printing of frame argument values at function |
| entry. |
| |
| <br><dt><code>set print repeats </code><var>number-of-repeats</var><dt><code>set print repeats unlimited</code><dd><a name="index-repeated-array-elements-694"></a>Set the threshold for suppressing display of repeated array |
| elements. When the number of consecutive identical elements of an |
| array exceeds the threshold, <span class="sc">gdb</span> prints the string |
| <code>"<repeats </code><var>n</var><code> times>"</code>, where <var>n</var> is the number of |
| identical repetitions, instead of displaying the identical elements |
| themselves. Setting the threshold to <code>unlimited</code> or zero will |
| cause all elements to be individually printed. The default threshold |
| is 10. |
| |
| <br><dt><code>show print repeats</code><dd>Display the current threshold for printing repeated identical |
| elements. |
| |
| <br><dt><code>set print null-stop</code><dd><a name="index-g_t_0040sc_007bnull_007d-elements-in-arrays-695"></a>Cause <span class="sc">gdb</span> to stop printing the characters of an array when the first |
| <span class="sc">null</span> is encountered. This is useful when large arrays actually |
| contain only short strings. |
| The default is off. |
| |
| <br><dt><code>show print null-stop</code><dd>Show whether <span class="sc">gdb</span> stops printing an array on the first |
| <span class="sc">null</span> character. |
| |
| <br><dt><code>set print pretty on</code><dd><a name="index-print-structures-in-indented-form-696"></a><a name="index-indentation-in-structure-display-697"></a>Cause <span class="sc">gdb</span> to print structures in an indented format with one member |
| per line, like this: |
| |
| <pre class="smallexample"> $1 = { |
| next = 0x0, |
| flags = { |
| sweet = 1, |
| sour = 1 |
| }, |
| meat = 0x54 "Pork" |
| } |
| </pre> |
| <br><dt><code>set print pretty off</code><dd>Cause <span class="sc">gdb</span> to print structures in a compact format, like this: |
| |
| <pre class="smallexample"> $1 = {next = 0x0, flags = {sweet = 1, sour = 1}, \ |
| meat = 0x54 "Pork"} |
| </pre> |
| <p class="noindent">This is the default format. |
| |
| <br><dt><code>show print pretty</code><dd>Show which format <span class="sc">gdb</span> is using to print structures. |
| |
| <br><dt><code>set print sevenbit-strings on</code><dd><a name="index-eight_002dbit-characters-in-strings-698"></a><a name="index-octal-escapes-in-strings-699"></a>Print using only seven-bit characters; if this option is set, |
| <span class="sc">gdb</span> displays any eight-bit characters (in strings or |
| character values) using the notation <code>\</code><var>nnn</var>. This setting is |
| best if you are working in English (<span class="sc">ascii</span>) and you use the |
| high-order bit of characters as a marker or “meta” bit. |
| |
| <br><dt><code>set print sevenbit-strings off</code><dd>Print full eight-bit characters. This allows the use of more |
| international character sets, and is the default. |
| |
| <br><dt><code>show print sevenbit-strings</code><dd>Show whether or not <span class="sc">gdb</span> is printing only seven-bit characters. |
| |
| <br><dt><code>set print union on</code><dd><a name="index-unions-in-structures_002c-printing-700"></a>Tell <span class="sc">gdb</span> to print unions which are contained in structures |
| and other unions. This is the default setting. |
| |
| <br><dt><code>set print union off</code><dd>Tell <span class="sc">gdb</span> not to print unions which are contained in |
| structures and other unions. <span class="sc">gdb</span> will print <code>"{...}"</code> |
| instead. |
| |
| <br><dt><code>show print union</code><dd>Ask <span class="sc">gdb</span> whether or not it will print unions which are contained in |
| structures and other unions. |
| |
| <p>For example, given the declarations |
| |
| <pre class="smallexample"> typedef enum {Tree, Bug} Species; |
| typedef enum {Big_tree, Acorn, Seedling} Tree_forms; |
| typedef enum {Caterpillar, Cocoon, Butterfly} |
| Bug_forms; |
| |
| struct thing { |
| Species it; |
| union { |
| Tree_forms tree; |
| Bug_forms bug; |
| } form; |
| }; |
| |
| struct thing foo = {Tree, {Acorn}}; |
| </pre> |
| <p class="noindent">with <code>set print union on</code> in effect ‘<samp><span class="samp">p foo</span></samp>’ would print |
| |
| <pre class="smallexample"> $1 = {it = Tree, form = {tree = Acorn, bug = Cocoon}} |
| </pre> |
| <p class="noindent">and with <code>set print union off</code> in effect it would print |
| |
| <pre class="smallexample"> $1 = {it = Tree, form = {...}} |
| </pre> |
| <p class="noindent"><code>set print union</code> affects programs written in C-like languages |
| and in Pascal. |
| </dl> |
| |
| <p class="noindent">These settings are of interest when debugging C<tt>++</tt> programs: |
| |
| |
| <a name="index-demangling-C_0040t_007b_002b_002b_007d-names-701"></a> |
| <dl><dt><code>set print demangle</code><dt><code>set print demangle on</code><dd>Print C<tt>++</tt> names in their source form rather than in the encoded |
| (“mangled”) form passed to the assembler and linker for type-safe |
| linkage. The default is on. |
| |
| <br><dt><code>show print demangle</code><dd>Show whether C<tt>++</tt> names are printed in mangled or demangled form. |
| |
| <br><dt><code>set print asm-demangle</code><dt><code>set print asm-demangle on</code><dd>Print C<tt>++</tt> names in their source form rather than their mangled form, even |
| in assembler code printouts such as instruction disassemblies. |
| The default is off. |
| |
| <br><dt><code>show print asm-demangle</code><dd>Show whether C<tt>++</tt> names in assembly listings are printed in mangled |
| or demangled form. |
| |
| <p><a name="index-C_0040t_007b_002b_002b_007d-symbol-decoding-style-702"></a><a name="index-symbol-decoding-style_002c-C_0040t_007b_002b_002b_007d-703"></a><a name="index-set-demangle_002dstyle-704"></a><br><dt><code>set demangle-style </code><var>style</var><dd>Choose among several encoding schemes used by different compilers to represent |
| C<tt>++</tt> names. If you omit <var>style</var>, you will see a list of possible |
| formats. The default value is <var>auto</var>, which lets <span class="sc">gdb</span> choose a |
| decoding style by inspecting your program. |
| |
| <br><dt><code>show demangle-style</code><dd>Display the encoding style currently in use for decoding C<tt>++</tt> symbols. |
| |
| <br><dt><code>set print object</code><dt><code>set print object on</code><dd><a name="index-derived-type-of-an-object_002c-printing-705"></a><a name="index-display-derived-types-706"></a>When displaying a pointer to an object, identify the <em>actual</em> |
| (derived) type of the object rather than the <em>declared</em> type, using |
| the virtual function table. Note that the virtual function table is |
| required—this feature can only work for objects that have run-time |
| type identification; a single virtual method in the object's declared |
| type is sufficient. Note that this setting is also taken into account when |
| working with variable objects via MI (see <a href="GDB_002fMI.html#GDB_002fMI">GDB/MI</a>). |
| |
| <br><dt><code>set print object off</code><dd>Display only the declared type of objects, without reference to the |
| virtual function table. This is the default setting. |
| |
| <br><dt><code>show print object</code><dd>Show whether actual, or declared, object types are displayed. |
| |
| <br><dt><code>set print static-members</code><dt><code>set print static-members on</code><dd><a name="index-static-members-of-C_0040t_007b_002b_002b_007d-objects-707"></a>Print static members when displaying a C<tt>++</tt> object. The default is on. |
| |
| <br><dt><code>set print static-members off</code><dd>Do not print static members when displaying a C<tt>++</tt> object. |
| |
| <br><dt><code>show print static-members</code><dd>Show whether C<tt>++</tt> static members are printed or not. |
| |
| <br><dt><code>set print pascal_static-members</code><dt><code>set print pascal_static-members on</code><dd><a name="index-static-members-of-Pascal-objects-708"></a><a name="index-Pascal-objects_002c-static-members-display-709"></a>Print static members when displaying a Pascal object. The default is on. |
| |
| <br><dt><code>set print pascal_static-members off</code><dd>Do not print static members when displaying a Pascal object. |
| |
| <br><dt><code>show print pascal_static-members</code><dd>Show whether Pascal static members are printed or not. |
| |
| <!-- These don't work with HP ANSI C++ yet. --> |
| <br><dt><code>set print vtbl</code><dt><code>set print vtbl on</code><dd><a name="index-pretty-print-C_0040t_007b_002b_002b_007d-virtual-function-tables-710"></a><a name="index-virtual-functions-_0028C_0040t_007b_002b_002b_007d_0029-display-711"></a><a name="index-VTBL-display-712"></a>Pretty print C<tt>++</tt> virtual function tables. The default is off. |
| (The <code>vtbl</code> commands do not work on programs compiled with the HP |
| ANSI C<tt>++</tt> compiler (<code>aCC</code>).) |
| |
| <br><dt><code>set print vtbl off</code><dd>Do not pretty print C<tt>++</tt> virtual function tables. |
| |
| <br><dt><code>show print vtbl</code><dd>Show whether C<tt>++</tt> virtual function tables are pretty printed, or not. |
| </dl> |
| |
| </body></html> |
| |
