1 /* General utility routines for GDB, the GNU debugger.
2 Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
6 GDB is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 1, or (at your option)
11 GDB is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GDB; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 #include <sys/ioctl.h>
22 #include <sys/param.h>
35 extern volatile void return_to_top_level ();
36 extern volatile void exit ();
37 extern char *gdb_readline ();
38 extern char *getenv();
39 extern char *malloc();
40 extern char *realloc();
42 /* If this definition isn't overridden by the header files, assume
43 that isatty and fileno exist on this system. */
45 #define ISATTY(FP) (isatty (fileno (FP)))
48 #ifdef MISSING_VPRINTF
50 #undef MISSING_VPRINTF
51 #else /* !__GNU_LIBRARY */
54 #define vfprintf(file, format, ap) _doprnt (format, ap, file)
58 /* Can't #define it since printcmd.c needs it */
61 char *format
; void *ap
;
63 vfprintf (stdout
, format
, ap
);
67 #endif /* GNU_LIBRARY */
68 #endif /* MISSING_VPRINTF */
73 /* Chain of cleanup actions established with make_cleanup,
74 to be executed if an error happens. */
76 static struct cleanup
*cleanup_chain
;
78 /* Nonzero means a quit has been requested. */
82 /* Nonzero means quit immediately if Control-C is typed now,
83 rather than waiting until QUIT is executed. */
87 /* Nonzero means that encoded C++ names should be printed out in their
88 C++ form rather than raw. */
92 /* Nonzero means that encoded C++ names should be printed out in their
93 C++ form even in assembler language displays. If this is set, but
94 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
98 /* Nonzero means that strings with character values >0x7F should be printed
99 as octal escapes. Zero means just print the value (e.g. it's an
100 international character, and the terminal or window can cope.) */
102 int sevenbit_strings
= 0;
104 /* Add a new cleanup to the cleanup_chain,
105 and return the previous chain pointer
106 to be passed later to do_cleanups or discard_cleanups.
107 Args are FUNCTION to clean up with, and ARG to pass to it. */
110 make_cleanup (function
, arg
)
114 register struct cleanup
*new
115 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
116 register struct cleanup
*old_chain
= cleanup_chain
;
118 new->next
= cleanup_chain
;
119 new->function
= function
;
126 /* Discard cleanups and do the actions they describe
127 until we get back to the point OLD_CHAIN in the cleanup_chain. */
130 do_cleanups (old_chain
)
131 register struct cleanup
*old_chain
;
133 register struct cleanup
*ptr
;
134 while ((ptr
= cleanup_chain
) != old_chain
)
136 (*ptr
->function
) (ptr
->arg
);
137 cleanup_chain
= ptr
->next
;
142 /* Discard cleanups, not doing the actions they describe,
143 until we get back to the point OLD_CHAIN in the cleanup_chain. */
146 discard_cleanups (old_chain
)
147 register struct cleanup
*old_chain
;
149 register struct cleanup
*ptr
;
150 while ((ptr
= cleanup_chain
) != old_chain
)
152 cleanup_chain
= ptr
->next
;
157 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
161 struct cleanup
*old_chain
= cleanup_chain
;
167 /* Restore the cleanup chain from a previously saved chain. */
169 restore_cleanups (chain
)
170 struct cleanup
*chain
;
172 cleanup_chain
= chain
;
175 /* This function is useful for cleanups.
179 old_chain = make_cleanup (free_current_contents, &foo);
181 to arrange to free the object thus allocated. */
184 free_current_contents (location
)
190 /* Print an error message and return to command level.
191 The first argument STRING is the error message, used as a fprintf string,
192 and the remaining args are passed as arguments to it. */
203 target_terminal_ours ();
205 string
= va_arg (args
, char *);
206 vfprintf (stderr
, string
, args
);
207 fprintf (stderr
, "\n");
209 return_to_top_level ();
212 /* Print an error message and exit reporting failure.
213 This is for a error that we cannot continue from.
214 The arguments are printed a la printf. */
225 string
= va_arg (args
, char *);
226 fprintf (stderr
, "gdb: ");
227 vfprintf (stderr
, string
, args
);
228 fprintf (stderr
, "\n");
233 /* Print an error message and exit, dumping core.
234 The arguments are printed a la printf (). */
237 fatal_dump_core (va_alist
)
244 string
= va_arg (args
, char *);
245 /* "internal error" is always correct, since GDB should never dump
246 core, no matter what the input. */
247 fprintf (stderr
, "gdb internal error: ");
248 vfprintf (stderr
, string
, args
);
249 fprintf (stderr
, "\n");
252 signal (SIGQUIT
, SIG_DFL
);
253 kill (getpid (), SIGQUIT
);
254 /* We should never get here, but just in case... */
258 /* Memory management stuff (malloc friends). */
260 #if defined (NO_MALLOC_CHECK)
264 #else /* Have mcheck(). */
268 fatal_dump_core ("Memory corruption");
274 mcheck (malloc_botch
);
277 #endif /* Have mcheck(). */
279 /* Like malloc but get error if no storage available. */
291 /* At least one place (dbxread.c:condense_misc_bunches where misc_count == 0)
292 GDB wants to allocate zero bytes. */
296 val
= (char *) malloc (size
);
298 fatal ("virtual memory exhausted.", 0);
302 /* Like realloc but get error if no storage available. */
313 register char *val
= (char *) realloc (ptr
, size
);
315 fatal ("virtual memory exhausted.", 0);
319 /* Print the system error message for errno, and also mention STRING
320 as the file name for which the error was encountered.
321 Then return to command level. */
324 perror_with_name (string
)
328 extern char *sys_errlist
[];
332 if (errno
< sys_nerr
)
333 err
= sys_errlist
[errno
];
335 err
= "unknown error";
337 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
338 strcpy (combined
, string
);
339 strcat (combined
, ": ");
340 strcat (combined
, err
);
342 /* I understand setting these is a matter of taste. Still, some people
343 may clear errno but not know about bfd_error. Doing this here is not
345 bfd_error
= no_error
;
348 error ("%s.", combined
);
351 /* Print the system error message for ERRCODE, and also mention STRING
352 as the file name for which the error was encountered. */
355 print_sys_errmsg (string
, errcode
)
360 extern char *sys_errlist
[];
364 if (errcode
< sys_nerr
)
365 err
= sys_errlist
[errcode
];
367 err
= "unknown error";
369 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
370 strcpy (combined
, string
);
371 strcat (combined
, ": ");
372 strcat (combined
, err
);
374 printf ("%s.\n", combined
);
377 /* Control C eventually causes this to be called, at a convenient time. */
382 target_terminal_ours ();
384 ioctl (fileno (stdout
), TCFLSH
, 1);
385 #else /* not HAVE_TERMIO */
386 ioctl (fileno (stdout
), TIOCFLUSH
, 0);
387 #endif /* not HAVE_TERMIO */
391 error ("Quit (expect signal %d when inferior is resumed)", SIGINT
);
392 #endif /* TIOCGPGRP */
395 /* Control C comes here */
403 /* Restore the signal handler. */
404 signal (SIGINT
, request_quit
);
411 /* My replacement for the read system call.
412 Used like `read' but keeps going if `read' returns too soon. */
415 myread (desc
, addr
, len
)
425 val
= read (desc
, addr
, len
);
436 /* Make a copy of the string at PTR with SIZE characters
437 (and add a null character at the end in the copy).
438 Uses malloc to get the space. Returns the address of the copy. */
441 savestring (ptr
, size
)
445 register char *p
= (char *) xmalloc (size
+ 1);
446 bcopy (ptr
, p
, size
);
451 /* The "const" is so it compiles under DGUX (which prototypes strsave
452 in <string.h>. FIXME: This should be named "xstrsave", shouldn't it?
453 Doesn't real strsave return NULL if out of memory? */
458 return savestring (ptr
, strlen (ptr
));
465 register int len
= strlen (s1
) + strlen (s2
) + strlen (s3
) + 1;
466 register char *val
= (char *) xmalloc (len
);
474 print_spaces (n
, file
)
482 /* Ask user a y-or-n question and return 1 iff answer is yes.
483 Takes three args which are given to printf to print the question.
484 The first, a control string, should end in "? ".
485 It should not say how to answer, because we do that. */
497 /* Automatically answer "yes" if input is not from a terminal. */
498 if (!input_from_terminal_p ())
504 ctlstr
= va_arg (args
, char *);
505 vfprintf (stdout
, ctlstr
, args
);
507 printf ("(y or n) ");
509 answer
= fgetc (stdin
);
510 clearerr (stdin
); /* in case of C-d */
511 if (answer
== EOF
) /* C-d */
513 if (answer
!= '\n') /* Eat rest of input line, to EOF or newline */
516 ans2
= fgetc (stdin
);
519 while (ans2
!= EOF
&& ans2
!= '\n');
526 printf ("Please answer y or n.\n");
530 /* Parse a C escape sequence. STRING_PTR points to a variable
531 containing a pointer to the string to parse. That pointer
532 should point to the character after the \. That pointer
533 is updated past the characters we use. The value of the
534 escape sequence is returned.
536 A negative value means the sequence \ newline was seen,
537 which is supposed to be equivalent to nothing at all.
539 If \ is followed by a null character, we return a negative
540 value and leave the string pointer pointing at the null character.
542 If \ is followed by 000, we return 0 and leave the string pointer
543 after the zeros. A value of 0 does not mean end of string. */
546 parse_escape (string_ptr
)
549 register int c
= *(*string_ptr
)++;
574 c
= *(*string_ptr
)++;
576 c
= parse_escape (string_ptr
);
579 return (c
& 0200) | (c
& 037);
590 register int i
= c
- '0';
591 register int count
= 0;
594 if ((c
= *(*string_ptr
)++) >= '0' && c
<= '7')
612 /* Print the character CH on STREAM as part of the contents
613 of a literal string whose delimiter is QUOTER. */
616 printchar (ch
, stream
, quoter
)
623 if (c
< 040 || (sevenbit_strings
&& c
>= 0177))
627 fputs_filtered ("\\n", stream
);
630 fputs_filtered ("\\b", stream
);
633 fputs_filtered ("\\t", stream
);
636 fputs_filtered ("\\f", stream
);
639 fputs_filtered ("\\r", stream
);
642 fputs_filtered ("\\e", stream
);
645 fputs_filtered ("\\a", stream
);
648 fprintf_filtered (stream
, "\\%.3o", (unsigned int) c
);
653 if (c
== '\\' || c
== quoter
)
654 fputs_filtered ("\\", stream
);
655 fprintf_filtered (stream
, "%c", c
);
659 /* Number of lines per page or UINT_MAX if paging is disabled. */
660 static unsigned int lines_per_page
;
661 /* Number of chars per line or UNIT_MAX is line folding is disabled. */
662 static unsigned int chars_per_line
;
663 /* Current count of lines printed on this page, chars on this line. */
664 static unsigned int lines_printed
, chars_printed
;
666 /* Buffer and start column of buffered text, for doing smarter word-
667 wrapping. When someone calls wrap_here(), we start buffering output
668 that comes through fputs_filtered(). If we see a newline, we just
669 spit it out and forget about the wrap_here(). If we see another
670 wrap_here(), we spit it out and remember the newer one. If we see
671 the end of the line, we spit out a newline, the indent, and then
674 wrap_column is the column number on the screen where wrap_buffer begins.
675 When wrap_column is zero, wrapping is not in effect.
676 wrap_buffer is malloc'd with chars_per_line+2 bytes.
677 When wrap_buffer[0] is null, the buffer is empty.
678 wrap_pointer points into it at the next character to fill.
679 wrap_indent is the string that should be used as indentation if the
682 static char *wrap_buffer
, *wrap_pointer
, *wrap_indent
;
683 static int wrap_column
;
685 /* Get the number of lines to print with commands like "list".
686 This is based on guessing how many long (i.e. more than chars_per_line
687 characters) lines there will be. To be completely correct, "list"
688 and friends should be rewritten to count characters and see where
689 things are wrapping, but that would be a fair amount of work. */
693 /* RMS didn't like the following algorithm. Let's set it back to
694 10 and see if anyone else complains. */
695 /* return lines_per_page == UINT_MAX ? 10 : lines_per_page / 2; */
701 set_width_command (args
, from_tty
, c
)
704 struct cmd_list_element
*c
;
708 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
709 wrap_buffer
[0] = '\0';
712 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
713 wrap_pointer
= wrap_buffer
; /* Start it at the beginning */
717 prompt_for_continue ()
720 gdb_readline ("---Type <return> to continue---", 0);
721 chars_printed
= lines_printed
= 0;
725 /* Reinitialize filter; ie. tell it to reset to original values. */
728 reinitialize_more_filter ()
734 /* Indicate that if the next sequence of characters overflows the line,
735 a newline should be inserted here rather than when it hits the end.
736 If INDENT is nonzero, it is a string to be printed to indent the
737 wrapped part on the next line. INDENT must remain accessible until
738 the next call to wrap_here() or until a newline is printed through
741 If the line is already overfull, we immediately print a newline and
742 the indentation, and disable further wrapping.
744 INDENT should not contain tabs, as that
745 will mess up the char count on the next line. FIXME. */
753 *wrap_pointer
= '\0';
754 fputs (wrap_buffer
, stdout
);
756 wrap_pointer
= wrap_buffer
;
757 wrap_buffer
[0] = '\0';
758 if (chars_printed
>= chars_per_line
)
760 puts_filtered ("\n");
761 puts_filtered (indent
);
766 wrap_column
= chars_printed
;
767 wrap_indent
= indent
;
771 /* Like fputs but pause after every screenful, and can wrap at points
772 other than the final character of a line.
773 Unlike fputs, fputs_filtered does not return a value.
774 It is OK for LINEBUFFER to be NULL, in which case just don't print
777 Note that a longjmp to top level may occur in this routine
778 (since prompt_for_continue may do so) so this routine should not be
779 called when cleanups are not in place. */
782 fputs_filtered (linebuffer
, stream
)
791 /* Don't do any filtering if it is disabled. */
793 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
795 fputs (linebuffer
, stream
);
799 /* Go through and output each character. Show line extension
800 when this is necessary; prompt user for new page when this is
803 lineptr
= linebuffer
;
806 /* Possible new page. */
807 if (lines_printed
>= lines_per_page
- 1)
808 prompt_for_continue ();
810 while (*lineptr
&& *lineptr
!= '\n')
812 /* Print a single line. */
813 if (*lineptr
== '\t')
816 *wrap_pointer
++ = '\t';
819 /* Shifting right by 3 produces the number of tab stops
820 we have already passed, and then adding one and
821 shifting left 3 advances to the next tab stop. */
822 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
828 *wrap_pointer
++ = *lineptr
;
830 putc (*lineptr
, stream
);
835 if (chars_printed
>= chars_per_line
)
837 unsigned int save_chars
= chars_printed
;
841 /* If we aren't actually wrapping, don't output newline --
842 if chars_per_line is right, we probably just overflowed
843 anyway; if it's wrong, let us keep going. */
847 /* Possible new page. */
848 if (lines_printed
>= lines_per_page
- 1)
849 prompt_for_continue ();
851 /* Now output indentation and wrapped string */
855 fputs (wrap_indent
, stream
);
856 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
857 fputs (wrap_buffer
, stream
); /* and eject it */
858 /* FIXME, this strlen is what prevents wrap_indent from
859 containing tabs. However, if we recurse to print it
860 and count its chars, we risk trouble if wrap_indent is
861 longer than (the user settable) chars_per_line.
862 Note also that this can set chars_printed > chars_per_line
863 if we are printing a long string. */
864 chars_printed
= strlen (wrap_indent
)
865 + (save_chars
- wrap_column
);
866 wrap_pointer
= wrap_buffer
; /* Reset buffer */
867 wrap_buffer
[0] = '\0';
868 wrap_column
= 0; /* And disable fancy wrap */
873 if (*lineptr
== '\n')
876 wrap_here (""); /* Spit out chars, cancel further wraps */
885 /* fputs_demangled is a variant of fputs_filtered that
886 demangles g++ names.*/
889 fputs_demangled (linebuffer
, stream
, arg_mode
)
895 extern char *cplus_demangle (const char *, int);
897 extern char *cplus_demangle ();
899 #define SYMBOL_MAX 1024
901 #define SYMBOL_CHAR(c) (isascii(c) \
902 && (isalnum(c) || (c) == '_' || (c) == CPLUS_MARKER))
904 char buf
[SYMBOL_MAX
+1];
905 # define SLOP 5 /* How much room to leave in buf */
908 if (linebuffer
== NULL
)
911 /* If user wants to see raw output, no problem. */
913 fputs_filtered (linebuffer
, stream
);
918 while ( *p
!= (char) 0 ) {
921 /* collect non-interesting characters into buf */
922 while ( *p
!= (char) 0 && !SYMBOL_CHAR(*p
) && i
< (int)sizeof(buf
)-SLOP
) {
927 /* output the non-interesting characters without demangling */
929 fputs_filtered(buf
, stream
);
930 i
= 0; /* reset buf */
933 /* and now the interesting characters */
934 while (i
< SYMBOL_MAX
937 && i
< (int)sizeof(buf
) - SLOP
) {
945 if ( (result
= cplus_demangle(buf
, arg_mode
)) != NULL
) {
946 fputs_filtered(result
, stream
);
950 fputs_filtered(buf
, stream
);
956 /* Print a variable number of ARGS using format FORMAT. If this
957 information is going to put the amount written (since the last call
958 to INITIALIZE_MORE_FILTER or the last page break) over the page size,
959 print out a pause message and do a gdb_readline to get the users
960 permision to continue.
962 Unlike fprintf, this function does not return a value.
964 We implement three variants, vfprintf (takes a vararg list and stream),
965 fprintf (takes a stream to write on), and printf (the usual).
967 Note that this routine has a restriction that the length of the
968 final output line must be less than 255 characters *or* it must be
969 less than twice the size of the format string. This is a very
970 arbitrary restriction, but it is an internal restriction, so I'll
971 put it in. This means that the %s format specifier is almost
972 useless; unless the caller can GUARANTEE that the string is short
973 enough, fputs_filtered should be used instead.
975 Note also that a longjmp to top level may occur in this routine
976 (since prompt_for_continue may do so) so this routine should not be
977 called when cleanups are not in place. */
979 #if !defined(MISSING_VPRINTF) || defined (vsprintf)
982 vfprintf_filtered (stream
, format
, args
)
985 void fprintf_filtered (stream
, format
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
)
990 static char *linebuffer
= (char *) 0;
991 static int line_size
;
994 format_length
= strlen (format
);
996 /* Allocated linebuffer for the first time. */
999 linebuffer
= (char *) xmalloc (255);
1003 /* Reallocate buffer to a larger size if this is necessary. */
1004 if (format_length
* 2 > line_size
)
1006 line_size
= format_length
* 2;
1008 /* You don't have to copy. */
1010 linebuffer
= (char *) xmalloc (line_size
);
1014 /* This won't blow up if the restrictions described above are
1016 #if !defined(MISSING_VPRINTF) || defined (vsprintf)
1017 (void) vsprintf (linebuffer
, format
, args
);
1019 (void) sprintf (linebuffer
, format
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
1022 fputs_filtered (linebuffer
, stream
);
1025 #if !defined(MISSING_VPRINTF) || defined (vsprintf)
1028 fprintf_filtered (va_alist
)
1036 stream
= va_arg (args
, FILE *);
1037 format
= va_arg (args
, char *);
1039 /* This won't blow up if the restrictions described above are
1041 (void) vfprintf_filtered (stream
, format
, args
);
1047 printf_filtered (va_alist
)
1054 format
= va_arg (args
, char *);
1056 (void) vfprintf_filtered (stdout
, format
, args
);
1061 printf_filtered (format
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
)
1063 int arg1
, arg2
, arg3
, arg4
, arg5
, arg6
;
1065 fprintf_filtered (stdout
, format
, arg1
, arg2
, arg3
, arg4
, arg5
, arg6
);
1072 puts_filtered (string
)
1075 fputs_filtered (string
, stdout
);
1078 /* Return a pointer to N spaces and a null. The pointer is good
1079 until the next call to here. */
1085 static char *spaces
;
1086 static int max_spaces
;
1092 spaces
= malloc (n
+1);
1093 for (t
= spaces
+n
; t
!= spaces
;)
1099 return spaces
+ max_spaces
- n
;
1102 /* Print N spaces. */
1104 print_spaces_filtered (n
, stream
)
1108 fputs_filtered (n_spaces (n
), stream
);
1111 /* C++ demangler stuff. */
1112 char *cplus_demangle ();
1114 /* Print NAME on STREAM, demangling if necessary. */
1116 fprint_symbol (stream
, name
)
1121 if ((!demangle
) || NULL
== (demangled
= cplus_demangle (name
, 1)))
1122 fputs_filtered (name
, stream
);
1125 fputs_filtered (demangled
, stream
);
1130 #if !defined (USG_UTILS)
1131 #define USG_UTILS defined (USG)
1135 bcopy (from
, to
, count
)
1138 memcpy (to
, from
, count
);
1141 bcmp (from
, to
, count
)
1143 return (memcmp (to
, from
, count
));
1156 getcwd (buf
, MAXPATHLEN
);
1164 return strchr (s
, c
);
1172 return strrchr (s
, c
);
1174 #endif /* USG_UTILS. */
1176 #if !defined (QUEUE_MISSING)
1177 #define QUEUE_MISSING defined (USG)
1181 /* Queue routines */
1188 insque (item
, after
)
1190 struct queue
*after
;
1192 item
->forw
= after
->forw
;
1193 after
->forw
->back
= item
;
1202 item
->forw
->back
= item
->back
;
1203 item
->back
->forw
= item
->forw
;
1205 #endif /* QUEUE_MISSING */
1207 /* Simple implementation of strstr, since some implementations lack it. */
1210 const char *in
, *find
;
1212 register const char *p
= in
- 1;
1214 while (0 != (p
= strchr (p
+1, *find
))) {
1215 if (strcmp (p
, find
))
1222 _initialize_utils ()
1224 struct cmd_list_element
*c
;
1226 c
= add_set_cmd ("width", class_support
, var_uinteger
,
1227 (char *)&chars_per_line
,
1228 "Set number of characters gdb thinks are in a line.",
1230 add_show_from_set (c
, &showlist
);
1231 c
->function
= set_width_command
;
1234 (add_set_cmd ("height", class_support
,
1235 var_uinteger
, (char *)&lines_per_page
,
1236 "Set number of lines gdb thinks are in a page.", &setlist
),
1239 /* These defaults will be used if we are unable to get the correct
1240 values from termcap. */
1241 lines_per_page
= 24;
1242 chars_per_line
= 80;
1243 /* Initialize the screen height and width from termcap. */
1245 char *termtype
= getenv ("TERM");
1247 /* Positive means success, nonpositive means failure. */
1250 /* 2048 is large enough for all known terminals, according to the
1251 GNU termcap manual. */
1252 char term_buffer
[2048];
1256 status
= tgetent (term_buffer
, termtype
);
1261 val
= tgetnum ("li");
1263 lines_per_page
= val
;
1265 /* The number of lines per page is not mentioned
1266 in the terminal description. This probably means
1267 that paging is not useful (e.g. emacs shell window),
1268 so disable paging. */
1269 lines_per_page
= UINT_MAX
;
1271 val
= tgetnum ("co");
1273 chars_per_line
= val
;
1278 set_width_command ((char *)NULL
, 0, c
);
1281 (add_set_cmd ("demangle", class_support
, var_boolean
,
1283 "Set demangling of encoded C++ names when displaying symbols.",
1288 (add_set_cmd ("sevenbit-strings", class_support
, var_boolean
,
1289 (char *)&sevenbit_strings
,
1290 "Set printing of 8-bit characters in strings as \\nnn.",
1295 (add_set_cmd ("asm-demangle", class_support
, var_boolean
,
1296 (char *)&asm_demangle
,
1297 "Set demangling of C++ names in disassembly listings.",
This page took 0.058895 seconds and 4 git commands to generate.