1 /* General utility routines for GDB, the GNU debugger.
2 Copyright 1986, 1989, 1990, 1991, 1992 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__)
22 #include <sys/ioctl.h>
23 #include <sys/param.h>
33 #include "terminal.h" /* For job_control */
37 #include "expression.h"
42 /* readline defines this. */
45 /* Prototypes for local functions */
47 #if defined (NO_MMALLOC) || defined (NO_MMALLOC_CHECK)
51 malloc_botch
PARAMS ((void));
53 #endif /* NO_MMALLOC, etc */
56 fatal_dump_core (); /* Can't prototype with <varargs.h> usage... */
59 prompt_for_continue
PARAMS ((void));
62 set_width_command
PARAMS ((char *, int, struct cmd_list_element
*));
64 /* If this definition isn't overridden by the header files, assume
65 that isatty and fileno exist on this system. */
67 #define ISATTY(FP) (isatty (fileno (FP)))
70 /* Chain of cleanup actions established with make_cleanup,
71 to be executed if an error happens. */
73 static struct cleanup
*cleanup_chain
;
75 /* Nonzero means a quit has been requested. */
79 /* Nonzero means quit immediately if Control-C is typed now, rather
80 than waiting until QUIT is executed. Be careful in setting this;
81 code which executes with immediate_quit set has to be very careful
82 about being able to deal with being interrupted at any time. It is
83 almost always better to use QUIT; the only exception I can think of
84 is being able to quit out of a system call (using EINTR loses if
85 the SIGINT happens between the previous QUIT and the system call).
86 To immediately quit in the case in which a SIGINT happens between
87 the previous QUIT and setting immediate_quit (desirable anytime we
88 expect to block), call QUIT after setting immediate_quit. */
92 /* Nonzero means that encoded C++ names should be printed out in their
93 C++ form rather than raw. */
97 /* Nonzero means that encoded C++ names should be printed out in their
98 C++ form even in assembler language displays. If this is set, but
99 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
101 int asm_demangle
= 0;
103 /* Nonzero means that strings with character values >0x7F should be printed
104 as octal escapes. Zero means just print the value (e.g. it's an
105 international character, and the terminal or window can cope.) */
107 int sevenbit_strings
= 0;
109 /* String to be printed before error messages, if any. */
111 char *error_pre_print
;
112 char *warning_pre_print
= "\nwarning: ";
114 /* Add a new cleanup to the cleanup_chain,
115 and return the previous chain pointer
116 to be passed later to do_cleanups or discard_cleanups.
117 Args are FUNCTION to clean up with, and ARG to pass to it. */
120 make_cleanup (function
, arg
)
121 void (*function
) PARAMS ((PTR
));
124 register struct cleanup
*new
125 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
126 register struct cleanup
*old_chain
= cleanup_chain
;
128 new->next
= cleanup_chain
;
129 new->function
= function
;
136 /* Discard cleanups and do the actions they describe
137 until we get back to the point OLD_CHAIN in the cleanup_chain. */
140 do_cleanups (old_chain
)
141 register struct cleanup
*old_chain
;
143 register struct cleanup
*ptr
;
144 while ((ptr
= cleanup_chain
) != old_chain
)
146 cleanup_chain
= ptr
->next
; /* Do this first incase recursion */
147 (*ptr
->function
) (ptr
->arg
);
152 /* Discard cleanups, not doing the actions they describe,
153 until we get back to the point OLD_CHAIN in the cleanup_chain. */
156 discard_cleanups (old_chain
)
157 register struct cleanup
*old_chain
;
159 register struct cleanup
*ptr
;
160 while ((ptr
= cleanup_chain
) != old_chain
)
162 cleanup_chain
= ptr
->next
;
167 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
171 struct cleanup
*old_chain
= cleanup_chain
;
177 /* Restore the cleanup chain from a previously saved chain. */
179 restore_cleanups (chain
)
180 struct cleanup
*chain
;
182 cleanup_chain
= chain
;
185 /* This function is useful for cleanups.
189 old_chain = make_cleanup (free_current_contents, &foo);
191 to arrange to free the object thus allocated. */
194 free_current_contents (location
)
200 /* Provide a known function that does nothing, to use as a base for
201 for a possibly long chain of cleanups. This is useful where we
202 use the cleanup chain for handling normal cleanups as well as dealing
203 with cleanups that need to be done as a result of a call to error().
204 In such cases, we may not be certain where the first cleanup is, unless
205 we have a do-nothing one to always use as the base. */
215 /* Provide a hook for modules wishing to print their own warning messages
216 to set up the terminal state in a compatible way, without them having
217 to import all the target_<...> macros. */
222 target_terminal_ours ();
223 wrap_here(""); /* Force out any buffered output */
224 gdb_flush (gdb_stdout
);
227 /* Print a warning message.
228 The first argument STRING is the warning message, used as a fprintf string,
229 and the remaining args are passed as arguments to it.
230 The primary difference between warnings and errors is that a warning
231 does not force the return to command level. */
242 target_terminal_ours ();
243 wrap_here(""); /* Force out any buffered output */
244 gdb_flush (gdb_stdout
);
245 if (warning_pre_print
)
246 fprintf_unfiltered (gdb_stderr
, warning_pre_print
);
247 string
= va_arg (args
, char *);
248 vfprintf_unfiltered (gdb_stderr
, string
, args
);
249 fprintf_unfiltered (gdb_stderr
, "\n");
253 /* Start the printing of an error message. Way to use this is to call
254 this, output the error message, and then call
255 return_to_top_level (RETURN_ERROR). error() provides a convenient way to
256 do this for the special case that the error message can be formatted with
257 a single printf call, but this is more general. */
261 target_terminal_ours ();
262 wrap_here (""); /* Force out any buffered output */
263 gdb_flush (gdb_stdout
);
265 if (annotation_level
> 1)
266 fprintf_filtered (gdb_stderr
, "\n\032\032error-begin\n");
269 fprintf_filtered (gdb_stderr
, error_pre_print
);
272 /* Print an error message and return to command level.
273 The first argument STRING is the error message, used as a fprintf string,
274 and the remaining args are passed as arguments to it. */
286 string
= va_arg (args
, char *);
287 vfprintf_filtered (gdb_stderr
, string
, args
);
288 fprintf_filtered (gdb_stderr
, "\n");
290 return_to_top_level (RETURN_ERROR
);
293 /* Print an error message and exit reporting failure.
294 This is for a error that we cannot continue from.
295 The arguments are printed a la printf.
297 This function cannot be declared volatile (NORETURN) in an
298 ANSI environment because exit() is not declared volatile. */
309 string
= va_arg (args
, char *);
310 fprintf_unfiltered (gdb_stderr
, "\ngdb: ");
311 vfprintf_unfiltered (gdb_stderr
, string
, args
);
312 fprintf_unfiltered (gdb_stderr
, "\n");
317 /* Print an error message and exit, dumping core.
318 The arguments are printed a la printf (). */
322 fatal_dump_core (va_alist
)
329 string
= va_arg (args
, char *);
330 /* "internal error" is always correct, since GDB should never dump
331 core, no matter what the input. */
332 fprintf_unfiltered (gdb_stderr
, "\ngdb internal error: ");
333 vfprintf_unfiltered (gdb_stderr
, string
, args
);
334 fprintf_unfiltered (gdb_stderr
, "\n");
337 signal (SIGQUIT
, SIG_DFL
);
338 kill (getpid (), SIGQUIT
);
339 /* We should never get here, but just in case... */
343 /* The strerror() function can return NULL for errno values that are
344 out of range. Provide a "safe" version that always returns a
348 safe_strerror (errnum
)
354 if ((msg
= strerror (errnum
)) == NULL
)
356 sprintf (buf
, "(undocumented errno %d)", errnum
);
362 /* The strsignal() function can return NULL for signal values that are
363 out of range. Provide a "safe" version that always returns a
367 safe_strsignal (signo
)
373 if ((msg
= strsignal (signo
)) == NULL
)
375 sprintf (buf
, "(undocumented signal %d)", signo
);
382 /* Print the system error message for errno, and also mention STRING
383 as the file name for which the error was encountered.
384 Then return to command level. */
387 perror_with_name (string
)
393 err
= safe_strerror (errno
);
394 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
395 strcpy (combined
, string
);
396 strcat (combined
, ": ");
397 strcat (combined
, err
);
399 /* I understand setting these is a matter of taste. Still, some people
400 may clear errno but not know about bfd_error. Doing this here is not
402 bfd_set_error (bfd_error_no_error
);
405 error ("%s.", combined
);
408 /* Print the system error message for ERRCODE, and also mention STRING
409 as the file name for which the error was encountered. */
412 print_sys_errmsg (string
, errcode
)
419 err
= safe_strerror (errcode
);
420 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
421 strcpy (combined
, string
);
422 strcat (combined
, ": ");
423 strcat (combined
, err
);
425 /* We want anything which was printed on stdout to come out first, before
427 gdb_flush (gdb_stdout
);
428 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
431 /* Control C eventually causes this to be called, at a convenient time. */
436 serial_t gdb_stdout_serial
= serial_fdopen (1);
438 target_terminal_ours ();
440 /* We want all output to appear now, before we print "Quit". We
441 have 3 levels of buffering we have to flush (it's possible that
442 some of these should be changed to flush the lower-level ones
445 /* 1. The _filtered buffer. */
446 wrap_here ((char *)0);
448 /* 2. The stdio buffer. */
449 gdb_flush (gdb_stdout
);
450 gdb_flush (gdb_stderr
);
452 /* 3. The system-level buffer. */
453 SERIAL_FLUSH_OUTPUT (gdb_stdout_serial
);
454 SERIAL_UN_FDOPEN (gdb_stdout_serial
);
456 if (annotation_level
> 1)
457 fprintf_filtered (gdb_stderr
, "\n\032\032error-begin\n");
459 /* Don't use *_filtered; we don't want to prompt the user to continue. */
461 fprintf_unfiltered (gdb_stderr
, error_pre_print
);
464 /* If there is no terminal switching for this target, then we can't
465 possibly get screwed by the lack of job control. */
466 || current_target
->to_terminal_ours
== NULL
)
467 fprintf_unfiltered (gdb_stderr
, "Quit\n");
469 fprintf_unfiltered (gdb_stderr
,
470 "Quit (expect signal SIGINT when the program is resumed)\n");
471 return_to_top_level (RETURN_QUIT
);
477 /* In the absence of signals, poll keyboard for a quit.
478 Called from #define QUIT pollquit() in xm-go32.h. */
496 /* We just ignore it */
497 fprintf_unfiltered (gdb_stderr
, "CTRL-A to quit, CTRL-B to quit harder\n");
519 fprintf_unfiltered (gdb_stderr
, "CTRL-A to quit, CTRL-B to quit harder\n");
526 /* Done by signals */
529 /* Control C comes here */
537 /* Restore the signal handler. Harmless with BSD-style signals, needed
538 for System V-style signals. So just always do it, rather than worrying
539 about USG defines and stuff like that. */
540 signal (signo
, request_quit
);
547 /* Memory management stuff (malloc friends). */
549 #if defined (NO_MMALLOC)
556 return (malloc (size
));
560 mrealloc (md
, ptr
, size
)
565 if (ptr
== 0) /* Guard against old realloc's */
566 return malloc (size
);
568 return realloc (ptr
, size
);
579 #endif /* NO_MMALLOC */
581 #if defined (NO_MMALLOC) || defined (NO_MMALLOC_CHECK)
589 #else /* have mmalloc and want corruption checking */
594 fatal_dump_core ("Memory corruption");
597 /* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified
598 by MD, to detect memory corruption. Note that MD may be NULL to specify
599 the default heap that grows via sbrk.
601 Note that for freshly created regions, we must call mmcheck prior to any
602 mallocs in the region. Otherwise, any region which was allocated prior to
603 installing the checking hooks, which is later reallocated or freed, will
604 fail the checks! The mmcheck function only allows initial hooks to be
605 installed before the first mmalloc. However, anytime after we have called
606 mmcheck the first time to install the checking hooks, we can call it again
607 to update the function pointer to the memory corruption handler.
609 Returns zero on failure, non-zero on success. */
615 if (!mmcheck (md
, malloc_botch
))
617 warning ("internal error: failed to install memory consistency checks");
623 #endif /* Have mmalloc and want corruption checking */
625 /* Called when a memory allocation fails, with the number of bytes of
626 memory requested in SIZE. */
634 fatal ("virtual memory exhausted: can't allocate %ld bytes.", size
);
638 fatal ("virtual memory exhausted.");
642 /* Like mmalloc but get error if no storage available, and protect against
643 the caller wanting to allocate zero bytes. Whether to return NULL for
644 a zero byte request, or translate the request into a request for one
645 byte of zero'd storage, is a religious issue. */
658 else if ((val
= mmalloc (md
, size
)) == NULL
)
665 /* Like mrealloc but get error if no storage available. */
668 xmrealloc (md
, ptr
, size
)
677 val
= mrealloc (md
, ptr
, size
);
681 val
= mmalloc (md
, size
);
690 /* Like malloc but get error if no storage available, and protect against
691 the caller wanting to allocate zero bytes. */
697 return (xmmalloc ((PTR
) NULL
, size
));
700 /* Like mrealloc but get error if no storage available. */
707 return (xmrealloc ((PTR
) NULL
, ptr
, size
));
711 /* My replacement for the read system call.
712 Used like `read' but keeps going if `read' returns too soon. */
715 myread (desc
, addr
, len
)
725 val
= read (desc
, addr
, len
);
736 /* Make a copy of the string at PTR with SIZE characters
737 (and add a null character at the end in the copy).
738 Uses malloc to get the space. Returns the address of the copy. */
741 savestring (ptr
, size
)
745 register char *p
= (char *) xmalloc (size
+ 1);
746 memcpy (p
, ptr
, size
);
752 msavestring (md
, ptr
, size
)
757 register char *p
= (char *) xmmalloc (md
, size
+ 1);
758 memcpy (p
, ptr
, size
);
763 /* The "const" is so it compiles under DGUX (which prototypes strsave
764 in <string.h>. FIXME: This should be named "xstrsave", shouldn't it?
765 Doesn't real strsave return NULL if out of memory? */
770 return savestring (ptr
, strlen (ptr
));
778 return (msavestring (md
, ptr
, strlen (ptr
)));
782 print_spaces (n
, file
)
790 /* Print a host address. */
793 gdb_print_address (addr
, stream
)
798 /* We could use the %p conversion specifier to fprintf if we had any
799 way of knowing whether this host supports it. But the following
800 should work on the Alpha and on 32 bit machines. */
802 fprintf_filtered (stream
, "0x%lx", (unsigned long)addr
);
805 /* Ask user a y-or-n question and return 1 iff answer is yes.
806 Takes three args which are given to printf to print the question.
807 The first, a control string, should end in "? ".
808 It should not say how to answer, because we do that. */
821 /* Automatically answer "yes" if input is not from a terminal. */
822 if (!input_from_terminal_p ())
827 wrap_here (""); /* Flush any buffered output */
828 gdb_flush (gdb_stdout
);
830 if (annotation_level
> 1)
831 printf_filtered ("\n\032\032pre-query\n");
834 ctlstr
= va_arg (args
, char *);
835 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
837 printf_filtered ("(y or n) ");
839 if (annotation_level
> 1)
840 printf_filtered ("\n\032\032query\n");
842 gdb_flush (gdb_stdout
);
843 answer
= fgetc (stdin
);
844 clearerr (stdin
); /* in case of C-d */
845 if (answer
== EOF
) /* C-d */
850 if (answer
!= '\n') /* Eat rest of input line, to EOF or newline */
853 ans2
= fgetc (stdin
);
856 while (ans2
!= EOF
&& ans2
!= '\n');
869 printf_filtered ("Please answer y or n.\n");
872 if (annotation_level
> 1)
873 printf_filtered ("\n\032\032post-query\n");
878 /* Parse a C escape sequence. STRING_PTR points to a variable
879 containing a pointer to the string to parse. That pointer
880 should point to the character after the \. That pointer
881 is updated past the characters we use. The value of the
882 escape sequence is returned.
884 A negative value means the sequence \ newline was seen,
885 which is supposed to be equivalent to nothing at all.
887 If \ is followed by a null character, we return a negative
888 value and leave the string pointer pointing at the null character.
890 If \ is followed by 000, we return 0 and leave the string pointer
891 after the zeros. A value of 0 does not mean end of string. */
894 parse_escape (string_ptr
)
897 register int c
= *(*string_ptr
)++;
901 return 007; /* Bell (alert) char */
904 case 'e': /* Escape character */
922 c
= *(*string_ptr
)++;
924 c
= parse_escape (string_ptr
);
927 return (c
& 0200) | (c
& 037);
938 register int i
= c
- '0';
939 register int count
= 0;
942 if ((c
= *(*string_ptr
)++) >= '0' && c
<= '7')
960 /* Print the character C on STREAM as part of the contents of a literal
961 string whose delimiter is QUOTER. Note that this routine should only
962 be call for printing things which are independent of the language
963 of the program being debugged. */
966 gdb_printchar (c
, stream
, quoter
)
972 c
&= 0xFF; /* Avoid sign bit follies */
974 if ( c
< 0x20 || /* Low control chars */
975 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
976 (sevenbit_strings
&& c
>= 0x80)) { /* high order bit set */
980 fputs_filtered ("\\n", stream
);
983 fputs_filtered ("\\b", stream
);
986 fputs_filtered ("\\t", stream
);
989 fputs_filtered ("\\f", stream
);
992 fputs_filtered ("\\r", stream
);
995 fputs_filtered ("\\e", stream
);
998 fputs_filtered ("\\a", stream
);
1001 fprintf_filtered (stream
, "\\%.3o", (unsigned int) c
);
1005 if (c
== '\\' || c
== quoter
)
1006 fputs_filtered ("\\", stream
);
1007 fprintf_filtered (stream
, "%c", c
);
1011 /* Number of lines per page or UINT_MAX if paging is disabled. */
1012 static unsigned int lines_per_page
;
1013 /* Number of chars per line or UNIT_MAX is line folding is disabled. */
1014 static unsigned int chars_per_line
;
1015 /* Current count of lines printed on this page, chars on this line. */
1016 static unsigned int lines_printed
, chars_printed
;
1018 /* Buffer and start column of buffered text, for doing smarter word-
1019 wrapping. When someone calls wrap_here(), we start buffering output
1020 that comes through fputs_filtered(). If we see a newline, we just
1021 spit it out and forget about the wrap_here(). If we see another
1022 wrap_here(), we spit it out and remember the newer one. If we see
1023 the end of the line, we spit out a newline, the indent, and then
1024 the buffered output. */
1026 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1027 are waiting to be output (they have already been counted in chars_printed).
1028 When wrap_buffer[0] is null, the buffer is empty. */
1029 static char *wrap_buffer
;
1031 /* Pointer in wrap_buffer to the next character to fill. */
1032 static char *wrap_pointer
;
1034 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1036 static char *wrap_indent
;
1038 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1039 is not in effect. */
1040 static int wrap_column
;
1044 set_width_command (args
, from_tty
, c
)
1047 struct cmd_list_element
*c
;
1051 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1052 wrap_buffer
[0] = '\0';
1055 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1056 wrap_pointer
= wrap_buffer
; /* Start it at the beginning */
1059 /* Wait, so the user can read what's on the screen. Prompt the user
1060 to continue by pressing RETURN. */
1063 prompt_for_continue ()
1066 char cont_prompt
[120];
1068 if (annotation_level
> 1)
1069 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1071 strcpy (cont_prompt
,
1072 "---Type <return> to continue, or q <return> to quit---");
1073 if (annotation_level
> 1)
1074 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1076 /* We must do this *before* we call gdb_readline, else it will eventually
1077 call us -- thinking that we're trying to print beyond the end of the
1079 reinitialize_more_filter ();
1082 /* On a real operating system, the user can quit with SIGINT.
1085 'q' is provided on all systems so users don't have to change habits
1086 from system to system, and because telling them what to do in
1087 the prompt is more user-friendly than expecting them to think of
1089 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1090 whereas control-C to gdb_readline will cause the user to get dumped
1092 ignore
= readline (cont_prompt
);
1094 if (annotation_level
> 1)
1095 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1100 while (*p
== ' ' || *p
== '\t')
1103 request_quit (SIGINT
);
1108 /* Now we have to do this again, so that GDB will know that it doesn't
1109 need to save the ---Type <return>--- line at the top of the screen. */
1110 reinitialize_more_filter ();
1112 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1115 /* Reinitialize filter; ie. tell it to reset to original values. */
1118 reinitialize_more_filter ()
1124 /* Indicate that if the next sequence of characters overflows the line,
1125 a newline should be inserted here rather than when it hits the end.
1126 If INDENT is non-null, it is a string to be printed to indent the
1127 wrapped part on the next line. INDENT must remain accessible until
1128 the next call to wrap_here() or until a newline is printed through
1131 If the line is already overfull, we immediately print a newline and
1132 the indentation, and disable further wrapping.
1134 If we don't know the width of lines, but we know the page height,
1135 we must not wrap words, but should still keep track of newlines
1136 that were explicitly printed.
1138 INDENT should not contain tabs, as that will mess up the char count
1139 on the next line. FIXME.
1141 This routine is guaranteed to force out any output which has been
1142 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1143 used to force out output from the wrap_buffer. */
1151 *wrap_pointer
= '\0';
1152 fputs (wrap_buffer
, gdb_stdout
);
1154 wrap_pointer
= wrap_buffer
;
1155 wrap_buffer
[0] = '\0';
1156 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1160 else if (chars_printed
>= chars_per_line
)
1162 puts_filtered ("\n");
1164 puts_filtered (indent
);
1169 wrap_column
= chars_printed
;
1173 wrap_indent
= indent
;
1177 /* Ensure that whatever gets printed next, using the filtered output
1178 commands, starts at the beginning of the line. I.E. if there is
1179 any pending output for the current line, flush it and start a new
1180 line. Otherwise do nothing. */
1185 if (chars_printed
> 0)
1187 puts_filtered ("\n");
1193 gdb_fopen (name
, mode
)
1197 return fopen (name
, mode
);
1207 /* Like fputs but if FILTER is true, pause after every screenful.
1209 Regardless of FILTER can wrap at points other than the final
1210 character of a line.
1212 Unlike fputs, fputs_maybe_filtered does not return a value.
1213 It is OK for LINEBUFFER to be NULL, in which case just don't print
1216 Note that a longjmp to top level may occur in this routine (only if
1217 FILTER is true) (since prompt_for_continue may do so) so this
1218 routine should not be called when cleanups are not in place. */
1221 fputs_maybe_filtered (linebuffer
, stream
, filter
)
1222 const char *linebuffer
;
1226 const char *lineptr
;
1228 if (linebuffer
== 0)
1231 /* Don't do any filtering if it is disabled. */
1232 if (stream
!= gdb_stdout
1233 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
1235 fputs (linebuffer
, stream
);
1239 /* Go through and output each character. Show line extension
1240 when this is necessary; prompt user for new page when this is
1243 lineptr
= linebuffer
;
1246 /* Possible new page. */
1248 (lines_printed
>= lines_per_page
- 1))
1249 prompt_for_continue ();
1251 while (*lineptr
&& *lineptr
!= '\n')
1253 /* Print a single line. */
1254 if (*lineptr
== '\t')
1257 *wrap_pointer
++ = '\t';
1259 putc ('\t', stream
);
1260 /* Shifting right by 3 produces the number of tab stops
1261 we have already passed, and then adding one and
1262 shifting left 3 advances to the next tab stop. */
1263 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1269 *wrap_pointer
++ = *lineptr
;
1271 putc (*lineptr
, stream
);
1276 if (chars_printed
>= chars_per_line
)
1278 unsigned int save_chars
= chars_printed
;
1282 /* If we aren't actually wrapping, don't output newline --
1283 if chars_per_line is right, we probably just overflowed
1284 anyway; if it's wrong, let us keep going. */
1286 putc ('\n', stream
);
1288 /* Possible new page. */
1289 if (lines_printed
>= lines_per_page
- 1)
1290 prompt_for_continue ();
1292 /* Now output indentation and wrapped string */
1295 fputs (wrap_indent
, stream
);
1296 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
1297 fputs (wrap_buffer
, stream
); /* and eject it */
1298 /* FIXME, this strlen is what prevents wrap_indent from
1299 containing tabs. However, if we recurse to print it
1300 and count its chars, we risk trouble if wrap_indent is
1301 longer than (the user settable) chars_per_line.
1302 Note also that this can set chars_printed > chars_per_line
1303 if we are printing a long string. */
1304 chars_printed
= strlen (wrap_indent
)
1305 + (save_chars
- wrap_column
);
1306 wrap_pointer
= wrap_buffer
; /* Reset buffer */
1307 wrap_buffer
[0] = '\0';
1308 wrap_column
= 0; /* And disable fancy wrap */
1313 if (*lineptr
== '\n')
1316 wrap_here ((char *)0); /* Spit out chars, cancel further wraps */
1318 putc ('\n', stream
);
1325 fputs_filtered (linebuffer
, stream
)
1326 const char *linebuffer
;
1329 fputs_maybe_filtered (linebuffer
, stream
, 1);
1333 fputs_unfiltered (linebuffer
, stream
)
1334 const char *linebuffer
;
1339 /* This gets the wrap_buffer buffering wrong when called from
1340 gdb_readline (GDB was sometimes failing to print the prompt
1341 before reading input). Even at other times, it seems kind of
1342 misguided, especially now that printf_unfiltered doesn't use
1343 printf_maybe_filtered. */
1345 fputs_maybe_filtered (linebuffer
, stream
, 0);
1347 fputs (linebuffer
, stream
);
1358 fputs_unfiltered (buf
, gdb_stdout
);
1362 fputc_unfiltered (c
, stream
)
1369 fputs_unfiltered (buf
, stream
);
1373 /* Print a variable number of ARGS using format FORMAT. If this
1374 information is going to put the amount written (since the last call
1375 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
1376 print out a pause message and do a gdb_readline to get the users
1377 permision to continue.
1379 Unlike fprintf, this function does not return a value.
1381 We implement three variants, vfprintf (takes a vararg list and stream),
1382 fprintf (takes a stream to write on), and printf (the usual).
1384 Note that this routine has a restriction that the length of the
1385 final output line must be less than 255 characters *or* it must be
1386 less than twice the size of the format string. This is a very
1387 arbitrary restriction, but it is an internal restriction, so I'll
1388 put it in. This means that the %s format specifier is almost
1389 useless; unless the caller can GUARANTEE that the string is short
1390 enough, fputs_filtered should be used instead.
1392 Note also that a longjmp to top level may occur in this routine
1393 (since prompt_for_continue may do so) so this routine should not be
1394 called when cleanups are not in place. */
1396 #define MIN_LINEBUF 255
1399 vfprintf_maybe_filtered (stream
, format
, args
, filter
)
1405 char line_buf
[MIN_LINEBUF
+10];
1406 char *linebuffer
= line_buf
;
1409 format_length
= strlen (format
);
1411 /* Reallocate buffer to a larger size if this is necessary. */
1412 if (format_length
* 2 > MIN_LINEBUF
)
1414 linebuffer
= alloca (10 + format_length
* 2);
1417 /* This won't blow up if the restrictions described above are
1419 vsprintf (linebuffer
, format
, args
);
1421 fputs_maybe_filtered (linebuffer
, stream
, filter
);
1426 vfprintf_filtered (stream
, format
, args
)
1431 vfprintf_maybe_filtered (stream
, format
, args
, 1);
1435 vfprintf_unfiltered (stream
, format
, args
)
1440 vfprintf (stream
, format
, args
);
1444 vprintf_filtered (format
, args
)
1448 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
1452 vprintf_unfiltered (format
, args
)
1456 vfprintf (gdb_stdout
, format
, args
);
1461 fprintf_filtered (va_alist
)
1469 stream
= va_arg (args
, FILE *);
1470 format
= va_arg (args
, char *);
1472 /* This won't blow up if the restrictions described above are
1474 vfprintf_filtered (stream
, format
, args
);
1480 fprintf_unfiltered (va_alist
)
1488 stream
= va_arg (args
, FILE *);
1489 format
= va_arg (args
, char *);
1491 /* This won't blow up if the restrictions described above are
1493 vfprintf_unfiltered (stream
, format
, args
);
1497 /* Like fprintf_filtered, but prints it's result indent.
1498 Called as fprintfi_filtered (spaces, stream, format, ...); */
1502 fprintfi_filtered (va_alist
)
1511 spaces
= va_arg (args
, int);
1512 stream
= va_arg (args
, FILE *);
1513 format
= va_arg (args
, char *);
1514 print_spaces_filtered (spaces
, stream
);
1516 /* This won't blow up if the restrictions described above are
1518 vfprintf_filtered (stream
, format
, args
);
1525 printf_filtered (va_alist
)
1532 format
= va_arg (args
, char *);
1534 vfprintf_filtered (gdb_stdout
, format
, args
);
1541 printf_unfiltered (va_alist
)
1548 format
= va_arg (args
, char *);
1550 vfprintf_unfiltered (gdb_stdout
, format
, args
);
1554 /* Like printf_filtered, but prints it's result indented.
1555 Called as printfi_filtered (spaces, format, ...); */
1559 printfi_filtered (va_alist
)
1567 spaces
= va_arg (args
, int);
1568 format
= va_arg (args
, char *);
1569 print_spaces_filtered (spaces
, gdb_stdout
);
1570 vfprintf_filtered (gdb_stdout
, format
, args
);
1574 /* Easy -- but watch out!
1576 This routine is *not* a replacement for puts()! puts() appends a newline.
1577 This one doesn't, and had better not! */
1580 puts_filtered (string
)
1583 fputs_filtered (string
, gdb_stdout
);
1587 puts_unfiltered (string
)
1590 fputs_unfiltered (string
, gdb_stdout
);
1593 /* Return a pointer to N spaces and a null. The pointer is good
1594 until the next call to here. */
1600 static char *spaces
;
1601 static int max_spaces
;
1607 spaces
= (char *) xmalloc (n
+1);
1608 for (t
= spaces
+n
; t
!= spaces
;)
1614 return spaces
+ max_spaces
- n
;
1617 /* Print N spaces. */
1619 print_spaces_filtered (n
, stream
)
1623 fputs_filtered (n_spaces (n
), stream
);
1626 /* C++ demangler stuff. */
1628 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
1629 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
1630 If the name is not mangled, or the language for the name is unknown, or
1631 demangling is off, the name is printed in its "raw" form. */
1634 fprintf_symbol_filtered (stream
, name
, lang
, arg_mode
)
1644 /* If user wants to see raw output, no problem. */
1647 fputs_filtered (name
, stream
);
1653 case language_cplus
:
1654 demangled
= cplus_demangle (name
, arg_mode
);
1656 case language_chill
:
1657 demangled
= chill_demangle (name
);
1663 fputs_filtered (demangled
? demangled
: name
, stream
);
1664 if (demangled
!= NULL
)
1672 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
1673 differences in whitespace. Returns 0 if they match, non-zero if they
1674 don't (slightly different than strcmp()'s range of return values).
1676 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
1677 This "feature" is useful when searching for matching C++ function names
1678 (such as if the user types 'break FOO', where FOO is a mangled C++
1682 strcmp_iw (string1
, string2
)
1683 const char *string1
;
1684 const char *string2
;
1686 while ((*string1
!= '\0') && (*string2
!= '\0'))
1688 while (isspace (*string1
))
1692 while (isspace (*string2
))
1696 if (*string1
!= *string2
)
1700 if (*string1
!= '\0')
1706 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
1711 _initialize_utils ()
1713 struct cmd_list_element
*c
;
1715 c
= add_set_cmd ("width", class_support
, var_uinteger
,
1716 (char *)&chars_per_line
,
1717 "Set number of characters gdb thinks are in a line.",
1719 add_show_from_set (c
, &showlist
);
1720 c
->function
.sfunc
= set_width_command
;
1723 (add_set_cmd ("height", class_support
,
1724 var_uinteger
, (char *)&lines_per_page
,
1725 "Set number of lines gdb thinks are in a page.", &setlist
),
1728 /* These defaults will be used if we are unable to get the correct
1729 values from termcap. */
1730 #if defined(__GO32__)
1731 lines_per_page
= ScreenRows();
1732 chars_per_line
= ScreenCols();
1734 lines_per_page
= 24;
1735 chars_per_line
= 80;
1736 /* Initialize the screen height and width from termcap. */
1738 char *termtype
= getenv ("TERM");
1740 /* Positive means success, nonpositive means failure. */
1743 /* 2048 is large enough for all known terminals, according to the
1744 GNU termcap manual. */
1745 char term_buffer
[2048];
1749 status
= tgetent (term_buffer
, termtype
);
1754 val
= tgetnum ("li");
1756 lines_per_page
= val
;
1758 /* The number of lines per page is not mentioned
1759 in the terminal description. This probably means
1760 that paging is not useful (e.g. emacs shell window),
1761 so disable paging. */
1762 lines_per_page
= UINT_MAX
;
1764 val
= tgetnum ("co");
1766 chars_per_line
= val
;
1771 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1773 /* If there is a better way to determine the window size, use it. */
1774 SIGWINCH_HANDLER ();
1777 /* If the output is not a terminal, don't paginate it. */
1778 if (!ISATTY (gdb_stdout
))
1779 lines_per_page
= UINT_MAX
;
1781 set_width_command ((char *)NULL
, 0, c
);
1784 (add_set_cmd ("demangle", class_support
, var_boolean
,
1786 "Set demangling of encoded C++ names when displaying symbols.",
1791 (add_set_cmd ("sevenbit-strings", class_support
, var_boolean
,
1792 (char *)&sevenbit_strings
,
1793 "Set printing of 8-bit characters in strings as \\nnn.",
1798 (add_set_cmd ("asm-demangle", class_support
, var_boolean
,
1799 (char *)&asm_demangle
,
1800 "Set demangling of C++ names in disassembly listings.",
1805 /* Machine specific function to handle SIGWINCH signal. */
1807 #ifdef SIGWINCH_HANDLER_BODY
1808 SIGWINCH_HANDLER_BODY