1 /* General utility routines for GDB, the GNU debugger.
2 Copyright 1986, 89, 90, 91, 92, 95, 96, 1998 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #include "gdb_string.h"
34 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
45 #include "expression.h"
49 #include <readline/readline.h>
51 /* readline defines this. */
54 /* Prototypes for local functions */
56 static void vfprintf_maybe_filtered
PARAMS ((GDB_FILE
*, const char *,
59 static void fputs_maybe_filtered
PARAMS ((const char *, GDB_FILE
*, int));
61 #if defined (USE_MMALLOC) && !defined (NO_MMCHECK)
62 static void malloc_botch
PARAMS ((void));
66 fatal_dump_core
PARAMS((char *, ...));
69 prompt_for_continue
PARAMS ((void));
72 set_width_command
PARAMS ((char *, int, struct cmd_list_element
*));
75 set_width
PARAMS ((void));
77 /* If this definition isn't overridden by the header files, assume
78 that isatty and fileno exist on this system. */
80 #define ISATTY(FP) (isatty (fileno (FP)))
83 #ifndef GDB_FILE_ISATTY
84 #define GDB_FILE_ISATTY(GDB_FILE_PTR) (gdb_file_isatty(GDB_FILE_PTR))
87 /* Chain of cleanup actions established with make_cleanup,
88 to be executed if an error happens. */
90 static struct cleanup
*cleanup_chain
; /* cleaned up after a failed command */
91 static struct cleanup
*final_cleanup_chain
; /* cleaned up when gdb exits */
92 static struct cleanup
*run_cleanup_chain
; /* cleaned up on each 'run' */
94 /* Nonzero if we have job control. */
98 /* Nonzero means a quit has been requested. */
102 /* Nonzero means quit immediately if Control-C is typed now, rather
103 than waiting until QUIT is executed. Be careful in setting this;
104 code which executes with immediate_quit set has to be very careful
105 about being able to deal with being interrupted at any time. It is
106 almost always better to use QUIT; the only exception I can think of
107 is being able to quit out of a system call (using EINTR loses if
108 the SIGINT happens between the previous QUIT and the system call).
109 To immediately quit in the case in which a SIGINT happens between
110 the previous QUIT and setting immediate_quit (desirable anytime we
111 expect to block), call QUIT after setting immediate_quit. */
115 /* Nonzero means that encoded C++ names should be printed out in their
116 C++ form rather than raw. */
120 /* Nonzero means that encoded C++ names should be printed out in their
121 C++ form even in assembler language displays. If this is set, but
122 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
124 int asm_demangle
= 0;
126 /* Nonzero means that strings with character values >0x7F should be printed
127 as octal escapes. Zero means just print the value (e.g. it's an
128 international character, and the terminal or window can cope.) */
130 int sevenbit_strings
= 0;
132 /* String to be printed before error messages, if any. */
134 char *error_pre_print
;
136 /* String to be printed before quit messages, if any. */
138 char *quit_pre_print
;
140 /* String to be printed before warning messages, if any. */
142 char *warning_pre_print
= "\nwarning: ";
144 int pagination_enabled
= 1;
147 /* Add a new cleanup to the cleanup_chain,
148 and return the previous chain pointer
149 to be passed later to do_cleanups or discard_cleanups.
150 Args are FUNCTION to clean up with, and ARG to pass to it. */
153 make_cleanup (function
, arg
)
154 void (*function
) PARAMS ((PTR
));
157 return make_my_cleanup (&cleanup_chain
, function
, arg
);
161 make_final_cleanup (function
, arg
)
162 void (*function
) PARAMS ((PTR
));
165 return make_my_cleanup (&final_cleanup_chain
, function
, arg
);
168 make_run_cleanup (function
, arg
)
169 void (*function
) PARAMS ((PTR
));
172 return make_my_cleanup (&run_cleanup_chain
, function
, arg
);
175 make_my_cleanup (pmy_chain
, function
, arg
)
176 struct cleanup
**pmy_chain
;
177 void (*function
) PARAMS ((PTR
));
180 register struct cleanup
*new
181 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
182 register struct cleanup
*old_chain
= *pmy_chain
;
184 new->next
= *pmy_chain
;
185 new->function
= function
;
192 /* Discard cleanups and do the actions they describe
193 until we get back to the point OLD_CHAIN in the cleanup_chain. */
196 do_cleanups (old_chain
)
197 register struct cleanup
*old_chain
;
199 do_my_cleanups (&cleanup_chain
, old_chain
);
203 do_final_cleanups (old_chain
)
204 register struct cleanup
*old_chain
;
206 do_my_cleanups (&final_cleanup_chain
, old_chain
);
210 do_run_cleanups (old_chain
)
211 register struct cleanup
*old_chain
;
213 do_my_cleanups (&run_cleanup_chain
, old_chain
);
217 do_my_cleanups (pmy_chain
, old_chain
)
218 register struct cleanup
**pmy_chain
;
219 register struct cleanup
*old_chain
;
221 register struct cleanup
*ptr
;
222 while ((ptr
= *pmy_chain
) != old_chain
)
224 *pmy_chain
= ptr
->next
; /* Do this first incase recursion */
225 (*ptr
->function
) (ptr
->arg
);
230 /* Discard cleanups, not doing the actions they describe,
231 until we get back to the point OLD_CHAIN in the cleanup_chain. */
234 discard_cleanups (old_chain
)
235 register struct cleanup
*old_chain
;
237 discard_my_cleanups (&cleanup_chain
, old_chain
);
241 discard_final_cleanups (old_chain
)
242 register struct cleanup
*old_chain
;
244 discard_my_cleanups (&final_cleanup_chain
, old_chain
);
248 discard_my_cleanups (pmy_chain
, old_chain
)
249 register struct cleanup
**pmy_chain
;
250 register struct cleanup
*old_chain
;
252 register struct cleanup
*ptr
;
253 while ((ptr
= *pmy_chain
) != old_chain
)
255 *pmy_chain
= ptr
->next
;
260 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
264 return save_my_cleanups (&cleanup_chain
);
268 save_final_cleanups ()
270 return save_my_cleanups (&final_cleanup_chain
);
274 save_my_cleanups (pmy_chain
)
275 struct cleanup
**pmy_chain
;
277 struct cleanup
*old_chain
= *pmy_chain
;
283 /* Restore the cleanup chain from a previously saved chain. */
285 restore_cleanups (chain
)
286 struct cleanup
*chain
;
288 restore_my_cleanups (&cleanup_chain
, chain
);
292 restore_final_cleanups (chain
)
293 struct cleanup
*chain
;
295 restore_my_cleanups (&final_cleanup_chain
, chain
);
299 restore_my_cleanups (pmy_chain
, chain
)
300 struct cleanup
**pmy_chain
;
301 struct cleanup
*chain
;
306 /* This function is useful for cleanups.
310 old_chain = make_cleanup (free_current_contents, &foo);
312 to arrange to free the object thus allocated. */
315 free_current_contents (location
)
321 /* Provide a known function that does nothing, to use as a base for
322 for a possibly long chain of cleanups. This is useful where we
323 use the cleanup chain for handling normal cleanups as well as dealing
324 with cleanups that need to be done as a result of a call to error().
325 In such cases, we may not be certain where the first cleanup is, unless
326 we have a do-nothing one to always use as the base. */
336 /* Print a warning message. Way to use this is to call warning_begin,
337 output the warning message (use unfiltered output to gdb_stderr),
338 ending in a newline. There is not currently a warning_end that you
339 call afterwards, but such a thing might be added if it is useful
340 for a GUI to separate warning messages from other output.
342 FIXME: Why do warnings use unfiltered output and errors filtered?
343 Is this anything other than a historical accident? */
348 target_terminal_ours ();
349 wrap_here(""); /* Force out any buffered output */
350 gdb_flush (gdb_stdout
);
351 if (warning_pre_print
)
352 fprintf_unfiltered (gdb_stderr
, warning_pre_print
);
355 /* Print a warning message.
356 The first argument STRING is the warning message, used as a fprintf string,
357 and the remaining args are passed as arguments to it.
358 The primary difference between warnings and errors is that a warning
359 does not force the return to command level. */
363 #ifdef ANSI_PROTOTYPES
364 warning (const char *string
, ...)
371 #ifdef ANSI_PROTOTYPES
372 va_start (args
, string
);
377 string
= va_arg (args
, char *);
380 (*warning_hook
) (string
, args
);
384 vfprintf_unfiltered (gdb_stderr
, string
, args
);
385 fprintf_unfiltered (gdb_stderr
, "\n");
390 /* Start the printing of an error message. Way to use this is to call
391 this, output the error message (use filtered output to gdb_stderr
392 (FIXME: Some callers, like memory_error, use gdb_stdout)), ending
393 in a newline, and then call return_to_top_level (RETURN_ERROR).
394 error() provides a convenient way to do this for the special case
395 that the error message can be formatted with a single printf call,
396 but this is more general. */
400 target_terminal_ours ();
401 wrap_here (""); /* Force out any buffered output */
402 gdb_flush (gdb_stdout
);
404 annotate_error_begin ();
407 fprintf_filtered (gdb_stderr
, error_pre_print
);
410 /* Print an error message and return to command level.
411 The first argument STRING is the error message, used as a fprintf string,
412 and the remaining args are passed as arguments to it. */
416 #ifdef ANSI_PROTOTYPES
417 error (const char *string
, ...)
424 #ifdef ANSI_PROTOTYPES
425 va_start (args
, string
);
434 #ifdef ANSI_PROTOTYPES
435 vfprintf_filtered (gdb_stderr
, string
, args
);
440 string1
= va_arg (args
, char *);
441 vfprintf_filtered (gdb_stderr
, string1
, args
);
444 fprintf_filtered (gdb_stderr
, "\n");
446 return_to_top_level (RETURN_ERROR
);
451 /* Print an error message and exit reporting failure.
452 This is for a error that we cannot continue from.
453 The arguments are printed a la printf.
455 This function cannot be declared volatile (NORETURN) in an
456 ANSI environment because exit() is not declared volatile. */
460 #ifdef ANSI_PROTOTYPES
461 fatal (char *string
, ...)
468 #ifdef ANSI_PROTOTYPES
469 va_start (args
, string
);
473 string
= va_arg (args
, char *);
475 fprintf_unfiltered (gdb_stderr
, "\ngdb: ");
476 vfprintf_unfiltered (gdb_stderr
, string
, args
);
477 fprintf_unfiltered (gdb_stderr
, "\n");
482 /* Print an error message and exit, dumping core.
483 The arguments are printed a la printf (). */
487 #ifdef ANSI_PROTOTYPES
488 fatal_dump_core (char *string
, ...)
490 fatal_dump_core (va_alist
)
495 #ifdef ANSI_PROTOTYPES
496 va_start (args
, string
);
501 string
= va_arg (args
, char *);
503 /* "internal error" is always correct, since GDB should never dump
504 core, no matter what the input. */
505 fprintf_unfiltered (gdb_stderr
, "\ngdb internal error: ");
506 vfprintf_unfiltered (gdb_stderr
, string
, args
);
507 fprintf_unfiltered (gdb_stderr
, "\n");
510 signal (SIGQUIT
, SIG_DFL
);
511 kill (getpid (), SIGQUIT
);
512 /* We should never get here, but just in case... */
516 /* The strerror() function can return NULL for errno values that are
517 out of range. Provide a "safe" version that always returns a
521 safe_strerror (errnum
)
527 if ((msg
= strerror (errnum
)) == NULL
)
529 sprintf (buf
, "(undocumented errno %d)", errnum
);
535 /* The strsignal() function can return NULL for signal values that are
536 out of range. Provide a "safe" version that always returns a
540 safe_strsignal (signo
)
546 if ((msg
= strsignal (signo
)) == NULL
)
548 sprintf (buf
, "(undocumented signal %d)", signo
);
555 /* Print the system error message for errno, and also mention STRING
556 as the file name for which the error was encountered.
557 Then return to command level. */
560 perror_with_name (string
)
566 err
= safe_strerror (errno
);
567 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
568 strcpy (combined
, string
);
569 strcat (combined
, ": ");
570 strcat (combined
, err
);
572 /* I understand setting these is a matter of taste. Still, some people
573 may clear errno but not know about bfd_error. Doing this here is not
575 bfd_set_error (bfd_error_no_error
);
578 error ("%s.", combined
);
581 /* Print the system error message for ERRCODE, and also mention STRING
582 as the file name for which the error was encountered. */
585 print_sys_errmsg (string
, errcode
)
592 err
= safe_strerror (errcode
);
593 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
594 strcpy (combined
, string
);
595 strcat (combined
, ": ");
596 strcat (combined
, err
);
598 /* We want anything which was printed on stdout to come out first, before
600 gdb_flush (gdb_stdout
);
601 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
604 /* Control C eventually causes this to be called, at a convenient time. */
609 serial_t gdb_stdout_serial
= serial_fdopen (1);
611 target_terminal_ours ();
613 /* We want all output to appear now, before we print "Quit". We
614 have 3 levels of buffering we have to flush (it's possible that
615 some of these should be changed to flush the lower-level ones
618 /* 1. The _filtered buffer. */
619 wrap_here ((char *)0);
621 /* 2. The stdio buffer. */
622 gdb_flush (gdb_stdout
);
623 gdb_flush (gdb_stderr
);
625 /* 3. The system-level buffer. */
626 SERIAL_DRAIN_OUTPUT (gdb_stdout_serial
);
627 SERIAL_UN_FDOPEN (gdb_stdout_serial
);
629 annotate_error_begin ();
631 /* Don't use *_filtered; we don't want to prompt the user to continue. */
633 fprintf_unfiltered (gdb_stderr
, quit_pre_print
);
636 /* If there is no terminal switching for this target, then we can't
637 possibly get screwed by the lack of job control. */
638 || current_target
.to_terminal_ours
== NULL
)
639 fprintf_unfiltered (gdb_stderr
, "Quit\n");
641 fprintf_unfiltered (gdb_stderr
,
642 "Quit (expect signal SIGINT when the program is resumed)\n");
643 return_to_top_level (RETURN_QUIT
);
647 #if defined(__GO32__)
649 /* In the absence of signals, poll keyboard for a quit.
650 Called from #define QUIT pollquit() in xm-go32.h. */
665 /* We just ignore it */
666 /* FIXME!! Don't think this actually works! */
667 fprintf_unfiltered (gdb_stderr
, "CTRL-A to quit, CTRL-B to quit harder\n");
672 #elif defined(_MSC_VER) /* should test for wingdb instead? */
675 * Windows translates all keyboard and mouse events
676 * into a message which is appended to the message
677 * queue for the process.
682 int k
= win32pollquit();
689 #else /* !defined(__GO32__) && !defined(_MSC_VER) */
693 /* Done by signals */
696 #endif /* !defined(__GO32__) && !defined(_MSC_VER) */
702 if (quit_flag
|| immediate_quit
)
706 /* Control C comes here */
713 /* Restore the signal handler. Harmless with BSD-style signals, needed
714 for System V-style signals. So just always do it, rather than worrying
715 about USG defines and stuff like that. */
716 signal (signo
, request_quit
);
727 /* Memory management stuff (malloc friends). */
729 /* Make a substitute size_t for non-ANSI compilers. */
731 #ifndef HAVE_STDDEF_H
733 #define size_t unsigned int
737 #if !defined (USE_MMALLOC)
744 return malloc (size
);
748 mrealloc (md
, ptr
, size
)
753 if (ptr
== 0) /* Guard against old realloc's */
754 return malloc (size
);
756 return realloc (ptr
, size
);
767 #endif /* USE_MMALLOC */
769 #if !defined (USE_MMALLOC) || defined (NO_MMCHECK)
777 #else /* Have mmalloc and want corruption checking */
782 fatal_dump_core ("Memory corruption");
785 /* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified
786 by MD, to detect memory corruption. Note that MD may be NULL to specify
787 the default heap that grows via sbrk.
789 Note that for freshly created regions, we must call mmcheckf prior to any
790 mallocs in the region. Otherwise, any region which was allocated prior to
791 installing the checking hooks, which is later reallocated or freed, will
792 fail the checks! The mmcheck function only allows initial hooks to be
793 installed before the first mmalloc. However, anytime after we have called
794 mmcheck the first time to install the checking hooks, we can call it again
795 to update the function pointer to the memory corruption handler.
797 Returns zero on failure, non-zero on success. */
799 #ifndef MMCHECK_FORCE
800 #define MMCHECK_FORCE 0
807 if (!mmcheckf (md
, malloc_botch
, MMCHECK_FORCE
))
809 /* Don't use warning(), which relies on current_target being set
810 to something other than dummy_target, until after
811 initialize_all_files(). */
814 (gdb_stderr
, "warning: failed to install memory consistency checks; ");
816 (gdb_stderr
, "configuration should define NO_MMCHECK or MMCHECK_FORCE\n");
822 #endif /* Have mmalloc and want corruption checking */
824 /* Called when a memory allocation fails, with the number of bytes of
825 memory requested in SIZE. */
833 fatal ("virtual memory exhausted: can't allocate %ld bytes.", size
);
837 fatal ("virtual memory exhausted.");
841 /* Like mmalloc but get error if no storage available, and protect against
842 the caller wanting to allocate zero bytes. Whether to return NULL for
843 a zero byte request, or translate the request into a request for one
844 byte of zero'd storage, is a religious issue. */
857 else if ((val
= mmalloc (md
, size
)) == NULL
)
864 /* Like mrealloc but get error if no storage available. */
867 xmrealloc (md
, ptr
, size
)
876 val
= mrealloc (md
, ptr
, size
);
880 val
= mmalloc (md
, size
);
889 /* Like malloc but get error if no storage available, and protect against
890 the caller wanting to allocate zero bytes. */
896 return (xmmalloc ((PTR
) NULL
, size
));
899 /* Like mrealloc but get error if no storage available. */
906 return (xmrealloc ((PTR
) NULL
, ptr
, size
));
910 /* My replacement for the read system call.
911 Used like `read' but keeps going if `read' returns too soon. */
914 myread (desc
, addr
, len
)
924 val
= read (desc
, addr
, len
);
935 /* Make a copy of the string at PTR with SIZE characters
936 (and add a null character at the end in the copy).
937 Uses malloc to get the space. Returns the address of the copy. */
940 savestring (ptr
, size
)
944 register char *p
= (char *) xmalloc (size
+ 1);
945 memcpy (p
, ptr
, size
);
951 msavestring (md
, ptr
, size
)
956 register char *p
= (char *) xmmalloc (md
, size
+ 1);
957 memcpy (p
, ptr
, size
);
962 /* The "const" is so it compiles under DGUX (which prototypes strsave
963 in <string.h>. FIXME: This should be named "xstrsave", shouldn't it?
964 Doesn't real strsave return NULL if out of memory? */
969 return savestring (ptr
, strlen (ptr
));
977 return (msavestring (md
, ptr
, strlen (ptr
)));
981 print_spaces (n
, file
)
983 register GDB_FILE
*file
;
985 if (file
->ts_streamtype
== astring
)
987 gdb_file_adjust_strbuf (n
, file
);
989 strcat(file
->ts_strbuf
, " ");
994 fputc (' ', file
->ts_filestream
);
998 /* Print a host address. */
1001 gdb_print_address (addr
, stream
)
1006 /* We could use the %p conversion specifier to fprintf if we had any
1007 way of knowing whether this host supports it. But the following
1008 should work on the Alpha and on 32 bit machines. */
1010 fprintf_filtered (stream
, "0x%lx", (unsigned long)addr
);
1013 /* Ask user a y-or-n question and return 1 iff answer is yes.
1014 Takes three args which are given to printf to print the question.
1015 The first, a control string, should end in "? ".
1016 It should not say how to answer, because we do that. */
1020 #ifdef ANSI_PROTOTYPES
1021 query (char *ctlstr
, ...)
1028 register int answer
;
1032 #ifdef ANSI_PROTOTYPES
1033 va_start (args
, ctlstr
);
1037 ctlstr
= va_arg (args
, char *);
1042 return query_hook (ctlstr
, args
);
1045 /* Automatically answer "yes" if input is not from a terminal. */
1046 if (!input_from_terminal_p ())
1049 /* FIXME Automatically answer "yes" if called from MacGDB. */
1056 wrap_here (""); /* Flush any buffered output */
1057 gdb_flush (gdb_stdout
);
1059 if (annotation_level
> 1)
1060 printf_filtered ("\n\032\032pre-query\n");
1062 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1063 printf_filtered ("(y or n) ");
1065 if (annotation_level
> 1)
1066 printf_filtered ("\n\032\032query\n");
1069 /* If not in MacGDB, move to a new line so the entered line doesn't
1070 have a prompt on the front of it. */
1072 fputs_unfiltered ("\n", gdb_stdout
);
1076 gdb_flush (gdb_stdout
);
1079 if (!tui_version
|| cmdWin
== tuiWinWithFocus())
1081 answer
= fgetc (stdin
);
1085 answer
= (unsigned char)tuiBufferGetc();
1088 clearerr (stdin
); /* in case of C-d */
1089 if (answer
== EOF
) /* C-d */
1094 /* Eat rest of input line, to EOF or newline */
1095 if ((answer
!= '\n') || (tui_version
&& answer
!= '\r'))
1099 if (!tui_version
|| cmdWin
== tuiWinWithFocus())
1101 ans2
= fgetc (stdin
);
1105 ans2
= (unsigned char)tuiBufferGetc();
1109 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1110 TUIDO(((TuiOpaqueFuncPtr
)tui_vStartNewLines
, 1));
1124 printf_filtered ("Please answer y or n.\n");
1127 if (annotation_level
> 1)
1128 printf_filtered ("\n\032\032post-query\n");
1133 /* Parse a C escape sequence. STRING_PTR points to a variable
1134 containing a pointer to the string to parse. That pointer
1135 should point to the character after the \. That pointer
1136 is updated past the characters we use. The value of the
1137 escape sequence is returned.
1139 A negative value means the sequence \ newline was seen,
1140 which is supposed to be equivalent to nothing at all.
1142 If \ is followed by a null character, we return a negative
1143 value and leave the string pointer pointing at the null character.
1145 If \ is followed by 000, we return 0 and leave the string pointer
1146 after the zeros. A value of 0 does not mean end of string. */
1149 parse_escape (string_ptr
)
1152 register int c
= *(*string_ptr
)++;
1156 return 007; /* Bell (alert) char */
1159 case 'e': /* Escape character */
1177 c
= *(*string_ptr
)++;
1179 c
= parse_escape (string_ptr
);
1182 return (c
& 0200) | (c
& 037);
1193 register int i
= c
- '0';
1194 register int count
= 0;
1197 if ((c
= *(*string_ptr
)++) >= '0' && c
<= '7')
1215 /* Print the character C on STREAM as part of the contents of a literal
1216 string whose delimiter is QUOTER. Note that this routine should only
1217 be call for printing things which are independent of the language
1218 of the program being debugged. */
1221 gdb_printchar (c
, stream
, quoter
)
1227 c
&= 0xFF; /* Avoid sign bit follies */
1229 if ( c
< 0x20 || /* Low control chars */
1230 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1231 (sevenbit_strings
&& c
>= 0x80)) { /* high order bit set */
1235 fputs_filtered ("\\n", stream
);
1238 fputs_filtered ("\\b", stream
);
1241 fputs_filtered ("\\t", stream
);
1244 fputs_filtered ("\\f", stream
);
1247 fputs_filtered ("\\r", stream
);
1250 fputs_filtered ("\\e", stream
);
1253 fputs_filtered ("\\a", stream
);
1256 fprintf_filtered (stream
, "\\%.3o", (unsigned int) c
);
1260 if (c
== '\\' || c
== quoter
)
1261 fputs_filtered ("\\", stream
);
1262 fprintf_filtered (stream
, "%c", c
);
1269 static char * hexlate
= "0123456789abcdef" ;
1270 int fmthex(inbuf
,outbuff
,length
,linelength
)
1271 unsigned char * inbuf
;
1272 unsigned char * outbuff
;
1276 unsigned char byte
, nib
;
1281 if (outlength
>= linelength
) break ;
1285 *outbuff
++ = hexlate
[nib
] ;
1287 *outbuff
++ = hexlate
[nib
] ;
1292 *outbuff
= '\0' ; /* null terminate our output line */
1297 /* Number of lines per page or UINT_MAX if paging is disabled. */
1298 static unsigned int lines_per_page
;
1299 /* Number of chars per line or UNIT_MAX is line folding is disabled. */
1300 static unsigned int chars_per_line
;
1301 /* Current count of lines printed on this page, chars on this line. */
1302 static unsigned int lines_printed
, chars_printed
;
1304 /* Buffer and start column of buffered text, for doing smarter word-
1305 wrapping. When someone calls wrap_here(), we start buffering output
1306 that comes through fputs_filtered(). If we see a newline, we just
1307 spit it out and forget about the wrap_here(). If we see another
1308 wrap_here(), we spit it out and remember the newer one. If we see
1309 the end of the line, we spit out a newline, the indent, and then
1310 the buffered output. */
1312 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1313 are waiting to be output (they have already been counted in chars_printed).
1314 When wrap_buffer[0] is null, the buffer is empty. */
1315 static char *wrap_buffer
;
1317 /* Pointer in wrap_buffer to the next character to fill. */
1318 static char *wrap_pointer
;
1320 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1322 static char *wrap_indent
;
1324 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1325 is not in effect. */
1326 static int wrap_column
;
1329 /* Inialize the lines and chars per page */
1334 if (tui_version
&& m_winPtrNotNull(cmdWin
))
1336 lines_per_page
= cmdWin
->generic
.height
;
1337 chars_per_line
= cmdWin
->generic
.width
;
1342 /* These defaults will be used if we are unable to get the correct
1343 values from termcap. */
1344 #if defined(__GO32__)
1345 lines_per_page
= ScreenRows();
1346 chars_per_line
= ScreenCols();
1348 lines_per_page
= 24;
1349 chars_per_line
= 80;
1351 #if !defined (MPW) && !defined (_WIN32)
1352 /* No termcap under MPW, although might be cool to do something
1353 by looking at worksheet or console window sizes. */
1354 /* Initialize the screen height and width from termcap. */
1356 char *termtype
= getenv ("TERM");
1358 /* Positive means success, nonpositive means failure. */
1361 /* 2048 is large enough for all known terminals, according to the
1362 GNU termcap manual. */
1363 char term_buffer
[2048];
1367 status
= tgetent (term_buffer
, termtype
);
1372 val
= tgetnum ("li");
1374 lines_per_page
= val
;
1376 /* The number of lines per page is not mentioned
1377 in the terminal description. This probably means
1378 that paging is not useful (e.g. emacs shell window),
1379 so disable paging. */
1380 lines_per_page
= UINT_MAX
;
1382 val
= tgetnum ("co");
1384 chars_per_line
= val
;
1390 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1392 /* If there is a better way to determine the window size, use it. */
1393 SIGWINCH_HANDLER (SIGWINCH
);
1396 /* If the output is not a terminal, don't paginate it. */
1397 if (!GDB_FILE_ISATTY (gdb_stdout
))
1398 lines_per_page
= UINT_MAX
;
1399 } /* the command_line_version */
1406 if (chars_per_line
== 0)
1411 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1412 wrap_buffer
[0] = '\0';
1415 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1416 wrap_pointer
= wrap_buffer
; /* Start it at the beginning */
1421 set_width_command (args
, from_tty
, c
)
1424 struct cmd_list_element
*c
;
1429 /* Wait, so the user can read what's on the screen. Prompt the user
1430 to continue by pressing RETURN. */
1433 prompt_for_continue ()
1436 char cont_prompt
[120];
1438 if (annotation_level
> 1)
1439 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1441 strcpy (cont_prompt
,
1442 "---Type <return> to continue, or q <return> to quit---");
1443 if (annotation_level
> 1)
1444 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1446 /* We must do this *before* we call gdb_readline, else it will eventually
1447 call us -- thinking that we're trying to print beyond the end of the
1449 reinitialize_more_filter ();
1452 /* On a real operating system, the user can quit with SIGINT.
1455 'q' is provided on all systems so users don't have to change habits
1456 from system to system, and because telling them what to do in
1457 the prompt is more user-friendly than expecting them to think of
1459 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1460 whereas control-C to gdb_readline will cause the user to get dumped
1462 ignore
= readline (cont_prompt
);
1464 if (annotation_level
> 1)
1465 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1470 while (*p
== ' ' || *p
== '\t')
1473 request_quit (SIGINT
);
1478 /* Now we have to do this again, so that GDB will know that it doesn't
1479 need to save the ---Type <return>--- line at the top of the screen. */
1480 reinitialize_more_filter ();
1482 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1485 /* Reinitialize filter; ie. tell it to reset to original values. */
1488 reinitialize_more_filter ()
1494 /* Indicate that if the next sequence of characters overflows the line,
1495 a newline should be inserted here rather than when it hits the end.
1496 If INDENT is non-null, it is a string to be printed to indent the
1497 wrapped part on the next line. INDENT must remain accessible until
1498 the next call to wrap_here() or until a newline is printed through
1501 If the line is already overfull, we immediately print a newline and
1502 the indentation, and disable further wrapping.
1504 If we don't know the width of lines, but we know the page height,
1505 we must not wrap words, but should still keep track of newlines
1506 that were explicitly printed.
1508 INDENT should not contain tabs, as that will mess up the char count
1509 on the next line. FIXME.
1511 This routine is guaranteed to force out any output which has been
1512 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1513 used to force out output from the wrap_buffer. */
1519 /* This should have been allocated, but be paranoid anyway. */
1525 *wrap_pointer
= '\0';
1526 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1528 wrap_pointer
= wrap_buffer
;
1529 wrap_buffer
[0] = '\0';
1530 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1534 else if (chars_printed
>= chars_per_line
)
1536 puts_filtered ("\n");
1538 puts_filtered (indent
);
1543 wrap_column
= chars_printed
;
1547 wrap_indent
= indent
;
1551 /* Ensure that whatever gets printed next, using the filtered output
1552 commands, starts at the beginning of the line. I.E. if there is
1553 any pending output for the current line, flush it and start a new
1554 line. Otherwise do nothing. */
1559 if (chars_printed
> 0)
1561 puts_filtered ("\n");
1566 gdb_file_isatty (stream
)
1570 if (stream
->ts_streamtype
== afile
)
1571 return (isatty(fileno(stream
->ts_filestream
)));
1576 gdb_file_init_astring (n
)
1579 GDB_FILE
*tmpstream
;
1581 tmpstream
= xmalloc (sizeof(GDB_FILE
));
1582 tmpstream
->ts_streamtype
= astring
;
1583 tmpstream
->ts_filestream
= NULL
;
1586 tmpstream
->ts_strbuf
= xmalloc ((n
+ 1)*sizeof(char));
1587 tmpstream
->ts_strbuf
[0] = '\0';
1590 tmpstream
->ts_strbuf
= NULL
;
1591 tmpstream
->ts_buflen
= n
;
1597 gdb_file_deallocate (streamptr
)
1598 GDB_FILE
**streamptr
;
1600 GDB_FILE
*tmpstream
;
1602 tmpstream
= *streamptr
;
1603 if ((tmpstream
->ts_streamtype
== astring
) &&
1604 (tmpstream
->ts_strbuf
!= NULL
))
1606 free (tmpstream
->ts_strbuf
);
1614 gdb_file_get_strbuf (stream
)
1617 return (stream
->ts_strbuf
);
1620 /* adjust the length of the buffer by the amount necessary
1621 to accomodate appending a string of length N to the buffer contents */
1623 gdb_file_adjust_strbuf (n
, stream
)
1629 non_null_chars
= strlen(stream
->ts_strbuf
);
1631 if (n
> (stream
->ts_buflen
- non_null_chars
- 1))
1633 stream
->ts_buflen
= n
+ non_null_chars
+ 1;
1634 stream
->ts_strbuf
= xrealloc (stream
->ts_strbuf
, stream
->ts_buflen
);
1639 gdb_fopen (name
, mode
)
1646 gdb_file_size
= sizeof(GDB_FILE
);
1647 tmp
= (GDB_FILE
*) xmalloc (gdb_file_size
);
1648 tmp
->ts_streamtype
= afile
;
1649 tmp
->ts_filestream
= fopen (name
, mode
);
1650 tmp
->ts_strbuf
= NULL
;
1661 && (stream
== gdb_stdout
1662 || stream
== gdb_stderr
))
1664 flush_hook (stream
);
1668 fflush (stream
->ts_filestream
);
1672 gdb_fclose(streamptr
)
1673 GDB_FILE
**streamptr
;
1675 GDB_FILE
*tmpstream
;
1677 tmpstream
= *streamptr
;
1678 fclose (tmpstream
->ts_filestream
);
1679 gdb_file_deallocate (streamptr
);
1682 /* Like fputs but if FILTER is true, pause after every screenful.
1684 Regardless of FILTER can wrap at points other than the final
1685 character of a line.
1687 Unlike fputs, fputs_maybe_filtered does not return a value.
1688 It is OK for LINEBUFFER to be NULL, in which case just don't print
1691 Note that a longjmp to top level may occur in this routine (only if
1692 FILTER is true) (since prompt_for_continue may do so) so this
1693 routine should not be called when cleanups are not in place. */
1696 fputs_maybe_filtered (linebuffer
, stream
, filter
)
1697 const char *linebuffer
;
1701 const char *lineptr
;
1703 if (linebuffer
== 0)
1706 /* Don't do any filtering if it is disabled. */
1707 if (stream
!= gdb_stdout
1708 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
1710 fputs_unfiltered (linebuffer
, stream
);
1714 /* Go through and output each character. Show line extension
1715 when this is necessary; prompt user for new page when this is
1718 lineptr
= linebuffer
;
1721 /* Possible new page. */
1723 (lines_printed
>= lines_per_page
- 1))
1724 prompt_for_continue ();
1726 while (*lineptr
&& *lineptr
!= '\n')
1728 /* Print a single line. */
1729 if (*lineptr
== '\t')
1732 *wrap_pointer
++ = '\t';
1734 fputc_unfiltered ('\t', stream
);
1735 /* Shifting right by 3 produces the number of tab stops
1736 we have already passed, and then adding one and
1737 shifting left 3 advances to the next tab stop. */
1738 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1744 *wrap_pointer
++ = *lineptr
;
1746 fputc_unfiltered (*lineptr
, stream
);
1751 if (chars_printed
>= chars_per_line
)
1753 unsigned int save_chars
= chars_printed
;
1757 /* If we aren't actually wrapping, don't output newline --
1758 if chars_per_line is right, we probably just overflowed
1759 anyway; if it's wrong, let us keep going. */
1761 fputc_unfiltered ('\n', stream
);
1763 /* Possible new page. */
1764 if (lines_printed
>= lines_per_page
- 1)
1765 prompt_for_continue ();
1767 /* Now output indentation and wrapped string */
1770 fputs_unfiltered (wrap_indent
, stream
);
1771 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
1772 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
1773 /* FIXME, this strlen is what prevents wrap_indent from
1774 containing tabs. However, if we recurse to print it
1775 and count its chars, we risk trouble if wrap_indent is
1776 longer than (the user settable) chars_per_line.
1777 Note also that this can set chars_printed > chars_per_line
1778 if we are printing a long string. */
1779 chars_printed
= strlen (wrap_indent
)
1780 + (save_chars
- wrap_column
);
1781 wrap_pointer
= wrap_buffer
; /* Reset buffer */
1782 wrap_buffer
[0] = '\0';
1783 wrap_column
= 0; /* And disable fancy wrap */
1788 if (*lineptr
== '\n')
1791 wrap_here ((char *)0); /* Spit out chars, cancel further wraps */
1793 fputc_unfiltered ('\n', stream
);
1800 fputs_filtered (linebuffer
, stream
)
1801 const char *linebuffer
;
1804 fputs_maybe_filtered (linebuffer
, stream
, 1);
1808 putchar_unfiltered (c
)
1815 fputs_unfiltered (buf
, gdb_stdout
);
1820 fputc_unfiltered (c
, stream
)
1828 fputs_unfiltered (buf
, stream
);
1833 fputc_filtered (c
, stream
)
1841 fputs_filtered (buf
, stream
);
1845 /* puts_debug is like fputs_unfiltered, except it prints special
1846 characters in printable fashion. */
1849 puts_debug (prefix
, string
, suffix
)
1856 /* Print prefix and suffix after each line. */
1857 static int new_line
= 1;
1858 static int return_p
= 0;
1859 static char *prev_prefix
= "";
1860 static char *prev_suffix
= "";
1862 if (*string
== '\n')
1865 /* If the prefix is changing, print the previous suffix, a new line,
1866 and the new prefix. */
1867 if ((return_p
|| (strcmp(prev_prefix
, prefix
) != 0)) && !new_line
)
1869 fputs_unfiltered (prev_suffix
, gdb_stderr
);
1870 fputs_unfiltered ("\n", gdb_stderr
);
1871 fputs_unfiltered (prefix
, gdb_stderr
);
1874 /* Print prefix if we printed a newline during the previous call. */
1878 fputs_unfiltered (prefix
, gdb_stderr
);
1881 prev_prefix
= prefix
;
1882 prev_suffix
= suffix
;
1884 /* Output characters in a printable format. */
1885 while ((ch
= *string
++) != '\0')
1891 fputc_unfiltered (ch
, gdb_stderr
);
1894 fprintf_unfiltered (gdb_stderr
, "\\x%02x", ch
& 0xff);
1897 case '\\': fputs_unfiltered ("\\\\", gdb_stderr
); break;
1898 case '\b': fputs_unfiltered ("\\b", gdb_stderr
); break;
1899 case '\f': fputs_unfiltered ("\\f", gdb_stderr
); break;
1900 case '\n': new_line
= 1;
1901 fputs_unfiltered ("\\n", gdb_stderr
); break;
1902 case '\r': fputs_unfiltered ("\\r", gdb_stderr
); break;
1903 case '\t': fputs_unfiltered ("\\t", gdb_stderr
); break;
1904 case '\v': fputs_unfiltered ("\\v", gdb_stderr
); break;
1907 return_p
= ch
== '\r';
1910 /* Print suffix if we printed a newline. */
1913 fputs_unfiltered (suffix
, gdb_stderr
);
1914 fputs_unfiltered ("\n", gdb_stderr
);
1919 /* Print a variable number of ARGS using format FORMAT. If this
1920 information is going to put the amount written (since the last call
1921 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
1922 call prompt_for_continue to get the users permision to continue.
1924 Unlike fprintf, this function does not return a value.
1926 We implement three variants, vfprintf (takes a vararg list and stream),
1927 fprintf (takes a stream to write on), and printf (the usual).
1929 Note also that a longjmp to top level may occur in this routine
1930 (since prompt_for_continue may do so) so this routine should not be
1931 called when cleanups are not in place. */
1934 vfprintf_maybe_filtered (stream
, format
, args
, filter
)
1941 struct cleanup
*old_cleanups
;
1943 vasprintf (&linebuffer
, format
, args
);
1944 if (linebuffer
== NULL
)
1946 fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr
);
1949 old_cleanups
= make_cleanup (free
, linebuffer
);
1950 fputs_maybe_filtered (linebuffer
, stream
, filter
);
1951 do_cleanups (old_cleanups
);
1956 vfprintf_filtered (stream
, format
, args
)
1961 vfprintf_maybe_filtered (stream
, format
, args
, 1);
1965 vfprintf_unfiltered (stream
, format
, args
)
1971 struct cleanup
*old_cleanups
;
1973 vasprintf (&linebuffer
, format
, args
);
1974 if (linebuffer
== NULL
)
1976 fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr
);
1979 old_cleanups
= make_cleanup (free
, linebuffer
);
1980 fputs_unfiltered (linebuffer
, stream
);
1981 do_cleanups (old_cleanups
);
1985 vprintf_filtered (format
, args
)
1989 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
1993 vprintf_unfiltered (format
, args
)
1997 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2002 #ifdef ANSI_PROTOTYPES
2003 fprintf_filtered (GDB_FILE
*stream
, const char *format
, ...)
2005 fprintf_filtered (va_alist
)
2010 #ifdef ANSI_PROTOTYPES
2011 va_start (args
, format
);
2017 stream
= va_arg (args
, GDB_FILE
*);
2018 format
= va_arg (args
, char *);
2020 vfprintf_filtered (stream
, format
, args
);
2026 #ifdef ANSI_PROTOTYPES
2027 fprintf_unfiltered (GDB_FILE
*stream
, const char *format
, ...)
2029 fprintf_unfiltered (va_alist
)
2034 #ifdef ANSI_PROTOTYPES
2035 va_start (args
, format
);
2041 stream
= va_arg (args
, GDB_FILE
*);
2042 format
= va_arg (args
, char *);
2044 vfprintf_unfiltered (stream
, format
, args
);
2048 /* Like fprintf_filtered, but prints its result indented.
2049 Called as fprintfi_filtered (spaces, stream, format, ...); */
2053 #ifdef ANSI_PROTOTYPES
2054 fprintfi_filtered (int spaces
, GDB_FILE
*stream
, const char *format
, ...)
2056 fprintfi_filtered (va_alist
)
2061 #ifdef ANSI_PROTOTYPES
2062 va_start (args
, format
);
2069 spaces
= va_arg (args
, int);
2070 stream
= va_arg (args
, GDB_FILE
*);
2071 format
= va_arg (args
, char *);
2073 print_spaces_filtered (spaces
, stream
);
2075 vfprintf_filtered (stream
, format
, args
);
2082 #ifdef ANSI_PROTOTYPES
2083 printf_filtered (const char *format
, ...)
2085 printf_filtered (va_alist
)
2090 #ifdef ANSI_PROTOTYPES
2091 va_start (args
, format
);
2096 format
= va_arg (args
, char *);
2098 vfprintf_filtered (gdb_stdout
, format
, args
);
2105 #ifdef ANSI_PROTOTYPES
2106 printf_unfiltered (const char *format
, ...)
2108 printf_unfiltered (va_alist
)
2113 #ifdef ANSI_PROTOTYPES
2114 va_start (args
, format
);
2119 format
= va_arg (args
, char *);
2121 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2125 /* Like printf_filtered, but prints it's result indented.
2126 Called as printfi_filtered (spaces, format, ...); */
2130 #ifdef ANSI_PROTOTYPES
2131 printfi_filtered (int spaces
, const char *format
, ...)
2133 printfi_filtered (va_alist
)
2138 #ifdef ANSI_PROTOTYPES
2139 va_start (args
, format
);
2145 spaces
= va_arg (args
, int);
2146 format
= va_arg (args
, char *);
2148 print_spaces_filtered (spaces
, gdb_stdout
);
2149 vfprintf_filtered (gdb_stdout
, format
, args
);
2153 /* Easy -- but watch out!
2155 This routine is *not* a replacement for puts()! puts() appends a newline.
2156 This one doesn't, and had better not! */
2159 puts_filtered (string
)
2162 fputs_filtered (string
, gdb_stdout
);
2166 puts_unfiltered (string
)
2169 fputs_unfiltered (string
, gdb_stdout
);
2172 /* Return a pointer to N spaces and a null. The pointer is good
2173 until the next call to here. */
2179 static char *spaces
;
2180 static int max_spaces
;
2186 spaces
= (char *) xmalloc (n
+1);
2187 for (t
= spaces
+n
; t
!= spaces
;)
2193 return spaces
+ max_spaces
- n
;
2196 /* Print N spaces. */
2198 print_spaces_filtered (n
, stream
)
2202 fputs_filtered (n_spaces (n
), stream
);
2205 /* C++ demangler stuff. */
2207 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2208 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2209 If the name is not mangled, or the language for the name is unknown, or
2210 demangling is off, the name is printed in its "raw" form. */
2213 fprintf_symbol_filtered (stream
, name
, lang
, arg_mode
)
2223 /* If user wants to see raw output, no problem. */
2226 fputs_filtered (name
, stream
);
2232 case language_cplus
:
2233 demangled
= cplus_demangle (name
, arg_mode
);
2235 /* start-sanitize-java */
2237 demangled
= cplus_demangle (name
, arg_mode
| DMGL_JAVA
);
2239 /* end-sanitize-java */
2240 case language_chill
:
2241 demangled
= chill_demangle (name
);
2247 fputs_filtered (demangled
? demangled
: name
, stream
);
2248 if (demangled
!= NULL
)
2256 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2257 differences in whitespace. Returns 0 if they match, non-zero if they
2258 don't (slightly different than strcmp()'s range of return values).
2260 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2261 This "feature" is useful when searching for matching C++ function names
2262 (such as if the user types 'break FOO', where FOO is a mangled C++
2266 strcmp_iw (string1
, string2
)
2267 const char *string1
;
2268 const char *string2
;
2270 while ((*string1
!= '\0') && (*string2
!= '\0'))
2272 while (isspace (*string1
))
2276 while (isspace (*string2
))
2280 if (*string1
!= *string2
)
2284 if (*string1
!= '\0')
2290 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2296 ** Answer whether stringToCompare is a full or partial match to
2297 ** templateString. The partial match must be in sequence starting
2303 char *stringToCompare
,
2304 char *templateString
)
2306 subsetCompare(stringToCompare
, templateString
)
2307 char *stringToCompare
;
2308 char *templateString
;
2313 if (templateString
!= (char *)NULL
&& stringToCompare
!= (char *)NULL
&&
2314 strlen(stringToCompare
) <= strlen(templateString
))
2315 match
= (strncmp(templateString
,
2317 strlen(stringToCompare
)) == 0);
2320 } /* subsetCompare */
2323 void pagination_on_command(arg
, from_tty
)
2327 pagination_enabled
= 1;
2330 void pagination_off_command(arg
, from_tty
)
2334 pagination_enabled
= 0;
2341 struct cmd_list_element
*c
;
2343 c
= add_set_cmd ("width", class_support
, var_uinteger
,
2344 (char *)&chars_per_line
,
2345 "Set number of characters gdb thinks are in a line.",
2347 add_show_from_set (c
, &showlist
);
2348 c
->function
.sfunc
= set_width_command
;
2351 (add_set_cmd ("height", class_support
,
2352 var_uinteger
, (char *)&lines_per_page
,
2353 "Set number of lines gdb thinks are in a page.", &setlist
),
2358 /* If the output is not a terminal, don't paginate it. */
2359 if (!GDB_FILE_ISATTY (gdb_stdout
))
2360 lines_per_page
= UINT_MAX
;
2362 set_width_command ((char *)NULL
, 0, c
);
2365 (add_set_cmd ("demangle", class_support
, var_boolean
,
2367 "Set demangling of encoded C++ names when displaying symbols.",
2372 (add_set_cmd ("pagination", class_support
,
2373 var_boolean
, (char *)&pagination_enabled
,
2374 "Set state of pagination.", &setlist
),
2378 add_com("am", class_support
, pagination_on_command
,
2379 "Enable pagination");
2380 add_com("sm", class_support
, pagination_off_command
,
2381 "Disable pagination");
2385 (add_set_cmd ("sevenbit-strings", class_support
, var_boolean
,
2386 (char *)&sevenbit_strings
,
2387 "Set printing of 8-bit characters in strings as \\nnn.",
2392 (add_set_cmd ("asm-demangle", class_support
, var_boolean
,
2393 (char *)&asm_demangle
,
2394 "Set demangling of C++ names in disassembly listings.",
2399 /* Machine specific function to handle SIGWINCH signal. */
2401 #ifdef SIGWINCH_HANDLER_BODY
2402 SIGWINCH_HANDLER_BODY
2405 /* Support for converting target fp numbers into host DOUBLEST format. */
2407 /* XXX - This code should really be in libiberty/floatformat.c, however
2408 configuration issues with libiberty made this very difficult to do in the
2411 #include "floatformat.h"
2412 #include <math.h> /* ldexp */
2414 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
2415 going to bother with trying to muck around with whether it is defined in
2416 a system header, what we do if not, etc. */
2417 #define FLOATFORMAT_CHAR_BIT 8
2419 static unsigned long get_field
PARAMS ((unsigned char *,
2420 enum floatformat_byteorders
,
2425 /* Extract a field which starts at START and is LEN bytes long. DATA and
2426 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
2427 static unsigned long
2428 get_field (data
, order
, total_len
, start
, len
)
2429 unsigned char *data
;
2430 enum floatformat_byteorders order
;
2431 unsigned int total_len
;
2435 unsigned long result
;
2436 unsigned int cur_byte
;
2439 /* Start at the least significant part of the field. */
2440 cur_byte
= (start
+ len
) / FLOATFORMAT_CHAR_BIT
;
2441 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
2442 cur_byte
= (total_len
/ FLOATFORMAT_CHAR_BIT
) - cur_byte
- 1;
2444 ((start
+ len
) % FLOATFORMAT_CHAR_BIT
) - FLOATFORMAT_CHAR_BIT
;
2445 result
= *(data
+ cur_byte
) >> (-cur_bitshift
);
2446 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
2447 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
2452 /* Move towards the most significant part of the field. */
2453 while (cur_bitshift
< len
)
2455 if (len
- cur_bitshift
< FLOATFORMAT_CHAR_BIT
)
2456 /* This is the last byte; zero out the bits which are not part of
2459 (*(data
+ cur_byte
) & ((1 << (len
- cur_bitshift
)) - 1))
2462 result
|= *(data
+ cur_byte
) << cur_bitshift
;
2463 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
2464 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
2472 /* Convert from FMT to a DOUBLEST.
2473 FROM is the address of the extended float.
2474 Store the DOUBLEST in *TO. */
2477 floatformat_to_doublest (fmt
, from
, to
)
2478 const struct floatformat
*fmt
;
2482 unsigned char *ufrom
= (unsigned char *)from
;
2486 unsigned int mant_bits
, mant_off
;
2488 int special_exponent
; /* It's a NaN, denorm or zero */
2490 /* If the mantissa bits are not contiguous from one end of the
2491 mantissa to the other, we need to make a private copy of the
2492 source bytes that is in the right order since the unpacking
2493 algorithm assumes that the bits are contiguous.
2495 Swap the bytes individually rather than accessing them through
2496 "long *" since we have no guarantee that they start on a long
2497 alignment, and also sizeof(long) for the host could be different
2498 than sizeof(long) for the target. FIXME: Assumes sizeof(long)
2499 for the target is 4. */
2501 if (fmt
-> byteorder
== floatformat_littlebyte_bigword
)
2503 static unsigned char *newfrom
;
2504 unsigned char *swapin
, *swapout
;
2507 longswaps
= fmt
-> totalsize
/ FLOATFORMAT_CHAR_BIT
;
2510 if (newfrom
== NULL
)
2512 newfrom
= (unsigned char *) xmalloc (fmt
-> totalsize
);
2517 while (longswaps
-- > 0)
2519 /* This is ugly, but efficient */
2520 *swapout
++ = swapin
[4];
2521 *swapout
++ = swapin
[5];
2522 *swapout
++ = swapin
[6];
2523 *swapout
++ = swapin
[7];
2524 *swapout
++ = swapin
[0];
2525 *swapout
++ = swapin
[1];
2526 *swapout
++ = swapin
[2];
2527 *swapout
++ = swapin
[3];
2532 exponent
= get_field (ufrom
, fmt
->byteorder
, fmt
->totalsize
,
2533 fmt
->exp_start
, fmt
->exp_len
);
2534 /* Note that if exponent indicates a NaN, we can't really do anything useful
2535 (not knowing if the host has NaN's, or how to build one). So it will
2536 end up as an infinity or something close; that is OK. */
2538 mant_bits_left
= fmt
->man_len
;
2539 mant_off
= fmt
->man_start
;
2542 special_exponent
= exponent
== 0 || exponent
== fmt
->exp_nan
;
2544 /* Don't bias zero's, denorms or NaNs. */
2545 if (!special_exponent
)
2546 exponent
-= fmt
->exp_bias
;
2548 /* Build the result algebraically. Might go infinite, underflow, etc;
2551 /* If this format uses a hidden bit, explicitly add it in now. Otherwise,
2552 increment the exponent by one to account for the integer bit. */
2554 if (!special_exponent
)
2555 if (fmt
->intbit
== floatformat_intbit_no
)
2556 dto
= ldexp (1.0, exponent
);
2560 while (mant_bits_left
> 0)
2562 mant_bits
= min (mant_bits_left
, 32);
2564 mant
= get_field (ufrom
, fmt
->byteorder
, fmt
->totalsize
,
2565 mant_off
, mant_bits
);
2567 dto
+= ldexp ((double)mant
, exponent
- mant_bits
);
2568 exponent
-= mant_bits
;
2569 mant_off
+= mant_bits
;
2570 mant_bits_left
-= mant_bits
;
2573 /* Negate it if negative. */
2574 if (get_field (ufrom
, fmt
->byteorder
, fmt
->totalsize
, fmt
->sign_start
, 1))
2579 static void put_field
PARAMS ((unsigned char *, enum floatformat_byteorders
,
2585 /* Set a field which starts at START and is LEN bytes long. DATA and
2586 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
2588 put_field (data
, order
, total_len
, start
, len
, stuff_to_put
)
2589 unsigned char *data
;
2590 enum floatformat_byteorders order
;
2591 unsigned int total_len
;
2594 unsigned long stuff_to_put
;
2596 unsigned int cur_byte
;
2599 /* Start at the least significant part of the field. */
2600 cur_byte
= (start
+ len
) / FLOATFORMAT_CHAR_BIT
;
2601 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
2602 cur_byte
= (total_len
/ FLOATFORMAT_CHAR_BIT
) - cur_byte
- 1;
2604 ((start
+ len
) % FLOATFORMAT_CHAR_BIT
) - FLOATFORMAT_CHAR_BIT
;
2605 *(data
+ cur_byte
) &=
2606 ~(((1 << ((start
+ len
) % FLOATFORMAT_CHAR_BIT
)) - 1) << (-cur_bitshift
));
2607 *(data
+ cur_byte
) |=
2608 (stuff_to_put
& ((1 << FLOATFORMAT_CHAR_BIT
) - 1)) << (-cur_bitshift
);
2609 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
2610 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
2615 /* Move towards the most significant part of the field. */
2616 while (cur_bitshift
< len
)
2618 if (len
- cur_bitshift
< FLOATFORMAT_CHAR_BIT
)
2620 /* This is the last byte. */
2621 *(data
+ cur_byte
) &=
2622 ~((1 << (len
- cur_bitshift
)) - 1);
2623 *(data
+ cur_byte
) |= (stuff_to_put
>> cur_bitshift
);
2626 *(data
+ cur_byte
) = ((stuff_to_put
>> cur_bitshift
)
2627 & ((1 << FLOATFORMAT_CHAR_BIT
) - 1));
2628 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
2629 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
2636 #ifdef HAVE_LONG_DOUBLE
2637 /* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR.
2638 The range of the returned value is >= 0.5 and < 1.0. This is equivalent to
2639 frexp, but operates on the long double data type. */
2641 static long double ldfrexp
PARAMS ((long double value
, int *eptr
));
2644 ldfrexp (value
, eptr
)
2651 /* Unfortunately, there are no portable functions for extracting the exponent
2652 of a long double, so we have to do it iteratively by multiplying or dividing
2653 by two until the fraction is between 0.5 and 1.0. */
2661 if (value
>= tmp
) /* Value >= 1.0 */
2662 while (value
>= tmp
)
2667 else if (value
!= 0.0l) /* Value < 1.0 and > 0.0 */
2681 #endif /* HAVE_LONG_DOUBLE */
2684 /* The converse: convert the DOUBLEST *FROM to an extended float
2685 and store where TO points. Neither FROM nor TO have any alignment
2689 floatformat_from_doublest (fmt
, from
, to
)
2690 CONST
struct floatformat
*fmt
;
2697 unsigned int mant_bits
, mant_off
;
2699 unsigned char *uto
= (unsigned char *)to
;
2701 memcpy (&dfrom
, from
, sizeof (dfrom
));
2702 memset (uto
, 0, fmt
->totalsize
/ FLOATFORMAT_CHAR_BIT
);
2704 return; /* Result is zero */
2705 if (dfrom
!= dfrom
) /* Result is NaN */
2708 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->exp_start
,
2709 fmt
->exp_len
, fmt
->exp_nan
);
2710 /* Be sure it's not infinity, but NaN value is irrel */
2711 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->man_start
,
2716 /* If negative, set the sign bit. */
2719 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->sign_start
, 1, 1);
2723 if (dfrom
+ dfrom
== dfrom
&& dfrom
!= 0.0) /* Result is Infinity */
2725 /* Infinity exponent is same as NaN's. */
2726 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->exp_start
,
2727 fmt
->exp_len
, fmt
->exp_nan
);
2728 /* Infinity mantissa is all zeroes. */
2729 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->man_start
,
2734 #ifdef HAVE_LONG_DOUBLE
2735 mant
= ldfrexp (dfrom
, &exponent
);
2737 mant
= frexp (dfrom
, &exponent
);
2740 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->exp_start
, fmt
->exp_len
,
2741 exponent
+ fmt
->exp_bias
- 1);
2743 mant_bits_left
= fmt
->man_len
;
2744 mant_off
= fmt
->man_start
;
2745 while (mant_bits_left
> 0)
2747 unsigned long mant_long
;
2748 mant_bits
= mant_bits_left
< 32 ? mant_bits_left
: 32;
2750 mant
*= 4294967296.0;
2751 mant_long
= (unsigned long)mant
;
2754 /* If the integer bit is implicit, then we need to discard it.
2755 If we are discarding a zero, we should be (but are not) creating
2756 a denormalized number which means adjusting the exponent
2758 if (mant_bits_left
== fmt
->man_len
2759 && fmt
->intbit
== floatformat_intbit_no
)
2767 /* The bits we want are in the most significant MANT_BITS bits of
2768 mant_long. Move them to the least significant. */
2769 mant_long
>>= 32 - mant_bits
;
2772 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
,
2773 mant_off
, mant_bits
, mant_long
);
2774 mant_off
+= mant_bits
;
2775 mant_bits_left
-= mant_bits
;
2777 if (fmt
-> byteorder
== floatformat_littlebyte_bigword
)
2780 unsigned char *swaplow
= uto
;
2781 unsigned char *swaphigh
= uto
+ 4;
2784 for (count
= 0; count
< 4; count
++)
2787 *swaplow
++ = *swaphigh
;
2793 /* temporary storage using circular buffer */
2799 static char buf
[NUMCELLS
][CELLSIZE
];
2801 if (++cell
>=NUMCELLS
) cell
=0;
2805 /* print routines to handle variable size regs, etc.
2807 FIXME: Note that t_addr is a bfd_vma, which is currently either an
2808 unsigned long or unsigned long long, determined at configure time.
2809 If t_addr is an unsigned long long and sizeof (unsigned long long)
2810 is greater than sizeof (unsigned long), then I believe this code will
2811 probably lose, at least for little endian machines. I believe that
2812 it would also be better to eliminate the switch on the absolute size
2813 of t_addr and replace it with a sequence of if statements that compare
2814 sizeof t_addr with sizeof the various types and do the right thing,
2815 which includes knowing whether or not the host supports long long.
2820 static int thirty_two
= 32; /* eliminate warning from compiler on 32-bit systems */
2826 char *paddr_str
=get_cell();
2827 switch (sizeof(t_addr
))
2830 sprintf (paddr_str
, "%08lx%08lx",
2831 (unsigned long) (addr
>> thirty_two
), (unsigned long) (addr
& 0xffffffff));
2834 sprintf (paddr_str
, "%08lx", (unsigned long) addr
);
2837 sprintf (paddr_str
, "%04x", (unsigned short) (addr
& 0xffff));
2840 sprintf (paddr_str
, "%lx", (unsigned long) addr
);
2849 char *preg_str
=get_cell();
2850 switch (sizeof(t_reg
))
2853 sprintf (preg_str
, "%08lx%08lx",
2854 (unsigned long) (reg
>> thirty_two
), (unsigned long) (reg
& 0xffffffff));
2857 sprintf (preg_str
, "%08lx", (unsigned long) reg
);
2860 sprintf (preg_str
, "%04x", (unsigned short) (reg
& 0xffff));
2863 sprintf (preg_str
, "%lx", (unsigned long) reg
);
2872 char *paddr_str
=get_cell();
2873 switch (sizeof(t_addr
))
2877 unsigned long high
= (unsigned long) (addr
>> thirty_two
);
2879 sprintf (paddr_str
, "%lx", (unsigned long) (addr
& 0xffffffff));
2881 sprintf (paddr_str
, "%lx%08lx",
2882 high
, (unsigned long) (addr
& 0xffffffff));
2886 sprintf (paddr_str
, "%lx", (unsigned long) addr
);
2889 sprintf (paddr_str
, "%x", (unsigned short) (addr
& 0xffff));
2892 sprintf (paddr_str
,"%lx", (unsigned long) addr
);
2901 char *preg_str
=get_cell();
2902 switch (sizeof(t_reg
))
2906 unsigned long high
= (unsigned long) (reg
>> thirty_two
);
2908 sprintf (preg_str
, "%lx", (unsigned long) (reg
& 0xffffffff));
2910 sprintf (preg_str
, "%lx%08lx",
2911 high
, (unsigned long) (reg
& 0xffffffff));
2915 sprintf (preg_str
, "%lx", (unsigned long) reg
);
2918 sprintf (preg_str
, "%x", (unsigned short) (reg
& 0xffff));
2921 sprintf (preg_str
, "%lx", (unsigned long) reg
);