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,
19 Boston, MA 02111-1307, USA. */
23 #include "gdb_string.h"
35 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
46 #include "expression.h"
50 #include <readline/readline.h>
52 /* readline defines this. */
55 void (*error_begin_hook
) PARAMS ((void));
57 /* Prototypes for local functions */
59 static void vfprintf_maybe_filtered
PARAMS ((GDB_FILE
*, const char *,
62 static void fputs_maybe_filtered
PARAMS ((const char *, GDB_FILE
*, int));
64 #if defined (USE_MMALLOC) && !defined (NO_MMCHECK)
65 static void malloc_botch
PARAMS ((void));
69 fatal_dump_core
PARAMS ((char *,...));
72 prompt_for_continue
PARAMS ((void));
75 set_width_command
PARAMS ((char *, int, struct cmd_list_element
*));
78 set_width
PARAMS ((void));
80 /* If this definition isn't overridden by the header files, assume
81 that isatty and fileno exist on this system. */
83 #define ISATTY(FP) (isatty (fileno (FP)))
86 #ifndef GDB_FILE_ISATTY
87 #define GDB_FILE_ISATTY(GDB_FILE_PTR) (gdb_file_isatty(GDB_FILE_PTR))
90 /* Chain of cleanup actions established with make_cleanup,
91 to be executed if an error happens. */
93 static struct cleanup
*cleanup_chain
; /* cleaned up after a failed command */
94 static struct cleanup
*final_cleanup_chain
; /* cleaned up when gdb exits */
95 static struct cleanup
*run_cleanup_chain
; /* cleaned up on each 'run' */
96 static struct cleanup
*exec_cleanup_chain
; /* cleaned up on each execution command */
98 /* Pointer to what is left to do for an execution command after the
99 target stops. Used only in asynchronous mode, by targets that
100 support async execution. The finish and until commands use it. So
101 does the target extended-remote command. */
102 struct continuation
*cmd_continuation
;
104 /* Nonzero if we have job control. */
108 /* Nonzero means a quit has been requested. */
112 /* Nonzero means quit immediately if Control-C is typed now, rather
113 than waiting until QUIT is executed. Be careful in setting this;
114 code which executes with immediate_quit set has to be very careful
115 about being able to deal with being interrupted at any time. It is
116 almost always better to use QUIT; the only exception I can think of
117 is being able to quit out of a system call (using EINTR loses if
118 the SIGINT happens between the previous QUIT and the system call).
119 To immediately quit in the case in which a SIGINT happens between
120 the previous QUIT and setting immediate_quit (desirable anytime we
121 expect to block), call QUIT after setting immediate_quit. */
125 /* Nonzero means that encoded C++ names should be printed out in their
126 C++ form rather than raw. */
130 /* Nonzero means that encoded C++ names should be printed out in their
131 C++ form even in assembler language displays. If this is set, but
132 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
134 int asm_demangle
= 0;
136 /* Nonzero means that strings with character values >0x7F should be printed
137 as octal escapes. Zero means just print the value (e.g. it's an
138 international character, and the terminal or window can cope.) */
140 int sevenbit_strings
= 0;
142 /* String to be printed before error messages, if any. */
144 char *error_pre_print
;
146 /* String to be printed before quit messages, if any. */
148 char *quit_pre_print
;
150 /* String to be printed before warning messages, if any. */
152 char *warning_pre_print
= "\nwarning: ";
154 int pagination_enabled
= 1;
157 /* Add a new cleanup to the cleanup_chain,
158 and return the previous chain pointer
159 to be passed later to do_cleanups or discard_cleanups.
160 Args are FUNCTION to clean up with, and ARG to pass to it. */
163 make_cleanup (function
, arg
)
164 void (*function
) PARAMS ((PTR
));
167 return make_my_cleanup (&cleanup_chain
, function
, arg
);
171 make_final_cleanup (function
, arg
)
172 void (*function
) PARAMS ((PTR
));
175 return make_my_cleanup (&final_cleanup_chain
, function
, arg
);
179 make_run_cleanup (function
, arg
)
180 void (*function
) PARAMS ((PTR
));
183 return make_my_cleanup (&run_cleanup_chain
, function
, arg
);
187 make_exec_cleanup (function
, arg
)
188 void (*function
) PARAMS ((PTR
));
191 return make_my_cleanup (&exec_cleanup_chain
, function
, arg
);
198 freeargv ((char **) arg
);
202 make_cleanup_freeargv (arg
)
205 return make_my_cleanup (&cleanup_chain
, do_freeargv
, arg
);
209 make_my_cleanup (pmy_chain
, function
, arg
)
210 struct cleanup
**pmy_chain
;
211 void (*function
) PARAMS ((PTR
));
214 register struct cleanup
*new
215 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
216 register struct cleanup
*old_chain
= *pmy_chain
;
218 new->next
= *pmy_chain
;
219 new->function
= function
;
226 /* Discard cleanups and do the actions they describe
227 until we get back to the point OLD_CHAIN in the cleanup_chain. */
230 do_cleanups (old_chain
)
231 register struct cleanup
*old_chain
;
233 do_my_cleanups (&cleanup_chain
, old_chain
);
237 do_final_cleanups (old_chain
)
238 register struct cleanup
*old_chain
;
240 do_my_cleanups (&final_cleanup_chain
, old_chain
);
244 do_run_cleanups (old_chain
)
245 register struct cleanup
*old_chain
;
247 do_my_cleanups (&run_cleanup_chain
, old_chain
);
251 do_exec_cleanups (old_chain
)
252 register struct cleanup
*old_chain
;
254 do_my_cleanups (&exec_cleanup_chain
, old_chain
);
258 do_my_cleanups (pmy_chain
, old_chain
)
259 register struct cleanup
**pmy_chain
;
260 register struct cleanup
*old_chain
;
262 register struct cleanup
*ptr
;
263 while ((ptr
= *pmy_chain
) != old_chain
)
265 *pmy_chain
= ptr
->next
; /* Do this first incase recursion */
266 (*ptr
->function
) (ptr
->arg
);
271 /* Discard cleanups, not doing the actions they describe,
272 until we get back to the point OLD_CHAIN in the cleanup_chain. */
275 discard_cleanups (old_chain
)
276 register struct cleanup
*old_chain
;
278 discard_my_cleanups (&cleanup_chain
, old_chain
);
282 discard_final_cleanups (old_chain
)
283 register struct cleanup
*old_chain
;
285 discard_my_cleanups (&final_cleanup_chain
, old_chain
);
289 discard_my_cleanups (pmy_chain
, old_chain
)
290 register struct cleanup
**pmy_chain
;
291 register struct cleanup
*old_chain
;
293 register struct cleanup
*ptr
;
294 while ((ptr
= *pmy_chain
) != old_chain
)
296 *pmy_chain
= ptr
->next
;
301 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
305 return save_my_cleanups (&cleanup_chain
);
309 save_final_cleanups ()
311 return save_my_cleanups (&final_cleanup_chain
);
315 save_my_cleanups (pmy_chain
)
316 struct cleanup
**pmy_chain
;
318 struct cleanup
*old_chain
= *pmy_chain
;
324 /* Restore the cleanup chain from a previously saved chain. */
326 restore_cleanups (chain
)
327 struct cleanup
*chain
;
329 restore_my_cleanups (&cleanup_chain
, chain
);
333 restore_final_cleanups (chain
)
334 struct cleanup
*chain
;
336 restore_my_cleanups (&final_cleanup_chain
, chain
);
340 restore_my_cleanups (pmy_chain
, chain
)
341 struct cleanup
**pmy_chain
;
342 struct cleanup
*chain
;
347 /* This function is useful for cleanups.
351 old_chain = make_cleanup (free_current_contents, &foo);
353 to arrange to free the object thus allocated. */
356 free_current_contents (location
)
362 /* Provide a known function that does nothing, to use as a base for
363 for a possibly long chain of cleanups. This is useful where we
364 use the cleanup chain for handling normal cleanups as well as dealing
365 with cleanups that need to be done as a result of a call to error().
366 In such cases, we may not be certain where the first cleanup is, unless
367 we have a do-nothing one to always use as the base. */
376 /* Add a continuation to the continuation list, the gloabl list
379 add_continuation (continuation_hook
, arg_list
)
380 void (*continuation_hook
) PARAMS ((struct continuation_arg
*));
381 struct continuation_arg
*arg_list
;
383 struct continuation
*continuation_ptr
;
385 continuation_ptr
= (struct continuation
*) xmalloc (sizeof (struct continuation
));
386 continuation_ptr
->continuation_hook
= continuation_hook
;
387 continuation_ptr
->arg_list
= arg_list
;
388 continuation_ptr
->next
= cmd_continuation
;
389 cmd_continuation
= continuation_ptr
;
392 /* Walk down the cmd_continuation list, and execute all the
395 do_all_continuations ()
397 struct continuation
*continuation_ptr
;
399 while (cmd_continuation
)
401 (cmd_continuation
->continuation_hook
) (cmd_continuation
->arg_list
);
402 continuation_ptr
= cmd_continuation
;
403 cmd_continuation
= continuation_ptr
->next
;
404 free (continuation_ptr
);
409 /* Print a warning message. Way to use this is to call warning_begin,
410 output the warning message (use unfiltered output to gdb_stderr),
411 ending in a newline. There is not currently a warning_end that you
412 call afterwards, but such a thing might be added if it is useful
413 for a GUI to separate warning messages from other output.
415 FIXME: Why do warnings use unfiltered output and errors filtered?
416 Is this anything other than a historical accident? */
421 target_terminal_ours ();
422 wrap_here (""); /* Force out any buffered output */
423 gdb_flush (gdb_stdout
);
424 if (warning_pre_print
)
425 fprintf_unfiltered (gdb_stderr
, warning_pre_print
);
428 /* Print a warning message.
429 The first argument STRING is the warning message, used as a fprintf string,
430 and the remaining args are passed as arguments to it.
431 The primary difference between warnings and errors is that a warning
432 does not force the return to command level. */
436 #ifdef ANSI_PROTOTYPES
437 warning (const char *string
,...)
444 #ifdef ANSI_PROTOTYPES
445 va_start (args
, string
);
450 string
= va_arg (args
, char *);
453 (*warning_hook
) (string
, args
);
457 vfprintf_unfiltered (gdb_stderr
, string
, args
);
458 fprintf_unfiltered (gdb_stderr
, "\n");
463 /* Start the printing of an error message. Way to use this is to call
464 this, output the error message (use filtered output to gdb_stderr
465 (FIXME: Some callers, like memory_error, use gdb_stdout)), ending
466 in a newline, and then call return_to_top_level (RETURN_ERROR).
467 error() provides a convenient way to do this for the special case
468 that the error message can be formatted with a single printf call,
469 but this is more general. */
473 if (error_begin_hook
)
476 target_terminal_ours ();
477 wrap_here (""); /* Force out any buffered output */
478 gdb_flush (gdb_stdout
);
480 annotate_error_begin ();
483 fprintf_filtered (gdb_stderr
, error_pre_print
);
486 /* Print an error message and return to command level.
487 The first argument STRING is the error message, used as a fprintf string,
488 and the remaining args are passed as arguments to it. */
492 #ifdef ANSI_PROTOTYPES
493 error (const char *string
,...)
500 #ifdef ANSI_PROTOTYPES
501 va_start (args
, string
);
510 #ifdef ANSI_PROTOTYPES
511 vfprintf_filtered (gdb_stderr
, string
, args
);
516 string1
= va_arg (args
, char *);
517 vfprintf_filtered (gdb_stderr
, string1
, args
);
520 fprintf_filtered (gdb_stderr
, "\n");
522 return_to_top_level (RETURN_ERROR
);
527 /* Print an error message and exit reporting failure.
528 This is for a error that we cannot continue from.
529 The arguments are printed a la printf.
531 This function cannot be declared volatile (NORETURN) in an
532 ANSI environment because exit() is not declared volatile. */
536 #ifdef ANSI_PROTOTYPES
537 fatal (char *string
,...)
544 #ifdef ANSI_PROTOTYPES
545 va_start (args
, string
);
549 string
= va_arg (args
, char *);
551 fprintf_unfiltered (gdb_stderr
, "\ngdb: ");
552 vfprintf_unfiltered (gdb_stderr
, string
, args
);
553 fprintf_unfiltered (gdb_stderr
, "\n");
558 /* Print an error message and exit, dumping core.
559 The arguments are printed a la printf (). */
563 #ifdef ANSI_PROTOTYPES
564 fatal_dump_core (char *string
,...)
566 fatal_dump_core (va_alist
)
571 #ifdef ANSI_PROTOTYPES
572 va_start (args
, string
);
577 string
= va_arg (args
, char *);
579 /* "internal error" is always correct, since GDB should never dump
580 core, no matter what the input. */
581 fprintf_unfiltered (gdb_stderr
, "\ngdb internal error: ");
582 vfprintf_unfiltered (gdb_stderr
, string
, args
);
583 fprintf_unfiltered (gdb_stderr
, "\n");
586 signal (SIGQUIT
, SIG_DFL
);
587 kill (getpid (), SIGQUIT
);
588 /* We should never get here, but just in case... */
592 /* The strerror() function can return NULL for errno values that are
593 out of range. Provide a "safe" version that always returns a
597 safe_strerror (errnum
)
603 if ((msg
= strerror (errnum
)) == NULL
)
605 sprintf (buf
, "(undocumented errno %d)", errnum
);
611 /* The strsignal() function can return NULL for signal values that are
612 out of range. Provide a "safe" version that always returns a
616 safe_strsignal (signo
)
622 if ((msg
= strsignal (signo
)) == NULL
)
624 sprintf (buf
, "(undocumented signal %d)", signo
);
631 /* Print the system error message for errno, and also mention STRING
632 as the file name for which the error was encountered.
633 Then return to command level. */
636 perror_with_name (string
)
642 err
= safe_strerror (errno
);
643 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
644 strcpy (combined
, string
);
645 strcat (combined
, ": ");
646 strcat (combined
, err
);
648 /* I understand setting these is a matter of taste. Still, some people
649 may clear errno but not know about bfd_error. Doing this here is not
651 bfd_set_error (bfd_error_no_error
);
654 error ("%s.", combined
);
657 /* Print the system error message for ERRCODE, and also mention STRING
658 as the file name for which the error was encountered. */
661 print_sys_errmsg (string
, errcode
)
668 err
= safe_strerror (errcode
);
669 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
670 strcpy (combined
, string
);
671 strcat (combined
, ": ");
672 strcat (combined
, err
);
674 /* We want anything which was printed on stdout to come out first, before
676 gdb_flush (gdb_stdout
);
677 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
680 /* Control C eventually causes this to be called, at a convenient time. */
685 serial_t gdb_stdout_serial
= serial_fdopen (1);
687 target_terminal_ours ();
689 /* We want all output to appear now, before we print "Quit". We
690 have 3 levels of buffering we have to flush (it's possible that
691 some of these should be changed to flush the lower-level ones
694 /* 1. The _filtered buffer. */
695 wrap_here ((char *) 0);
697 /* 2. The stdio buffer. */
698 gdb_flush (gdb_stdout
);
699 gdb_flush (gdb_stderr
);
701 /* 3. The system-level buffer. */
702 SERIAL_DRAIN_OUTPUT (gdb_stdout_serial
);
703 SERIAL_UN_FDOPEN (gdb_stdout_serial
);
705 annotate_error_begin ();
707 /* Don't use *_filtered; we don't want to prompt the user to continue. */
709 fprintf_unfiltered (gdb_stderr
, quit_pre_print
);
712 /* If there is no terminal switching for this target, then we can't
713 possibly get screwed by the lack of job control. */
714 || current_target
.to_terminal_ours
== NULL
)
715 fprintf_unfiltered (gdb_stderr
, "Quit\n");
717 fprintf_unfiltered (gdb_stderr
,
718 "Quit (expect signal SIGINT when the program is resumed)\n");
719 return_to_top_level (RETURN_QUIT
);
723 #if defined(__GO32__)
725 /* In the absence of signals, poll keyboard for a quit.
726 Called from #define QUIT pollquit() in xm-go32.h. */
741 /* We just ignore it */
742 /* FIXME!! Don't think this actually works! */
743 fprintf_unfiltered (gdb_stderr
, "CTRL-A to quit, CTRL-B to quit harder\n");
748 #elif defined(_MSC_VER) /* should test for wingdb instead? */
751 * Windows translates all keyboard and mouse events
752 * into a message which is appended to the message
753 * queue for the process.
759 int k
= win32pollquit ();
766 #else /* !defined(__GO32__) && !defined(_MSC_VER) */
771 /* Done by signals */
774 #endif /* !defined(__GO32__) && !defined(_MSC_VER) */
776 /* Control C comes here */
782 /* Restore the signal handler. Harmless with BSD-style signals, needed
783 for System V-style signals. So just always do it, rather than worrying
784 about USG defines and stuff like that. */
785 signal (signo
, request_quit
);
795 /* Memory management stuff (malloc friends). */
797 /* Make a substitute size_t for non-ANSI compilers. */
799 #ifndef HAVE_STDDEF_H
801 #define size_t unsigned int
805 #if !defined (USE_MMALLOC)
812 return malloc (size
);
816 mrealloc (md
, ptr
, size
)
821 if (ptr
== 0) /* Guard against old realloc's */
822 return malloc (size
);
824 return realloc (ptr
, size
);
835 #endif /* USE_MMALLOC */
837 #if !defined (USE_MMALLOC) || defined (NO_MMCHECK)
845 #else /* Have mmalloc and want corruption checking */
850 fatal_dump_core ("Memory corruption");
853 /* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified
854 by MD, to detect memory corruption. Note that MD may be NULL to specify
855 the default heap that grows via sbrk.
857 Note that for freshly created regions, we must call mmcheckf prior to any
858 mallocs in the region. Otherwise, any region which was allocated prior to
859 installing the checking hooks, which is later reallocated or freed, will
860 fail the checks! The mmcheck function only allows initial hooks to be
861 installed before the first mmalloc. However, anytime after we have called
862 mmcheck the first time to install the checking hooks, we can call it again
863 to update the function pointer to the memory corruption handler.
865 Returns zero on failure, non-zero on success. */
867 #ifndef MMCHECK_FORCE
868 #define MMCHECK_FORCE 0
875 if (!mmcheckf (md
, malloc_botch
, MMCHECK_FORCE
))
877 /* Don't use warning(), which relies on current_target being set
878 to something other than dummy_target, until after
879 initialize_all_files(). */
882 (gdb_stderr
, "warning: failed to install memory consistency checks; ");
884 (gdb_stderr
, "configuration should define NO_MMCHECK or MMCHECK_FORCE\n");
890 #endif /* Have mmalloc and want corruption checking */
892 /* Called when a memory allocation fails, with the number of bytes of
893 memory requested in SIZE. */
901 fatal ("virtual memory exhausted: can't allocate %ld bytes.", size
);
905 fatal ("virtual memory exhausted.");
909 /* Like mmalloc but get error if no storage available, and protect against
910 the caller wanting to allocate zero bytes. Whether to return NULL for
911 a zero byte request, or translate the request into a request for one
912 byte of zero'd storage, is a religious issue. */
925 else if ((val
= mmalloc (md
, size
)) == NULL
)
932 /* Like mrealloc but get error if no storage available. */
935 xmrealloc (md
, ptr
, size
)
944 val
= mrealloc (md
, ptr
, size
);
948 val
= mmalloc (md
, size
);
957 /* Like malloc but get error if no storage available, and protect against
958 the caller wanting to allocate zero bytes. */
964 return (xmmalloc ((PTR
) NULL
, size
));
967 /* Like mrealloc but get error if no storage available. */
974 return (xmrealloc ((PTR
) NULL
, ptr
, size
));
978 /* My replacement for the read system call.
979 Used like `read' but keeps going if `read' returns too soon. */
982 myread (desc
, addr
, len
)
992 val
= read (desc
, addr
, len
);
1003 /* Make a copy of the string at PTR with SIZE characters
1004 (and add a null character at the end in the copy).
1005 Uses malloc to get the space. Returns the address of the copy. */
1008 savestring (ptr
, size
)
1012 register char *p
= (char *) xmalloc (size
+ 1);
1013 memcpy (p
, ptr
, size
);
1019 msavestring (md
, ptr
, size
)
1024 register char *p
= (char *) xmmalloc (md
, size
+ 1);
1025 memcpy (p
, ptr
, size
);
1030 /* The "const" is so it compiles under DGUX (which prototypes strsave
1031 in <string.h>. FIXME: This should be named "xstrsave", shouldn't it?
1032 Doesn't real strsave return NULL if out of memory? */
1037 return savestring (ptr
, strlen (ptr
));
1045 return (msavestring (md
, ptr
, strlen (ptr
)));
1049 print_spaces (n
, file
)
1051 register GDB_FILE
*file
;
1053 fputs_unfiltered (n_spaces (n
), file
);
1056 /* Print a host address. */
1059 gdb_print_address (addr
, stream
)
1064 /* We could use the %p conversion specifier to fprintf if we had any
1065 way of knowing whether this host supports it. But the following
1066 should work on the Alpha and on 32 bit machines. */
1068 fprintf_filtered (stream
, "0x%lx", (unsigned long) addr
);
1071 /* Ask user a y-or-n question and return 1 iff answer is yes.
1072 Takes three args which are given to printf to print the question.
1073 The first, a control string, should end in "? ".
1074 It should not say how to answer, because we do that. */
1078 #ifdef ANSI_PROTOTYPES
1079 query (char *ctlstr
,...)
1086 register int answer
;
1090 #ifdef ANSI_PROTOTYPES
1091 va_start (args
, ctlstr
);
1095 ctlstr
= va_arg (args
, char *);
1100 return query_hook (ctlstr
, args
);
1103 /* Automatically answer "yes" if input is not from a terminal. */
1104 if (!input_from_terminal_p ())
1107 /* FIXME Automatically answer "yes" if called from MacGDB. */
1114 wrap_here (""); /* Flush any buffered output */
1115 gdb_flush (gdb_stdout
);
1117 if (annotation_level
> 1)
1118 printf_filtered ("\n\032\032pre-query\n");
1120 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1121 printf_filtered ("(y or n) ");
1123 if (annotation_level
> 1)
1124 printf_filtered ("\n\032\032query\n");
1127 /* If not in MacGDB, move to a new line so the entered line doesn't
1128 have a prompt on the front of it. */
1130 fputs_unfiltered ("\n", gdb_stdout
);
1134 gdb_flush (gdb_stdout
);
1137 if (!tui_version
|| cmdWin
== tuiWinWithFocus ())
1139 answer
= fgetc (stdin
);
1142 answer
= (unsigned char) tuiBufferGetc ();
1145 clearerr (stdin
); /* in case of C-d */
1146 if (answer
== EOF
) /* C-d */
1151 /* Eat rest of input line, to EOF or newline */
1152 if ((answer
!= '\n') || (tui_version
&& answer
!= '\r'))
1156 if (!tui_version
|| cmdWin
== tuiWinWithFocus ())
1158 ans2
= fgetc (stdin
);
1161 ans2
= (unsigned char) tuiBufferGetc ();
1165 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1166 TUIDO (((TuiOpaqueFuncPtr
) tui_vStartNewLines
, 1));
1180 printf_filtered ("Please answer y or n.\n");
1183 if (annotation_level
> 1)
1184 printf_filtered ("\n\032\032post-query\n");
1189 /* Parse a C escape sequence. STRING_PTR points to a variable
1190 containing a pointer to the string to parse. That pointer
1191 should point to the character after the \. That pointer
1192 is updated past the characters we use. The value of the
1193 escape sequence is returned.
1195 A negative value means the sequence \ newline was seen,
1196 which is supposed to be equivalent to nothing at all.
1198 If \ is followed by a null character, we return a negative
1199 value and leave the string pointer pointing at the null character.
1201 If \ is followed by 000, we return 0 and leave the string pointer
1202 after the zeros. A value of 0 does not mean end of string. */
1205 parse_escape (string_ptr
)
1208 register int c
= *(*string_ptr
)++;
1212 return 007; /* Bell (alert) char */
1215 case 'e': /* Escape character */
1233 c
= *(*string_ptr
)++;
1235 c
= parse_escape (string_ptr
);
1238 return (c
& 0200) | (c
& 037);
1249 register int i
= c
- '0';
1250 register int count
= 0;
1253 if ((c
= *(*string_ptr
)++) >= '0' && c
<= '7')
1271 /* Print the character C on STREAM as part of the contents of a literal
1272 string whose delimiter is QUOTER. Note that this routine should only
1273 be call for printing things which are independent of the language
1274 of the program being debugged. */
1276 static void printchar
PARAMS ((int c
, void (*do_fputs
) (const char *, GDB_FILE
*), void (*do_fprintf
) (GDB_FILE
*, const char *, ...), GDB_FILE
*stream
, int quoter
));
1279 printchar (c
, do_fputs
, do_fprintf
, stream
, quoter
)
1281 void (*do_fputs
) PARAMS ((const char *, GDB_FILE
*));
1282 void (*do_fprintf
) PARAMS ((GDB_FILE
*, const char *, ...));
1287 c
&= 0xFF; /* Avoid sign bit follies */
1289 if (c
< 0x20 || /* Low control chars */
1290 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1291 (sevenbit_strings
&& c
>= 0x80))
1292 { /* high order bit set */
1296 do_fputs ("\\n", stream
);
1299 do_fputs ("\\b", stream
);
1302 do_fputs ("\\t", stream
);
1305 do_fputs ("\\f", stream
);
1308 do_fputs ("\\r", stream
);
1311 do_fputs ("\\e", stream
);
1314 do_fputs ("\\a", stream
);
1317 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1323 if (c
== '\\' || c
== quoter
)
1324 do_fputs ("\\", stream
);
1325 do_fprintf (stream
, "%c", c
);
1329 /* Print the character C on STREAM as part of the contents of a
1330 literal string whose delimiter is QUOTER. Note that these routines
1331 should only be call for printing things which are independent of
1332 the language of the program being debugged. */
1335 fputstr_filtered (str
, quoter
, stream
)
1341 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1345 fputstr_unfiltered (str
, quoter
, stream
)
1351 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1355 fputstrn_unfiltered (str
, n
, quoter
, stream
)
1362 for (i
= 0; i
< n
; i
++)
1363 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1368 /* Number of lines per page or UINT_MAX if paging is disabled. */
1369 static unsigned int lines_per_page
;
1370 /* Number of chars per line or UNIT_MAX is line folding is disabled. */
1371 static unsigned int chars_per_line
;
1372 /* Current count of lines printed on this page, chars on this line. */
1373 static unsigned int lines_printed
, chars_printed
;
1375 /* Buffer and start column of buffered text, for doing smarter word-
1376 wrapping. When someone calls wrap_here(), we start buffering output
1377 that comes through fputs_filtered(). If we see a newline, we just
1378 spit it out and forget about the wrap_here(). If we see another
1379 wrap_here(), we spit it out and remember the newer one. If we see
1380 the end of the line, we spit out a newline, the indent, and then
1381 the buffered output. */
1383 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1384 are waiting to be output (they have already been counted in chars_printed).
1385 When wrap_buffer[0] is null, the buffer is empty. */
1386 static char *wrap_buffer
;
1388 /* Pointer in wrap_buffer to the next character to fill. */
1389 static char *wrap_pointer
;
1391 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1393 static char *wrap_indent
;
1395 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1396 is not in effect. */
1397 static int wrap_column
;
1400 /* Inialize the lines and chars per page */
1405 if (tui_version
&& m_winPtrNotNull (cmdWin
))
1407 lines_per_page
= cmdWin
->generic
.height
;
1408 chars_per_line
= cmdWin
->generic
.width
;
1413 /* These defaults will be used if we are unable to get the correct
1414 values from termcap. */
1415 #if defined(__GO32__)
1416 lines_per_page
= ScreenRows ();
1417 chars_per_line
= ScreenCols ();
1419 lines_per_page
= 24;
1420 chars_per_line
= 80;
1422 #if !defined (MPW) && !defined (_WIN32)
1423 /* No termcap under MPW, although might be cool to do something
1424 by looking at worksheet or console window sizes. */
1425 /* Initialize the screen height and width from termcap. */
1427 char *termtype
= getenv ("TERM");
1429 /* Positive means success, nonpositive means failure. */
1432 /* 2048 is large enough for all known terminals, according to the
1433 GNU termcap manual. */
1434 char term_buffer
[2048];
1438 status
= tgetent (term_buffer
, termtype
);
1442 int running_in_emacs
= getenv ("EMACS") != NULL
;
1444 val
= tgetnum ("li");
1445 if (val
>= 0 && !running_in_emacs
)
1446 lines_per_page
= val
;
1448 /* The number of lines per page is not mentioned
1449 in the terminal description. This probably means
1450 that paging is not useful (e.g. emacs shell window),
1451 so disable paging. */
1452 lines_per_page
= UINT_MAX
;
1454 val
= tgetnum ("co");
1456 chars_per_line
= val
;
1462 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1464 /* If there is a better way to determine the window size, use it. */
1465 SIGWINCH_HANDLER (SIGWINCH
);
1468 /* If the output is not a terminal, don't paginate it. */
1469 if (!GDB_FILE_ISATTY (gdb_stdout
))
1470 lines_per_page
= UINT_MAX
;
1471 } /* the command_line_version */
1478 if (chars_per_line
== 0)
1483 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1484 wrap_buffer
[0] = '\0';
1487 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1488 wrap_pointer
= wrap_buffer
; /* Start it at the beginning */
1493 set_width_command (args
, from_tty
, c
)
1496 struct cmd_list_element
*c
;
1501 /* Wait, so the user can read what's on the screen. Prompt the user
1502 to continue by pressing RETURN. */
1505 prompt_for_continue ()
1508 char cont_prompt
[120];
1510 if (annotation_level
> 1)
1511 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1513 strcpy (cont_prompt
,
1514 "---Type <return> to continue, or q <return> to quit---");
1515 if (annotation_level
> 1)
1516 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1518 /* We must do this *before* we call gdb_readline, else it will eventually
1519 call us -- thinking that we're trying to print beyond the end of the
1521 reinitialize_more_filter ();
1524 /* On a real operating system, the user can quit with SIGINT.
1527 'q' is provided on all systems so users don't have to change habits
1528 from system to system, and because telling them what to do in
1529 the prompt is more user-friendly than expecting them to think of
1531 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1532 whereas control-C to gdb_readline will cause the user to get dumped
1534 ignore
= readline (cont_prompt
);
1536 if (annotation_level
> 1)
1537 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1542 while (*p
== ' ' || *p
== '\t')
1547 request_quit (SIGINT
);
1549 async_request_quit (0);
1555 /* Now we have to do this again, so that GDB will know that it doesn't
1556 need to save the ---Type <return>--- line at the top of the screen. */
1557 reinitialize_more_filter ();
1559 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1562 /* Reinitialize filter; ie. tell it to reset to original values. */
1565 reinitialize_more_filter ()
1571 /* Indicate that if the next sequence of characters overflows the line,
1572 a newline should be inserted here rather than when it hits the end.
1573 If INDENT is non-null, it is a string to be printed to indent the
1574 wrapped part on the next line. INDENT must remain accessible until
1575 the next call to wrap_here() or until a newline is printed through
1578 If the line is already overfull, we immediately print a newline and
1579 the indentation, and disable further wrapping.
1581 If we don't know the width of lines, but we know the page height,
1582 we must not wrap words, but should still keep track of newlines
1583 that were explicitly printed.
1585 INDENT should not contain tabs, as that will mess up the char count
1586 on the next line. FIXME.
1588 This routine is guaranteed to force out any output which has been
1589 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1590 used to force out output from the wrap_buffer. */
1596 /* This should have been allocated, but be paranoid anyway. */
1602 *wrap_pointer
= '\0';
1603 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1605 wrap_pointer
= wrap_buffer
;
1606 wrap_buffer
[0] = '\0';
1607 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1611 else if (chars_printed
>= chars_per_line
)
1613 puts_filtered ("\n");
1615 puts_filtered (indent
);
1620 wrap_column
= chars_printed
;
1624 wrap_indent
= indent
;
1628 /* Ensure that whatever gets printed next, using the filtered output
1629 commands, starts at the beginning of the line. I.E. if there is
1630 any pending output for the current line, flush it and start a new
1631 line. Otherwise do nothing. */
1636 if (chars_printed
> 0)
1638 puts_filtered ("\n");
1643 /* ``struct gdb_file'' implementation that maps directly onto
1644 <stdio.h>'s FILE. */
1646 static gdb_file_fputs_ftype stdio_file_fputs
;
1647 static gdb_file_isatty_ftype stdio_file_isatty
;
1648 static gdb_file_delete_ftype stdio_file_delete
;
1649 static struct gdb_file
*stdio_file_new
PARAMS ((FILE * file
, int close_p
));
1650 static gdb_file_flush_ftype stdio_file_flush
;
1652 static int stdio_file_magic
;
1661 static struct gdb_file
*
1662 stdio_file_new (file
, close_p
)
1666 struct gdb_file
*gdb_file
= gdb_file_new ();
1667 struct stdio_file
*stdio
= xmalloc (sizeof (struct stdio_file
));
1668 stdio
->magic
= &stdio_file_magic
;
1670 stdio
->close_p
= close_p
;
1671 set_gdb_file_data (gdb_file
, stdio
, stdio_file_delete
);
1672 set_gdb_file_flush (gdb_file
, stdio_file_flush
);
1673 set_gdb_file_fputs (gdb_file
, stdio_file_fputs
);
1674 set_gdb_file_isatty (gdb_file
, stdio_file_isatty
);
1679 stdio_file_delete (file
)
1680 struct gdb_file
*file
;
1682 struct stdio_file
*stdio
= gdb_file_data (file
);
1683 if (stdio
->magic
!= &stdio_file_magic
)
1684 error ("Internal error: bad magic number");
1687 fclose (stdio
->file
);
1693 stdio_file_flush (file
)
1694 struct gdb_file
*file
;
1696 struct stdio_file
*stdio
= gdb_file_data (file
);
1697 if (stdio
->magic
!= &stdio_file_magic
)
1698 error ("Internal error: bad magic number");
1699 fflush (stdio
->file
);
1703 stdio_file_fputs (linebuffer
, file
)
1704 const char *linebuffer
;
1705 struct gdb_file
*file
;
1707 struct stdio_file
*stdio
= gdb_file_data (file
);
1708 if (stdio
->magic
!= &stdio_file_magic
)
1709 error ("Internal error: bad magic number");
1710 fputs (linebuffer
, stdio
->file
);
1714 stdio_file_isatty (file
)
1715 struct gdb_file
*file
;
1717 struct stdio_file
*stdio
= gdb_file_data (file
);
1718 if (stdio
->magic
!= &stdio_file_magic
)
1719 error ("Internal error: bad magic number");
1720 return (isatty (fileno (stdio
->file
)));
1723 /* Like fdopen(). Create a gdb_file from a previously opened FILE. */
1726 stdio_fileopen (file
)
1729 return stdio_file_new (file
, 0);
1733 /* A ``struct gdb_file'' that is compatible with all the legacy
1736 static gdb_file_flush_ftype tui_file_flush
;
1737 extern gdb_file_fputs_ftype tui_file_fputs
;
1738 static gdb_file_isatty_ftype tui_file_isatty
;
1739 static gdb_file_rewind_ftype tui_file_rewind
;
1740 static gdb_file_put_ftype tui_file_put
;
1741 static gdb_file_delete_ftype tui_file_delete
;
1742 static struct gdb_file
*tui_file_new
PARAMS ((void));
1743 static int tui_file_magic
;
1745 static struct gdb_file
*
1748 struct tui_stream
*tui
= xmalloc (sizeof (struct tui_stream
));
1749 struct gdb_file
*file
= gdb_file_new ();
1750 set_gdb_file_data (file
, tui
, tui_file_delete
);
1751 set_gdb_file_flush (file
, tui_file_flush
);
1752 set_gdb_file_fputs (file
, tui_file_fputs
);
1753 set_gdb_file_isatty (file
, tui_file_isatty
);
1754 set_gdb_file_rewind (file
, tui_file_rewind
);
1755 set_gdb_file_put (file
, tui_file_put
);
1756 tui
->ts_magic
= &tui_file_magic
;
1761 tui_file_delete (file
)
1762 struct gdb_file
*file
;
1764 struct tui_stream
*tmpstream
= gdb_file_data (file
);
1765 if (tmpstream
->ts_magic
!= &tui_file_magic
)
1766 error ("Internal error: bad magic number");
1767 if ((tmpstream
->ts_streamtype
== astring
) &&
1768 (tmpstream
->ts_strbuf
!= NULL
))
1770 free (tmpstream
->ts_strbuf
);
1776 tui_fileopen (stream
)
1779 struct gdb_file
*file
= tui_file_new ();
1780 struct tui_stream
*tmpstream
= gdb_file_data (file
);
1781 tmpstream
->ts_streamtype
= afile
;
1782 tmpstream
->ts_filestream
= stream
;
1783 tmpstream
->ts_strbuf
= NULL
;
1784 tmpstream
->ts_buflen
= 0;
1789 tui_file_isatty (file
)
1790 struct gdb_file
*file
;
1792 struct tui_stream
*stream
= gdb_file_data (file
);
1793 if (stream
->ts_magic
!= &tui_file_magic
)
1794 error ("Internal error: bad magic number");
1795 if (stream
->ts_streamtype
== afile
)
1796 return (isatty (fileno (stream
->ts_filestream
)));
1802 tui_file_rewind (file
)
1803 struct gdb_file
*file
;
1805 struct tui_stream
*stream
= gdb_file_data (file
);
1806 if (stream
->ts_magic
!= &tui_file_magic
)
1807 error ("Internal error: bad magic number");
1808 stream
->ts_strbuf
[0] = '\0';
1812 tui_file_put (file
, dest
)
1813 struct gdb_file
*file
;
1814 struct gdb_file
*dest
;
1816 struct tui_stream
*stream
= gdb_file_data (file
);
1817 if (stream
->ts_magic
!= &tui_file_magic
)
1818 error ("Internal error: bad magic number");
1819 if (stream
->ts_streamtype
== astring
)
1821 fputs_unfiltered (stream
->ts_strbuf
, dest
);
1826 gdb_file_init_astring (n
)
1829 struct gdb_file
*file
= tui_file_new ();
1830 struct tui_stream
*tmpstream
= gdb_file_data (file
);
1831 if (tmpstream
->ts_magic
!= &tui_file_magic
)
1832 error ("Internal error: bad magic number");
1834 tmpstream
->ts_streamtype
= astring
;
1835 tmpstream
->ts_filestream
= NULL
;
1838 tmpstream
->ts_strbuf
= xmalloc ((n
+ 1) * sizeof (char));
1839 tmpstream
->ts_strbuf
[0] = '\0';
1842 tmpstream
->ts_strbuf
= NULL
;
1843 tmpstream
->ts_buflen
= n
;
1849 gdb_file_deallocate (streamptr
)
1850 GDB_FILE
**streamptr
;
1852 gdb_file_delete (*streamptr
);
1857 gdb_file_get_strbuf (file
)
1860 struct tui_stream
*stream
= gdb_file_data (file
);
1861 if (stream
->ts_magic
!= &tui_file_magic
)
1862 error ("Internal error: bad magic number");
1863 return (stream
->ts_strbuf
);
1866 /* adjust the length of the buffer by the amount necessary
1867 to accomodate appending a string of length N to the buffer contents */
1869 gdb_file_adjust_strbuf (n
, file
)
1873 struct tui_stream
*stream
= gdb_file_data (file
);
1875 if (stream
->ts_magic
!= &tui_file_magic
)
1876 error ("Internal error: bad magic number");
1878 if (stream
->ts_streamtype
!= astring
)
1881 if (stream
->ts_strbuf
)
1883 /* There is already a buffer allocated */
1884 non_null_chars
= strlen (stream
->ts_strbuf
);
1886 if (n
> (stream
->ts_buflen
- non_null_chars
- 1))
1888 stream
->ts_buflen
= n
+ non_null_chars
+ 1;
1889 stream
->ts_strbuf
= xrealloc (stream
->ts_strbuf
, stream
->ts_buflen
);
1893 /* No buffer yet, so allocate one of the desired size */
1894 stream
->ts_strbuf
= xmalloc ((n
+ 1) * sizeof (char));
1898 gdb_fopen (name
, mode
)
1902 FILE *f
= fopen (name
, mode
);
1905 return stdio_file_new (f
, 1);
1909 tui_file_flush (file
)
1912 struct tui_stream
*stream
= gdb_file_data (file
);
1913 if (stream
->ts_magic
!= &tui_file_magic
)
1914 error ("Internal error: bad magic number");
1916 && (file
== gdb_stdout
1917 || file
== gdb_stderr
))
1923 fflush (stream
->ts_filestream
);
1927 gdb_fclose (streamptr
)
1928 GDB_FILE
**streamptr
;
1930 gdb_file_delete (*streamptr
);
1935 /* Implement the ``struct gdb_file'' object. */
1937 static gdb_file_isatty_ftype null_file_isatty
;
1938 static gdb_file_fputs_ftype null_file_fputs
;
1939 static gdb_file_flush_ftype null_file_flush
;
1940 static gdb_file_delete_ftype null_file_delete
;
1941 static gdb_file_rewind_ftype null_file_rewind
;
1942 static gdb_file_put_ftype null_file_put
;
1946 gdb_file_flush_ftype
*to_flush
;
1947 gdb_file_fputs_ftype
*to_fputs
;
1948 gdb_file_delete_ftype
*to_delete
;
1949 gdb_file_isatty_ftype
*to_isatty
;
1950 gdb_file_rewind_ftype
*to_rewind
;
1951 gdb_file_put_ftype
*to_put
;
1958 struct gdb_file
*file
= xmalloc (sizeof (struct gdb_file
));
1959 set_gdb_file_data (file
, NULL
, null_file_delete
);
1960 set_gdb_file_flush (file
, null_file_flush
);
1961 set_gdb_file_fputs (file
, null_file_fputs
);
1962 set_gdb_file_isatty (file
, null_file_isatty
);
1963 set_gdb_file_rewind (file
, null_file_rewind
);
1964 set_gdb_file_put (file
, null_file_put
);
1969 gdb_file_delete (file
)
1970 struct gdb_file
*file
;
1972 file
->to_delete (file
);
1977 null_file_isatty (file
)
1978 struct gdb_file
*file
;
1984 null_file_rewind (file
)
1985 struct gdb_file
*file
;
1991 null_file_put (file
, src
)
1992 struct gdb_file
*file
;
1993 struct gdb_file
*src
;
1999 null_file_flush (file
)
2000 struct gdb_file
*file
;
2006 null_file_fputs (buf
, file
)
2008 struct gdb_file
*file
;
2014 null_file_delete (file
)
2015 struct gdb_file
*file
;
2021 gdb_file_data (file
)
2022 struct gdb_file
*file
;
2024 return file
->to_data
;
2029 struct gdb_file
*file
;
2031 file
->to_flush (file
);
2035 gdb_file_isatty (file
)
2036 struct gdb_file
*file
;
2038 return file
->to_isatty (file
);
2042 gdb_file_rewind (file
)
2043 struct gdb_file
*file
;
2045 file
->to_rewind (file
);
2049 gdb_file_put (file
, dest
)
2050 struct gdb_file
*file
;
2051 struct gdb_file
*dest
;
2053 file
->to_put (file
, dest
);
2057 fputs_unfiltered (buf
, file
)
2059 struct gdb_file
*file
;
2061 file
->to_fputs (buf
, file
);
2065 set_gdb_file_flush (file
, flush
)
2066 struct gdb_file
*file
;
2067 gdb_file_flush_ftype
*flush
;
2069 file
->to_flush
= flush
;
2073 set_gdb_file_isatty (file
, isatty
)
2074 struct gdb_file
*file
;
2075 gdb_file_isatty_ftype
*isatty
;
2077 file
->to_isatty
= isatty
;
2081 set_gdb_file_rewind (file
, rewind
)
2082 struct gdb_file
*file
;
2083 gdb_file_rewind_ftype
*rewind
;
2085 file
->to_rewind
= rewind
;
2089 set_gdb_file_put (file
, put
)
2090 struct gdb_file
*file
;
2091 gdb_file_put_ftype
*put
;
2097 set_gdb_file_fputs (file
, fputs
)
2098 struct gdb_file
*file
;
2099 gdb_file_fputs_ftype
*fputs
;
2101 file
->to_fputs
= fputs
;
2105 set_gdb_file_data (file
, data
, delete)
2106 struct gdb_file
*file
;
2108 gdb_file_delete_ftype
*delete;
2110 file
->to_data
= data
;
2111 file
->to_delete
= delete;
2114 /* Like fputs but if FILTER is true, pause after every screenful.
2116 Regardless of FILTER can wrap at points other than the final
2117 character of a line.
2119 Unlike fputs, fputs_maybe_filtered does not return a value.
2120 It is OK for LINEBUFFER to be NULL, in which case just don't print
2123 Note that a longjmp to top level may occur in this routine (only if
2124 FILTER is true) (since prompt_for_continue may do so) so this
2125 routine should not be called when cleanups are not in place. */
2128 fputs_maybe_filtered (linebuffer
, stream
, filter
)
2129 const char *linebuffer
;
2133 const char *lineptr
;
2135 if (linebuffer
== 0)
2138 /* Don't do any filtering if it is disabled. */
2139 if ((stream
!= gdb_stdout
) || !pagination_enabled
2140 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
2142 fputs_unfiltered (linebuffer
, stream
);
2146 /* Go through and output each character. Show line extension
2147 when this is necessary; prompt user for new page when this is
2150 lineptr
= linebuffer
;
2153 /* Possible new page. */
2155 (lines_printed
>= lines_per_page
- 1))
2156 prompt_for_continue ();
2158 while (*lineptr
&& *lineptr
!= '\n')
2160 /* Print a single line. */
2161 if (*lineptr
== '\t')
2164 *wrap_pointer
++ = '\t';
2166 fputc_unfiltered ('\t', stream
);
2167 /* Shifting right by 3 produces the number of tab stops
2168 we have already passed, and then adding one and
2169 shifting left 3 advances to the next tab stop. */
2170 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
2176 *wrap_pointer
++ = *lineptr
;
2178 fputc_unfiltered (*lineptr
, stream
);
2183 if (chars_printed
>= chars_per_line
)
2185 unsigned int save_chars
= chars_printed
;
2189 /* If we aren't actually wrapping, don't output newline --
2190 if chars_per_line is right, we probably just overflowed
2191 anyway; if it's wrong, let us keep going. */
2193 fputc_unfiltered ('\n', stream
);
2195 /* Possible new page. */
2196 if (lines_printed
>= lines_per_page
- 1)
2197 prompt_for_continue ();
2199 /* Now output indentation and wrapped string */
2202 fputs_unfiltered (wrap_indent
, stream
);
2203 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
2204 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
2205 /* FIXME, this strlen is what prevents wrap_indent from
2206 containing tabs. However, if we recurse to print it
2207 and count its chars, we risk trouble if wrap_indent is
2208 longer than (the user settable) chars_per_line.
2209 Note also that this can set chars_printed > chars_per_line
2210 if we are printing a long string. */
2211 chars_printed
= strlen (wrap_indent
)
2212 + (save_chars
- wrap_column
);
2213 wrap_pointer
= wrap_buffer
; /* Reset buffer */
2214 wrap_buffer
[0] = '\0';
2215 wrap_column
= 0; /* And disable fancy wrap */
2220 if (*lineptr
== '\n')
2223 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
2225 fputc_unfiltered ('\n', stream
);
2232 fputs_filtered (linebuffer
, stream
)
2233 const char *linebuffer
;
2236 fputs_maybe_filtered (linebuffer
, stream
, 1);
2240 putchar_unfiltered (c
)
2247 fputs_unfiltered (buf
, gdb_stdout
);
2252 fputc_unfiltered (c
, stream
)
2260 fputs_unfiltered (buf
, stream
);
2265 fputc_filtered (c
, stream
)
2273 fputs_filtered (buf
, stream
);
2277 /* puts_debug is like fputs_unfiltered, except it prints special
2278 characters in printable fashion. */
2281 puts_debug (prefix
, string
, suffix
)
2288 /* Print prefix and suffix after each line. */
2289 static int new_line
= 1;
2290 static int return_p
= 0;
2291 static char *prev_prefix
= "";
2292 static char *prev_suffix
= "";
2294 if (*string
== '\n')
2297 /* If the prefix is changing, print the previous suffix, a new line,
2298 and the new prefix. */
2299 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2301 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2302 fputs_unfiltered ("\n", gdb_stdlog
);
2303 fputs_unfiltered (prefix
, gdb_stdlog
);
2306 /* Print prefix if we printed a newline during the previous call. */
2310 fputs_unfiltered (prefix
, gdb_stdlog
);
2313 prev_prefix
= prefix
;
2314 prev_suffix
= suffix
;
2316 /* Output characters in a printable format. */
2317 while ((ch
= *string
++) != '\0')
2323 fputc_unfiltered (ch
, gdb_stdlog
);
2326 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2330 fputs_unfiltered ("\\\\", gdb_stdlog
);
2333 fputs_unfiltered ("\\b", gdb_stdlog
);
2336 fputs_unfiltered ("\\f", gdb_stdlog
);
2340 fputs_unfiltered ("\\n", gdb_stdlog
);
2343 fputs_unfiltered ("\\r", gdb_stdlog
);
2346 fputs_unfiltered ("\\t", gdb_stdlog
);
2349 fputs_unfiltered ("\\v", gdb_stdlog
);
2353 return_p
= ch
== '\r';
2356 /* Print suffix if we printed a newline. */
2359 fputs_unfiltered (suffix
, gdb_stdlog
);
2360 fputs_unfiltered ("\n", gdb_stdlog
);
2365 /* Print a variable number of ARGS using format FORMAT. If this
2366 information is going to put the amount written (since the last call
2367 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2368 call prompt_for_continue to get the users permision to continue.
2370 Unlike fprintf, this function does not return a value.
2372 We implement three variants, vfprintf (takes a vararg list and stream),
2373 fprintf (takes a stream to write on), and printf (the usual).
2375 Note also that a longjmp to top level may occur in this routine
2376 (since prompt_for_continue may do so) so this routine should not be
2377 called when cleanups are not in place. */
2380 vfprintf_maybe_filtered (stream
, format
, args
, filter
)
2387 struct cleanup
*old_cleanups
;
2389 vasprintf (&linebuffer
, format
, args
);
2390 if (linebuffer
== NULL
)
2392 fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr
);
2395 old_cleanups
= make_cleanup (free
, linebuffer
);
2396 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2397 do_cleanups (old_cleanups
);
2402 vfprintf_filtered (stream
, format
, args
)
2407 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2411 vfprintf_unfiltered (stream
, format
, args
)
2417 struct cleanup
*old_cleanups
;
2419 vasprintf (&linebuffer
, format
, args
);
2420 if (linebuffer
== NULL
)
2422 fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr
);
2425 old_cleanups
= make_cleanup (free
, linebuffer
);
2426 fputs_unfiltered (linebuffer
, stream
);
2427 do_cleanups (old_cleanups
);
2431 vprintf_filtered (format
, args
)
2435 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2439 vprintf_unfiltered (format
, args
)
2443 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2448 #ifdef ANSI_PROTOTYPES
2449 fprintf_filtered (GDB_FILE
* stream
, const char *format
,...)
2451 fprintf_filtered (va_alist
)
2456 #ifdef ANSI_PROTOTYPES
2457 va_start (args
, format
);
2463 stream
= va_arg (args
, GDB_FILE
*);
2464 format
= va_arg (args
, char *);
2466 vfprintf_filtered (stream
, format
, args
);
2472 #ifdef ANSI_PROTOTYPES
2473 fprintf_unfiltered (GDB_FILE
* stream
, const char *format
,...)
2475 fprintf_unfiltered (va_alist
)
2480 #ifdef ANSI_PROTOTYPES
2481 va_start (args
, format
);
2487 stream
= va_arg (args
, GDB_FILE
*);
2488 format
= va_arg (args
, char *);
2490 vfprintf_unfiltered (stream
, format
, args
);
2494 /* Like fprintf_filtered, but prints its result indented.
2495 Called as fprintfi_filtered (spaces, stream, format, ...); */
2499 #ifdef ANSI_PROTOTYPES
2500 fprintfi_filtered (int spaces
, GDB_FILE
* stream
, const char *format
,...)
2502 fprintfi_filtered (va_alist
)
2507 #ifdef ANSI_PROTOTYPES
2508 va_start (args
, format
);
2515 spaces
= va_arg (args
, int);
2516 stream
= va_arg (args
, GDB_FILE
*);
2517 format
= va_arg (args
, char *);
2519 print_spaces_filtered (spaces
, stream
);
2521 vfprintf_filtered (stream
, format
, args
);
2528 #ifdef ANSI_PROTOTYPES
2529 printf_filtered (const char *format
,...)
2531 printf_filtered (va_alist
)
2536 #ifdef ANSI_PROTOTYPES
2537 va_start (args
, format
);
2542 format
= va_arg (args
, char *);
2544 vfprintf_filtered (gdb_stdout
, format
, args
);
2551 #ifdef ANSI_PROTOTYPES
2552 printf_unfiltered (const char *format
,...)
2554 printf_unfiltered (va_alist
)
2559 #ifdef ANSI_PROTOTYPES
2560 va_start (args
, format
);
2565 format
= va_arg (args
, char *);
2567 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2571 /* Like printf_filtered, but prints it's result indented.
2572 Called as printfi_filtered (spaces, format, ...); */
2576 #ifdef ANSI_PROTOTYPES
2577 printfi_filtered (int spaces
, const char *format
,...)
2579 printfi_filtered (va_alist
)
2584 #ifdef ANSI_PROTOTYPES
2585 va_start (args
, format
);
2591 spaces
= va_arg (args
, int);
2592 format
= va_arg (args
, char *);
2594 print_spaces_filtered (spaces
, gdb_stdout
);
2595 vfprintf_filtered (gdb_stdout
, format
, args
);
2599 /* Easy -- but watch out!
2601 This routine is *not* a replacement for puts()! puts() appends a newline.
2602 This one doesn't, and had better not! */
2605 puts_filtered (string
)
2608 fputs_filtered (string
, gdb_stdout
);
2612 puts_unfiltered (string
)
2615 fputs_unfiltered (string
, gdb_stdout
);
2618 /* Return a pointer to N spaces and a null. The pointer is good
2619 until the next call to here. */
2625 static char *spaces
= 0;
2626 static int max_spaces
= -1;
2632 spaces
= (char *) xmalloc (n
+ 1);
2633 for (t
= spaces
+ n
; t
!= spaces
;)
2639 return spaces
+ max_spaces
- n
;
2642 /* Print N spaces. */
2644 print_spaces_filtered (n
, stream
)
2648 fputs_filtered (n_spaces (n
), stream
);
2651 /* C++ demangler stuff. */
2653 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2654 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2655 If the name is not mangled, or the language for the name is unknown, or
2656 demangling is off, the name is printed in its "raw" form. */
2659 fprintf_symbol_filtered (stream
, name
, lang
, arg_mode
)
2669 /* If user wants to see raw output, no problem. */
2672 fputs_filtered (name
, stream
);
2678 case language_cplus
:
2679 demangled
= cplus_demangle (name
, arg_mode
);
2682 demangled
= cplus_demangle (name
, arg_mode
| DMGL_JAVA
);
2684 case language_chill
:
2685 demangled
= chill_demangle (name
);
2691 fputs_filtered (demangled
? demangled
: name
, stream
);
2692 if (demangled
!= NULL
)
2700 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2701 differences in whitespace. Returns 0 if they match, non-zero if they
2702 don't (slightly different than strcmp()'s range of return values).
2704 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2705 This "feature" is useful when searching for matching C++ function names
2706 (such as if the user types 'break FOO', where FOO is a mangled C++
2710 strcmp_iw (string1
, string2
)
2711 const char *string1
;
2712 const char *string2
;
2714 while ((*string1
!= '\0') && (*string2
!= '\0'))
2716 while (isspace (*string1
))
2720 while (isspace (*string2
))
2724 if (*string1
!= *string2
)
2728 if (*string1
!= '\0')
2734 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2740 ** Answer whether string_to_compare is a full or partial match to
2741 ** template_string. The partial match must be in sequence starting
2745 subset_compare (string_to_compare
, template_string
)
2746 char *string_to_compare
;
2747 char *template_string
;
2750 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
&&
2751 strlen (string_to_compare
) <= strlen (template_string
))
2752 match
= (strncmp (template_string
,
2754 strlen (string_to_compare
)) == 0);
2761 static void pagination_on_command
PARAMS ((char *arg
, int from_tty
));
2763 pagination_on_command (arg
, from_tty
)
2767 pagination_enabled
= 1;
2770 static void pagination_on_command
PARAMS ((char *arg
, int from_tty
));
2772 pagination_off_command (arg
, from_tty
)
2776 pagination_enabled
= 0;
2783 struct cmd_list_element
*c
;
2785 c
= add_set_cmd ("width", class_support
, var_uinteger
,
2786 (char *) &chars_per_line
,
2787 "Set number of characters gdb thinks are in a line.",
2789 add_show_from_set (c
, &showlist
);
2790 c
->function
.sfunc
= set_width_command
;
2793 (add_set_cmd ("height", class_support
,
2794 var_uinteger
, (char *) &lines_per_page
,
2795 "Set number of lines gdb thinks are in a page.", &setlist
),
2800 /* If the output is not a terminal, don't paginate it. */
2801 if (!GDB_FILE_ISATTY (gdb_stdout
))
2802 lines_per_page
= UINT_MAX
;
2804 set_width_command ((char *) NULL
, 0, c
);
2807 (add_set_cmd ("demangle", class_support
, var_boolean
,
2809 "Set demangling of encoded C++ names when displaying symbols.",
2814 (add_set_cmd ("pagination", class_support
,
2815 var_boolean
, (char *) &pagination_enabled
,
2816 "Set state of pagination.", &setlist
),
2820 add_com ("am", class_support
, pagination_on_command
,
2821 "Enable pagination");
2822 add_com ("sm", class_support
, pagination_off_command
,
2823 "Disable pagination");
2827 (add_set_cmd ("sevenbit-strings", class_support
, var_boolean
,
2828 (char *) &sevenbit_strings
,
2829 "Set printing of 8-bit characters in strings as \\nnn.",
2834 (add_set_cmd ("asm-demangle", class_support
, var_boolean
,
2835 (char *) &asm_demangle
,
2836 "Set demangling of C++ names in disassembly listings.",
2841 /* Machine specific function to handle SIGWINCH signal. */
2843 #ifdef SIGWINCH_HANDLER_BODY
2844 SIGWINCH_HANDLER_BODY
2847 /* Support for converting target fp numbers into host DOUBLEST format. */
2849 /* XXX - This code should really be in libiberty/floatformat.c, however
2850 configuration issues with libiberty made this very difficult to do in the
2853 #include "floatformat.h"
2854 #include <math.h> /* ldexp */
2856 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
2857 going to bother with trying to muck around with whether it is defined in
2858 a system header, what we do if not, etc. */
2859 #define FLOATFORMAT_CHAR_BIT 8
2861 static unsigned long get_field
PARAMS ((unsigned char *,
2862 enum floatformat_byteorders
,
2867 /* Extract a field which starts at START and is LEN bytes long. DATA and
2868 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
2869 static unsigned long
2870 get_field (data
, order
, total_len
, start
, len
)
2871 unsigned char *data
;
2872 enum floatformat_byteorders order
;
2873 unsigned int total_len
;
2877 unsigned long result
;
2878 unsigned int cur_byte
;
2881 /* Start at the least significant part of the field. */
2882 cur_byte
= (start
+ len
) / FLOATFORMAT_CHAR_BIT
;
2883 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
2884 cur_byte
= (total_len
/ FLOATFORMAT_CHAR_BIT
) - cur_byte
- 1;
2886 ((start
+ len
) % FLOATFORMAT_CHAR_BIT
) - FLOATFORMAT_CHAR_BIT
;
2887 result
= *(data
+ cur_byte
) >> (-cur_bitshift
);
2888 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
2889 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
2894 /* Move towards the most significant part of the field. */
2895 while (cur_bitshift
< len
)
2897 if (len
- cur_bitshift
< FLOATFORMAT_CHAR_BIT
)
2898 /* This is the last byte; zero out the bits which are not part of
2901 (*(data
+ cur_byte
) & ((1 << (len
- cur_bitshift
)) - 1))
2904 result
|= *(data
+ cur_byte
) << cur_bitshift
;
2905 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
2906 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
2914 /* Convert from FMT to a DOUBLEST.
2915 FROM is the address of the extended float.
2916 Store the DOUBLEST in *TO. */
2919 floatformat_to_doublest (fmt
, from
, to
)
2920 const struct floatformat
*fmt
;
2924 unsigned char *ufrom
= (unsigned char *) from
;
2928 unsigned int mant_bits
, mant_off
;
2930 int special_exponent
; /* It's a NaN, denorm or zero */
2932 /* If the mantissa bits are not contiguous from one end of the
2933 mantissa to the other, we need to make a private copy of the
2934 source bytes that is in the right order since the unpacking
2935 algorithm assumes that the bits are contiguous.
2937 Swap the bytes individually rather than accessing them through
2938 "long *" since we have no guarantee that they start on a long
2939 alignment, and also sizeof(long) for the host could be different
2940 than sizeof(long) for the target. FIXME: Assumes sizeof(long)
2941 for the target is 4. */
2943 if (fmt
->byteorder
== floatformat_littlebyte_bigword
)
2945 static unsigned char *newfrom
;
2946 unsigned char *swapin
, *swapout
;
2949 longswaps
= fmt
->totalsize
/ FLOATFORMAT_CHAR_BIT
;
2952 if (newfrom
== NULL
)
2954 newfrom
= (unsigned char *) xmalloc (fmt
->totalsize
);
2959 while (longswaps
-- > 0)
2961 /* This is ugly, but efficient */
2962 *swapout
++ = swapin
[4];
2963 *swapout
++ = swapin
[5];
2964 *swapout
++ = swapin
[6];
2965 *swapout
++ = swapin
[7];
2966 *swapout
++ = swapin
[0];
2967 *swapout
++ = swapin
[1];
2968 *swapout
++ = swapin
[2];
2969 *swapout
++ = swapin
[3];
2974 exponent
= get_field (ufrom
, fmt
->byteorder
, fmt
->totalsize
,
2975 fmt
->exp_start
, fmt
->exp_len
);
2976 /* Note that if exponent indicates a NaN, we can't really do anything useful
2977 (not knowing if the host has NaN's, or how to build one). So it will
2978 end up as an infinity or something close; that is OK. */
2980 mant_bits_left
= fmt
->man_len
;
2981 mant_off
= fmt
->man_start
;
2984 special_exponent
= exponent
== 0 || exponent
== fmt
->exp_nan
;
2986 /* Don't bias zero's, denorms or NaNs. */
2987 if (!special_exponent
)
2988 exponent
-= fmt
->exp_bias
;
2990 /* Build the result algebraically. Might go infinite, underflow, etc;
2993 /* If this format uses a hidden bit, explicitly add it in now. Otherwise,
2994 increment the exponent by one to account for the integer bit. */
2996 if (!special_exponent
)
2998 if (fmt
->intbit
== floatformat_intbit_no
)
2999 dto
= ldexp (1.0, exponent
);
3004 while (mant_bits_left
> 0)
3006 mant_bits
= min (mant_bits_left
, 32);
3008 mant
= get_field (ufrom
, fmt
->byteorder
, fmt
->totalsize
,
3009 mant_off
, mant_bits
);
3011 dto
+= ldexp ((double) mant
, exponent
- mant_bits
);
3012 exponent
-= mant_bits
;
3013 mant_off
+= mant_bits
;
3014 mant_bits_left
-= mant_bits
;
3017 /* Negate it if negative. */
3018 if (get_field (ufrom
, fmt
->byteorder
, fmt
->totalsize
, fmt
->sign_start
, 1))
3023 static void put_field
PARAMS ((unsigned char *, enum floatformat_byteorders
,
3029 /* Set a field which starts at START and is LEN bytes long. DATA and
3030 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
3032 put_field (data
, order
, total_len
, start
, len
, stuff_to_put
)
3033 unsigned char *data
;
3034 enum floatformat_byteorders order
;
3035 unsigned int total_len
;
3038 unsigned long stuff_to_put
;
3040 unsigned int cur_byte
;
3043 /* Start at the least significant part of the field. */
3044 cur_byte
= (start
+ len
) / FLOATFORMAT_CHAR_BIT
;
3045 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
3046 cur_byte
= (total_len
/ FLOATFORMAT_CHAR_BIT
) - cur_byte
- 1;
3048 ((start
+ len
) % FLOATFORMAT_CHAR_BIT
) - FLOATFORMAT_CHAR_BIT
;
3049 *(data
+ cur_byte
) &=
3050 ~(((1 << ((start
+ len
) % FLOATFORMAT_CHAR_BIT
)) - 1) << (-cur_bitshift
));
3051 *(data
+ cur_byte
) |=
3052 (stuff_to_put
& ((1 << FLOATFORMAT_CHAR_BIT
) - 1)) << (-cur_bitshift
);
3053 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
3054 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
3059 /* Move towards the most significant part of the field. */
3060 while (cur_bitshift
< len
)
3062 if (len
- cur_bitshift
< FLOATFORMAT_CHAR_BIT
)
3064 /* This is the last byte. */
3065 *(data
+ cur_byte
) &=
3066 ~((1 << (len
- cur_bitshift
)) - 1);
3067 *(data
+ cur_byte
) |= (stuff_to_put
>> cur_bitshift
);
3070 *(data
+ cur_byte
) = ((stuff_to_put
>> cur_bitshift
)
3071 & ((1 << FLOATFORMAT_CHAR_BIT
) - 1));
3072 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
3073 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
3080 #ifdef HAVE_LONG_DOUBLE
3081 /* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR.
3082 The range of the returned value is >= 0.5 and < 1.0. This is equivalent to
3083 frexp, but operates on the long double data type. */
3085 static long double ldfrexp
PARAMS ((long double value
, int *eptr
));
3088 ldfrexp (value
, eptr
)
3095 /* Unfortunately, there are no portable functions for extracting the exponent
3096 of a long double, so we have to do it iteratively by multiplying or dividing
3097 by two until the fraction is between 0.5 and 1.0. */
3105 if (value
>= tmp
) /* Value >= 1.0 */
3106 while (value
>= tmp
)
3111 else if (value
!= 0.0l) /* Value < 1.0 and > 0.0 */
3125 #endif /* HAVE_LONG_DOUBLE */
3128 /* The converse: convert the DOUBLEST *FROM to an extended float
3129 and store where TO points. Neither FROM nor TO have any alignment
3133 floatformat_from_doublest (fmt
, from
, to
)
3134 CONST
struct floatformat
*fmt
;
3141 unsigned int mant_bits
, mant_off
;
3143 unsigned char *uto
= (unsigned char *) to
;
3145 memcpy (&dfrom
, from
, sizeof (dfrom
));
3146 memset (uto
, 0, fmt
->totalsize
/ FLOATFORMAT_CHAR_BIT
);
3148 return; /* Result is zero */
3149 if (dfrom
!= dfrom
) /* Result is NaN */
3152 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->exp_start
,
3153 fmt
->exp_len
, fmt
->exp_nan
);
3154 /* Be sure it's not infinity, but NaN value is irrel */
3155 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->man_start
,
3160 /* If negative, set the sign bit. */
3163 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->sign_start
, 1, 1);
3167 if (dfrom
+ dfrom
== dfrom
&& dfrom
!= 0.0) /* Result is Infinity */
3169 /* Infinity exponent is same as NaN's. */
3170 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->exp_start
,
3171 fmt
->exp_len
, fmt
->exp_nan
);
3172 /* Infinity mantissa is all zeroes. */
3173 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->man_start
,
3178 #ifdef HAVE_LONG_DOUBLE
3179 mant
= ldfrexp (dfrom
, &exponent
);
3181 mant
= frexp (dfrom
, &exponent
);
3184 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->exp_start
, fmt
->exp_len
,
3185 exponent
+ fmt
->exp_bias
- 1);
3187 mant_bits_left
= fmt
->man_len
;
3188 mant_off
= fmt
->man_start
;
3189 while (mant_bits_left
> 0)
3191 unsigned long mant_long
;
3192 mant_bits
= mant_bits_left
< 32 ? mant_bits_left
: 32;
3194 mant
*= 4294967296.0;
3195 mant_long
= (unsigned long) mant
;
3198 /* If the integer bit is implicit, then we need to discard it.
3199 If we are discarding a zero, we should be (but are not) creating
3200 a denormalized number which means adjusting the exponent
3202 if (mant_bits_left
== fmt
->man_len
3203 && fmt
->intbit
== floatformat_intbit_no
)
3211 /* The bits we want are in the most significant MANT_BITS bits of
3212 mant_long. Move them to the least significant. */
3213 mant_long
>>= 32 - mant_bits
;
3216 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
,
3217 mant_off
, mant_bits
, mant_long
);
3218 mant_off
+= mant_bits
;
3219 mant_bits_left
-= mant_bits
;
3221 if (fmt
->byteorder
== floatformat_littlebyte_bigword
)
3224 unsigned char *swaplow
= uto
;
3225 unsigned char *swaphigh
= uto
+ 4;
3228 for (count
= 0; count
< 4; count
++)
3231 *swaplow
++ = *swaphigh
;
3237 /* temporary storage using circular buffer */
3243 static char buf
[NUMCELLS
][CELLSIZE
];
3244 static int cell
= 0;
3245 if (++cell
>= NUMCELLS
)
3250 /* print routines to handle variable size regs, etc.
3252 FIXME: Note that t_addr is a bfd_vma, which is currently either an
3253 unsigned long or unsigned long long, determined at configure time.
3254 If t_addr is an unsigned long long and sizeof (unsigned long long)
3255 is greater than sizeof (unsigned long), then I believe this code will
3256 probably lose, at least for little endian machines. I believe that
3257 it would also be better to eliminate the switch on the absolute size
3258 of t_addr and replace it with a sequence of if statements that compare
3259 sizeof t_addr with sizeof the various types and do the right thing,
3260 which includes knowing whether or not the host supports long long.
3265 static int thirty_two
= 32; /* eliminate warning from compiler on 32-bit systems */
3271 char *paddr_str
= get_cell ();
3272 switch (sizeof (t_addr
))
3275 sprintf (paddr_str
, "%08lx%08lx",
3276 (unsigned long) (addr
>> thirty_two
), (unsigned long) (addr
& 0xffffffff));
3279 sprintf (paddr_str
, "%08lx", (unsigned long) addr
);
3282 sprintf (paddr_str
, "%04x", (unsigned short) (addr
& 0xffff));
3285 sprintf (paddr_str
, "%lx", (unsigned long) addr
);
3294 char *preg_str
= get_cell ();
3295 switch (sizeof (t_reg
))
3298 sprintf (preg_str
, "%08lx%08lx",
3299 (unsigned long) (reg
>> thirty_two
), (unsigned long) (reg
& 0xffffffff));
3302 sprintf (preg_str
, "%08lx", (unsigned long) reg
);
3305 sprintf (preg_str
, "%04x", (unsigned short) (reg
& 0xffff));
3308 sprintf (preg_str
, "%lx", (unsigned long) reg
);
3317 char *paddr_str
= get_cell ();
3318 switch (sizeof (t_addr
))
3322 unsigned long high
= (unsigned long) (addr
>> thirty_two
);
3324 sprintf (paddr_str
, "%lx", (unsigned long) (addr
& 0xffffffff));
3326 sprintf (paddr_str
, "%lx%08lx",
3327 high
, (unsigned long) (addr
& 0xffffffff));
3331 sprintf (paddr_str
, "%lx", (unsigned long) addr
);
3334 sprintf (paddr_str
, "%x", (unsigned short) (addr
& 0xffff));
3337 sprintf (paddr_str
, "%lx", (unsigned long) addr
);
3346 char *preg_str
= get_cell ();
3347 switch (sizeof (t_reg
))
3351 unsigned long high
= (unsigned long) (reg
>> thirty_two
);
3353 sprintf (preg_str
, "%lx", (unsigned long) (reg
& 0xffffffff));
3355 sprintf (preg_str
, "%lx%08lx",
3356 high
, (unsigned long) (reg
& 0xffffffff));
3360 sprintf (preg_str
, "%lx", (unsigned long) reg
);
3363 sprintf (preg_str
, "%x", (unsigned short) (reg
& 0xffff));
3366 sprintf (preg_str
, "%lx", (unsigned long) reg
);
3371 /* Helper functions for INNER_THAN */
3373 core_addr_lessthan (lhs
, rhs
)
3381 core_addr_greaterthan (lhs
, rhs
)