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"
24 #include "event-top.h"
33 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
44 #include "expression.h"
48 #include <readline/readline.h>
51 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
53 /* readline defines this. */
56 void (*error_begin_hook) PARAMS ((void));
58 /* Holds the last error message issued by gdb */
60 static GDB_FILE *gdb_lasterr;
62 /* Prototypes for local functions */
64 static void vfprintf_maybe_filtered PARAMS ((GDB_FILE *, const char *,
67 static void fputs_maybe_filtered PARAMS ((const char *, GDB_FILE *, int));
69 #if defined (USE_MMALLOC) && !defined (NO_MMCHECK)
70 static void malloc_botch PARAMS ((void));
74 prompt_for_continue PARAMS ((void));
77 set_width_command PARAMS ((char *, int, struct cmd_list_element *));
80 set_width PARAMS ((void));
82 #ifndef GDB_FILE_ISATTY
83 #define GDB_FILE_ISATTY(GDB_FILE_PTR) (gdb_file_isatty(GDB_FILE_PTR))
86 /* Chain of cleanup actions established with make_cleanup,
87 to be executed if an error happens. */
89 static struct cleanup *cleanup_chain; /* cleaned up after a failed command */
90 static struct cleanup *final_cleanup_chain; /* cleaned up when gdb exits */
91 static struct cleanup *run_cleanup_chain; /* cleaned up on each 'run' */
92 static struct cleanup *exec_cleanup_chain; /* cleaned up on each execution command */
93 /* cleaned up on each error from within an execution command */
94 static struct cleanup *exec_error_cleanup_chain;
96 /* Pointer to what is left to do for an execution command after the
97 target stops. Used only in asynchronous mode, by targets that
98 support async execution. The finish and until commands use it. So
99 does the target extended-remote command. */
100 struct continuation *cmd_continuation;
101 struct continuation *intermediate_continuation;
103 /* Nonzero if we have job control. */
107 /* Nonzero means a quit has been requested. */
111 /* Nonzero means quit immediately if Control-C is typed now, rather
112 than waiting until QUIT is executed. Be careful in setting this;
113 code which executes with immediate_quit set has to be very careful
114 about being able to deal with being interrupted at any time. It is
115 almost always better to use QUIT; the only exception I can think of
116 is being able to quit out of a system call (using EINTR loses if
117 the SIGINT happens between the previous QUIT and the system call).
118 To immediately quit in the case in which a SIGINT happens between
119 the previous QUIT and setting immediate_quit (desirable anytime we
120 expect to block), call QUIT after setting immediate_quit. */
124 /* Nonzero means that encoded C++ names should be printed out in their
125 C++ form rather than raw. */
129 /* Nonzero means that encoded C++ names should be printed out in their
130 C++ form even in assembler language displays. If this is set, but
131 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
133 int asm_demangle = 0;
135 /* Nonzero means that strings with character values >0x7F should be printed
136 as octal escapes. Zero means just print the value (e.g. it's an
137 international character, and the terminal or window can cope.) */
139 int sevenbit_strings = 0;
141 /* String to be printed before error messages, if any. */
143 char *error_pre_print;
145 /* String to be printed before quit messages, if any. */
147 char *quit_pre_print;
149 /* String to be printed before warning messages, if any. */
151 char *warning_pre_print = "\nwarning: ";
153 int pagination_enabled = 1;
156 /* Add a new cleanup to the cleanup_chain,
157 and return the previous chain pointer
158 to be passed later to do_cleanups or discard_cleanups.
159 Args are FUNCTION to clean up with, and ARG to pass to it. */
162 make_cleanup (function, arg)
163 void (*function) PARAMS ((PTR));
166 return make_my_cleanup (&cleanup_chain, function, arg);
170 make_final_cleanup (function, arg)
171 void (*function) PARAMS ((PTR));
174 return make_my_cleanup (&final_cleanup_chain, function, arg);
178 make_run_cleanup (function, arg)
179 void (*function) PARAMS ((PTR));
182 return make_my_cleanup (&run_cleanup_chain, function, arg);
186 make_exec_cleanup (function, arg)
187 void (*function) PARAMS ((PTR));
190 return make_my_cleanup (&exec_cleanup_chain, function, arg);
194 make_exec_error_cleanup (function, arg)
195 void (*function) PARAMS ((PTR));
198 return make_my_cleanup (&exec_error_cleanup_chain, function, arg);
205 freeargv ((char **) arg);
209 make_cleanup_freeargv (arg)
212 return make_my_cleanup (&cleanup_chain, do_freeargv, arg);
216 do_gdb_file_delete (void *arg)
218 gdb_file_delete (arg);
222 make_cleanup_gdb_file_delete (struct gdb_file *arg)
224 return make_my_cleanup (&cleanup_chain, do_gdb_file_delete, arg);
228 make_my_cleanup (pmy_chain, function, arg)
229 struct cleanup **pmy_chain;
230 void (*function) PARAMS ((PTR));
233 register struct cleanup *new
234 = (struct cleanup *) xmalloc (sizeof (struct cleanup));
235 register struct cleanup *old_chain = *pmy_chain;
237 new->next = *pmy_chain;
238 new->function = function;
245 /* Discard cleanups and do the actions they describe
246 until we get back to the point OLD_CHAIN in the cleanup_chain. */
249 do_cleanups (old_chain)
250 register struct cleanup *old_chain;
252 do_my_cleanups (&cleanup_chain, old_chain);
256 do_final_cleanups (old_chain)
257 register struct cleanup *old_chain;
259 do_my_cleanups (&final_cleanup_chain, old_chain);
263 do_run_cleanups (old_chain)
264 register struct cleanup *old_chain;
266 do_my_cleanups (&run_cleanup_chain, old_chain);
270 do_exec_cleanups (old_chain)
271 register struct cleanup *old_chain;
273 do_my_cleanups (&exec_cleanup_chain, old_chain);
277 do_exec_error_cleanups (old_chain)
278 register struct cleanup *old_chain;
280 do_my_cleanups (&exec_error_cleanup_chain, old_chain);
284 do_my_cleanups (pmy_chain, old_chain)
285 register struct cleanup **pmy_chain;
286 register struct cleanup *old_chain;
288 register struct cleanup *ptr;
289 while ((ptr = *pmy_chain) != old_chain)
291 *pmy_chain = ptr->next; /* Do this first incase recursion */
292 (*ptr->function) (ptr->arg);
297 /* Discard cleanups, not doing the actions they describe,
298 until we get back to the point OLD_CHAIN in the cleanup_chain. */
301 discard_cleanups (old_chain)
302 register struct cleanup *old_chain;
304 discard_my_cleanups (&cleanup_chain, old_chain);
308 discard_final_cleanups (old_chain)
309 register struct cleanup *old_chain;
311 discard_my_cleanups (&final_cleanup_chain, old_chain);
315 discard_exec_error_cleanups (old_chain)
316 register struct cleanup *old_chain;
318 discard_my_cleanups (&exec_error_cleanup_chain, old_chain);
322 discard_my_cleanups (pmy_chain, old_chain)
323 register struct cleanup **pmy_chain;
324 register struct cleanup *old_chain;
326 register struct cleanup *ptr;
327 while ((ptr = *pmy_chain) != old_chain)
329 *pmy_chain = ptr->next;
334 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
338 return save_my_cleanups (&cleanup_chain);
342 save_final_cleanups ()
344 return save_my_cleanups (&final_cleanup_chain);
348 save_my_cleanups (pmy_chain)
349 struct cleanup **pmy_chain;
351 struct cleanup *old_chain = *pmy_chain;
357 /* Restore the cleanup chain from a previously saved chain. */
359 restore_cleanups (chain)
360 struct cleanup *chain;
362 restore_my_cleanups (&cleanup_chain, chain);
366 restore_final_cleanups (chain)
367 struct cleanup *chain;
369 restore_my_cleanups (&final_cleanup_chain, chain);
373 restore_my_cleanups (pmy_chain, chain)
374 struct cleanup **pmy_chain;
375 struct cleanup *chain;
380 /* This function is useful for cleanups.
384 old_chain = make_cleanup (free_current_contents, &foo);
386 to arrange to free the object thus allocated. */
389 free_current_contents (location)
395 /* Provide a known function that does nothing, to use as a base for
396 for a possibly long chain of cleanups. This is useful where we
397 use the cleanup chain for handling normal cleanups as well as dealing
398 with cleanups that need to be done as a result of a call to error().
399 In such cases, we may not be certain where the first cleanup is, unless
400 we have a do-nothing one to always use as the base. */
409 /* Add a continuation to the continuation list, the gloabl list
410 cmd_continuation. The new continuation will be added at the front.*/
412 add_continuation (continuation_hook, arg_list)
413 void (*continuation_hook) PARAMS ((struct continuation_arg *));
414 struct continuation_arg *arg_list;
416 struct continuation *continuation_ptr;
418 continuation_ptr = (struct continuation *) xmalloc (sizeof (struct continuation));
419 continuation_ptr->continuation_hook = continuation_hook;
420 continuation_ptr->arg_list = arg_list;
421 continuation_ptr->next = cmd_continuation;
422 cmd_continuation = continuation_ptr;
425 /* Walk down the cmd_continuation list, and execute all the
426 continuations. There is a problem though. In some cases new
427 continuations may be added while we are in the middle of this
428 loop. If this happens they will be added in the front, and done
429 before we have a chance of exhausting those that were already
430 there. We need to then save the beginning of the list in a pointer
431 and do the continuations from there on, instead of using the
432 global beginning of list as our iteration pointer.*/
434 do_all_continuations ()
436 struct continuation *continuation_ptr;
437 struct continuation *saved_continuation;
439 /* Copy the list header into another pointer, and set the global
440 list header to null, so that the global list can change as a side
441 effect of invoking the continuations and the processing of
442 the preexisting continuations will not be affected. */
443 continuation_ptr = cmd_continuation;
444 cmd_continuation = NULL;
446 /* Work now on the list we have set aside. */
447 while (continuation_ptr)
449 (continuation_ptr->continuation_hook) (continuation_ptr->arg_list);
450 saved_continuation = continuation_ptr;
451 continuation_ptr = continuation_ptr->next;
452 free (saved_continuation);
456 /* Walk down the cmd_continuation list, and get rid of all the
459 discard_all_continuations ()
461 struct continuation *continuation_ptr;
463 while (cmd_continuation)
465 continuation_ptr = cmd_continuation;
466 cmd_continuation = continuation_ptr->next;
467 free (continuation_ptr);
471 /* Add a continuation to the continuation list, the gloabl list
472 intermediate_continuation. The new continuation will be added at the front.*/
474 add_intermediate_continuation (continuation_hook, arg_list)
475 void (*continuation_hook) PARAMS ((struct continuation_arg *));
476 struct continuation_arg *arg_list;
478 struct continuation *continuation_ptr;
480 continuation_ptr = (struct continuation *) xmalloc (sizeof (struct continuation));
481 continuation_ptr->continuation_hook = continuation_hook;
482 continuation_ptr->arg_list = arg_list;
483 continuation_ptr->next = intermediate_continuation;
484 intermediate_continuation = continuation_ptr;
487 /* Walk down the cmd_continuation list, and execute all the
488 continuations. There is a problem though. In some cases new
489 continuations may be added while we are in the middle of this
490 loop. If this happens they will be added in the front, and done
491 before we have a chance of exhausting those that were already
492 there. We need to then save the beginning of the list in a pointer
493 and do the continuations from there on, instead of using the
494 global beginning of list as our iteration pointer.*/
496 do_all_intermediate_continuations ()
498 struct continuation *continuation_ptr;
499 struct continuation *saved_continuation;
501 /* Copy the list header into another pointer, and set the global
502 list header to null, so that the global list can change as a side
503 effect of invoking the continuations and the processing of
504 the preexisting continuations will not be affected. */
505 continuation_ptr = intermediate_continuation;
506 intermediate_continuation = NULL;
508 /* Work now on the list we have set aside. */
509 while (continuation_ptr)
511 (continuation_ptr->continuation_hook) (continuation_ptr->arg_list);
512 saved_continuation = continuation_ptr;
513 continuation_ptr = continuation_ptr->next;
514 free (saved_continuation);
518 /* Walk down the cmd_continuation list, and get rid of all the
521 discard_all_intermediate_continuations ()
523 struct continuation *continuation_ptr;
525 while (intermediate_continuation)
527 continuation_ptr = intermediate_continuation;
528 intermediate_continuation = continuation_ptr->next;
529 free (continuation_ptr);
535 /* Print a warning message. Way to use this is to call warning_begin,
536 output the warning message (use unfiltered output to gdb_stderr),
537 ending in a newline. There is not currently a warning_end that you
538 call afterwards, but such a thing might be added if it is useful
539 for a GUI to separate warning messages from other output.
541 FIXME: Why do warnings use unfiltered output and errors filtered?
542 Is this anything other than a historical accident? */
547 target_terminal_ours ();
548 wrap_here (""); /* Force out any buffered output */
549 gdb_flush (gdb_stdout);
550 if (warning_pre_print)
551 fprintf_unfiltered (gdb_stderr, warning_pre_print);
554 /* Print a warning message.
555 The first argument STRING is the warning message, used as a fprintf string,
556 and the remaining args are passed as arguments to it.
557 The primary difference between warnings and errors is that a warning
558 does not force the return to command level. */
561 warning (const char *string,...)
564 va_start (args, string);
566 (*warning_hook) (string, args);
570 vfprintf_unfiltered (gdb_stderr, string, args);
571 fprintf_unfiltered (gdb_stderr, "\n");
576 /* Start the printing of an error message. Way to use this is to call
577 this, output the error message (use filtered output to gdb_stderr
578 (FIXME: Some callers, like memory_error, use gdb_stdout)), ending
579 in a newline, and then call return_to_top_level (RETURN_ERROR).
580 error() provides a convenient way to do this for the special case
581 that the error message can be formatted with a single printf call,
582 but this is more general. */
586 if (error_begin_hook)
589 target_terminal_ours ();
590 wrap_here (""); /* Force out any buffered output */
591 gdb_flush (gdb_stdout);
593 annotate_error_begin ();
596 fprintf_filtered (gdb_stderr, error_pre_print);
599 /* Print an error message and return to command level.
600 The first argument STRING is the error message, used as a fprintf string,
601 and the remaining args are passed as arguments to it. */
604 verror (const char *string, va_list args)
607 struct cleanup *err_string_cleanup;
608 /* FIXME: cagney/1999-11-10: All error calls should come here.
609 Unfortunatly some code uses the sequence: error_begin(); print
610 error message; return_to_top_level. That code should be
613 /* NOTE: It's tempting to just do the following...
614 vfprintf_filtered (gdb_stderr, string, args);
615 and then follow with a similar looking statement to cause the message
616 to also go to gdb_lasterr. But if we do this, we'll be traversing the
617 va_list twice which works on some platforms and fails miserably on
619 /* Save it as the last error */
620 gdb_file_rewind (gdb_lasterr);
621 vfprintf_filtered (gdb_lasterr, string, args);
622 /* Retrieve the last error and print it to gdb_stderr */
623 err_string = error_last_message ();
624 err_string_cleanup = make_cleanup (free, err_string);
625 fputs_filtered (err_string, gdb_stderr);
626 fprintf_filtered (gdb_stderr, "\n");
627 do_cleanups (err_string_cleanup);
628 return_to_top_level (RETURN_ERROR);
632 error (const char *string,...)
635 va_start (args, string);
636 verror (string, args);
641 error_stream (GDB_FILE *stream)
644 char *msg = gdb_file_xstrdup (stream, &size);
645 make_cleanup (free, msg);
649 /* Get the last error message issued by gdb */
652 error_last_message (void)
655 return gdb_file_xstrdup (gdb_lasterr, &len);
658 /* This is to be called by main() at the very beginning */
663 gdb_lasterr = mem_fileopen ();
666 /* Print a message reporting an internal error. Ask the user if they
667 want to continue, dump core, or just exit. */
670 internal_verror (const char *fmt, va_list ap)
672 static char msg[] = "Internal GDB error: recursive internal error.\n";
673 static int dejavu = 0;
677 /* don't allow infinite error recursion. */
685 fputs_unfiltered (msg, gdb_stderr);
689 write (STDERR_FILENO, msg, sizeof (msg));
693 /* Try to get the message out */
694 fputs_unfiltered ("gdb-internal-error: ", gdb_stderr);
695 vfprintf_unfiltered (gdb_stderr, fmt, ap);
696 fputs_unfiltered ("\n", gdb_stderr);
698 /* Default (no case) is to quit GDB. When in batch mode this
699 lessens the likelhood of GDB going into an infinate loop. */
700 continue_p = query ("\
701 An internal GDB error was detected. This may make make further\n\
702 debugging unreliable. Continue this debugging session? ");
704 /* Default (no case) is to not dump core. Lessen the chance of GDB
705 leaving random core files around. */
706 dump_core_p = query ("\
707 Create a core file containing the current state of GDB? ");
726 return_to_top_level (RETURN_ERROR);
730 internal_error (char *string, ...)
733 va_start (ap, string);
734 internal_verror (string, ap);
738 /* The strerror() function can return NULL for errno values that are
739 out of range. Provide a "safe" version that always returns a
743 safe_strerror (errnum)
749 if ((msg = strerror (errnum)) == NULL)
751 sprintf (buf, "(undocumented errno %d)", errnum);
757 /* The strsignal() function can return NULL for signal values that are
758 out of range. Provide a "safe" version that always returns a
762 safe_strsignal (signo)
768 if ((msg = strsignal (signo)) == NULL)
770 sprintf (buf, "(undocumented signal %d)", signo);
777 /* Print the system error message for errno, and also mention STRING
778 as the file name for which the error was encountered.
779 Then return to command level. */
782 perror_with_name (string)
788 err = safe_strerror (errno);
789 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
790 strcpy (combined, string);
791 strcat (combined, ": ");
792 strcat (combined, err);
794 /* I understand setting these is a matter of taste. Still, some people
795 may clear errno but not know about bfd_error. Doing this here is not
797 bfd_set_error (bfd_error_no_error);
800 error ("%s.", combined);
803 /* Print the system error message for ERRCODE, and also mention STRING
804 as the file name for which the error was encountered. */
807 print_sys_errmsg (string, errcode)
814 err = safe_strerror (errcode);
815 combined = (char *) alloca (strlen (err) + strlen (string) + 3);
816 strcpy (combined, string);
817 strcat (combined, ": ");
818 strcat (combined, err);
820 /* We want anything which was printed on stdout to come out first, before
822 gdb_flush (gdb_stdout);
823 fprintf_unfiltered (gdb_stderr, "%s.\n", combined);
826 /* Control C eventually causes this to be called, at a convenient time. */
831 serial_t gdb_stdout_serial = serial_fdopen (1);
833 target_terminal_ours ();
835 /* We want all output to appear now, before we print "Quit". We
836 have 3 levels of buffering we have to flush (it's possible that
837 some of these should be changed to flush the lower-level ones
840 /* 1. The _filtered buffer. */
841 wrap_here ((char *) 0);
843 /* 2. The stdio buffer. */
844 gdb_flush (gdb_stdout);
845 gdb_flush (gdb_stderr);
847 /* 3. The system-level buffer. */
848 SERIAL_DRAIN_OUTPUT (gdb_stdout_serial);
849 SERIAL_UN_FDOPEN (gdb_stdout_serial);
851 annotate_error_begin ();
853 /* Don't use *_filtered; we don't want to prompt the user to continue. */
855 fprintf_unfiltered (gdb_stderr, quit_pre_print);
858 /* No steenking SIGINT will ever be coming our way when the
859 program is resumed. Don't lie. */
860 fprintf_unfiltered (gdb_stderr, "Quit\n");
863 /* If there is no terminal switching for this target, then we can't
864 possibly get screwed by the lack of job control. */
865 || current_target.to_terminal_ours == NULL)
866 fprintf_unfiltered (gdb_stderr, "Quit\n");
868 fprintf_unfiltered (gdb_stderr,
869 "Quit (expect signal SIGINT when the program is resumed)\n");
871 return_to_top_level (RETURN_QUIT);
875 #if defined(_MSC_VER) /* should test for wingdb instead? */
878 * Windows translates all keyboard and mouse events
879 * into a message which is appended to the message
880 * queue for the process.
886 int k = win32pollquit ();
893 #else /* !defined(_MSC_VER) */
898 /* Done by signals */
901 #endif /* !defined(_MSC_VER) */
903 /* Control C comes here */
909 /* Restore the signal handler. Harmless with BSD-style signals, needed
910 for System V-style signals. So just always do it, rather than worrying
911 about USG defines and stuff like that. */
912 signal (signo, request_quit);
922 /* Memory management stuff (malloc friends). */
924 /* Make a substitute size_t for non-ANSI compilers. */
926 #ifndef HAVE_STDDEF_H
928 #define size_t unsigned int
932 #if !defined (USE_MMALLOC)
939 return malloc (size);
943 mrealloc (md, ptr, size)
948 if (ptr == 0) /* Guard against old realloc's */
949 return malloc (size);
951 return realloc (ptr, size);
962 #endif /* USE_MMALLOC */
964 #if !defined (USE_MMALLOC) || defined (NO_MMCHECK)
972 #else /* Have mmalloc and want corruption checking */
977 fprintf_unfiltered (gdb_stderr, "Memory corruption\n");
981 /* Attempt to install hooks in mmalloc/mrealloc/mfree for the heap specified
982 by MD, to detect memory corruption. Note that MD may be NULL to specify
983 the default heap that grows via sbrk.
985 Note that for freshly created regions, we must call mmcheckf prior to any
986 mallocs in the region. Otherwise, any region which was allocated prior to
987 installing the checking hooks, which is later reallocated or freed, will
988 fail the checks! The mmcheck function only allows initial hooks to be
989 installed before the first mmalloc. However, anytime after we have called
990 mmcheck the first time to install the checking hooks, we can call it again
991 to update the function pointer to the memory corruption handler.
993 Returns zero on failure, non-zero on success. */
995 #ifndef MMCHECK_FORCE
996 #define MMCHECK_FORCE 0
1003 if (!mmcheckf (md, malloc_botch, MMCHECK_FORCE))
1005 /* Don't use warning(), which relies on current_target being set
1006 to something other than dummy_target, until after
1007 initialize_all_files(). */
1010 (gdb_stderr, "warning: failed to install memory consistency checks; ");
1012 (gdb_stderr, "configuration should define NO_MMCHECK or MMCHECK_FORCE\n");
1018 #endif /* Have mmalloc and want corruption checking */
1020 /* Called when a memory allocation fails, with the number of bytes of
1021 memory requested in SIZE. */
1029 internal_error ("virtual memory exhausted: can't allocate %ld bytes.", size);
1033 internal_error ("virtual memory exhausted.");
1037 /* Like mmalloc but get error if no storage available, and protect against
1038 the caller wanting to allocate zero bytes. Whether to return NULL for
1039 a zero byte request, or translate the request into a request for one
1040 byte of zero'd storage, is a religious issue. */
1053 else if ((val = mmalloc (md, size)) == NULL)
1060 /* Like mrealloc but get error if no storage available. */
1063 xmrealloc (md, ptr, size)
1072 val = mrealloc (md, ptr, size);
1076 val = mmalloc (md, size);
1085 /* Like malloc but get error if no storage available, and protect against
1086 the caller wanting to allocate zero bytes. */
1092 return (xmmalloc ((PTR) NULL, size));
1095 /* Like mrealloc but get error if no storage available. */
1098 xrealloc (ptr, size)
1102 return (xmrealloc ((PTR) NULL, ptr, size));
1106 /* My replacement for the read system call.
1107 Used like `read' but keeps going if `read' returns too soon. */
1110 myread (desc, addr, len)
1120 val = read (desc, addr, len);
1124 return orglen - len;
1131 /* Make a copy of the string at PTR with SIZE characters
1132 (and add a null character at the end in the copy).
1133 Uses malloc to get the space. Returns the address of the copy. */
1136 savestring (ptr, size)
1140 register char *p = (char *) xmalloc (size + 1);
1141 memcpy (p, ptr, size);
1147 msavestring (md, ptr, size)
1152 register char *p = (char *) xmmalloc (md, size + 1);
1153 memcpy (p, ptr, size);
1158 /* The "const" is so it compiles under DGUX (which prototypes strsave
1159 in <string.h>. FIXME: This should be named "xstrsave", shouldn't it?
1160 Doesn't real strsave return NULL if out of memory? */
1165 return savestring (ptr, strlen (ptr));
1173 return (msavestring (md, ptr, strlen (ptr)));
1177 print_spaces (n, file)
1179 register GDB_FILE *file;
1181 fputs_unfiltered (n_spaces (n), file);
1184 /* Print a host address. */
1187 gdb_print_host_address (void *addr, struct gdb_file *stream)
1190 /* We could use the %p conversion specifier to fprintf if we had any
1191 way of knowing whether this host supports it. But the following
1192 should work on the Alpha and on 32 bit machines. */
1194 fprintf_filtered (stream, "0x%lx", (unsigned long) addr);
1197 /* Ask user a y-or-n question and return 1 iff answer is yes.
1198 Takes three args which are given to printf to print the question.
1199 The first, a control string, should end in "? ".
1200 It should not say how to answer, because we do that. */
1204 query (char *ctlstr,...)
1207 register int answer;
1211 va_start (args, ctlstr);
1215 return query_hook (ctlstr, args);
1218 /* Automatically answer "yes" if input is not from a terminal. */
1219 if (!input_from_terminal_p ())
1222 /* FIXME Automatically answer "yes" if called from MacGDB. */
1229 wrap_here (""); /* Flush any buffered output */
1230 gdb_flush (gdb_stdout);
1232 if (annotation_level > 1)
1233 printf_filtered ("\n\032\032pre-query\n");
1235 vfprintf_filtered (gdb_stdout, ctlstr, args);
1236 printf_filtered ("(y or n) ");
1238 if (annotation_level > 1)
1239 printf_filtered ("\n\032\032query\n");
1242 /* If not in MacGDB, move to a new line so the entered line doesn't
1243 have a prompt on the front of it. */
1245 fputs_unfiltered ("\n", gdb_stdout);
1249 gdb_flush (gdb_stdout);
1252 if (!tui_version || cmdWin == tuiWinWithFocus ())
1254 answer = fgetc (stdin);
1257 answer = (unsigned char) tuiBufferGetc ();
1260 clearerr (stdin); /* in case of C-d */
1261 if (answer == EOF) /* C-d */
1266 /* Eat rest of input line, to EOF or newline */
1267 if ((answer != '\n') || (tui_version && answer != '\r'))
1271 if (!tui_version || cmdWin == tuiWinWithFocus ())
1273 ans2 = fgetc (stdin);
1276 ans2 = (unsigned char) tuiBufferGetc ();
1280 while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
1281 TUIDO (((TuiOpaqueFuncPtr) tui_vStartNewLines, 1));
1295 printf_filtered ("Please answer y or n.\n");
1298 if (annotation_level > 1)
1299 printf_filtered ("\n\032\032post-query\n");
1304 /* Parse a C escape sequence. STRING_PTR points to a variable
1305 containing a pointer to the string to parse. That pointer
1306 should point to the character after the \. That pointer
1307 is updated past the characters we use. The value of the
1308 escape sequence is returned.
1310 A negative value means the sequence \ newline was seen,
1311 which is supposed to be equivalent to nothing at all.
1313 If \ is followed by a null character, we return a negative
1314 value and leave the string pointer pointing at the null character.
1316 If \ is followed by 000, we return 0 and leave the string pointer
1317 after the zeros. A value of 0 does not mean end of string. */
1320 parse_escape (string_ptr)
1323 register int c = *(*string_ptr)++;
1327 return 007; /* Bell (alert) char */
1330 case 'e': /* Escape character */
1348 c = *(*string_ptr)++;
1350 c = parse_escape (string_ptr);
1353 return (c & 0200) | (c & 037);
1364 register int i = c - '0';
1365 register int count = 0;
1368 if ((c = *(*string_ptr)++) >= '0' && c <= '7')
1386 /* Print the character C on STREAM as part of the contents of a literal
1387 string whose delimiter is QUOTER. Note that this routine should only
1388 be call for printing things which are independent of the language
1389 of the program being debugged. */
1391 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));
1394 printchar (c, do_fputs, do_fprintf, stream, quoter)
1396 void (*do_fputs) PARAMS ((const char *, GDB_FILE*));
1397 void (*do_fprintf) PARAMS ((GDB_FILE*, const char *, ...));
1402 c &= 0xFF; /* Avoid sign bit follies */
1404 if (c < 0x20 || /* Low control chars */
1405 (c >= 0x7F && c < 0xA0) || /* DEL, High controls */
1406 (sevenbit_strings && c >= 0x80))
1407 { /* high order bit set */
1411 do_fputs ("\\n", stream);
1414 do_fputs ("\\b", stream);
1417 do_fputs ("\\t", stream);
1420 do_fputs ("\\f", stream);
1423 do_fputs ("\\r", stream);
1426 do_fputs ("\\e", stream);
1429 do_fputs ("\\a", stream);
1432 do_fprintf (stream, "\\%.3o", (unsigned int) c);
1438 if (c == '\\' || c == quoter)
1439 do_fputs ("\\", stream);
1440 do_fprintf (stream, "%c", c);
1444 /* Print the character C on STREAM as part of the contents of a
1445 literal string whose delimiter is QUOTER. Note that these routines
1446 should only be call for printing things which are independent of
1447 the language of the program being debugged. */
1450 fputstr_filtered (str, quoter, stream)
1456 printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter);
1460 fputstr_unfiltered (str, quoter, stream)
1466 printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1470 fputstrn_unfiltered (str, n, quoter, stream)
1477 for (i = 0; i < n; i++)
1478 printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter);
1483 /* Number of lines per page or UINT_MAX if paging is disabled. */
1484 static unsigned int lines_per_page;
1485 /* Number of chars per line or UNIT_MAX if line folding is disabled. */
1486 static unsigned int chars_per_line;
1487 /* Current count of lines printed on this page, chars on this line. */
1488 static unsigned int lines_printed, chars_printed;
1490 /* Buffer and start column of buffered text, for doing smarter word-
1491 wrapping. When someone calls wrap_here(), we start buffering output
1492 that comes through fputs_filtered(). If we see a newline, we just
1493 spit it out and forget about the wrap_here(). If we see another
1494 wrap_here(), we spit it out and remember the newer one. If we see
1495 the end of the line, we spit out a newline, the indent, and then
1496 the buffered output. */
1498 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1499 are waiting to be output (they have already been counted in chars_printed).
1500 When wrap_buffer[0] is null, the buffer is empty. */
1501 static char *wrap_buffer;
1503 /* Pointer in wrap_buffer to the next character to fill. */
1504 static char *wrap_pointer;
1506 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1508 static char *wrap_indent;
1510 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1511 is not in effect. */
1512 static int wrap_column;
1515 /* Inialize the lines and chars per page */
1520 if (tui_version && m_winPtrNotNull (cmdWin))
1522 lines_per_page = cmdWin->generic.height;
1523 chars_per_line = cmdWin->generic.width;
1528 /* These defaults will be used if we are unable to get the correct
1529 values from termcap. */
1530 #if defined(__GO32__)
1531 lines_per_page = ScreenRows ();
1532 chars_per_line = ScreenCols ();
1534 lines_per_page = 24;
1535 chars_per_line = 80;
1537 #if !defined (MPW) && !defined (_WIN32)
1538 /* No termcap under MPW, although might be cool to do something
1539 by looking at worksheet or console window sizes. */
1540 /* Initialize the screen height and width from termcap. */
1542 char *termtype = getenv ("TERM");
1544 /* Positive means success, nonpositive means failure. */
1547 /* 2048 is large enough for all known terminals, according to the
1548 GNU termcap manual. */
1549 char term_buffer[2048];
1553 status = tgetent (term_buffer, termtype);
1557 int running_in_emacs = getenv ("EMACS") != NULL;
1559 val = tgetnum ("li");
1560 if (val >= 0 && !running_in_emacs)
1561 lines_per_page = val;
1563 /* The number of lines per page is not mentioned
1564 in the terminal description. This probably means
1565 that paging is not useful (e.g. emacs shell window),
1566 so disable paging. */
1567 lines_per_page = UINT_MAX;
1569 val = tgetnum ("co");
1571 chars_per_line = val;
1577 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1579 /* If there is a better way to determine the window size, use it. */
1580 SIGWINCH_HANDLER (SIGWINCH);
1583 /* If the output is not a terminal, don't paginate it. */
1584 if (!GDB_FILE_ISATTY (gdb_stdout))
1585 lines_per_page = UINT_MAX;
1586 } /* the command_line_version */
1593 if (chars_per_line == 0)
1598 wrap_buffer = (char *) xmalloc (chars_per_line + 2);
1599 wrap_buffer[0] = '\0';
1602 wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
1603 wrap_pointer = wrap_buffer; /* Start it at the beginning */
1608 set_width_command (args, from_tty, c)
1611 struct cmd_list_element *c;
1616 /* Wait, so the user can read what's on the screen. Prompt the user
1617 to continue by pressing RETURN. */
1620 prompt_for_continue ()
1623 char cont_prompt[120];
1625 if (annotation_level > 1)
1626 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1628 strcpy (cont_prompt,
1629 "---Type <return> to continue, or q <return> to quit---");
1630 if (annotation_level > 1)
1631 strcat (cont_prompt, "\n\032\032prompt-for-continue\n");
1633 /* We must do this *before* we call gdb_readline, else it will eventually
1634 call us -- thinking that we're trying to print beyond the end of the
1636 reinitialize_more_filter ();
1639 /* On a real operating system, the user can quit with SIGINT.
1642 'q' is provided on all systems so users don't have to change habits
1643 from system to system, and because telling them what to do in
1644 the prompt is more user-friendly than expecting them to think of
1646 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1647 whereas control-C to gdb_readline will cause the user to get dumped
1649 ignore = readline (cont_prompt);
1651 if (annotation_level > 1)
1652 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1657 while (*p == ' ' || *p == '\t')
1662 request_quit (SIGINT);
1664 async_request_quit (0);
1670 /* Now we have to do this again, so that GDB will know that it doesn't
1671 need to save the ---Type <return>--- line at the top of the screen. */
1672 reinitialize_more_filter ();
1674 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1677 /* Reinitialize filter; ie. tell it to reset to original values. */
1680 reinitialize_more_filter ()
1686 /* Indicate that if the next sequence of characters overflows the line,
1687 a newline should be inserted here rather than when it hits the end.
1688 If INDENT is non-null, it is a string to be printed to indent the
1689 wrapped part on the next line. INDENT must remain accessible until
1690 the next call to wrap_here() or until a newline is printed through
1693 If the line is already overfull, we immediately print a newline and
1694 the indentation, and disable further wrapping.
1696 If we don't know the width of lines, but we know the page height,
1697 we must not wrap words, but should still keep track of newlines
1698 that were explicitly printed.
1700 INDENT should not contain tabs, as that will mess up the char count
1701 on the next line. FIXME.
1703 This routine is guaranteed to force out any output which has been
1704 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1705 used to force out output from the wrap_buffer. */
1711 /* This should have been allocated, but be paranoid anyway. */
1717 *wrap_pointer = '\0';
1718 fputs_unfiltered (wrap_buffer, gdb_stdout);
1720 wrap_pointer = wrap_buffer;
1721 wrap_buffer[0] = '\0';
1722 if (chars_per_line == UINT_MAX) /* No line overflow checking */
1726 else if (chars_printed >= chars_per_line)
1728 puts_filtered ("\n");
1730 puts_filtered (indent);
1735 wrap_column = chars_printed;
1739 wrap_indent = indent;
1743 /* Ensure that whatever gets printed next, using the filtered output
1744 commands, starts at the beginning of the line. I.E. if there is
1745 any pending output for the current line, flush it and start a new
1746 line. Otherwise do nothing. */
1751 if (chars_printed > 0)
1753 puts_filtered ("\n");
1758 /* ``struct gdb_file'' implementation that maps directly onto
1759 <stdio.h>'s FILE. */
1761 static gdb_file_write_ftype stdio_file_write;
1762 static gdb_file_fputs_ftype stdio_file_fputs;
1763 static gdb_file_isatty_ftype stdio_file_isatty;
1764 static gdb_file_delete_ftype stdio_file_delete;
1765 static struct gdb_file *stdio_file_new PARAMS ((FILE * file, int close_p));
1766 static gdb_file_flush_ftype stdio_file_flush;
1768 static int stdio_file_magic;
1777 static struct gdb_file *
1778 stdio_file_new (file, close_p)
1782 struct gdb_file *gdb_file = gdb_file_new ();
1783 struct stdio_file *stdio = xmalloc (sizeof (struct stdio_file));
1784 stdio->magic = &stdio_file_magic;
1786 stdio->close_p = close_p;
1787 set_gdb_file_data (gdb_file, stdio, stdio_file_delete);
1788 set_gdb_file_flush (gdb_file, stdio_file_flush);
1789 set_gdb_file_write (gdb_file, stdio_file_write);
1790 set_gdb_file_fputs (gdb_file, stdio_file_fputs);
1791 set_gdb_file_isatty (gdb_file, stdio_file_isatty);
1796 stdio_file_delete (file)
1797 struct gdb_file *file;
1799 struct stdio_file *stdio = gdb_file_data (file);
1800 if (stdio->magic != &stdio_file_magic)
1801 internal_error ("stdio_file_delete: bad magic number");
1804 fclose (stdio->file);
1810 stdio_file_flush (file)
1811 struct gdb_file *file;
1813 struct stdio_file *stdio = gdb_file_data (file);
1814 if (stdio->magic != &stdio_file_magic)
1815 internal_error ("stdio_file_flush: bad magic number");
1816 fflush (stdio->file);
1820 stdio_file_write (struct gdb_file *file, const char *buf, long length_buf)
1822 struct stdio_file *stdio = gdb_file_data (file);
1823 if (stdio->magic != &stdio_file_magic)
1824 internal_error ("stdio_file_write: bad magic number");
1825 fwrite (buf, length_buf, 1, stdio->file);
1829 stdio_file_fputs (linebuffer, file)
1830 const char *linebuffer;
1831 struct gdb_file *file;
1833 struct stdio_file *stdio = gdb_file_data (file);
1834 if (stdio->magic != &stdio_file_magic)
1835 internal_error ("stdio_file_fputs: bad magic number");
1836 fputs (linebuffer, stdio->file);
1840 stdio_file_isatty (file)
1841 struct gdb_file *file;
1843 struct stdio_file *stdio = gdb_file_data (file);
1844 if (stdio->magic != &stdio_file_magic)
1845 internal_error ("stdio_file_isatty: bad magic number");
1846 return (isatty (fileno (stdio->file)));
1849 /* Like fdopen(). Create a gdb_file from a previously opened FILE. */
1852 stdio_fileopen (file)
1855 return stdio_file_new (file, 0);
1859 /* A pure memory based ``struct gdb_file'' that can be used an output
1860 buffer. The buffers accumulated contents are available via
1871 static gdb_file_rewind_ftype mem_file_rewind;
1872 static gdb_file_put_ftype mem_file_put;
1873 static gdb_file_write_ftype mem_file_write;
1874 static gdb_file_delete_ftype mem_file_delete;
1875 static struct gdb_file *mem_file_new PARAMS ((void));
1876 static int mem_file_magic;
1878 static struct gdb_file *
1881 struct mem_file *stream = XMALLOC (struct mem_file);
1882 struct gdb_file *file = gdb_file_new ();
1883 set_gdb_file_data (file, stream, mem_file_delete);
1884 set_gdb_file_rewind (file, mem_file_rewind);
1885 set_gdb_file_put (file, mem_file_put);
1886 set_gdb_file_write (file, mem_file_write);
1887 stream->magic = &mem_file_magic;
1888 stream->buffer = NULL;
1889 stream->sizeof_buffer = 0;
1890 stream->length_buffer = 0;
1895 mem_file_delete (struct gdb_file *file)
1897 struct mem_file *stream = gdb_file_data (file);
1898 if (stream->magic != &mem_file_magic)
1899 internal_error ("mem_file_delete: bad magic number");
1900 if (stream->buffer != NULL)
1901 free (stream->buffer);
1908 return mem_file_new ();
1912 mem_file_rewind (struct gdb_file *file)
1914 struct mem_file *stream = gdb_file_data (file);
1915 if (stream->magic != &mem_file_magic)
1916 internal_error ("mem_file_rewind: bad magic number");
1917 stream->length_buffer = 0;
1921 mem_file_put (struct gdb_file *file,
1922 gdb_file_put_method_ftype *write,
1925 struct mem_file *stream = gdb_file_data (file);
1926 if (stream->magic != &mem_file_magic)
1927 internal_error ("mem_file_put: bad magic number");
1928 if (stream->length_buffer > 0)
1929 write (dest, stream->buffer, stream->length_buffer);
1933 mem_file_write (struct gdb_file *file,
1937 struct mem_file *stream = gdb_file_data (file);
1938 if (stream->magic != &mem_file_magic)
1939 internal_error ("mem_file_write: bad magic number");
1940 if (stream->buffer == NULL)
1942 stream->length_buffer = length_buffer;
1943 stream->sizeof_buffer = length_buffer;
1944 stream->buffer = xmalloc (stream->sizeof_buffer);
1945 memcpy (stream->buffer, buffer, length_buffer);
1949 int new_length = stream->length_buffer + length_buffer;
1950 if (new_length >= stream->sizeof_buffer)
1952 stream->sizeof_buffer = new_length;
1953 stream->buffer = xrealloc (stream->buffer, stream->sizeof_buffer);
1955 memcpy (stream->buffer + stream->length_buffer, buffer, length_buffer);
1956 stream->length_buffer = new_length;
1960 /* A ``struct gdb_file'' that is compatible with all the legacy
1974 enum streamtype ts_streamtype;
1975 FILE *ts_filestream;
1980 static gdb_file_flush_ftype tui_file_flush;
1981 extern gdb_file_fputs_ftype tui_file_fputs;
1982 static gdb_file_isatty_ftype tui_file_isatty;
1983 static gdb_file_rewind_ftype tui_file_rewind;
1984 static gdb_file_put_ftype tui_file_put;
1985 static gdb_file_delete_ftype tui_file_delete;
1986 static struct gdb_file *tui_file_new PARAMS ((void));
1987 static int tui_file_magic;
1989 static struct gdb_file *
1992 struct tui_stream *tui = xmalloc (sizeof (struct tui_stream));
1993 struct gdb_file *file = gdb_file_new ();
1994 set_gdb_file_data (file, tui, tui_file_delete);
1995 set_gdb_file_flush (file, tui_file_flush);
1996 set_gdb_file_fputs (file, tui_file_fputs);
1997 set_gdb_file_isatty (file, tui_file_isatty);
1998 set_gdb_file_rewind (file, tui_file_rewind);
1999 set_gdb_file_put (file, tui_file_put);
2000 tui->ts_magic = &tui_file_magic;
2005 tui_file_delete (file)
2006 struct gdb_file *file;
2008 struct tui_stream *tmpstream = gdb_file_data (file);
2009 if (tmpstream->ts_magic != &tui_file_magic)
2010 internal_error ("tui_file_delete: bad magic number");
2011 if ((tmpstream->ts_streamtype == astring) &&
2012 (tmpstream->ts_strbuf != NULL))
2014 free (tmpstream->ts_strbuf);
2020 tui_fileopen (stream)
2023 struct gdb_file *file = tui_file_new ();
2024 struct tui_stream *tmpstream = gdb_file_data (file);
2025 tmpstream->ts_streamtype = afile;
2026 tmpstream->ts_filestream = stream;
2027 tmpstream->ts_strbuf = NULL;
2028 tmpstream->ts_buflen = 0;
2036 struct gdb_file *file = tui_file_new ();
2037 struct tui_stream *tmpstream = gdb_file_data (file);
2038 tmpstream->ts_streamtype = astring;
2039 tmpstream->ts_filestream = NULL;
2042 tmpstream->ts_strbuf = xmalloc ((n + 1) * sizeof (char));
2043 tmpstream->ts_strbuf[0] = '\0';
2046 /* Do not allocate the buffer now. The first time something is printed
2047 one will be allocated by tui_file_adjust_strbuf() */
2048 tmpstream->ts_strbuf = NULL;
2049 tmpstream->ts_buflen = n;
2054 tui_file_isatty (file)
2055 struct gdb_file *file;
2057 struct tui_stream *stream = gdb_file_data (file);
2058 if (stream->ts_magic != &tui_file_magic)
2059 internal_error ("tui_file_isatty: bad magic number");
2060 if (stream->ts_streamtype == afile)
2061 return (isatty (fileno (stream->ts_filestream)));
2067 tui_file_rewind (file)
2068 struct gdb_file *file;
2070 struct tui_stream *stream = gdb_file_data (file);
2071 if (stream->ts_magic != &tui_file_magic)
2072 internal_error ("tui_file_rewind: bad magic number");
2073 stream->ts_strbuf[0] = '\0';
2077 tui_file_put (struct gdb_file *file,
2078 gdb_file_put_method_ftype *write,
2081 struct tui_stream *stream = gdb_file_data (file);
2082 if (stream->ts_magic != &tui_file_magic)
2083 internal_error ("tui_file_put: bad magic number");
2084 if (stream->ts_streamtype == astring)
2085 write (dest, stream->ts_strbuf, strlen (stream->ts_strbuf));
2088 /* All TUI I/O sent to the *_filtered and *_unfiltered functions
2089 eventually ends up here. The fputs_unfiltered_hook is primarily
2090 used by GUIs to collect all output and send it to the GUI, instead
2091 of the controlling terminal. Only output to gdb_stdout and
2092 gdb_stderr are sent to the hook. Everything else is sent on to
2093 fputs to allow file I/O to be handled appropriately. */
2095 /* FIXME: Should be broken up and moved to a TUI specific file. */
2098 tui_file_fputs (linebuffer, file)
2099 const char *linebuffer;
2102 struct tui_stream *stream = gdb_file_data (file);
2104 extern int tui_owns_terminal;
2106 /* NOTE: cagney/1999-10-13: The use of fputs_unfiltered_hook is
2107 seriously discouraged. Those wanting to hook output should
2108 instead implement their own gdb_file object and install that. See
2109 also tui_file_flush(). */
2110 if (fputs_unfiltered_hook
2111 && (file == gdb_stdout
2112 || file == gdb_stderr))
2113 fputs_unfiltered_hook (linebuffer, file);
2117 if (tui_version && tui_owns_terminal)
2119 /* If we get here somehow while updating the TUI (from
2120 * within a tuiDo(), then we need to temporarily
2121 * set up the terminal for GDB output. This probably just
2122 * happens on error output.
2125 if (stream->ts_streamtype == astring)
2127 tui_file_adjust_strbuf (strlen (linebuffer), stream);
2128 strcat (stream->ts_strbuf, linebuffer);
2132 tuiTermUnsetup (0, (tui_version) ? cmdWin->detail.commandInfo.curch : 0);
2133 fputs (linebuffer, stream->ts_filestream);
2135 if (linebuffer[strlen (linebuffer) - 1] == '\n')
2136 tuiClearCommandCharCount ();
2138 tuiIncrCommandCharCountBy (strlen (linebuffer));
2143 /* The normal case - just do a fputs() */
2144 if (stream->ts_streamtype == astring)
2146 tui_file_adjust_strbuf (strlen (linebuffer), stream);
2147 strcat (stream->ts_strbuf, linebuffer);
2150 fputs (linebuffer, stream->ts_filestream);
2155 if (stream->ts_streamtype == astring)
2157 tui_file_adjust_strbuf (strlen (linebuffer), file);
2158 strcat (stream->ts_strbuf, linebuffer);
2161 fputs (linebuffer, stream->ts_filestream);
2167 tui_file_get_strbuf (struct gdb_file *file)
2169 struct tui_stream *stream = gdb_file_data (file);
2170 if (stream->ts_magic != &tui_file_magic)
2171 internal_error ("tui_file_get_strbuf: bad magic number");
2172 return (stream->ts_strbuf);
2175 /* adjust the length of the buffer by the amount necessary
2176 to accomodate appending a string of length N to the buffer contents */
2178 tui_file_adjust_strbuf (int n, struct gdb_file *file)
2180 struct tui_stream *stream = gdb_file_data (file);
2182 if (stream->ts_magic != &tui_file_magic)
2183 internal_error ("tui_file_adjust_strbuf: bad magic number");
2185 if (stream->ts_streamtype != astring)
2188 if (stream->ts_strbuf)
2190 /* There is already a buffer allocated */
2191 non_null_chars = strlen (stream->ts_strbuf);
2193 if (n > (stream->ts_buflen - non_null_chars - 1))
2195 stream->ts_buflen = n + non_null_chars + 1;
2196 stream->ts_strbuf = xrealloc (stream->ts_strbuf, stream->ts_buflen);
2200 /* No buffer yet, so allocate one of the desired size */
2201 stream->ts_strbuf = xmalloc ((n + 1) * sizeof (char));
2205 gdb_fopen (name, mode)
2209 FILE *f = fopen (name, mode);
2212 return stdio_file_new (f, 1);
2216 tui_file_flush (file)
2219 struct tui_stream *stream = gdb_file_data (file);
2220 if (stream->ts_magic != &tui_file_magic)
2221 internal_error ("tui_file_flush: bad magic number");
2223 /* NOTE: cagney/1999-10-12: If we've been linked with code that uses
2224 fputs_unfiltered_hook then we assume that it doesn't need to know
2225 about flushes. Code that does need to know about flushes can
2226 implement a proper gdb_file object. */
2227 if (fputs_unfiltered_hook)
2230 switch (stream->ts_streamtype)
2235 fflush (stream->ts_filestream);
2240 /* Implement the ``struct gdb_file'' object. */
2242 static gdb_file_isatty_ftype null_file_isatty;
2243 static gdb_file_write_ftype null_file_write;
2244 static gdb_file_fputs_ftype null_file_fputs;
2245 static gdb_file_flush_ftype null_file_flush;
2246 static gdb_file_delete_ftype null_file_delete;
2247 static gdb_file_rewind_ftype null_file_rewind;
2248 static gdb_file_put_ftype null_file_put;
2253 gdb_file_flush_ftype *to_flush;
2254 gdb_file_write_ftype *to_write;
2255 gdb_file_fputs_ftype *to_fputs;
2256 gdb_file_delete_ftype *to_delete;
2257 gdb_file_isatty_ftype *to_isatty;
2258 gdb_file_rewind_ftype *to_rewind;
2259 gdb_file_put_ftype *to_put;
2267 struct gdb_file *file = xmalloc (sizeof (struct gdb_file));
2268 file->magic = &gdb_file_magic;
2269 set_gdb_file_data (file, NULL, null_file_delete);
2270 set_gdb_file_flush (file, null_file_flush);
2271 set_gdb_file_write (file, null_file_write);
2272 set_gdb_file_fputs (file, null_file_fputs);
2273 set_gdb_file_isatty (file, null_file_isatty);
2274 set_gdb_file_rewind (file, null_file_rewind);
2275 set_gdb_file_put (file, null_file_put);
2280 gdb_file_delete (file)
2281 struct gdb_file *file;
2283 file->to_delete (file);
2288 null_file_isatty (file)
2289 struct gdb_file *file;
2295 null_file_rewind (file)
2296 struct gdb_file *file;
2302 null_file_put (struct gdb_file *file,
2303 gdb_file_put_method_ftype *write,
2310 null_file_flush (file)
2311 struct gdb_file *file;
2317 null_file_write (struct gdb_file *file,
2321 if (file->to_fputs == null_file_fputs)
2322 /* Both the write and fputs methods are null. Discard the
2327 /* The fputs method isn't null, slowly pass the write request
2328 onto that. FYI, this isn't as bad as it may look - the
2329 current (as of 1999-11-07) printf_* function calls fputc and
2330 fputc does exactly the below. By having a write function it
2331 is possible to clean up that code. */
2335 for (i = 0; i < sizeof_buf; i++)
2338 file->to_fputs (b, file);
2345 null_file_fputs (buf, file)
2347 struct gdb_file *file;
2349 if (file->to_write == null_file_write)
2350 /* Both the write and fputs methods are null. Discard the
2355 /* The write method was implemented, use that. */
2356 file->to_write (file, buf, strlen (buf));
2361 null_file_delete (file)
2362 struct gdb_file *file;
2368 gdb_file_data (file)
2369 struct gdb_file *file;
2371 if (file->magic != &gdb_file_magic)
2372 internal_error ("gdb_file_data: bad magic number");
2373 return file->to_data;
2378 struct gdb_file *file;
2380 file->to_flush (file);
2384 gdb_file_isatty (file)
2385 struct gdb_file *file;
2387 return file->to_isatty (file);
2391 gdb_file_rewind (file)
2392 struct gdb_file *file;
2394 file->to_rewind (file);
2398 gdb_file_put (struct gdb_file *file,
2399 gdb_file_put_method_ftype *write,
2402 file->to_put (file, write, dest);
2406 gdb_file_write (struct gdb_file *file,
2410 file->to_write (file, buf, length_buf);
2414 fputs_unfiltered (buf, file)
2416 struct gdb_file *file;
2418 file->to_fputs (buf, file);
2422 set_gdb_file_flush (file, flush)
2423 struct gdb_file *file;
2424 gdb_file_flush_ftype *flush;
2426 file->to_flush = flush;
2430 set_gdb_file_isatty (file, isatty)
2431 struct gdb_file *file;
2432 gdb_file_isatty_ftype *isatty;
2434 file->to_isatty = isatty;
2438 set_gdb_file_rewind (file, rewind)
2439 struct gdb_file *file;
2440 gdb_file_rewind_ftype *rewind;
2442 file->to_rewind = rewind;
2446 set_gdb_file_put (file, put)
2447 struct gdb_file *file;
2448 gdb_file_put_ftype *put;
2454 set_gdb_file_write (struct gdb_file *file,
2455 gdb_file_write_ftype *write)
2457 file->to_write = write;
2461 set_gdb_file_fputs (file, fputs)
2462 struct gdb_file *file;
2463 gdb_file_fputs_ftype *fputs;
2465 file->to_fputs = fputs;
2469 set_gdb_file_data (file, data, delete)
2470 struct gdb_file *file;
2472 gdb_file_delete_ftype *delete;
2474 file->to_data = data;
2475 file->to_delete = delete;
2478 /* gdb_file utility function for converting a ``struct gdb_file'' into
2479 a memory buffer''. */
2481 struct accumulated_gdb_file
2488 do_gdb_file_xstrdup (void *context, const char *buffer, long length)
2490 struct accumulated_gdb_file *acc = context;
2491 if (acc->buffer == NULL)
2492 acc->buffer = xmalloc (length + 1);
2494 acc->buffer = xrealloc (acc->buffer, acc->length + length + 1);
2495 memcpy (acc->buffer + acc->length, buffer, length);
2496 acc->length += length;
2497 acc->buffer[acc->length] = '\0';
2501 gdb_file_xstrdup (struct gdb_file *file,
2504 struct accumulated_gdb_file acc;
2507 gdb_file_put (file, do_gdb_file_xstrdup, &acc);
2508 if (acc.buffer == NULL)
2509 acc.buffer = xstrdup ("");
2510 *length = acc.length;
2515 /* Like fputs but if FILTER is true, pause after every screenful.
2517 Regardless of FILTER can wrap at points other than the final
2518 character of a line.
2520 Unlike fputs, fputs_maybe_filtered does not return a value.
2521 It is OK for LINEBUFFER to be NULL, in which case just don't print
2524 Note that a longjmp to top level may occur in this routine (only if
2525 FILTER is true) (since prompt_for_continue may do so) so this
2526 routine should not be called when cleanups are not in place. */
2529 fputs_maybe_filtered (linebuffer, stream, filter)
2530 const char *linebuffer;
2534 const char *lineptr;
2536 if (linebuffer == 0)
2539 /* Don't do any filtering if it is disabled. */
2540 if ((stream != gdb_stdout) || !pagination_enabled
2541 || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX))
2543 fputs_unfiltered (linebuffer, stream);
2547 /* Go through and output each character. Show line extension
2548 when this is necessary; prompt user for new page when this is
2551 lineptr = linebuffer;
2554 /* Possible new page. */
2556 (lines_printed >= lines_per_page - 1))
2557 prompt_for_continue ();
2559 while (*lineptr && *lineptr != '\n')
2561 /* Print a single line. */
2562 if (*lineptr == '\t')
2565 *wrap_pointer++ = '\t';
2567 fputc_unfiltered ('\t', stream);
2568 /* Shifting right by 3 produces the number of tab stops
2569 we have already passed, and then adding one and
2570 shifting left 3 advances to the next tab stop. */
2571 chars_printed = ((chars_printed >> 3) + 1) << 3;
2577 *wrap_pointer++ = *lineptr;
2579 fputc_unfiltered (*lineptr, stream);
2584 if (chars_printed >= chars_per_line)
2586 unsigned int save_chars = chars_printed;
2590 /* If we aren't actually wrapping, don't output newline --
2591 if chars_per_line is right, we probably just overflowed
2592 anyway; if it's wrong, let us keep going. */
2594 fputc_unfiltered ('\n', stream);
2596 /* Possible new page. */
2597 if (lines_printed >= lines_per_page - 1)
2598 prompt_for_continue ();
2600 /* Now output indentation and wrapped string */
2603 fputs_unfiltered (wrap_indent, stream);
2604 *wrap_pointer = '\0'; /* Null-terminate saved stuff */
2605 fputs_unfiltered (wrap_buffer, stream); /* and eject it */
2606 /* FIXME, this strlen is what prevents wrap_indent from
2607 containing tabs. However, if we recurse to print it
2608 and count its chars, we risk trouble if wrap_indent is
2609 longer than (the user settable) chars_per_line.
2610 Note also that this can set chars_printed > chars_per_line
2611 if we are printing a long string. */
2612 chars_printed = strlen (wrap_indent)
2613 + (save_chars - wrap_column);
2614 wrap_pointer = wrap_buffer; /* Reset buffer */
2615 wrap_buffer[0] = '\0';
2616 wrap_column = 0; /* And disable fancy wrap */
2621 if (*lineptr == '\n')
2624 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
2626 fputc_unfiltered ('\n', stream);
2633 fputs_filtered (linebuffer, stream)
2634 const char *linebuffer;
2637 fputs_maybe_filtered (linebuffer, stream, 1);
2641 putchar_unfiltered (c)
2645 gdb_file_write (gdb_stdout, &buf, 1);
2650 fputc_unfiltered (c, stream)
2655 gdb_file_write (stream, &buf, 1);
2660 fputc_filtered (c, stream)
2668 fputs_filtered (buf, stream);
2672 /* puts_debug is like fputs_unfiltered, except it prints special
2673 characters in printable fashion. */
2676 puts_debug (prefix, string, suffix)
2683 /* Print prefix and suffix after each line. */
2684 static int new_line = 1;
2685 static int return_p = 0;
2686 static char *prev_prefix = "";
2687 static char *prev_suffix = "";
2689 if (*string == '\n')
2692 /* If the prefix is changing, print the previous suffix, a new line,
2693 and the new prefix. */
2694 if ((return_p || (strcmp (prev_prefix, prefix) != 0)) && !new_line)
2696 fputs_unfiltered (prev_suffix, gdb_stdlog);
2697 fputs_unfiltered ("\n", gdb_stdlog);
2698 fputs_unfiltered (prefix, gdb_stdlog);
2701 /* Print prefix if we printed a newline during the previous call. */
2705 fputs_unfiltered (prefix, gdb_stdlog);
2708 prev_prefix = prefix;
2709 prev_suffix = suffix;
2711 /* Output characters in a printable format. */
2712 while ((ch = *string++) != '\0')
2718 fputc_unfiltered (ch, gdb_stdlog);
2721 fprintf_unfiltered (gdb_stdlog, "\\x%02x", ch & 0xff);
2725 fputs_unfiltered ("\\\\", gdb_stdlog);
2728 fputs_unfiltered ("\\b", gdb_stdlog);
2731 fputs_unfiltered ("\\f", gdb_stdlog);
2735 fputs_unfiltered ("\\n", gdb_stdlog);
2738 fputs_unfiltered ("\\r", gdb_stdlog);
2741 fputs_unfiltered ("\\t", gdb_stdlog);
2744 fputs_unfiltered ("\\v", gdb_stdlog);
2748 return_p = ch == '\r';
2751 /* Print suffix if we printed a newline. */
2754 fputs_unfiltered (suffix, gdb_stdlog);
2755 fputs_unfiltered ("\n", gdb_stdlog);
2760 /* Print a variable number of ARGS using format FORMAT. If this
2761 information is going to put the amount written (since the last call
2762 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2763 call prompt_for_continue to get the users permision to continue.
2765 Unlike fprintf, this function does not return a value.
2767 We implement three variants, vfprintf (takes a vararg list and stream),
2768 fprintf (takes a stream to write on), and printf (the usual).
2770 Note also that a longjmp to top level may occur in this routine
2771 (since prompt_for_continue may do so) so this routine should not be
2772 called when cleanups are not in place. */
2775 vfprintf_maybe_filtered (stream, format, args, filter)
2782 struct cleanup *old_cleanups;
2784 vasprintf (&linebuffer, format, args);
2785 if (linebuffer == NULL)
2787 fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr);
2790 old_cleanups = make_cleanup (free, linebuffer);
2791 fputs_maybe_filtered (linebuffer, stream, filter);
2792 do_cleanups (old_cleanups);
2797 vfprintf_filtered (stream, format, args)
2802 vfprintf_maybe_filtered (stream, format, args, 1);
2806 vfprintf_unfiltered (stream, format, args)
2812 struct cleanup *old_cleanups;
2814 vasprintf (&linebuffer, format, args);
2815 if (linebuffer == NULL)
2817 fputs_unfiltered ("\ngdb: virtual memory exhausted.\n", gdb_stderr);
2820 old_cleanups = make_cleanup (free, linebuffer);
2821 fputs_unfiltered (linebuffer, stream);
2822 do_cleanups (old_cleanups);
2826 vprintf_filtered (format, args)
2830 vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
2834 vprintf_unfiltered (format, args)
2838 vfprintf_unfiltered (gdb_stdout, format, args);
2842 fprintf_filtered (GDB_FILE * stream, const char *format,...)
2845 va_start (args, format);
2846 vfprintf_filtered (stream, format, args);
2851 fprintf_unfiltered (GDB_FILE * stream, const char *format,...)
2854 va_start (args, format);
2855 vfprintf_unfiltered (stream, format, args);
2859 /* Like fprintf_filtered, but prints its result indented.
2860 Called as fprintfi_filtered (spaces, stream, format, ...); */
2863 fprintfi_filtered (int spaces, GDB_FILE * stream, const char *format,...)
2866 va_start (args, format);
2867 print_spaces_filtered (spaces, stream);
2869 vfprintf_filtered (stream, format, args);
2875 printf_filtered (const char *format,...)
2878 va_start (args, format);
2879 vfprintf_filtered (gdb_stdout, format, args);
2885 printf_unfiltered (const char *format,...)
2888 va_start (args, format);
2889 vfprintf_unfiltered (gdb_stdout, format, args);
2893 /* Like printf_filtered, but prints it's result indented.
2894 Called as printfi_filtered (spaces, format, ...); */
2897 printfi_filtered (int spaces, const char *format,...)
2900 va_start (args, format);
2901 print_spaces_filtered (spaces, gdb_stdout);
2902 vfprintf_filtered (gdb_stdout, format, args);
2906 /* Easy -- but watch out!
2908 This routine is *not* a replacement for puts()! puts() appends a newline.
2909 This one doesn't, and had better not! */
2912 puts_filtered (string)
2915 fputs_filtered (string, gdb_stdout);
2919 puts_unfiltered (string)
2922 fputs_unfiltered (string, gdb_stdout);
2925 /* Return a pointer to N spaces and a null. The pointer is good
2926 until the next call to here. */
2932 static char *spaces = 0;
2933 static int max_spaces = -1;
2939 spaces = (char *) xmalloc (n + 1);
2940 for (t = spaces + n; t != spaces;)
2946 return spaces + max_spaces - n;
2949 /* Print N spaces. */
2951 print_spaces_filtered (n, stream)
2955 fputs_filtered (n_spaces (n), stream);
2958 /* C++ demangler stuff. */
2960 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2961 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2962 If the name is not mangled, or the language for the name is unknown, or
2963 demangling is off, the name is printed in its "raw" form. */
2966 fprintf_symbol_filtered (stream, name, lang, arg_mode)
2976 /* If user wants to see raw output, no problem. */
2979 fputs_filtered (name, stream);
2985 case language_cplus:
2986 demangled = cplus_demangle (name, arg_mode);
2989 demangled = cplus_demangle (name, arg_mode | DMGL_JAVA);
2991 case language_chill:
2992 demangled = chill_demangle (name);
2998 fputs_filtered (demangled ? demangled : name, stream);
2999 if (demangled != NULL)
3007 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
3008 differences in whitespace. Returns 0 if they match, non-zero if they
3009 don't (slightly different than strcmp()'s range of return values).
3011 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
3012 This "feature" is useful when searching for matching C++ function names
3013 (such as if the user types 'break FOO', where FOO is a mangled C++
3017 strcmp_iw (string1, string2)
3018 const char *string1;
3019 const char *string2;
3021 while ((*string1 != '\0') && (*string2 != '\0'))
3023 while (isspace (*string1))
3027 while (isspace (*string2))
3031 if (*string1 != *string2)
3035 if (*string1 != '\0')
3041 return (*string1 != '\0' && *string1 != '(') || (*string2 != '\0');
3047 ** Answer whether string_to_compare is a full or partial match to
3048 ** template_string. The partial match must be in sequence starting
3052 subset_compare (string_to_compare, template_string)
3053 char *string_to_compare;
3054 char *template_string;
3057 if (template_string != (char *) NULL && string_to_compare != (char *) NULL &&
3058 strlen (string_to_compare) <= strlen (template_string))
3059 match = (strncmp (template_string,
3061 strlen (string_to_compare)) == 0);
3068 static void pagination_on_command PARAMS ((char *arg, int from_tty));
3070 pagination_on_command (arg, from_tty)
3074 pagination_enabled = 1;
3077 static void pagination_on_command PARAMS ((char *arg, int from_tty));
3079 pagination_off_command (arg, from_tty)
3083 pagination_enabled = 0;
3090 struct cmd_list_element *c;
3092 c = add_set_cmd ("width", class_support, var_uinteger,
3093 (char *) &chars_per_line,
3094 "Set number of characters gdb thinks are in a line.",
3096 add_show_from_set (c, &showlist);
3097 c->function.sfunc = set_width_command;
3100 (add_set_cmd ("height", class_support,
3101 var_uinteger, (char *) &lines_per_page,
3102 "Set number of lines gdb thinks are in a page.", &setlist),
3107 /* If the output is not a terminal, don't paginate it. */
3108 if (!GDB_FILE_ISATTY (gdb_stdout))
3109 lines_per_page = UINT_MAX;
3111 set_width_command ((char *) NULL, 0, c);
3114 (add_set_cmd ("demangle", class_support, var_boolean,
3116 "Set demangling of encoded C++ names when displaying symbols.",
3121 (add_set_cmd ("pagination", class_support,
3122 var_boolean, (char *) &pagination_enabled,
3123 "Set state of pagination.", &setlist),
3127 add_com ("am", class_support, pagination_on_command,
3128 "Enable pagination");
3129 add_com ("sm", class_support, pagination_off_command,
3130 "Disable pagination");
3134 (add_set_cmd ("sevenbit-strings", class_support, var_boolean,
3135 (char *) &sevenbit_strings,
3136 "Set printing of 8-bit characters in strings as \\nnn.",
3141 (add_set_cmd ("asm-demangle", class_support, var_boolean,
3142 (char *) &asm_demangle,
3143 "Set demangling of C++ names in disassembly listings.",
3148 /* Machine specific function to handle SIGWINCH signal. */
3150 #ifdef SIGWINCH_HANDLER_BODY
3151 SIGWINCH_HANDLER_BODY
3154 /* Support for converting target fp numbers into host DOUBLEST format. */
3156 /* XXX - This code should really be in libiberty/floatformat.c, however
3157 configuration issues with libiberty made this very difficult to do in the
3160 #include "floatformat.h"
3161 #include <math.h> /* ldexp */
3163 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
3164 going to bother with trying to muck around with whether it is defined in
3165 a system header, what we do if not, etc. */
3166 #define FLOATFORMAT_CHAR_BIT 8
3168 static unsigned long get_field PARAMS ((unsigned char *,
3169 enum floatformat_byteorders,
3174 /* Extract a field which starts at START and is LEN bytes long. DATA and
3175 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
3176 static unsigned long
3177 get_field (data, order, total_len, start, len)
3178 unsigned char *data;
3179 enum floatformat_byteorders order;
3180 unsigned int total_len;
3184 unsigned long result;
3185 unsigned int cur_byte;
3188 /* Start at the least significant part of the field. */
3189 cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
3190 if (order == floatformat_little || order == floatformat_littlebyte_bigword)
3191 cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
3193 ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
3194 result = *(data + cur_byte) >> (-cur_bitshift);
3195 cur_bitshift += FLOATFORMAT_CHAR_BIT;
3196 if (order == floatformat_little || order == floatformat_littlebyte_bigword)
3201 /* Move towards the most significant part of the field. */
3202 while (cur_bitshift < len)
3204 if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
3205 /* This is the last byte; zero out the bits which are not part of
3208 (*(data + cur_byte) & ((1 << (len - cur_bitshift)) - 1))
3211 result |= *(data + cur_byte) << cur_bitshift;
3212 cur_bitshift += FLOATFORMAT_CHAR_BIT;
3213 if (order == floatformat_little || order == floatformat_littlebyte_bigword)
3221 /* Convert from FMT to a DOUBLEST.
3222 FROM is the address of the extended float.
3223 Store the DOUBLEST in *TO. */
3226 floatformat_to_doublest (fmt, from, to)
3227 const struct floatformat *fmt;
3231 unsigned char *ufrom = (unsigned char *) from;
3235 unsigned int mant_bits, mant_off;
3237 int special_exponent; /* It's a NaN, denorm or zero */
3239 /* If the mantissa bits are not contiguous from one end of the
3240 mantissa to the other, we need to make a private copy of the
3241 source bytes that is in the right order since the unpacking
3242 algorithm assumes that the bits are contiguous.
3244 Swap the bytes individually rather than accessing them through
3245 "long *" since we have no guarantee that they start on a long
3246 alignment, and also sizeof(long) for the host could be different
3247 than sizeof(long) for the target. FIXME: Assumes sizeof(long)
3248 for the target is 4. */
3250 if (fmt->byteorder == floatformat_littlebyte_bigword)
3252 static unsigned char *newfrom;
3253 unsigned char *swapin, *swapout;
3256 longswaps = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
3259 if (newfrom == NULL)
3261 newfrom = (unsigned char *) xmalloc (fmt->totalsize);
3266 while (longswaps-- > 0)
3268 /* This is ugly, but efficient */
3269 *swapout++ = swapin[4];
3270 *swapout++ = swapin[5];
3271 *swapout++ = swapin[6];
3272 *swapout++ = swapin[7];
3273 *swapout++ = swapin[0];
3274 *swapout++ = swapin[1];
3275 *swapout++ = swapin[2];
3276 *swapout++ = swapin[3];
3281 exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
3282 fmt->exp_start, fmt->exp_len);
3283 /* Note that if exponent indicates a NaN, we can't really do anything useful
3284 (not knowing if the host has NaN's, or how to build one). So it will
3285 end up as an infinity or something close; that is OK. */
3287 mant_bits_left = fmt->man_len;
3288 mant_off = fmt->man_start;
3291 special_exponent = exponent == 0 || exponent == fmt->exp_nan;
3293 /* Don't bias NaNs. Use minimum exponent for denorms. For simplicity,
3294 we don't check for zero as the exponent doesn't matter. */
3295 if (!special_exponent)
3296 exponent -= fmt->exp_bias;
3297 else if (exponent == 0)
3298 exponent = 1 - fmt->exp_bias;
3300 /* Build the result algebraically. Might go infinite, underflow, etc;
3303 /* If this format uses a hidden bit, explicitly add it in now. Otherwise,
3304 increment the exponent by one to account for the integer bit. */
3306 if (!special_exponent)
3308 if (fmt->intbit == floatformat_intbit_no)
3309 dto = ldexp (1.0, exponent);
3314 while (mant_bits_left > 0)
3316 mant_bits = min (mant_bits_left, 32);
3318 mant = get_field (ufrom, fmt->byteorder, fmt->totalsize,
3319 mant_off, mant_bits);
3321 dto += ldexp ((double) mant, exponent - mant_bits);
3322 exponent -= mant_bits;
3323 mant_off += mant_bits;
3324 mant_bits_left -= mant_bits;
3327 /* Negate it if negative. */
3328 if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
3333 static void put_field PARAMS ((unsigned char *, enum floatformat_byteorders,
3339 /* Set a field which starts at START and is LEN bytes long. DATA and
3340 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
3342 put_field (data, order, total_len, start, len, stuff_to_put)
3343 unsigned char *data;
3344 enum floatformat_byteorders order;
3345 unsigned int total_len;
3348 unsigned long stuff_to_put;
3350 unsigned int cur_byte;
3353 /* Start at the least significant part of the field. */
3354 cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
3355 if (order == floatformat_little || order == floatformat_littlebyte_bigword)
3356 cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1;
3358 ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
3359 *(data + cur_byte) &=
3360 ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1) << (-cur_bitshift));
3361 *(data + cur_byte) |=
3362 (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
3363 cur_bitshift += FLOATFORMAT_CHAR_BIT;
3364 if (order == floatformat_little || order == floatformat_littlebyte_bigword)
3369 /* Move towards the most significant part of the field. */
3370 while (cur_bitshift < len)
3372 if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
3374 /* This is the last byte. */
3375 *(data + cur_byte) &=
3376 ~((1 << (len - cur_bitshift)) - 1);
3377 *(data + cur_byte) |= (stuff_to_put >> cur_bitshift);
3380 *(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
3381 & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
3382 cur_bitshift += FLOATFORMAT_CHAR_BIT;
3383 if (order == floatformat_little || order == floatformat_littlebyte_bigword)
3390 #ifdef HAVE_LONG_DOUBLE
3391 /* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR.
3392 The range of the returned value is >= 0.5 and < 1.0. This is equivalent to
3393 frexp, but operates on the long double data type. */
3395 static long double ldfrexp PARAMS ((long double value, int *eptr));
3398 ldfrexp (value, eptr)
3405 /* Unfortunately, there are no portable functions for extracting the exponent
3406 of a long double, so we have to do it iteratively by multiplying or dividing
3407 by two until the fraction is between 0.5 and 1.0. */
3415 if (value >= tmp) /* Value >= 1.0 */
3416 while (value >= tmp)
3421 else if (value != 0.0l) /* Value < 1.0 and > 0.0 */
3435 #endif /* HAVE_LONG_DOUBLE */
3438 /* The converse: convert the DOUBLEST *FROM to an extended float
3439 and store where TO points. Neither FROM nor TO have any alignment
3443 floatformat_from_doublest (fmt, from, to)
3444 CONST struct floatformat *fmt;
3451 unsigned int mant_bits, mant_off;
3453 unsigned char *uto = (unsigned char *) to;
3455 memcpy (&dfrom, from, sizeof (dfrom));
3456 memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT);
3458 return; /* Result is zero */
3459 if (dfrom != dfrom) /* Result is NaN */
3462 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
3463 fmt->exp_len, fmt->exp_nan);
3464 /* Be sure it's not infinity, but NaN value is irrel */
3465 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
3470 /* If negative, set the sign bit. */
3473 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
3477 if (dfrom + dfrom == dfrom && dfrom != 0.0) /* Result is Infinity */
3479 /* Infinity exponent is same as NaN's. */
3480 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
3481 fmt->exp_len, fmt->exp_nan);
3482 /* Infinity mantissa is all zeroes. */
3483 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
3488 #ifdef HAVE_LONG_DOUBLE
3489 mant = ldfrexp (dfrom, &exponent);
3491 mant = frexp (dfrom, &exponent);
3494 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len,
3495 exponent + fmt->exp_bias - 1);
3497 mant_bits_left = fmt->man_len;
3498 mant_off = fmt->man_start;
3499 while (mant_bits_left > 0)
3501 unsigned long mant_long;
3502 mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
3504 mant *= 4294967296.0;
3505 mant_long = (unsigned long) mant;
3508 /* If the integer bit is implicit, then we need to discard it.
3509 If we are discarding a zero, we should be (but are not) creating
3510 a denormalized number which means adjusting the exponent
3512 if (mant_bits_left == fmt->man_len
3513 && fmt->intbit == floatformat_intbit_no)
3521 /* The bits we want are in the most significant MANT_BITS bits of
3522 mant_long. Move them to the least significant. */
3523 mant_long >>= 32 - mant_bits;
3526 put_field (uto, fmt->byteorder, fmt->totalsize,
3527 mant_off, mant_bits, mant_long);
3528 mant_off += mant_bits;
3529 mant_bits_left -= mant_bits;
3531 if (fmt->byteorder == floatformat_littlebyte_bigword)
3534 unsigned char *swaplow = uto;
3535 unsigned char *swaphigh = uto + 4;
3538 for (count = 0; count < 4; count++)
3541 *swaplow++ = *swaphigh;
3547 /* temporary storage using circular buffer */
3553 static char buf[NUMCELLS][CELLSIZE];
3554 static int cell = 0;
3555 if (++cell >= NUMCELLS)
3560 /* print routines to handle variable size regs, etc.
3562 FIXME: Note that t_addr is a bfd_vma, which is currently either an
3563 unsigned long or unsigned long long, determined at configure time.
3564 If t_addr is an unsigned long long and sizeof (unsigned long long)
3565 is greater than sizeof (unsigned long), then I believe this code will
3566 probably lose, at least for little endian machines. I believe that
3567 it would also be better to eliminate the switch on the absolute size
3568 of t_addr and replace it with a sequence of if statements that compare
3569 sizeof t_addr with sizeof the various types and do the right thing,
3570 which includes knowing whether or not the host supports long long.
3578 return (TARGET_PTR_BIT / 8 * 2);
3582 /* eliminate warning from compiler on 32-bit systems */
3583 static int thirty_two = 32;
3586 paddr (CORE_ADDR addr)
3588 char *paddr_str = get_cell ();
3589 switch (TARGET_PTR_BIT / 8)
3592 sprintf (paddr_str, "%08lx%08lx",
3593 (unsigned long) (addr >> thirty_two), (unsigned long) (addr & 0xffffffff));
3596 sprintf (paddr_str, "%08lx", (unsigned long) addr);
3599 sprintf (paddr_str, "%04x", (unsigned short) (addr & 0xffff));
3602 sprintf (paddr_str, "%lx", (unsigned long) addr);
3608 paddr_nz (CORE_ADDR addr)
3610 char *paddr_str = get_cell ();
3611 switch (TARGET_PTR_BIT / 8)
3615 unsigned long high = (unsigned long) (addr >> thirty_two);
3617 sprintf (paddr_str, "%lx", (unsigned long) (addr & 0xffffffff));
3619 sprintf (paddr_str, "%lx%08lx",
3620 high, (unsigned long) (addr & 0xffffffff));
3624 sprintf (paddr_str, "%lx", (unsigned long) addr);
3627 sprintf (paddr_str, "%x", (unsigned short) (addr & 0xffff));
3630 sprintf (paddr_str, "%lx", (unsigned long) addr);
3636 decimal2str (char *paddr_str, char *sign, ULONGEST addr)
3638 /* steal code from valprint.c:print_decimal(). Should this worry
3639 about the real size of addr as the above does? */
3640 unsigned long temp[3];
3644 temp[i] = addr % (1000 * 1000 * 1000);
3645 addr /= (1000 * 1000 * 1000);
3648 while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
3652 sprintf (paddr_str, "%s%lu",
3656 sprintf (paddr_str, "%s%lu%09lu",
3657 sign, temp[1], temp[0]);
3660 sprintf (paddr_str, "%s%lu%09lu%09lu",
3661 sign, temp[2], temp[1], temp[0]);
3669 paddr_u (CORE_ADDR addr)
3671 char *paddr_str = get_cell ();
3672 decimal2str (paddr_str, "", addr);
3677 paddr_d (LONGEST addr)
3679 char *paddr_str = get_cell ();
3681 decimal2str (paddr_str, "-", -addr);
3683 decimal2str (paddr_str, "", addr);
3691 char *preg_str = get_cell ();
3692 switch (sizeof (t_reg))
3695 sprintf (preg_str, "%08lx%08lx",
3696 (unsigned long) (reg >> thirty_two), (unsigned long) (reg & 0xffffffff));
3699 sprintf (preg_str, "%08lx", (unsigned long) reg);
3702 sprintf (preg_str, "%04x", (unsigned short) (reg & 0xffff));
3705 sprintf (preg_str, "%lx", (unsigned long) reg);
3714 char *preg_str = get_cell ();
3715 switch (sizeof (t_reg))
3719 unsigned long high = (unsigned long) (reg >> thirty_two);
3721 sprintf (preg_str, "%lx", (unsigned long) (reg & 0xffffffff));
3723 sprintf (preg_str, "%lx%08lx",
3724 high, (unsigned long) (reg & 0xffffffff));
3728 sprintf (preg_str, "%lx", (unsigned long) reg);
3731 sprintf (preg_str, "%x", (unsigned short) (reg & 0xffff));
3734 sprintf (preg_str, "%lx", (unsigned long) reg);
3739 /* Helper functions for INNER_THAN */
3741 core_addr_lessthan (lhs, rhs)
3749 core_addr_greaterthan (lhs, rhs)