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. */
20 /* $FreeBSD: src/contrib/gdb/gdb/utils.c,v 1.1.1.2.2.1 2002/09/01 23:30:00 obrien Exp $ */
21 /* $DragonFly: src/contrib/gdb/gdb/Attic/utils.c,v 1.2 2003/06/17 04:24:02 dillon Exp $ */
25 #include "gdb_string.h"
37 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
48 #include "expression.h"
52 #include <readline/readline.h>
54 /* readline defines this. */
57 void (*error_begin_hook) PARAMS ((void));
59 /* Prototypes for local functions */
61 static void vfprintf_maybe_filtered PARAMS ((GDB_FILE *, const char *,
64 static void fputs_maybe_filtered PARAMS ((const char *, GDB_FILE *, int));
66 #if defined (USE_MMALLOC) && !defined (NO_MMCHECK)
67 static void malloc_botch PARAMS ((void));
71 fatal_dump_core PARAMS((char *, ...));
74 prompt_for_continue PARAMS ((void));
77 set_width_command PARAMS ((char *, int, struct cmd_list_element *));
80 set_width PARAMS ((void));
82 /* If this definition isn't overridden by the header files, assume
83 that isatty and fileno exist on this system. */
85 #define ISATTY(FP) (isatty (fileno (FP)))
88 #ifndef GDB_FILE_ISATTY
89 #define GDB_FILE_ISATTY(GDB_FILE_PTR) (gdb_file_isatty(GDB_FILE_PTR))
92 /* Chain of cleanup actions established with make_cleanup,
93 to be executed if an error happens. */
95 static struct cleanup *cleanup_chain; /* cleaned up after a failed command */
96 static struct cleanup *final_cleanup_chain; /* cleaned up when gdb exits */
97 static struct cleanup *run_cleanup_chain; /* cleaned up on each 'run' */
99 /* Nonzero if we have job control. */
103 /* Nonzero means a quit has been requested. */
107 /* Nonzero means quit immediately if Control-C is typed now, rather
108 than waiting until QUIT is executed. Be careful in setting this;
109 code which executes with immediate_quit set has to be very careful
110 about being able to deal with being interrupted at any time. It is
111 almost always better to use QUIT; the only exception I can think of
112 is being able to quit out of a system call (using EINTR loses if
113 the SIGINT happens between the previous QUIT and the system call).
114 To immediately quit in the case in which a SIGINT happens between
115 the previous QUIT and setting immediate_quit (desirable anytime we
116 expect to block), call QUIT after setting immediate_quit. */
120 /* Nonzero means that encoded C++ names should be printed out in their
121 C++ form rather than raw. */
125 /* Nonzero means that encoded C++ names should be printed out in their
126 C++ form even in assembler language displays. If this is set, but
127 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
129 int asm_demangle = 0;
131 /* Nonzero means that strings with character values >0x7F should be printed
132 as octal escapes. Zero means just print the value (e.g. it's an
133 international character, and the terminal or window can cope.) */
135 int sevenbit_strings = 0;
137 /* String to be printed before error messages, if any. */
139 char *error_pre_print;
141 /* String to be printed before quit messages, if any. */
143 char *quit_pre_print;
145 /* String to be printed before warning messages, if any. */
147 char *warning_pre_print = "\nwarning: ";
149 int pagination_enabled = 1;
152 /* Add a new cleanup to the cleanup_chain,
153 and return the previous chain pointer
154 to be passed later to do_cleanups or discard_cleanups.
155 Args are FUNCTION to clean up with, and ARG to pass to it. */
158 make_cleanup (function, arg)
159 void (*function) PARAMS ((PTR));
162 return make_my_cleanup (&cleanup_chain, function, arg);
166 make_final_cleanup (function, arg)
167 void (*function) PARAMS ((PTR));
170 return make_my_cleanup (&final_cleanup_chain, function, arg);
173 make_run_cleanup (function, arg)
174 void (*function) PARAMS ((PTR));
177 return make_my_cleanup (&run_cleanup_chain, function, arg);
180 make_my_cleanup (pmy_chain, function, arg)
181 struct cleanup **pmy_chain;
182 void (*function) PARAMS ((PTR));
185 register struct cleanup *new
186 = (struct cleanup *) xmalloc (sizeof (struct cleanup));
187 register struct cleanup *old_chain = *pmy_chain;
189 new->next = *pmy_chain;
190 new->function = function;
197 /* Discard cleanups and do the actions they describe
198 until we get back to the point OLD_CHAIN in the cleanup_chain. */
201 do_cleanups (old_chain)
202 register struct cleanup *old_chain;
204 do_my_cleanups (&cleanup_chain, old_chain);
208 do_final_cleanups (old_chain)
209 register struct cleanup *old_chain;
211 do_my_cleanups (&final_cleanup_chain, old_chain);
215 do_run_cleanups (old_chain)
216 register struct cleanup *old_chain;
218 do_my_cleanups (&run_cleanup_chain, old_chain);
222 do_my_cleanups (pmy_chain, old_chain)
223 register struct cleanup **pmy_chain;
224 register struct cleanup *old_chain;
226 register struct cleanup *ptr;
227 while ((ptr = *pmy_chain) != old_chain)
229 *pmy_chain = ptr->next; /* Do this first incase recursion */
230 (*ptr->function) (ptr->arg);
235 /* Discard cleanups, not doing the actions they describe,
236 until we get back to the point OLD_CHAIN in the cleanup_chain. */
239 discard_cleanups (old_chain)
240 register struct cleanup *old_chain;
242 discard_my_cleanups (&cleanup_chain, old_chain);
246 discard_final_cleanups (old_chain)
247 register struct cleanup *old_chain;
249 discard_my_cleanups (&final_cleanup_chain, old_chain);
253 discard_my_cleanups (pmy_chain, old_chain)
254 register struct cleanup **pmy_chain;
255 register struct cleanup *old_chain;
257 register struct cleanup *ptr;
258 while ((ptr = *pmy_chain) != old_chain)
260 *pmy_chain = ptr->next;
265 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
269 return save_my_cleanups (&cleanup_chain);
273 save_final_cleanups ()
275 return save_my_cleanups (&final_cleanup_chain);
279 save_my_cleanups (pmy_chain)
280 struct cleanup **pmy_chain;
282 struct cleanup *old_chain = *pmy_chain;
288 /* Restore the cleanup chain from a previously saved chain. */
290 restore_cleanups (chain)
291 struct cleanup *chain;
293 restore_my_cleanups (&cleanup_chain, chain);
297 restore_final_cleanups (chain)
298 struct cleanup *chain;
300 restore_my_cleanups (&final_cleanup_chain, chain);
304 restore_my_cleanups (pmy_chain, chain)
305 struct cleanup **pmy_chain;
306 struct cleanup *chain;
311 /* This function is useful for cleanups.
315 old_chain = make_cleanup (free_current_contents, &foo);
317 to arrange to free the object thus allocated. */
320 free_current_contents (location)
326 /* Provide a known function that does nothing, to use as a base for
327 for a possibly long chain of cleanups. This is useful where we
328 use the cleanup chain for handling normal cleanups as well as dealing
329 with cleanups that need to be done as a result of a call to error().
330 In such cases, we may not be certain where the first cleanup is, unless
331 we have a do-nothing one to always use as the base. */
341 /* Print a warning message. Way to use this is to call warning_begin,
342 output the warning message (use unfiltered output to gdb_stderr),
343 ending in a newline. There is not currently a warning_end that you
344 call afterwards, but such a thing might be added if it is useful
345 for a GUI to separate warning messages from other output.
347 FIXME: Why do warnings use unfiltered output and errors filtered?
348 Is this anything other than a historical accident? */
353 target_terminal_ours ();
354 wrap_here(""); /* Force out any buffered output */
355 gdb_flush (gdb_stdout);
356 if (warning_pre_print)
357 fprintf_unfiltered (gdb_stderr, warning_pre_print);
360 /* Print a warning message.
361 The first argument STRING is the warning message, used as a fprintf string,
362 and the remaining args are passed as arguments to it.
363 The primary difference between warnings and errors is that a warning
364 does not force the return to command level. */
368 #ifdef ANSI_PROTOTYPES
369 warning (const char *string, ...)
376 #ifdef ANSI_PROTOTYPES
377 va_start (args, string);
382 string = va_arg (args, char *);
385 (*warning_hook) (string, args);
389 vfprintf_unfiltered (gdb_stderr, string, args);
390 fprintf_unfiltered (gdb_stderr, "\n");
395 /* Start the printing of an error message. Way to use this is to call
396 this, output the error message (use filtered output to gdb_stderr
397 (FIXME: Some callers, like memory_error, use gdb_stdout)), ending
398 in a newline, and then call return_to_top_level (RETURN_ERROR).
399 error() provides a convenient way to do this for the special case
400 that the error message can be formatted with a single printf call,
401 but this is more general. */
405 if (error_begin_hook)
408 target_terminal_ours ();
409 wrap_here (""); /* Force out any buffered output */
410 gdb_flush (gdb_stdout);
412 annotate_error_begin ();
415 fprintf_filtered (gdb_stderr, error_pre_print);
418 /* Print an error message and return to command level.
419 The first argument STRING is the error message, used as a fprintf string,
420 and the remaining args are passed as arguments to it. */
424 #ifdef ANSI_PROTOTYPES
425 error (const char *string, ...)
432 #ifdef ANSI_PROTOTYPES
433 va_start (args, string);
442 #ifdef ANSI_PROTOTYPES
443 vfprintf_filtered (gdb_stderr, string, args);
448 string1 = va_arg (args, char *);
449 vfprintf_filtered (gdb_stderr, string1, args);
452 fprintf_filtered (gdb_stderr, "\n");
454 return_to_top_level (RETURN_ERROR);
459 /* Print an error message and exit reporting failure.
460 This is for a error that we cannot continue from.
461 The arguments are printed a la printf.
463 This function cannot be declared volatile (NORETURN) in an
464 ANSI environment because exit() is not declared volatile. */
468 #ifdef ANSI_PROTOTYPES
469 fatal (char *string, ...)
476 #ifdef ANSI_PROTOTYPES
477 va_start (args, string);
481 string = va_arg (args, char *);
483 fprintf_unfiltered (gdb_stderr, "\ngdb: ");
484 vfprintf_unfiltered (gdb_stderr, string, args);
485 fprintf_unfiltered (gdb_stderr, "\n");
490 /* Print an error message and exit, dumping core.
491 The arguments are printed a la printf (). */
495 #ifdef ANSI_PROTOTYPES
496 fatal_dump_core (char *string, ...)
498 fatal_dump_core (va_alist)
503 #ifdef ANSI_PROTOTYPES
504 va_start (args, string);
509 string = va_arg (args, char *);
511 /* "internal error" is always correct, since GDB should never dump
512 core, no matter what the input. */
513 fprintf_unfiltered (gdb_stderr, "\ngdb internal error: ");
514 vfprintf_unfiltered (gdb_stderr, string, args);
515 fprintf_unfiltered (gdb_stderr, "\n");
518 signal (SIGQUIT, SIG_DFL);
519 kill (getpid (), SIGQUIT);
520 /* We should never get here, but just in case... */
524 /* The strerror() function can return NULL for errno values that are
525 out of range. Provide a "safe" version that always returns a
529 safe_strerror (errnum)
535 if ((msg = strerror (errnum)) == NULL)
537 sprintf (buf, "(undocumented errno %d)", errnum);
543 /* The strsignal() function can return NULL for signal values that are
544 out of range. Provide a "safe" version that always returns a
548 safe_strsignal (signo)
554 if ((msg = strsignal (signo)) == NULL)
556 sprintf (buf, "(undocumented signal %d)", signo);
563 /* Print the system error message for errno, and also mention STRING
564 as the file name for which the error was encountered.
565 Then return to command level. */
568 perror_with_name (string)
574 err = safe_strerror (errno);
575 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
576 strcpy (combined, string);
577 strcat (combined, ": ");
578 strcat (combined, err);
580 /* I understand setting these is a matter of taste. Still, some people
581 may clear errno but not know about bfd_error. Doing this here is not
583 bfd_set_error (bfd_error_no_error);
586 error ("%s.", combined);
589 /* Print the system error message for ERRCODE, and also mention STRING
590 as the file name for which the error was encountered. */
593 print_sys_errmsg (string, errcode)
600 err = safe_strerror (errcode);
601 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
602 strcpy (combined, string);
603 strcat (combined, ": ");
604 strcat (combined, err);
606 /* We want anything which was printed on stdout to come out first, before
608 gdb_flush (gdb_stdout);
609 fprintf_unfiltered (gdb_stderr, "%s.\n", combined);
612 /* Control C eventually causes this to be called, at a convenient time. */
617 serial_t gdb_stdout_serial = serial_fdopen (1);
619 target_terminal_ours ();
621 /* We want all output to appear now, before we print "Quit". We
622 have 3 levels of buffering we have to flush (it's possible that
623 some of these should be changed to flush the lower-level ones
626 /* 1. The _filtered buffer. */
627 wrap_here ((char *)0);
629 /* 2. The stdio buffer. */
630 gdb_flush (gdb_stdout);
631 gdb_flush (gdb_stderr);
633 /* 3. The system-level buffer. */
634 SERIAL_DRAIN_OUTPUT (gdb_stdout_serial);
635 SERIAL_UN_FDOPEN (gdb_stdout_serial);
637 annotate_error_begin ();
639 /* Don't use *_filtered; we don't want to prompt the user to continue. */
641 fprintf_unfiltered (gdb_stderr, quit_pre_print);
644 /* If there is no terminal switching for this target, then we can't
645 possibly get screwed by the lack of job control. */
646 || current_target.to_terminal_ours == NULL)
647 fprintf_unfiltered (gdb_stderr, "Quit\n");
649 fprintf_unfiltered (gdb_stderr,
650 "Quit (expect signal SIGINT when the program is resumed)\n");
651 return_to_top_level (RETURN_QUIT);
655 #if defined(__GO32__)
657 /* In the absence of signals, poll keyboard for a quit.
658 Called from #define QUIT pollquit() in xm-go32.h. */
673 /* We just ignore it */
674 /* FIXME!! Don't think this actually works! */
675 fprintf_unfiltered (gdb_stderr, "CTRL-A to quit, CTRL-B to quit harder\n");
680 #elif defined(_MSC_VER) /* should test for wingdb instead? */
683 * Windows translates all keyboard and mouse events
684 * into a message which is appended to the message
685 * queue for the process.
690 int k = win32pollquit();
697 #else /* !defined(__GO32__) && !defined(_MSC_VER) */
701 /* Done by signals */
704 #endif /* !defined(__GO32__) && !defined(_MSC_VER) */
710 if (quit_flag || immediate_quit)
714 /* Control C comes here */
721 /* Restore the signal handler. Harmless with BSD-style signals, needed
722 for System V-style signals. So just always do it, rather than worrying
723 about USG defines and stuff like that. */
724 signal (signo, request_quit);
735 /* Memory management stuff (malloc friends). */
737 /* Make a substitute size_t for non-ANSI compilers. */
739 #ifndef HAVE_STDDEF_H
741 #define size_t unsigned int
745 #if !defined (USE_MMALLOC)
752 return malloc (size);
756 mrealloc (md, ptr, size)
761 if (ptr == 0) /* Guard against old realloc's */
762 return malloc (size);
764 return realloc (ptr, size);
775 #endif /* USE_MMALLOC */
777 #if !defined (USE_MMALLOC) || defined (NO_MMCHECK)
785 #else /* Have mmalloc and want corruption checking */
790 fatal_dump_core ("Memory corruption");
793 /* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified
794 by MD, to detect memory corruption. Note that MD may be NULL to specify
795 the default heap that grows via sbrk.
797 Note that for freshly created regions, we must call mmcheckf prior to any
798 mallocs in the region. Otherwise, any region which was allocated prior to
799 installing the checking hooks, which is later reallocated or freed, will
800 fail the checks! The mmcheck function only allows initial hooks to be
801 installed before the first mmalloc. However, anytime after we have called
802 mmcheck the first time to install the checking hooks, we can call it again
803 to update the function pointer to the memory corruption handler.
805 Returns zero on failure, non-zero on success. */
807 #ifndef MMCHECK_FORCE
808 #define MMCHECK_FORCE 0
815 if (!mmcheckf (md, malloc_botch, MMCHECK_FORCE))
817 /* Don't use warning(), which relies on current_target being set
818 to something other than dummy_target, until after
819 initialize_all_files(). */
822 (gdb_stderr, "warning: failed to install memory consistency checks; ");
824 (gdb_stderr, "configuration should define NO_MMCHECK or MMCHECK_FORCE\n");
830 #endif /* Have mmalloc and want corruption checking */
832 /* Called when a memory allocation fails, with the number of bytes of
833 memory requested in SIZE. */
841 fatal ("virtual memory exhausted: can't allocate %ld bytes.", size);
845 fatal ("virtual memory exhausted.");
849 /* Like mmalloc but get error if no storage available, and protect against
850 the caller wanting to allocate zero bytes. Whether to return NULL for
851 a zero byte request, or translate the request into a request for one
852 byte of zero'd storage, is a religious issue. */
865 else if ((val = mmalloc (md, size)) == NULL)
872 /* Like mrealloc but get error if no storage available. */
875 xmrealloc (md, ptr, size)
884 val = mrealloc (md, ptr, size);
888 val = mmalloc (md, size);
897 /* Like malloc but get error if no storage available, and protect against
898 the caller wanting to allocate zero bytes. */
901 USE_FROM_LIBIBERTY_NOW_xmalloc (size)
904 return (xmmalloc ((PTR) NULL, size));
907 /* Like mrealloc but get error if no storage available. */
910 USE_FROM_LIBIBERTY_NOW_xrealloc (ptr, size)
914 return (xmrealloc ((PTR) NULL, ptr, size));
918 /* My replacement for the read system call.
919 Used like `read' but keeps going if `read' returns too soon. */
922 myread (desc, addr, len)
932 val = read (desc, addr, len);
943 /* Make a copy of the string at PTR with SIZE characters
944 (and add a null character at the end in the copy).
945 Uses malloc to get the space. Returns the address of the copy. */
948 savestring (ptr, size)
952 register char *p = (char *) xmalloc (size + 1);
953 memcpy (p, ptr, size);
959 msavestring (md, ptr, size)
964 register char *p = (char *) xmmalloc (md, size + 1);
965 memcpy (p, ptr, size);
970 /* The "const" is so it compiles under DGUX (which prototypes strsave
971 in <string.h>. FIXME: This should be named "xstrsave", shouldn't it?
972 Doesn't real strsave return NULL if out of memory? */
977 return savestring (ptr, strlen (ptr));
985 return (msavestring (md, ptr, strlen (ptr)));
989 print_spaces (n, file)
991 register GDB_FILE *file;
993 if (file->ts_streamtype == astring)
997 gdb_file_adjust_strbuf (n, file);
998 p = file->ts_strbuf + strlen (file->ts_strbuf);
1006 fputc (' ', file->ts_filestream);
1010 /* Print a host address. */
1013 gdb_print_address (addr, stream)
1018 /* We could use the %p conversion specifier to fprintf if we had any
1019 way of knowing whether this host supports it. But the following
1020 should work on the Alpha and on 32 bit machines. */
1022 fprintf_filtered (stream, "0x%lx", (unsigned long)addr);
1025 /* Ask user a y-or-n question and return 1 iff answer is yes.
1026 Takes three args which are given to printf to print the question.
1027 The first, a control string, should end in "? ".
1028 It should not say how to answer, because we do that. */
1032 #ifdef ANSI_PROTOTYPES
1033 query (char *ctlstr, ...)
1040 register int answer;
1044 #ifdef ANSI_PROTOTYPES
1045 va_start (args, ctlstr);
1049 ctlstr = va_arg (args, char *);
1054 return query_hook (ctlstr, args);
1057 /* Automatically answer "yes" if input is not from a terminal. */
1058 if (!input_from_terminal_p ())
1061 /* FIXME Automatically answer "yes" if called from MacGDB. */
1068 wrap_here (""); /* Flush any buffered output */
1069 gdb_flush (gdb_stdout);
1071 if (annotation_level > 1)
1072 printf_filtered ("\n\032\032pre-query\n");
1074 vfprintf_filtered (gdb_stdout, ctlstr, args);
1075 printf_filtered ("(y or n) ");
1077 if (annotation_level > 1)
1078 printf_filtered ("\n\032\032query\n");
1081 /* If not in MacGDB, move to a new line so the entered line doesn't
1082 have a prompt on the front of it. */
1084 fputs_unfiltered ("\n", gdb_stdout);
1088 gdb_flush (gdb_stdout);
1091 if (!tui_version || cmdWin == tuiWinWithFocus())
1093 answer = fgetc (stdin);
1097 answer = (unsigned char)tuiBufferGetc();
1100 clearerr (stdin); /* in case of C-d */
1101 if (answer == EOF) /* C-d */
1106 /* Eat rest of input line, to EOF or newline */
1107 if ((answer != '\n') || (tui_version && answer != '\r'))
1111 if (!tui_version || cmdWin == tuiWinWithFocus())
1113 ans2 = fgetc (stdin);
1117 ans2 = (unsigned char)tuiBufferGetc();
1121 while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
1122 TUIDO(((TuiOpaqueFuncPtr)tui_vStartNewLines, 1));
1136 printf_filtered ("Please answer y or n.\n");
1139 if (annotation_level > 1)
1140 printf_filtered ("\n\032\032post-query\n");
1145 /* Parse a C escape sequence. STRING_PTR points to a variable
1146 containing a pointer to the string to parse. That pointer
1147 should point to the character after the \. That pointer
1148 is updated past the characters we use. The value of the
1149 escape sequence is returned.
1151 A negative value means the sequence \ newline was seen,
1152 which is supposed to be equivalent to nothing at all.
1154 If \ is followed by a null character, we return a negative
1155 value and leave the string pointer pointing at the null character.
1157 If \ is followed by 000, we return 0 and leave the string pointer
1158 after the zeros. A value of 0 does not mean end of string. */
1161 parse_escape (string_ptr)
1164 register int c = *(*string_ptr)++;
1168 return 007; /* Bell (alert) char */
1171 case 'e': /* Escape character */
1189 c = *(*string_ptr)++;
1191 c = parse_escape (string_ptr);
1194 return (c & 0200) | (c & 037);
1205 register int i = c - '0';
1206 register int count = 0;
1209 if ((c = *(*string_ptr)++) >= '0' && c <= '7')
1227 /* Print the character C on STREAM as part of the contents of a literal
1228 string whose delimiter is QUOTER. Note that this routine should only
1229 be call for printing things which are independent of the language
1230 of the program being debugged. */
1233 gdb_printchar (c, stream, quoter)
1239 c &= 0xFF; /* Avoid sign bit follies */
1241 if ( c < 0x20 || /* Low control chars */
1242 (c >= 0x7F && c < 0xA0) || /* DEL, High controls */
1243 (sevenbit_strings && c >= 0x80)) { /* high order bit set */
1247 fputs_filtered ("\\n", stream);
1250 fputs_filtered ("\\b", stream);
1253 fputs_filtered ("\\t", stream);
1256 fputs_filtered ("\\f", stream);
1259 fputs_filtered ("\\r", stream);
1262 fputs_filtered ("\\e", stream);
1265 fputs_filtered ("\\a", stream);
1268 fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
1272 if (c == '\\' || c == quoter)
1273 fputs_filtered ("\\", stream);
1274 fprintf_filtered (stream, "%c", c);
1281 static char * hexlate = "0123456789abcdef" ;
1282 int fmthex(inbuf,outbuff,length,linelength)
1283 unsigned char * inbuf ;
1284 unsigned char * outbuff;
1288 unsigned char byte , nib ;
1293 if (outlength >= linelength) break ;
1297 *outbuff++ = hexlate[nib] ;
1299 *outbuff++ = hexlate[nib] ;
1304 *outbuff = '\0' ; /* null terminate our output line */
1309 /* Number of lines per page or UINT_MAX if paging is disabled. */
1310 static unsigned int lines_per_page;
1311 /* Number of chars per line or UNIT_MAX is line folding is disabled. */
1312 static unsigned int chars_per_line;
1313 /* Current count of lines printed on this page, chars on this line. */
1314 static unsigned int lines_printed, chars_printed;
1316 /* Buffer and start column of buffered text, for doing smarter word-
1317 wrapping. When someone calls wrap_here(), we start buffering output
1318 that comes through fputs_filtered(). If we see a newline, we just
1319 spit it out and forget about the wrap_here(). If we see another
1320 wrap_here(), we spit it out and remember the newer one. If we see
1321 the end of the line, we spit out a newline, the indent, and then
1322 the buffered output. */
1324 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1325 are waiting to be output (they have already been counted in chars_printed).
1326 When wrap_buffer[0] is null, the buffer is empty. */
1327 static char *wrap_buffer;
1329 /* Pointer in wrap_buffer to the next character to fill. */
1330 static char *wrap_pointer;
1332 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1334 static char *wrap_indent;
1336 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1337 is not in effect. */
1338 static int wrap_column;
1341 /* Inialize the lines and chars per page */
1346 if (tui_version && m_winPtrNotNull(cmdWin))
1348 lines_per_page = cmdWin->generic.height;
1349 chars_per_line = cmdWin->generic.width;
1354 /* These defaults will be used if we are unable to get the correct
1355 values from termcap. */
1356 #if defined(__GO32__)
1357 lines_per_page = ScreenRows();
1358 chars_per_line = ScreenCols();
1360 lines_per_page = 24;
1361 chars_per_line = 80;
1363 #if !defined (MPW) && !defined (_WIN32)
1364 /* No termcap under MPW, although might be cool to do something
1365 by looking at worksheet or console window sizes. */
1366 /* Initialize the screen height and width from termcap. */
1368 char *termtype = getenv ("TERM");
1370 /* Positive means success, nonpositive means failure. */
1373 /* 2048 is large enough for all known terminals, according to the
1374 GNU termcap manual. */
1375 char term_buffer[2048];
1379 status = tgetent (term_buffer, termtype);
1383 int running_in_emacs = getenv ("EMACS") != NULL;
1385 val = tgetnum ("li");
1386 if (val >= 0 && !running_in_emacs)
1387 lines_per_page = val;
1389 /* The number of lines per page is not mentioned
1390 in the terminal description. This probably means
1391 that paging is not useful (e.g. emacs shell window),
1392 so disable paging. */
1393 lines_per_page = UINT_MAX;
1395 val = tgetnum ("co");
1397 chars_per_line = val;
1403 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1405 /* If there is a better way to determine the window size, use it. */
1406 SIGWINCH_HANDLER (SIGWINCH);
1409 /* If the output is not a terminal, don't paginate it. */
1410 if (!GDB_FILE_ISATTY (gdb_stdout))
1411 lines_per_page = UINT_MAX;
1412 } /* the command_line_version */
1419 if (chars_per_line == 0)
1424 wrap_buffer = (char *) xmalloc (chars_per_line + 2);
1425 wrap_buffer[0] = '\0';
1428 wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
1429 wrap_pointer = wrap_buffer; /* Start it at the beginning */
1434 set_width_command (args, from_tty, c)
1437 struct cmd_list_element *c;
1442 /* Wait, so the user can read what's on the screen. Prompt the user
1443 to continue by pressing RETURN. */
1446 prompt_for_continue ()
1449 char cont_prompt[120];
1451 if (annotation_level > 1)
1452 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1454 strcpy (cont_prompt,
1455 "---Type <return> to continue, or q <return> to quit---");
1456 if (annotation_level > 1)
1457 strcat (cont_prompt, "\n\032\032prompt-for-continue\n");
1459 /* We must do this *before* we call gdb_readline, else it will eventually
1460 call us -- thinking that we're trying to print beyond the end of the
1462 reinitialize_more_filter ();
1465 /* On a real operating system, the user can quit with SIGINT.
1468 'q' is provided on all systems so users don't have to change habits
1469 from system to system, and because telling them what to do in
1470 the prompt is more user-friendly than expecting them to think of
1472 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1473 whereas control-C to gdb_readline will cause the user to get dumped
1475 ignore = readline (cont_prompt);
1477 if (annotation_level > 1)
1478 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1483 while (*p == ' ' || *p == '\t')
1486 request_quit (SIGINT);
1491 /* Now we have to do this again, so that GDB will know that it doesn't
1492 need to save the ---Type <return>--- line at the top of the screen. */
1493 reinitialize_more_filter ();
1495 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1498 /* Reinitialize filter; ie. tell it to reset to original values. */
1501 reinitialize_more_filter ()
1507 /* Indicate that if the next sequence of characters overflows the line,
1508 a newline should be inserted here rather than when it hits the end.
1509 If INDENT is non-null, it is a string to be printed to indent the
1510 wrapped part on the next line. INDENT must remain accessible until
1511 the next call to wrap_here() or until a newline is printed through
1514 If the line is already overfull, we immediately print a newline and
1515 the indentation, and disable further wrapping.
1517 If we don't know the width of lines, but we know the page height,
1518 we must not wrap words, but should still keep track of newlines
1519 that were explicitly printed.
1521 INDENT should not contain tabs, as that will mess up the char count
1522 on the next line. FIXME.
1524 This routine is guaranteed to force out any output which has been
1525 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1526 used to force out output from the wrap_buffer. */
1532 /* This should have been allocated, but be paranoid anyway. */
1538 *wrap_pointer = '\0';
1539 fputs_unfiltered (wrap_buffer, gdb_stdout);
1541 wrap_pointer = wrap_buffer;
1542 wrap_buffer[0] = '\0';
1543 if (chars_per_line == UINT_MAX) /* No line overflow checking */
1547 else if (chars_printed >= chars_per_line)
1549 puts_filtered ("\n");
1551 puts_filtered (indent);
1556 wrap_column = chars_printed;
1560 wrap_indent = indent;
1564 /* Ensure that whatever gets printed next, using the filtered output
1565 commands, starts at the beginning of the line. I.E. if there is
1566 any pending output for the current line, flush it and start a new
1567 line. Otherwise do nothing. */
1572 if (chars_printed > 0)
1574 puts_filtered ("\n");
1579 gdb_file_isatty (stream)
1583 if (stream->ts_streamtype == afile)
1584 return (isatty(fileno(stream->ts_filestream)));
1589 gdb_file_init_astring (n)
1592 GDB_FILE *tmpstream;
1594 tmpstream = xmalloc (sizeof(GDB_FILE));
1595 tmpstream->ts_streamtype = astring;
1596 tmpstream->ts_filestream = NULL;
1599 tmpstream->ts_strbuf = xmalloc ((n + 1)*sizeof(char));
1600 tmpstream->ts_strbuf[0] = '\0';
1603 tmpstream->ts_strbuf = NULL;
1604 tmpstream->ts_buflen = n;
1610 gdb_file_deallocate (streamptr)
1611 GDB_FILE **streamptr;
1613 GDB_FILE *tmpstream;
1615 tmpstream = *streamptr;
1616 if ((tmpstream->ts_streamtype == astring) &&
1617 (tmpstream->ts_strbuf != NULL))
1619 free (tmpstream->ts_strbuf);
1627 gdb_file_get_strbuf (stream)
1630 return (stream->ts_strbuf);
1633 /* adjust the length of the buffer by the amount necessary
1634 to accomodate appending a string of length N to the buffer contents */
1636 gdb_file_adjust_strbuf (n, stream)
1642 non_null_chars = strlen(stream->ts_strbuf);
1644 if (n > (stream->ts_buflen - non_null_chars - 1))
1646 stream->ts_buflen = n + non_null_chars + 1;
1647 stream->ts_strbuf = xrealloc (stream->ts_strbuf, stream->ts_buflen);
1652 gdb_fopen (name, mode)
1659 gdb_file_size = sizeof(GDB_FILE);
1660 tmp = (GDB_FILE *) xmalloc (gdb_file_size);
1661 tmp->ts_streamtype = afile;
1662 tmp->ts_filestream = fopen (name, mode);
1663 tmp->ts_strbuf = NULL;
1674 && (stream == gdb_stdout
1675 || stream == gdb_stderr))
1677 flush_hook (stream);
1681 fflush (stream->ts_filestream);
1685 gdb_fclose(streamptr)
1686 GDB_FILE **streamptr;
1688 GDB_FILE *tmpstream;
1690 tmpstream = *streamptr;
1691 fclose (tmpstream->ts_filestream);
1692 gdb_file_deallocate (streamptr);
1695 /* Like fputs but if FILTER is true, pause after every screenful.
1697 Regardless of FILTER can wrap at points other than the final
1698 character of a line.
1700 Unlike fputs, fputs_maybe_filtered does not return a value.
1701 It is OK for LINEBUFFER to be NULL, in which case just don't print
1704 Note that a longjmp to top level may occur in this routine (only if
1705 FILTER is true) (since prompt_for_continue may do so) so this
1706 routine should not be called when cleanups are not in place. */
1709 fputs_maybe_filtered (linebuffer, stream, filter)
1710 const char *linebuffer;
1714 const char *lineptr;
1716 if (linebuffer == 0)
1719 /* Don't do any filtering if it is disabled. */
1720 if (stream != gdb_stdout
1721 || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX))
1723 fputs_unfiltered (linebuffer, stream);
1727 /* Go through and output each character. Show line extension
1728 when this is necessary; prompt user for new page when this is
1731 lineptr = linebuffer;
1734 /* Possible new page. */
1736 (lines_printed >= lines_per_page - 1))
1737 prompt_for_continue ();
1739 while (*lineptr && *lineptr != '\n')
1741 /* Print a single line. */
1742 if (*lineptr == '\t')
1745 *wrap_pointer++ = '\t';
1747 fputc_unfiltered ('\t', stream);
1748 /* Shifting right by 3 produces the number of tab stops
1749 we have already passed, and then adding one and
1750 shifting left 3 advances to the next tab stop. */
1751 chars_printed = ((chars_printed >> 3) + 1) << 3;
1757 *wrap_pointer++ = *lineptr;
1759 fputc_unfiltered (*lineptr, stream);
1764 if (chars_printed >= chars_per_line)
1766 unsigned int save_chars = chars_printed;
1770 /* If we aren't actually wrapping, don't output newline --
1771 if chars_per_line is right, we probably just overflowed
1772 anyway; if it's wrong, let us keep going. */
1774 fputc_unfiltered ('\n', stream);
1776 /* Possible new page. */
1777 if (lines_printed >= lines_per_page - 1)
1778 prompt_for_continue ();
1780 /* Now output indentation and wrapped string */
1783 fputs_unfiltered (wrap_indent, stream);
1784 *wrap_pointer = '\0'; /* Null-terminate saved stuff */
1785 fputs_unfiltered (wrap_buffer, stream); /* and eject it */
1786 /* FIXME, this strlen is what prevents wrap_indent from
1787 containing tabs. However, if we recurse to print it
1788 and count its chars, we risk trouble if wrap_indent is
1789 longer than (the user settable) chars_per_line.
1790 Note also that this can set chars_printed > chars_per_line
1791 if we are printing a long string. */
1792 chars_printed = strlen (wrap_indent)
1793 + (save_chars - wrap_column);
1794 wrap_pointer = wrap_buffer; /* Reset buffer */
1795 wrap_buffer[0] = '\0';
1796 wrap_column = 0; /* And disable fancy wrap */
1801 if (*lineptr == '\n')
1804 wrap_here ((char *)0); /* Spit out chars, cancel further wraps */
1806 fputc_unfiltered ('\n', stream);
1813 fputs_filtered (linebuffer, stream)
1814 const char *linebuffer;
1817 fputs_maybe_filtered (linebuffer, stream, 1);
1821 putchar_unfiltered (c)
1828 fputs_unfiltered (buf, gdb_stdout);
1833 fputc_unfiltered (c, stream)
1841 fputs_unfiltered (buf, stream);
1846 fputc_filtered (c, stream)
1854 fputs_filtered (buf, stream);
1858 /* puts_debug is like fputs_unfiltered, except it prints special
1859 characters in printable fashion. */
1862 puts_debug (prefix, string, suffix)
1869 /* Print prefix and suffix after each line. */
1870 static int new_line = 1;
1871 static int return_p = 0;
1872 static char *prev_prefix = "";
1873 static char *prev_suffix = "";
1875 if (*string == '\n')
1878 /* If the prefix is changing, print the previous suffix, a new line,
1879 and the new prefix. */
1880 if ((return_p || (strcmp(prev_prefix, prefix) != 0)) && !new_line)
1882 fputs_unfiltered (prev_suffix, gdb_stderr);
1883 fputs_unfiltered ("\n", gdb_stderr);
1884 fputs_unfiltered (prefix, gdb_stderr);
1887 /* Print prefix if we printed a newline during the previous call. */
1891 fputs_unfiltered (prefix, gdb_stderr);
1894 prev_prefix = prefix;
1895 prev_suffix = suffix;
1897 /* Output characters in a printable format. */
1898 while ((ch = *string++) != '\0')
1904 fputc_unfiltered (ch, gdb_stderr);
1907 fprintf_unfiltered (gdb_stderr, "\\x%02x", ch & 0xff);
1910 case '\\': fputs_unfiltered ("\\\\", gdb_stderr); break;
1911 case '\b': fputs_unfiltered ("\\b", gdb_stderr); break;
1912 case '\f': fputs_unfiltered ("\\f", gdb_stderr); break;
1913 case '\n': new_line = 1;
1914 fputs_unfiltered ("\\n", gdb_stderr); break;
1915 case '\r': fputs_unfiltered ("\\r", gdb_stderr); break;
1916 case '\t': fputs_unfiltered ("\\t", gdb_stderr); break;
1917 case '\v': fputs_unfiltered ("\\v", gdb_stderr); break;
1920 return_p = ch == '\r';
1923 /* Print suffix if we printed a newline. */
1926 fputs_unfiltered (suffix, gdb_stderr);
1927 fputs_unfiltered ("\n", gdb_stderr);
1932 /* Print a variable number of ARGS using format FORMAT. If this
1933 information is going to put the amount written (since the last call
1934 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
1935 call prompt_for_continue to get the users permision to continue.
1937 Unlike fprintf, this function does not return a value.
1939 We implement three variants, vfprintf (takes a vararg list and stream),
1940 fprintf (takes a stream to write on), and printf (the usual).
1942 Note also that a longjmp to top level may occur in this routine
1943 (since prompt_for_continue may do so) so this routine should not be
1944 called when cleanups are not in place. */
1947 vfprintf_maybe_filtered (stream, format, args, filter)
1954 struct cleanup *old_cleanups;
1956 vasprintf (&linebuffer, format, args);
1957 if (linebuffer == NULL)
1959 fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr);
1962 old_cleanups = make_cleanup (free, linebuffer);
1963 fputs_maybe_filtered (linebuffer, stream, filter);
1964 do_cleanups (old_cleanups);
1969 vfprintf_filtered (stream, format, args)
1974 vfprintf_maybe_filtered (stream, format, args, 1);
1978 vfprintf_unfiltered (stream, format, args)
1984 struct cleanup *old_cleanups;
1986 vasprintf (&linebuffer, format, args);
1987 if (linebuffer == NULL)
1989 fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr);
1992 old_cleanups = make_cleanup (free, linebuffer);
1993 fputs_unfiltered (linebuffer, stream);
1994 do_cleanups (old_cleanups);
1998 vprintf_filtered (format, args)
2002 vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
2006 vprintf_unfiltered (format, args)
2010 vfprintf_unfiltered (gdb_stdout, format, args);
2015 #ifdef ANSI_PROTOTYPES
2016 fprintf_filtered (GDB_FILE *stream, const char *format, ...)
2018 fprintf_filtered (va_alist)
2023 #ifdef ANSI_PROTOTYPES
2024 va_start (args, format);
2030 stream = va_arg (args, GDB_FILE *);
2031 format = va_arg (args, char *);
2033 vfprintf_filtered (stream, format, args);
2039 #ifdef ANSI_PROTOTYPES
2040 fprintf_unfiltered (GDB_FILE *stream, const char *format, ...)
2042 fprintf_unfiltered (va_alist)
2047 #ifdef ANSI_PROTOTYPES
2048 va_start (args, format);
2054 stream = va_arg (args, GDB_FILE *);
2055 format = va_arg (args, char *);
2057 vfprintf_unfiltered (stream, format, args);
2061 /* Like fprintf_filtered, but prints its result indented.
2062 Called as fprintfi_filtered (spaces, stream, format, ...); */
2066 #ifdef ANSI_PROTOTYPES
2067 fprintfi_filtered (int spaces, GDB_FILE *stream, const char *format, ...)
2069 fprintfi_filtered (va_alist)
2074 #ifdef ANSI_PROTOTYPES
2075 va_start (args, format);
2082 spaces = va_arg (args, int);
2083 stream = va_arg (args, GDB_FILE *);
2084 format = va_arg (args, char *);
2086 print_spaces_filtered (spaces, stream);
2088 vfprintf_filtered (stream, format, args);
2095 #ifdef ANSI_PROTOTYPES
2096 printf_filtered (const char *format, ...)
2098 printf_filtered (va_alist)
2103 #ifdef ANSI_PROTOTYPES
2104 va_start (args, format);
2109 format = va_arg (args, char *);
2111 vfprintf_filtered (gdb_stdout, format, args);
2118 #ifdef ANSI_PROTOTYPES
2119 printf_unfiltered (const char *format, ...)
2121 printf_unfiltered (va_alist)
2126 #ifdef ANSI_PROTOTYPES
2127 va_start (args, format);
2132 format = va_arg (args, char *);
2134 vfprintf_unfiltered (gdb_stdout, format, args);
2138 /* Like printf_filtered, but prints it's result indented.
2139 Called as printfi_filtered (spaces, format, ...); */
2143 #ifdef ANSI_PROTOTYPES
2144 printfi_filtered (int spaces, const char *format, ...)
2146 printfi_filtered (va_alist)
2151 #ifdef ANSI_PROTOTYPES
2152 va_start (args, format);
2158 spaces = va_arg (args, int);
2159 format = va_arg (args, char *);
2161 print_spaces_filtered (spaces, gdb_stdout);
2162 vfprintf_filtered (gdb_stdout, format, args);
2166 /* Easy -- but watch out!
2168 This routine is *not* a replacement for puts()! puts() appends a newline.
2169 This one doesn't, and had better not! */
2172 puts_filtered (string)
2175 fputs_filtered (string, gdb_stdout);
2179 puts_unfiltered (string)
2182 fputs_unfiltered (string, gdb_stdout);
2185 /* Return a pointer to N spaces and a null. The pointer is good
2186 until the next call to here. */
2192 static char *spaces;
2193 static int max_spaces;
2199 spaces = (char *) xmalloc (n+1);
2200 for (t = spaces+n; t != spaces;)
2206 return spaces + max_spaces - n;
2209 /* Print N spaces. */
2211 print_spaces_filtered (n, stream)
2215 fputs_filtered (n_spaces (n), stream);
2218 /* C++ demangler stuff. */
2220 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2221 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2222 If the name is not mangled, or the language for the name is unknown, or
2223 demangling is off, the name is printed in its "raw" form. */
2226 fprintf_symbol_filtered (stream, name, lang, arg_mode)
2236 /* If user wants to see raw output, no problem. */
2239 fputs_filtered (name, stream);
2245 case language_cplus:
2246 demangled = cplus_demangle (name, arg_mode);
2249 demangled = cplus_demangle (name, arg_mode | DMGL_JAVA);
2251 case language_chill:
2252 demangled = chill_demangle (name);
2258 fputs_filtered (demangled ? demangled : name, stream);
2259 if (demangled != NULL)
2267 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2268 differences in whitespace. Returns 0 if they match, non-zero if they
2269 don't (slightly different than strcmp()'s range of return values).
2271 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2272 This "feature" is useful when searching for matching C++ function names
2273 (such as if the user types 'break FOO', where FOO is a mangled C++
2277 strcmp_iw (string1, string2)
2278 const char *string1;
2279 const char *string2;
2281 while ((*string1 != '\0') && (*string2 != '\0'))
2283 while (isspace (*string1))
2287 while (isspace (*string2))
2291 if (*string1 != *string2)
2295 if (*string1 != '\0')
2301 return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0');
2307 ** Answer whether stringToCompare is a full or partial match to
2308 ** templateString. The partial match must be in sequence starting
2314 char *stringToCompare,
2315 char *templateString)
2317 subsetCompare(stringToCompare, templateString)
2318 char *stringToCompare;
2319 char *templateString;
2324 if (templateString != (char *)NULL && stringToCompare != (char *)NULL &&
2325 strlen(stringToCompare) <= strlen(templateString))
2326 match = (strncmp(templateString,
2328 strlen(stringToCompare)) == 0);
2331 } /* subsetCompare */
2334 void pagination_on_command(arg, from_tty)
2338 pagination_enabled = 1;
2341 void pagination_off_command(arg, from_tty)
2345 pagination_enabled = 0;
2352 struct cmd_list_element *c;
2354 c = add_set_cmd ("width", class_support, var_uinteger,
2355 (char *)&chars_per_line,
2356 "Set number of characters gdb thinks are in a line.",
2358 add_show_from_set (c, &showlist);
2359 c->function.sfunc = set_width_command;
2362 (add_set_cmd ("height", class_support,
2363 var_uinteger, (char *)&lines_per_page,
2364 "Set number of lines gdb thinks are in a page.", &setlist),
2369 /* If the output is not a terminal, don't paginate it. */
2370 if (!GDB_FILE_ISATTY (gdb_stdout))
2371 lines_per_page = UINT_MAX;
2373 set_width_command ((char *)NULL, 0, c);
2376 (add_set_cmd ("demangle", class_support, var_boolean,
2378 "Set demangling of encoded C++ names when displaying symbols.",
2383 (add_set_cmd ("pagination", class_support,
2384 var_boolean, (char *)&pagination_enabled,
2385 "Set state of pagination.", &setlist),
2389 add_com("am", class_support, pagination_on_command,
2390 "Enable pagination");
2391 add_com("sm", class_support, pagination_off_command,
2392 "Disable pagination");
2396 (add_set_cmd ("sevenbit-strings", class_support, var_boolean,
2397 (char *)&sevenbit_strings,
2398 "Set printing of 8-bit characters in strings as \\nnn.",
2403 (add_set_cmd ("asm-demangle", class_support, var_boolean,
2404 (char *)&asm_demangle,
2405 "Set demangling of C++ names in disassembly listings.",
2410 /* Machine specific function to handle SIGWINCH signal. */
2412 #ifdef SIGWINCH_HANDLER_BODY
2413 SIGWINCH_HANDLER_BODY
2416 /* Support for converting target fp numbers into host DOUBLEST format. */
2418 /* XXX - This code should really be in libiberty/floatformat.c, however
2419 configuration issues with libiberty made this very difficult to do in the
2422 #include "floatformat.h"
2423 #include <math.h> /* ldexp */
2425 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
2426 going to bother with trying to muck around with whether it is defined in
2427 a system header, what we do if not, etc. */
2428 #define FLOATFORMAT_CHAR_BIT 8
2430 static unsigned long get_field PARAMS ((unsigned char *,
2431 enum floatformat_byteorders,
2436 /* Extract a field which starts at START and is LEN bytes long. DATA and
2437 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
2438 static unsigned long
2439 get_field (data, order, total_len, start, len)
2440 unsigned char *data;
2441 enum floatformat_byteorders order;
2442 unsigned int total_len;
2446 unsigned long result;
2447 unsigned int cur_byte;
2450 /* Start at the least significant part of the field. */
2451 cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
2452 if (order == floatformat_little || order == floatformat_littlebyte_bigword)
2453 cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
2455 ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
2456 result = *(data + cur_byte) >> (-cur_bitshift);
2457 cur_bitshift += FLOATFORMAT_CHAR_BIT;
2458 if (order == floatformat_little || order == floatformat_littlebyte_bigword)
2463 /* Move towards the most significant part of the field. */
2464 while (cur_bitshift < len)
2466 if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
2467 /* This is the last byte; zero out the bits which are not part of
2470 (*(data + cur_byte) & ((1 << (len - cur_bitshift)) - 1))
2473 result |= *(data + cur_byte) << cur_bitshift;
2474 cur_bitshift += FLOATFORMAT_CHAR_BIT;
2475 if (order == floatformat_little || order == floatformat_littlebyte_bigword)
2483 /* Convert from FMT to a DOUBLEST.
2484 FROM is the address of the extended float.
2485 Store the DOUBLEST in *TO. */
2488 floatformat_to_doublest (fmt, from, to)
2489 const struct floatformat *fmt;
2493 unsigned char *ufrom = (unsigned char *)from;
2497 unsigned int mant_bits, mant_off;
2499 int special_exponent; /* It's a NaN, denorm or zero */
2501 /* If the mantissa bits are not contiguous from one end of the
2502 mantissa to the other, we need to make a private copy of the
2503 source bytes that is in the right order since the unpacking
2504 algorithm assumes that the bits are contiguous.
2506 Swap the bytes individually rather than accessing them through
2507 "long *" since we have no guarantee that they start on a long
2508 alignment, and also sizeof(long) for the host could be different
2509 than sizeof(long) for the target. FIXME: Assumes sizeof(long)
2510 for the target is 4. */
2512 if (fmt -> byteorder == floatformat_littlebyte_bigword)
2514 static unsigned char *newfrom;
2515 unsigned char *swapin, *swapout;
2518 longswaps = fmt -> totalsize / FLOATFORMAT_CHAR_BIT;
2521 if (newfrom == NULL)
2523 newfrom = (unsigned char *) xmalloc (fmt -> totalsize);
2528 while (longswaps-- > 0)
2530 /* This is ugly, but efficient */
2531 *swapout++ = swapin[4];
2532 *swapout++ = swapin[5];
2533 *swapout++ = swapin[6];
2534 *swapout++ = swapin[7];
2535 *swapout++ = swapin[0];
2536 *swapout++ = swapin[1];
2537 *swapout++ = swapin[2];
2538 *swapout++ = swapin[3];
2543 exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
2544 fmt->exp_start, fmt->exp_len);
2545 /* Note that if exponent indicates a NaN, we can't really do anything useful
2546 (not knowing if the host has NaN's, or how to build one). So it will
2547 end up as an infinity or something close; that is OK. */
2549 mant_bits_left = fmt->man_len;
2550 mant_off = fmt->man_start;
2553 special_exponent = exponent == 0 || exponent == fmt->exp_nan;
2555 /* Don't bias zero's, denorms or NaNs. */
2556 if (!special_exponent)
2557 exponent -= fmt->exp_bias;
2559 /* Build the result algebraically. Might go infinite, underflow, etc;
2562 /* If this format uses a hidden bit, explicitly add it in now. Otherwise,
2563 increment the exponent by one to account for the integer bit. */
2565 if (!special_exponent)
2566 if (fmt->intbit == floatformat_intbit_no)
2567 dto = ldexp (1.0, exponent);
2571 while (mant_bits_left > 0)
2573 mant_bits = min (mant_bits_left, 32);
2575 mant = get_field (ufrom, fmt->byteorder, fmt->totalsize,
2576 mant_off, mant_bits);
2578 dto += ldexp ((double)mant, exponent - mant_bits);
2579 exponent -= mant_bits;
2580 mant_off += mant_bits;
2581 mant_bits_left -= mant_bits;
2584 /* Negate it if negative. */
2585 if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
2590 static void put_field PARAMS ((unsigned char *, enum floatformat_byteorders,
2596 /* Set a field which starts at START and is LEN bytes long. DATA and
2597 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
2599 put_field (data, order, total_len, start, len, stuff_to_put)
2600 unsigned char *data;
2601 enum floatformat_byteorders order;
2602 unsigned int total_len;
2605 unsigned long stuff_to_put;
2607 unsigned int cur_byte;
2610 /* Start at the least significant part of the field. */
2611 cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
2612 if (order == floatformat_little || order == floatformat_littlebyte_bigword)
2613 cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
2615 ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
2616 *(data + cur_byte) &=
2617 ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1) << (-cur_bitshift));
2618 *(data + cur_byte) |=
2619 (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
2620 cur_bitshift += FLOATFORMAT_CHAR_BIT;
2621 if (order == floatformat_little || order == floatformat_littlebyte_bigword)
2626 /* Move towards the most significant part of the field. */
2627 while (cur_bitshift < len)
2629 if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
2631 /* This is the last byte. */
2632 *(data + cur_byte) &=
2633 ~((1 << (len - cur_bitshift)) - 1);
2634 *(data + cur_byte) |= (stuff_to_put >> cur_bitshift);
2637 *(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
2638 & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
2639 cur_bitshift += FLOATFORMAT_CHAR_BIT;
2640 if (order == floatformat_little || order == floatformat_littlebyte_bigword)
2647 #ifdef HAVE_LONG_DOUBLE
2648 /* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR.
2649 The range of the returned value is >= 0.5 and < 1.0. This is equivalent to
2650 frexp, but operates on the long double data type. */
2652 static long double ldfrexp PARAMS ((long double value, int *eptr));
2655 ldfrexp (value, eptr)
2662 /* Unfortunately, there are no portable functions for extracting the exponent
2663 of a long double, so we have to do it iteratively by multiplying or dividing
2664 by two until the fraction is between 0.5 and 1.0. */
2672 if (value >= tmp) /* Value >= 1.0 */
2673 while (value >= tmp)
2678 else if (value != 0.0l) /* Value < 1.0 and > 0.0 */
2692 #endif /* HAVE_LONG_DOUBLE */
2695 /* The converse: convert the DOUBLEST *FROM to an extended float
2696 and store where TO points. Neither FROM nor TO have any alignment
2700 floatformat_from_doublest (fmt, from, to)
2701 CONST struct floatformat *fmt;
2708 unsigned int mant_bits, mant_off;
2710 unsigned char *uto = (unsigned char *)to;
2712 memcpy (&dfrom, from, sizeof (dfrom));
2713 memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT);
2715 return; /* Result is zero */
2716 if (dfrom != dfrom) /* Result is NaN */
2719 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
2720 fmt->exp_len, fmt->exp_nan);
2721 /* Be sure it's not infinity, but NaN value is irrel */
2722 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
2727 /* If negative, set the sign bit. */
2730 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
2734 if (dfrom + dfrom == dfrom && dfrom != 0.0) /* Result is Infinity */
2736 /* Infinity exponent is same as NaN's. */
2737 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
2738 fmt->exp_len, fmt->exp_nan);
2739 /* Infinity mantissa is all zeroes. */
2740 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
2745 #ifdef HAVE_LONG_DOUBLE
2746 mant = ldfrexp (dfrom, &exponent);
2748 mant = frexp (dfrom, &exponent);
2751 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len,
2752 exponent + fmt->exp_bias - 1);
2754 mant_bits_left = fmt->man_len;
2755 mant_off = fmt->man_start;
2756 while (mant_bits_left > 0)
2758 unsigned long mant_long;
2759 mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
2761 mant *= 4294967296.0;
2762 mant_long = (unsigned long)mant;
2765 /* If the integer bit is implicit, then we need to discard it.
2766 If we are discarding a zero, we should be (but are not) creating
2767 a denormalized number which means adjusting the exponent
2769 if (mant_bits_left == fmt->man_len
2770 && fmt->intbit == floatformat_intbit_no)
2778 /* The bits we want are in the most significant MANT_BITS bits of
2779 mant_long. Move them to the least significant. */
2780 mant_long >>= 32 - mant_bits;
2783 put_field (uto, fmt->byteorder, fmt->totalsize,
2784 mant_off, mant_bits, mant_long);
2785 mant_off += mant_bits;
2786 mant_bits_left -= mant_bits;
2788 if (fmt -> byteorder == floatformat_littlebyte_bigword)
2791 unsigned char *swaplow = uto;
2792 unsigned char *swaphigh = uto + 4;
2795 for (count = 0; count < 4; count++)
2798 *swaplow++ = *swaphigh;
2804 /* temporary storage using circular buffer */
2810 static char buf[NUMCELLS][CELLSIZE];
2812 if (++cell>=NUMCELLS) cell=0;
2816 /* print routines to handle variable size regs, etc.
2818 FIXME: Note that t_addr is a bfd_vma, which is currently either an
2819 unsigned long or unsigned long long, determined at configure time.
2820 If t_addr is an unsigned long long and sizeof (unsigned long long)
2821 is greater than sizeof (unsigned long), then I believe this code will
2822 probably lose, at least for little endian machines. I believe that
2823 it would also be better to eliminate the switch on the absolute size
2824 of t_addr and replace it with a sequence of if statements that compare
2825 sizeof t_addr with sizeof the various types and do the right thing,
2826 which includes knowing whether or not the host supports long long.
2831 static int thirty_two = 32; /* eliminate warning from compiler on 32-bit systems */
2837 char *paddr_str=get_cell();
2838 switch (sizeof(t_addr))
2841 sprintf (paddr_str, "%08lx%08lx",
2842 (unsigned long) (addr >> thirty_two), (unsigned long) (addr & 0xffffffff));
2845 sprintf (paddr_str, "%08lx", (unsigned long) addr);
2848 sprintf (paddr_str, "%04x", (unsigned short) (addr & 0xffff));
2851 sprintf (paddr_str, "%lx", (unsigned long) addr);
2860 char *preg_str=get_cell();
2861 switch (sizeof(t_reg))
2864 sprintf (preg_str, "%08lx%08lx",
2865 (unsigned long) (reg >> thirty_two), (unsigned long) (reg & 0xffffffff));
2868 sprintf (preg_str, "%08lx", (unsigned long) reg);
2871 sprintf (preg_str, "%04x", (unsigned short) (reg & 0xffff));
2874 sprintf (preg_str, "%lx", (unsigned long) reg);
2883 char *paddr_str=get_cell();
2884 switch (sizeof(t_addr))
2888 unsigned long high = (unsigned long) (addr >> thirty_two);
2890 sprintf (paddr_str, "%lx", (unsigned long) (addr & 0xffffffff));
2892 sprintf (paddr_str, "%lx%08lx",
2893 high, (unsigned long) (addr & 0xffffffff));
2897 sprintf (paddr_str, "%lx", (unsigned long) addr);
2900 sprintf (paddr_str, "%x", (unsigned short) (addr & 0xffff));
2903 sprintf (paddr_str,"%lx", (unsigned long) addr);
2912 char *preg_str=get_cell();
2913 switch (sizeof(t_reg))
2917 unsigned long high = (unsigned long) (reg >> thirty_two);
2919 sprintf (preg_str, "%lx", (unsigned long) (reg & 0xffffffff));
2921 sprintf (preg_str, "%lx%08lx",
2922 high, (unsigned long) (reg & 0xffffffff));
2926 sprintf (preg_str, "%lx", (unsigned long) reg);
2929 sprintf (preg_str, "%x", (unsigned short) (reg & 0xffff));
2932 sprintf (preg_str, "%lx", (unsigned long) reg);