1 /* General utility routines for GDB, the GNU debugger.
2 Copyright 1986, 1989, 1990, 1991, 1992, 1995 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program 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 2 of the License, or
9 (at your option) any later version.
11 This program 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 this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 #if !defined(__GO32__) && !defined(WIN32)
22 #include <sys/ioctl.h>
23 #include <sys/param.h>
26 #ifdef ANSI_PROTOTYPES
43 #include "expression.h"
49 /* readline defines this. */
52 /* Prototypes for local functions */
54 #if defined (NO_MMALLOC) || defined (NO_MMALLOC_CHECK)
58 malloc_botch
PARAMS ((void));
60 #endif /* NO_MMALLOC, etc */
63 fatal_dump_core
PARAMS((char *, ...));
66 prompt_for_continue
PARAMS ((void));
69 set_width_command
PARAMS ((char *, int, struct cmd_list_element
*));
71 /* If this definition isn't overridden by the header files, assume
72 that isatty and fileno exist on this system. */
74 #define ISATTY(FP) (isatty (fileno (FP)))
77 /* Chain of cleanup actions established with make_cleanup,
78 to be executed if an error happens. */
80 static struct cleanup
*cleanup_chain
;
82 /* Nonzero if we have job control. */
86 /* Nonzero means a quit has been requested. */
90 /* Nonzero means quit immediately if Control-C is typed now, rather
91 than waiting until QUIT is executed. Be careful in setting this;
92 code which executes with immediate_quit set has to be very careful
93 about being able to deal with being interrupted at any time. It is
94 almost always better to use QUIT; the only exception I can think of
95 is being able to quit out of a system call (using EINTR loses if
96 the SIGINT happens between the previous QUIT and the system call).
97 To immediately quit in the case in which a SIGINT happens between
98 the previous QUIT and setting immediate_quit (desirable anytime we
99 expect to block), call QUIT after setting immediate_quit. */
103 /* Nonzero means that encoded C++ names should be printed out in their
104 C++ form rather than raw. */
108 /* Nonzero means that encoded C++ names should be printed out in their
109 C++ form even in assembler language displays. If this is set, but
110 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
112 int asm_demangle
= 0;
114 /* Nonzero means that strings with character values >0x7F should be printed
115 as octal escapes. Zero means just print the value (e.g. it's an
116 international character, and the terminal or window can cope.) */
118 int sevenbit_strings
= 0;
120 /* String to be printed before error messages, if any. */
122 char *error_pre_print
;
124 /* String to be printed before quit messages, if any. */
126 char *quit_pre_print
;
128 /* String to be printed before warning messages, if any. */
130 char *warning_pre_print
= "\nwarning: ";
132 /* Add a new cleanup to the cleanup_chain,
133 and return the previous chain pointer
134 to be passed later to do_cleanups or discard_cleanups.
135 Args are FUNCTION to clean up with, and ARG to pass to it. */
138 make_cleanup (function
, arg
)
139 void (*function
) PARAMS ((PTR
));
142 register struct cleanup
*new
143 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
144 register struct cleanup
*old_chain
= cleanup_chain
;
146 new->next
= cleanup_chain
;
147 new->function
= function
;
154 /* Discard cleanups and do the actions they describe
155 until we get back to the point OLD_CHAIN in the cleanup_chain. */
158 do_cleanups (old_chain
)
159 register struct cleanup
*old_chain
;
161 register struct cleanup
*ptr
;
162 while ((ptr
= cleanup_chain
) != old_chain
)
164 cleanup_chain
= ptr
->next
; /* Do this first incase recursion */
165 (*ptr
->function
) (ptr
->arg
);
170 /* Discard cleanups, not doing the actions they describe,
171 until we get back to the point OLD_CHAIN in the cleanup_chain. */
174 discard_cleanups (old_chain
)
175 register struct cleanup
*old_chain
;
177 register struct cleanup
*ptr
;
178 while ((ptr
= cleanup_chain
) != old_chain
)
180 cleanup_chain
= ptr
->next
;
185 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
189 struct cleanup
*old_chain
= cleanup_chain
;
195 /* Restore the cleanup chain from a previously saved chain. */
197 restore_cleanups (chain
)
198 struct cleanup
*chain
;
200 cleanup_chain
= chain
;
203 /* This function is useful for cleanups.
207 old_chain = make_cleanup (free_current_contents, &foo);
209 to arrange to free the object thus allocated. */
212 free_current_contents (location
)
218 /* Provide a known function that does nothing, to use as a base for
219 for a possibly long chain of cleanups. This is useful where we
220 use the cleanup chain for handling normal cleanups as well as dealing
221 with cleanups that need to be done as a result of a call to error().
222 In such cases, we may not be certain where the first cleanup is, unless
223 we have a do-nothing one to always use as the base. */
233 /* Print a warning message. Way to use this is to call warning_begin,
234 output the warning message (use unfiltered output to gdb_stderr),
235 ending in a newline. There is not currently a warning_end that you
236 call afterwards, but such a thing might be added if it is useful
237 for a GUI to separate warning messages from other output.
239 FIXME: Why do warnings use unfiltered output and errors filtered?
240 Is this anything other than a historical accident? */
245 target_terminal_ours ();
246 wrap_here(""); /* Force out any buffered output */
247 gdb_flush (gdb_stdout
);
248 if (warning_pre_print
)
249 fprintf_unfiltered (gdb_stderr
, warning_pre_print
);
252 /* Print a warning message.
253 The first argument STRING is the warning message, used as a fprintf string,
254 and the remaining args are passed as arguments to it.
255 The primary difference between warnings and errors is that a warning
256 does not force the return to command level. */
260 #ifdef ANSI_PROTOTYPES
261 warning (char *string
, ...)
268 #ifdef ANSI_PROTOTYPES
269 va_start (args
, string
);
274 string
= va_arg (args
, char *);
277 vfprintf_unfiltered (gdb_stderr
, string
, args
);
278 fprintf_unfiltered (gdb_stderr
, "\n");
282 /* Start the printing of an error message. Way to use this is to call
283 this, output the error message (use filtered output to gdb_stderr
284 (FIXME: Some callers, like memory_error, use gdb_stdout)), ending
285 in a newline, and then call return_to_top_level (RETURN_ERROR).
286 error() provides a convenient way to do this for the special case
287 that the error message can be formatted with a single printf call,
288 but this is more general. */
292 target_terminal_ours ();
293 wrap_here (""); /* Force out any buffered output */
294 gdb_flush (gdb_stdout
);
296 annotate_error_begin ();
299 fprintf_filtered (gdb_stderr
, error_pre_print
);
302 /* Print an error message and return to command level.
303 The first argument STRING is the error message, used as a fprintf string,
304 and the remaining args are passed as arguments to it. */
306 #ifdef ANSI_PROTOTYPES
308 error (char *string
, ...)
316 #ifdef ANSI_PROTOTYPES
317 va_start (args
, string
);
326 #ifdef ANSI_PROTOTYPES
327 vfprintf_filtered (gdb_stderr
, string
, args
);
332 string1
= va_arg (args
, char *);
333 vfprintf_filtered (gdb_stderr
, string1
, args
);
336 fprintf_filtered (gdb_stderr
, "\n");
338 return_to_top_level (RETURN_ERROR
);
343 /* Print an error message and exit reporting failure.
344 This is for a error that we cannot continue from.
345 The arguments are printed a la printf.
347 This function cannot be declared volatile (NORETURN) in an
348 ANSI environment because exit() is not declared volatile. */
352 #ifdef ANSI_PROTOTYPES
353 fatal (char *string
, ...)
360 #ifdef ANSI_PROTOTYPES
361 va_start (args
, string
);
365 string
= va_arg (args
, char *);
367 fprintf_unfiltered (gdb_stderr
, "\ngdb: ");
368 vfprintf_unfiltered (gdb_stderr
, string
, args
);
369 fprintf_unfiltered (gdb_stderr
, "\n");
374 /* Print an error message and exit, dumping core.
375 The arguments are printed a la printf (). */
379 #ifdef ANSI_PROTOTYPES
380 fatal_dump_core (char *string
, ...)
382 fatal_dump_core (va_alist
)
387 #ifdef ANSI_PROTOTYPES
388 va_start (args
, string
);
393 string
= va_arg (args
, char *);
395 /* "internal error" is always correct, since GDB should never dump
396 core, no matter what the input. */
397 fprintf_unfiltered (gdb_stderr
, "\ngdb internal error: ");
398 vfprintf_unfiltered (gdb_stderr
, string
, args
);
399 fprintf_unfiltered (gdb_stderr
, "\n");
402 signal (SIGQUIT
, SIG_DFL
);
403 kill (getpid (), SIGQUIT
);
404 /* We should never get here, but just in case... */
408 /* The strerror() function can return NULL for errno values that are
409 out of range. Provide a "safe" version that always returns a
413 safe_strerror (errnum
)
419 if ((msg
= strerror (errnum
)) == NULL
)
421 sprintf (buf
, "(undocumented errno %d)", errnum
);
427 /* The strsignal() function can return NULL for signal values that are
428 out of range. Provide a "safe" version that always returns a
432 safe_strsignal (signo
)
438 if ((msg
= strsignal (signo
)) == NULL
)
440 sprintf (buf
, "(undocumented signal %d)", signo
);
447 /* Print the system error message for errno, and also mention STRING
448 as the file name for which the error was encountered.
449 Then return to command level. */
452 perror_with_name (string
)
458 err
= safe_strerror (errno
);
459 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
460 strcpy (combined
, string
);
461 strcat (combined
, ": ");
462 strcat (combined
, err
);
464 /* I understand setting these is a matter of taste. Still, some people
465 may clear errno but not know about bfd_error. Doing this here is not
467 bfd_set_error (bfd_error_no_error
);
470 error ("%s.", combined
);
473 /* Print the system error message for ERRCODE, and also mention STRING
474 as the file name for which the error was encountered. */
477 print_sys_errmsg (string
, errcode
)
484 err
= safe_strerror (errcode
);
485 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
486 strcpy (combined
, string
);
487 strcat (combined
, ": ");
488 strcat (combined
, err
);
490 /* We want anything which was printed on stdout to come out first, before
492 gdb_flush (gdb_stdout
);
493 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
496 /* Control C eventually causes this to be called, at a convenient time. */
501 serial_t gdb_stdout_serial
= serial_fdopen (1);
503 target_terminal_ours ();
505 /* We want all output to appear now, before we print "Quit". We
506 have 3 levels of buffering we have to flush (it's possible that
507 some of these should be changed to flush the lower-level ones
510 /* 1. The _filtered buffer. */
511 wrap_here ((char *)0);
513 /* 2. The stdio buffer. */
514 gdb_flush (gdb_stdout
);
515 gdb_flush (gdb_stderr
);
517 /* 3. The system-level buffer. */
518 SERIAL_FLUSH_OUTPUT (gdb_stdout_serial
);
519 SERIAL_UN_FDOPEN (gdb_stdout_serial
);
521 annotate_error_begin ();
523 /* Don't use *_filtered; we don't want to prompt the user to continue. */
525 fprintf_unfiltered (gdb_stderr
, quit_pre_print
);
528 /* If there is no terminal switching for this target, then we can't
529 possibly get screwed by the lack of job control. */
530 || current_target
.to_terminal_ours
== NULL
)
531 fprintf_unfiltered (gdb_stderr
, "Quit\n");
533 fprintf_unfiltered (gdb_stderr
,
534 "Quit (expect signal SIGINT when the program is resumed)\n");
535 return_to_top_level (RETURN_QUIT
);
539 #if defined(__GO32__)||defined(WIN32)
541 /* In the absence of signals, poll keyboard for a quit.
542 Called from #define QUIT pollquit() in xm-go32.h. */
560 /* We just ignore it */
561 fprintf_unfiltered (gdb_stderr
, "CTRL-A to quit, CTRL-B to quit harder\n");
568 #if defined(__GO32__)||defined(WIN32)
583 fprintf_unfiltered (gdb_stderr
, "CTRL-A to quit, CTRL-B to quit harder\n");
590 /* Done by signals */
593 /* Control C comes here */
601 /* Restore the signal handler. Harmless with BSD-style signals, needed
602 for System V-style signals. So just always do it, rather than worrying
603 about USG defines and stuff like that. */
604 signal (signo
, request_quit
);
615 /* Memory management stuff (malloc friends). */
617 #if defined (NO_MMALLOC)
619 /* Make a substitute size_t for non-ANSI compilers. */
626 #define size_t unsigned int
636 return malloc (size
);
640 mrealloc (md
, ptr
, size
)
645 if (ptr
== 0) /* Guard against old realloc's */
646 return malloc (size
);
648 return realloc (ptr
, size
);
659 #endif /* NO_MMALLOC */
661 #if defined (NO_MMALLOC) || defined (NO_MMALLOC_CHECK)
669 #else /* have mmalloc and want corruption checking */
674 fatal_dump_core ("Memory corruption");
677 /* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified
678 by MD, to detect memory corruption. Note that MD may be NULL to specify
679 the default heap that grows via sbrk.
681 Note that for freshly created regions, we must call mmcheck prior to any
682 mallocs in the region. Otherwise, any region which was allocated prior to
683 installing the checking hooks, which is later reallocated or freed, will
684 fail the checks! The mmcheck function only allows initial hooks to be
685 installed before the first mmalloc. However, anytime after we have called
686 mmcheck the first time to install the checking hooks, we can call it again
687 to update the function pointer to the memory corruption handler.
689 Returns zero on failure, non-zero on success. */
695 if (!mmcheck (md
, malloc_botch
))
697 warning ("internal error: failed to install memory consistency checks");
703 #endif /* Have mmalloc and want corruption checking */
705 /* Called when a memory allocation fails, with the number of bytes of
706 memory requested in SIZE. */
714 fatal ("virtual memory exhausted: can't allocate %ld bytes.", size
);
718 fatal ("virtual memory exhausted.");
722 /* Like mmalloc but get error if no storage available, and protect against
723 the caller wanting to allocate zero bytes. Whether to return NULL for
724 a zero byte request, or translate the request into a request for one
725 byte of zero'd storage, is a religious issue. */
738 else if ((val
= mmalloc (md
, size
)) == NULL
)
745 /* Like mrealloc but get error if no storage available. */
748 xmrealloc (md
, ptr
, size
)
757 val
= mrealloc (md
, ptr
, size
);
761 val
= mmalloc (md
, size
);
770 /* Like malloc but get error if no storage available, and protect against
771 the caller wanting to allocate zero bytes. */
777 return (xmmalloc ((PTR
) NULL
, size
));
780 /* Like mrealloc but get error if no storage available. */
787 return (xmrealloc ((PTR
) NULL
, ptr
, size
));
791 /* My replacement for the read system call.
792 Used like `read' but keeps going if `read' returns too soon. */
795 myread (desc
, addr
, len
)
805 val
= read (desc
, addr
, len
);
816 /* Make a copy of the string at PTR with SIZE characters
817 (and add a null character at the end in the copy).
818 Uses malloc to get the space. Returns the address of the copy. */
821 savestring (ptr
, size
)
825 register char *p
= (char *) xmalloc (size
+ 1);
826 memcpy (p
, ptr
, size
);
832 msavestring (md
, ptr
, size
)
837 register char *p
= (char *) xmmalloc (md
, size
+ 1);
838 memcpy (p
, ptr
, size
);
843 /* The "const" is so it compiles under DGUX (which prototypes strsave
844 in <string.h>. FIXME: This should be named "xstrsave", shouldn't it?
845 Doesn't real strsave return NULL if out of memory? */
850 return savestring (ptr
, strlen (ptr
));
858 return (msavestring (md
, ptr
, strlen (ptr
)));
862 print_spaces (n
, file
)
870 /* Print a host address. */
873 gdb_print_address (addr
, stream
)
878 /* We could use the %p conversion specifier to fprintf if we had any
879 way of knowing whether this host supports it. But the following
880 should work on the Alpha and on 32 bit machines. */
882 fprintf_filtered (stream
, "0x%lx", (unsigned long)addr
);
885 /* Ask user a y-or-n question and return 1 iff answer is yes.
886 Takes three args which are given to printf to print the question.
887 The first, a control string, should end in "? ".
888 It should not say how to answer, because we do that. */
892 #ifdef ANSI_PROTOTYPES
893 query (char *ctlstr
, ...)
904 #ifdef ANSI_PROTOTYPES
905 va_start (args
, ctlstr
);
909 ctlstr
= va_arg (args
, char *);
914 return query_hook (ctlstr
, args
);
917 /* Automatically answer "yes" if input is not from a terminal. */
918 if (!input_from_terminal_p ())
921 /* FIXME Automatically answer "yes" if called from MacGDB. */
928 wrap_here (""); /* Flush any buffered output */
929 gdb_flush (gdb_stdout
);
931 if (annotation_level
> 1)
932 printf_filtered ("\n\032\032pre-query\n");
934 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
935 printf_filtered ("(y or n) ");
937 if (annotation_level
> 1)
938 printf_filtered ("\n\032\032query\n");
941 /* If not in MacGDB, move to a new line so the entered line doesn't
942 have a prompt on the front of it. */
944 fputs_unfiltered ("\n", gdb_stdout
);
947 gdb_flush (gdb_stdout
);
948 answer
= fgetc (stdin
);
949 clearerr (stdin
); /* in case of C-d */
950 if (answer
== EOF
) /* C-d */
955 if (answer
!= '\n') /* Eat rest of input line, to EOF or newline */
958 ans2
= fgetc (stdin
);
961 while (ans2
!= EOF
&& ans2
!= '\n');
974 printf_filtered ("Please answer y or n.\n");
977 if (annotation_level
> 1)
978 printf_filtered ("\n\032\032post-query\n");
983 /* Parse a C escape sequence. STRING_PTR points to a variable
984 containing a pointer to the string to parse. That pointer
985 should point to the character after the \. That pointer
986 is updated past the characters we use. The value of the
987 escape sequence is returned.
989 A negative value means the sequence \ newline was seen,
990 which is supposed to be equivalent to nothing at all.
992 If \ is followed by a null character, we return a negative
993 value and leave the string pointer pointing at the null character.
995 If \ is followed by 000, we return 0 and leave the string pointer
996 after the zeros. A value of 0 does not mean end of string. */
999 parse_escape (string_ptr
)
1002 register int c
= *(*string_ptr
)++;
1006 return 007; /* Bell (alert) char */
1009 case 'e': /* Escape character */
1027 c
= *(*string_ptr
)++;
1029 c
= parse_escape (string_ptr
);
1032 return (c
& 0200) | (c
& 037);
1043 register int i
= c
- '0';
1044 register int count
= 0;
1047 if ((c
= *(*string_ptr
)++) >= '0' && c
<= '7')
1065 /* Print the character C on STREAM as part of the contents of a literal
1066 string whose delimiter is QUOTER. Note that this routine should only
1067 be call for printing things which are independent of the language
1068 of the program being debugged. */
1071 gdb_printchar (c
, stream
, quoter
)
1077 c
&= 0xFF; /* Avoid sign bit follies */
1079 if ( c
< 0x20 || /* Low control chars */
1080 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1081 (sevenbit_strings
&& c
>= 0x80)) { /* high order bit set */
1085 fputs_filtered ("\\n", stream
);
1088 fputs_filtered ("\\b", stream
);
1091 fputs_filtered ("\\t", stream
);
1094 fputs_filtered ("\\f", stream
);
1097 fputs_filtered ("\\r", stream
);
1100 fputs_filtered ("\\e", stream
);
1103 fputs_filtered ("\\a", stream
);
1106 fprintf_filtered (stream
, "\\%.3o", (unsigned int) c
);
1110 if (c
== '\\' || c
== quoter
)
1111 fputs_filtered ("\\", stream
);
1112 fprintf_filtered (stream
, "%c", c
);
1116 /* Number of lines per page or UINT_MAX if paging is disabled. */
1117 static unsigned int lines_per_page
;
1118 /* Number of chars per line or UNIT_MAX is line folding is disabled. */
1119 static unsigned int chars_per_line
;
1120 /* Current count of lines printed on this page, chars on this line. */
1121 static unsigned int lines_printed
, chars_printed
;
1123 /* Buffer and start column of buffered text, for doing smarter word-
1124 wrapping. When someone calls wrap_here(), we start buffering output
1125 that comes through fputs_filtered(). If we see a newline, we just
1126 spit it out and forget about the wrap_here(). If we see another
1127 wrap_here(), we spit it out and remember the newer one. If we see
1128 the end of the line, we spit out a newline, the indent, and then
1129 the buffered output. */
1131 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1132 are waiting to be output (they have already been counted in chars_printed).
1133 When wrap_buffer[0] is null, the buffer is empty. */
1134 static char *wrap_buffer
;
1136 /* Pointer in wrap_buffer to the next character to fill. */
1137 static char *wrap_pointer
;
1139 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1141 static char *wrap_indent
;
1143 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1144 is not in effect. */
1145 static int wrap_column
;
1149 set_width_command (args
, from_tty
, c
)
1152 struct cmd_list_element
*c
;
1156 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1157 wrap_buffer
[0] = '\0';
1160 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1161 wrap_pointer
= wrap_buffer
; /* Start it at the beginning */
1164 /* Wait, so the user can read what's on the screen. Prompt the user
1165 to continue by pressing RETURN. */
1168 prompt_for_continue ()
1171 char cont_prompt
[120];
1173 if (annotation_level
> 1)
1174 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1176 strcpy (cont_prompt
,
1177 "---Type <return> to continue, or q <return> to quit---");
1178 if (annotation_level
> 1)
1179 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1181 /* We must do this *before* we call gdb_readline, else it will eventually
1182 call us -- thinking that we're trying to print beyond the end of the
1184 reinitialize_more_filter ();
1187 /* On a real operating system, the user can quit with SIGINT.
1190 'q' is provided on all systems so users don't have to change habits
1191 from system to system, and because telling them what to do in
1192 the prompt is more user-friendly than expecting them to think of
1194 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1195 whereas control-C to gdb_readline will cause the user to get dumped
1197 ignore
= readline (cont_prompt
);
1199 if (annotation_level
> 1)
1200 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1205 while (*p
== ' ' || *p
== '\t')
1208 request_quit (SIGINT
);
1213 /* Now we have to do this again, so that GDB will know that it doesn't
1214 need to save the ---Type <return>--- line at the top of the screen. */
1215 reinitialize_more_filter ();
1217 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1220 /* Reinitialize filter; ie. tell it to reset to original values. */
1223 reinitialize_more_filter ()
1229 /* Indicate that if the next sequence of characters overflows the line,
1230 a newline should be inserted here rather than when it hits the end.
1231 If INDENT is non-null, it is a string to be printed to indent the
1232 wrapped part on the next line. INDENT must remain accessible until
1233 the next call to wrap_here() or until a newline is printed through
1236 If the line is already overfull, we immediately print a newline and
1237 the indentation, and disable further wrapping.
1239 If we don't know the width of lines, but we know the page height,
1240 we must not wrap words, but should still keep track of newlines
1241 that were explicitly printed.
1243 INDENT should not contain tabs, as that will mess up the char count
1244 on the next line. FIXME.
1246 This routine is guaranteed to force out any output which has been
1247 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1248 used to force out output from the wrap_buffer. */
1254 /* This should have been allocated, but be paranoid anyway. */
1260 *wrap_pointer
= '\0';
1261 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1263 wrap_pointer
= wrap_buffer
;
1264 wrap_buffer
[0] = '\0';
1265 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1269 else if (chars_printed
>= chars_per_line
)
1271 puts_filtered ("\n");
1273 puts_filtered (indent
);
1278 wrap_column
= chars_printed
;
1282 wrap_indent
= indent
;
1286 /* Ensure that whatever gets printed next, using the filtered output
1287 commands, starts at the beginning of the line. I.E. if there is
1288 any pending output for the current line, flush it and start a new
1289 line. Otherwise do nothing. */
1294 if (chars_printed
> 0)
1296 puts_filtered ("\n");
1302 gdb_fopen (name
, mode
)
1306 return fopen (name
, mode
);
1315 flush_hook (stream
);
1322 /* Like fputs but if FILTER is true, pause after every screenful.
1324 Regardless of FILTER can wrap at points other than the final
1325 character of a line.
1327 Unlike fputs, fputs_maybe_filtered does not return a value.
1328 It is OK for LINEBUFFER to be NULL, in which case just don't print
1331 Note that a longjmp to top level may occur in this routine (only if
1332 FILTER is true) (since prompt_for_continue may do so) so this
1333 routine should not be called when cleanups are not in place. */
1336 fputs_maybe_filtered (linebuffer
, stream
, filter
)
1337 const char *linebuffer
;
1341 const char *lineptr
;
1343 if (linebuffer
== 0)
1346 /* Don't do any filtering if it is disabled. */
1347 if (stream
!= gdb_stdout
1348 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
1350 fputs_unfiltered (linebuffer
, stream
);
1354 /* Go through and output each character. Show line extension
1355 when this is necessary; prompt user for new page when this is
1358 lineptr
= linebuffer
;
1361 /* Possible new page. */
1363 (lines_printed
>= lines_per_page
- 1))
1364 prompt_for_continue ();
1366 while (*lineptr
&& *lineptr
!= '\n')
1368 /* Print a single line. */
1369 if (*lineptr
== '\t')
1372 *wrap_pointer
++ = '\t';
1374 fputc_unfiltered ('\t', stream
);
1375 /* Shifting right by 3 produces the number of tab stops
1376 we have already passed, and then adding one and
1377 shifting left 3 advances to the next tab stop. */
1378 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1384 *wrap_pointer
++ = *lineptr
;
1386 fputc_unfiltered (*lineptr
, stream
);
1391 if (chars_printed
>= chars_per_line
)
1393 unsigned int save_chars
= chars_printed
;
1397 /* If we aren't actually wrapping, don't output newline --
1398 if chars_per_line is right, we probably just overflowed
1399 anyway; if it's wrong, let us keep going. */
1401 fputc_unfiltered ('\n', stream
);
1403 /* Possible new page. */
1404 if (lines_printed
>= lines_per_page
- 1)
1405 prompt_for_continue ();
1407 /* Now output indentation and wrapped string */
1410 fputs_unfiltered (wrap_indent
, stream
);
1411 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
1412 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
1413 /* FIXME, this strlen is what prevents wrap_indent from
1414 containing tabs. However, if we recurse to print it
1415 and count its chars, we risk trouble if wrap_indent is
1416 longer than (the user settable) chars_per_line.
1417 Note also that this can set chars_printed > chars_per_line
1418 if we are printing a long string. */
1419 chars_printed
= strlen (wrap_indent
)
1420 + (save_chars
- wrap_column
);
1421 wrap_pointer
= wrap_buffer
; /* Reset buffer */
1422 wrap_buffer
[0] = '\0';
1423 wrap_column
= 0; /* And disable fancy wrap */
1428 if (*lineptr
== '\n')
1431 wrap_here ((char *)0); /* Spit out chars, cancel further wraps */
1433 fputc_unfiltered ('\n', stream
);
1440 fputs_filtered (linebuffer
, stream
)
1441 const char *linebuffer
;
1444 fputs_maybe_filtered (linebuffer
, stream
, 1);
1448 putchar_unfiltered (c
)
1455 fputs_unfiltered (buf
, gdb_stdout
);
1460 fputc_unfiltered (c
, stream
)
1468 fputs_unfiltered (buf
, stream
);
1473 /* Print a variable number of ARGS using format FORMAT. If this
1474 information is going to put the amount written (since the last call
1475 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
1476 call prompt_for_continue to get the users permision to continue.
1478 Unlike fprintf, this function does not return a value.
1480 We implement three variants, vfprintf (takes a vararg list and stream),
1481 fprintf (takes a stream to write on), and printf (the usual).
1483 Note also that a longjmp to top level may occur in this routine
1484 (since prompt_for_continue may do so) so this routine should not be
1485 called when cleanups are not in place. */
1488 vfprintf_maybe_filtered (stream
, format
, args
, filter
)
1495 struct cleanup
*old_cleanups
;
1497 vasprintf (&linebuffer
, format
, args
);
1498 if (linebuffer
== NULL
)
1500 fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr
);
1503 old_cleanups
= make_cleanup (free
, linebuffer
);
1504 fputs_maybe_filtered (linebuffer
, stream
, filter
);
1505 do_cleanups (old_cleanups
);
1510 vfprintf_filtered (stream
, format
, args
)
1515 vfprintf_maybe_filtered (stream
, format
, args
, 1);
1519 vfprintf_unfiltered (stream
, format
, args
)
1525 struct cleanup
*old_cleanups
;
1527 vasprintf (&linebuffer
, format
, args
);
1528 if (linebuffer
== NULL
)
1530 fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr
);
1533 old_cleanups
= make_cleanup (free
, linebuffer
);
1534 fputs_unfiltered (linebuffer
, stream
);
1535 do_cleanups (old_cleanups
);
1539 vprintf_filtered (format
, args
)
1543 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
1547 vprintf_unfiltered (format
, args
)
1551 vfprintf_unfiltered (gdb_stdout
, format
, args
);
1556 #ifdef ANSI_PROTOTYPES
1557 fprintf_filtered (FILE *stream
, char *format
, ...)
1559 fprintf_filtered (va_alist
)
1564 #ifdef ANSI_PROTOTYPES
1565 va_start (args
, format
);
1571 stream
= va_arg (args
, FILE *);
1572 format
= va_arg (args
, char *);
1574 vfprintf_filtered (stream
, format
, args
);
1580 #ifdef ANSI_PROTOTYPES
1581 fprintf_unfiltered (FILE *stream
, char *format
, ...)
1583 fprintf_unfiltered (va_alist
)
1588 #ifdef ANSI_PROTOTYPES
1589 va_start (args
, format
);
1595 stream
= va_arg (args
, FILE *);
1596 format
= va_arg (args
, char *);
1598 vfprintf_unfiltered (stream
, format
, args
);
1602 /* Like fprintf_filtered, but prints its result indented.
1603 Called as fprintfi_filtered (spaces, stream, format, ...); */
1607 #ifdef ANSI_PROTOTYPES
1608 fprintfi_filtered (int spaces
, FILE *stream
, char *format
, ...)
1610 fprintfi_filtered (va_alist
)
1615 #ifdef ANSI_PROTOTYPES
1616 va_start (args
, format
);
1623 spaces
= va_arg (args
, int);
1624 stream
= va_arg (args
, FILE *);
1625 format
= va_arg (args
, char *);
1627 print_spaces_filtered (spaces
, stream
);
1629 vfprintf_filtered (stream
, format
, args
);
1636 #ifdef ANSI_PROTOTYPES
1637 printf_filtered (char *format
, ...)
1639 printf_filtered (va_alist
)
1644 #ifdef ANSI_PROTOTYPES
1645 va_start (args
, format
);
1650 format
= va_arg (args
, char *);
1652 vfprintf_filtered (gdb_stdout
, format
, args
);
1659 #ifdef ANSI_PROTOTYPES
1660 printf_unfiltered (char *format
, ...)
1662 printf_unfiltered (va_alist
)
1667 #ifdef ANSI_PROTOTYPES
1668 va_start (args
, format
);
1673 format
= va_arg (args
, char *);
1675 vfprintf_unfiltered (gdb_stdout
, format
, args
);
1679 /* Like printf_filtered, but prints it's result indented.
1680 Called as printfi_filtered (spaces, format, ...); */
1684 #ifdef ANSI_PROTOTYPES
1685 printfi_filtered (int spaces
, char *format
, ...)
1687 printfi_filtered (va_alist
)
1692 #ifdef ANSI_PROTOTYPES
1693 va_start (args
, format
);
1699 spaces
= va_arg (args
, int);
1700 format
= va_arg (args
, char *);
1702 print_spaces_filtered (spaces
, gdb_stdout
);
1703 vfprintf_filtered (gdb_stdout
, format
, args
);
1707 /* Easy -- but watch out!
1709 This routine is *not* a replacement for puts()! puts() appends a newline.
1710 This one doesn't, and had better not! */
1713 puts_filtered (string
)
1716 fputs_filtered (string
, gdb_stdout
);
1720 puts_unfiltered (string
)
1723 fputs_unfiltered (string
, gdb_stdout
);
1726 /* Return a pointer to N spaces and a null. The pointer is good
1727 until the next call to here. */
1733 static char *spaces
;
1734 static int max_spaces
;
1740 spaces
= (char *) xmalloc (n
+1);
1741 for (t
= spaces
+n
; t
!= spaces
;)
1747 return spaces
+ max_spaces
- n
;
1750 /* Print N spaces. */
1752 print_spaces_filtered (n
, stream
)
1756 fputs_filtered (n_spaces (n
), stream
);
1759 /* C++ demangler stuff. */
1761 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
1762 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
1763 If the name is not mangled, or the language for the name is unknown, or
1764 demangling is off, the name is printed in its "raw" form. */
1767 fprintf_symbol_filtered (stream
, name
, lang
, arg_mode
)
1777 /* If user wants to see raw output, no problem. */
1780 fputs_filtered (name
, stream
);
1786 case language_cplus
:
1787 demangled
= cplus_demangle (name
, arg_mode
);
1789 case language_chill
:
1790 demangled
= chill_demangle (name
);
1796 fputs_filtered (demangled
? demangled
: name
, stream
);
1797 if (demangled
!= NULL
)
1805 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
1806 differences in whitespace. Returns 0 if they match, non-zero if they
1807 don't (slightly different than strcmp()'s range of return values).
1809 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
1810 This "feature" is useful when searching for matching C++ function names
1811 (such as if the user types 'break FOO', where FOO is a mangled C++
1815 strcmp_iw (string1
, string2
)
1816 const char *string1
;
1817 const char *string2
;
1819 while ((*string1
!= '\0') && (*string2
!= '\0'))
1821 while (isspace (*string1
))
1825 while (isspace (*string2
))
1829 if (*string1
!= *string2
)
1833 if (*string1
!= '\0')
1839 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
1846 struct cmd_list_element
*c
;
1848 c
= add_set_cmd ("width", class_support
, var_uinteger
,
1849 (char *)&chars_per_line
,
1850 "Set number of characters gdb thinks are in a line.",
1852 add_show_from_set (c
, &showlist
);
1853 c
->function
.sfunc
= set_width_command
;
1856 (add_set_cmd ("height", class_support
,
1857 var_uinteger
, (char *)&lines_per_page
,
1858 "Set number of lines gdb thinks are in a page.", &setlist
),
1861 /* These defaults will be used if we are unable to get the correct
1862 values from termcap. */
1863 #if defined(__GO32__) || defined(WIN32)
1864 lines_per_page
= ScreenRows();
1865 chars_per_line
= ScreenCols();
1867 lines_per_page
= 24;
1868 chars_per_line
= 80;
1871 /* No termcap under MPW, although might be cool to do something
1872 by looking at worksheet or console window sizes. */
1873 /* Initialize the screen height and width from termcap. */
1875 char *termtype
= getenv ("TERM");
1877 /* Positive means success, nonpositive means failure. */
1880 /* 2048 is large enough for all known terminals, according to the
1881 GNU termcap manual. */
1882 char term_buffer
[2048];
1886 status
= tgetent (term_buffer
, termtype
);
1891 val
= tgetnum ("li");
1893 lines_per_page
= val
;
1895 /* The number of lines per page is not mentioned
1896 in the terminal description. This probably means
1897 that paging is not useful (e.g. emacs shell window),
1898 so disable paging. */
1899 lines_per_page
= UINT_MAX
;
1901 val
= tgetnum ("co");
1903 chars_per_line
= val
;
1909 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1911 /* If there is a better way to determine the window size, use it. */
1912 SIGWINCH_HANDLER ();
1915 /* If the output is not a terminal, don't paginate it. */
1916 if (!ISATTY (gdb_stdout
))
1917 lines_per_page
= UINT_MAX
;
1919 set_width_command ((char *)NULL
, 0, c
);
1922 (add_set_cmd ("demangle", class_support
, var_boolean
,
1924 "Set demangling of encoded C++ names when displaying symbols.",
1929 (add_set_cmd ("sevenbit-strings", class_support
, var_boolean
,
1930 (char *)&sevenbit_strings
,
1931 "Set printing of 8-bit characters in strings as \\nnn.",
1936 (add_set_cmd ("asm-demangle", class_support
, var_boolean
,
1937 (char *)&asm_demangle
,
1938 "Set demangling of C++ names in disassembly listings.",
1943 /* Machine specific function to handle SIGWINCH signal. */
1945 #ifdef SIGWINCH_HANDLER_BODY
1946 SIGWINCH_HANDLER_BODY