1 /* General utility routines for GDB, the GNU debugger.
3 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "gdb_assert.h"
27 #include "gdb_string.h"
28 #include "event-top.h"
31 #include "tui/tui.h" /* For tui_get_command_dimension. */
38 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
49 #include "expression.h"
53 #include "filenames.h"
56 #include "inferior.h" /* for signed_pointer_to_address */
58 #include <sys/param.h> /* For MAXPATHLEN */
67 #include "readline/readline.h"
69 #ifdef NEED_DECLARATION_MALLOC
70 extern PTR
malloc (); /* OK: PTR */
72 #ifdef NEED_DECLARATION_REALLOC
73 extern PTR
realloc (); /* OK: PTR */
75 #ifdef NEED_DECLARATION_FREE
78 /* Actually, we'll never have the decl, since we don't define _GNU_SOURCE. */
79 #if defined(HAVE_CANONICALIZE_FILE_NAME) \
80 && defined(NEED_DECLARATION_CANONICALIZE_FILE_NAME)
81 extern char *canonicalize_file_name (const char *);
84 /* readline defines this. */
87 void (*deprecated_error_begin_hook
) (void);
89 /* Holds the last error message issued by gdb */
91 static struct ui_file
*gdb_lasterr
;
93 /* Prototypes for local functions */
95 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
98 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
100 static void do_my_cleanups (struct cleanup
**, struct cleanup
*);
102 static void prompt_for_continue (void);
104 static void set_screen_size (void);
105 static void set_width (void);
107 /* Chain of cleanup actions established with make_cleanup,
108 to be executed if an error happens. */
110 static struct cleanup
*cleanup_chain
; /* cleaned up after a failed command */
111 static struct cleanup
*final_cleanup_chain
; /* cleaned up when gdb exits */
112 static struct cleanup
*run_cleanup_chain
; /* cleaned up on each 'run' */
113 static struct cleanup
*exec_cleanup_chain
; /* cleaned up on each execution command */
114 /* cleaned up on each error from within an execution command */
115 static struct cleanup
*exec_error_cleanup_chain
;
117 /* Pointer to what is left to do for an execution command after the
118 target stops. Used only in asynchronous mode, by targets that
119 support async execution. The finish and until commands use it. So
120 does the target extended-remote command. */
121 struct continuation
*cmd_continuation
;
122 struct continuation
*intermediate_continuation
;
124 /* Nonzero if we have job control. */
128 /* Nonzero means a quit has been requested. */
132 /* Nonzero means quit immediately if Control-C is typed now, rather
133 than waiting until QUIT is executed. Be careful in setting this;
134 code which executes with immediate_quit set has to be very careful
135 about being able to deal with being interrupted at any time. It is
136 almost always better to use QUIT; the only exception I can think of
137 is being able to quit out of a system call (using EINTR loses if
138 the SIGINT happens between the previous QUIT and the system call).
139 To immediately quit in the case in which a SIGINT happens between
140 the previous QUIT and setting immediate_quit (desirable anytime we
141 expect to block), call QUIT after setting immediate_quit. */
145 /* Nonzero means that encoded C++/ObjC names should be printed out in their
146 C++/ObjC form rather than raw. */
150 /* Nonzero means that encoded C++/ObjC names should be printed out in their
151 C++/ObjC form even in assembler language displays. If this is set, but
152 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
154 int asm_demangle
= 0;
156 /* Nonzero means that strings with character values >0x7F should be printed
157 as octal escapes. Zero means just print the value (e.g. it's an
158 international character, and the terminal or window can cope.) */
160 int sevenbit_strings
= 0;
162 /* String to be printed before error messages, if any. */
164 char *error_pre_print
;
166 /* String to be printed before quit messages, if any. */
168 char *quit_pre_print
;
170 /* String to be printed before warning messages, if any. */
172 char *warning_pre_print
= "\nwarning: ";
174 int pagination_enabled
= 1;
177 /* Add a new cleanup to the cleanup_chain,
178 and return the previous chain pointer
179 to be passed later to do_cleanups or discard_cleanups.
180 Args are FUNCTION to clean up with, and ARG to pass to it. */
183 make_cleanup (make_cleanup_ftype
*function
, void *arg
)
185 return make_my_cleanup (&cleanup_chain
, function
, arg
);
189 make_final_cleanup (make_cleanup_ftype
*function
, void *arg
)
191 return make_my_cleanup (&final_cleanup_chain
, function
, arg
);
195 make_run_cleanup (make_cleanup_ftype
*function
, void *arg
)
197 return make_my_cleanup (&run_cleanup_chain
, function
, arg
);
201 make_exec_cleanup (make_cleanup_ftype
*function
, void *arg
)
203 return make_my_cleanup (&exec_cleanup_chain
, function
, arg
);
207 make_exec_error_cleanup (make_cleanup_ftype
*function
, void *arg
)
209 return make_my_cleanup (&exec_error_cleanup_chain
, function
, arg
);
213 do_freeargv (void *arg
)
215 freeargv ((char **) arg
);
219 make_cleanup_freeargv (char **arg
)
221 return make_my_cleanup (&cleanup_chain
, do_freeargv
, arg
);
225 do_bfd_close_cleanup (void *arg
)
231 make_cleanup_bfd_close (bfd
*abfd
)
233 return make_cleanup (do_bfd_close_cleanup
, abfd
);
237 do_close_cleanup (void *arg
)
245 make_cleanup_close (int fd
)
247 int *saved_fd
= xmalloc (sizeof (fd
));
249 return make_cleanup (do_close_cleanup
, saved_fd
);
253 do_ui_file_delete (void *arg
)
255 ui_file_delete (arg
);
259 make_cleanup_ui_file_delete (struct ui_file
*arg
)
261 return make_my_cleanup (&cleanup_chain
, do_ui_file_delete
, arg
);
265 do_free_section_addr_info (void *arg
)
267 free_section_addr_info (arg
);
271 make_cleanup_free_section_addr_info (struct section_addr_info
*addrs
)
273 return make_my_cleanup (&cleanup_chain
, do_free_section_addr_info
, addrs
);
278 make_my_cleanup (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
282 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
283 struct cleanup
*old_chain
= *pmy_chain
;
285 new->next
= *pmy_chain
;
286 new->function
= function
;
293 /* Discard cleanups and do the actions they describe
294 until we get back to the point OLD_CHAIN in the cleanup_chain. */
297 do_cleanups (struct cleanup
*old_chain
)
299 do_my_cleanups (&cleanup_chain
, old_chain
);
303 do_final_cleanups (struct cleanup
*old_chain
)
305 do_my_cleanups (&final_cleanup_chain
, old_chain
);
309 do_run_cleanups (struct cleanup
*old_chain
)
311 do_my_cleanups (&run_cleanup_chain
, old_chain
);
315 do_exec_cleanups (struct cleanup
*old_chain
)
317 do_my_cleanups (&exec_cleanup_chain
, old_chain
);
321 do_exec_error_cleanups (struct cleanup
*old_chain
)
323 do_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
327 do_my_cleanups (struct cleanup
**pmy_chain
,
328 struct cleanup
*old_chain
)
331 while ((ptr
= *pmy_chain
) != old_chain
)
333 *pmy_chain
= ptr
->next
; /* Do this first incase recursion */
334 (*ptr
->function
) (ptr
->arg
);
339 /* Discard cleanups, not doing the actions they describe,
340 until we get back to the point OLD_CHAIN in the cleanup_chain. */
343 discard_cleanups (struct cleanup
*old_chain
)
345 discard_my_cleanups (&cleanup_chain
, old_chain
);
349 discard_final_cleanups (struct cleanup
*old_chain
)
351 discard_my_cleanups (&final_cleanup_chain
, old_chain
);
355 discard_exec_error_cleanups (struct cleanup
*old_chain
)
357 discard_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
361 discard_my_cleanups (struct cleanup
**pmy_chain
,
362 struct cleanup
*old_chain
)
365 while ((ptr
= *pmy_chain
) != old_chain
)
367 *pmy_chain
= ptr
->next
;
372 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
376 return save_my_cleanups (&cleanup_chain
);
380 save_final_cleanups (void)
382 return save_my_cleanups (&final_cleanup_chain
);
386 save_my_cleanups (struct cleanup
**pmy_chain
)
388 struct cleanup
*old_chain
= *pmy_chain
;
394 /* Restore the cleanup chain from a previously saved chain. */
396 restore_cleanups (struct cleanup
*chain
)
398 restore_my_cleanups (&cleanup_chain
, chain
);
402 restore_final_cleanups (struct cleanup
*chain
)
404 restore_my_cleanups (&final_cleanup_chain
, chain
);
408 restore_my_cleanups (struct cleanup
**pmy_chain
, struct cleanup
*chain
)
413 /* This function is useful for cleanups.
417 old_chain = make_cleanup (free_current_contents, &foo);
419 to arrange to free the object thus allocated. */
422 free_current_contents (void *ptr
)
424 void **location
= ptr
;
425 if (location
== NULL
)
426 internal_error (__FILE__
, __LINE__
,
427 "free_current_contents: NULL pointer");
428 if (*location
!= NULL
)
435 /* Provide a known function that does nothing, to use as a base for
436 for a possibly long chain of cleanups. This is useful where we
437 use the cleanup chain for handling normal cleanups as well as dealing
438 with cleanups that need to be done as a result of a call to error().
439 In such cases, we may not be certain where the first cleanup is, unless
440 we have a do-nothing one to always use as the base. */
443 null_cleanup (void *arg
)
447 /* Add a continuation to the continuation list, the global list
448 cmd_continuation. The new continuation will be added at the front.*/
450 add_continuation (void (*continuation_hook
) (struct continuation_arg
*),
451 struct continuation_arg
*arg_list
)
453 struct continuation
*continuation_ptr
;
456 (struct continuation
*) xmalloc (sizeof (struct continuation
));
457 continuation_ptr
->continuation_hook
= continuation_hook
;
458 continuation_ptr
->arg_list
= arg_list
;
459 continuation_ptr
->next
= cmd_continuation
;
460 cmd_continuation
= continuation_ptr
;
463 /* Walk down the cmd_continuation list, and execute all the
464 continuations. There is a problem though. In some cases new
465 continuations may be added while we are in the middle of this
466 loop. If this happens they will be added in the front, and done
467 before we have a chance of exhausting those that were already
468 there. We need to then save the beginning of the list in a pointer
469 and do the continuations from there on, instead of using the
470 global beginning of list as our iteration pointer.*/
472 do_all_continuations (void)
474 struct continuation
*continuation_ptr
;
475 struct continuation
*saved_continuation
;
477 /* Copy the list header into another pointer, and set the global
478 list header to null, so that the global list can change as a side
479 effect of invoking the continuations and the processing of
480 the preexisting continuations will not be affected. */
481 continuation_ptr
= cmd_continuation
;
482 cmd_continuation
= NULL
;
484 /* Work now on the list we have set aside. */
485 while (continuation_ptr
)
487 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
488 saved_continuation
= continuation_ptr
;
489 continuation_ptr
= continuation_ptr
->next
;
490 xfree (saved_continuation
);
494 /* Walk down the cmd_continuation list, and get rid of all the
497 discard_all_continuations (void)
499 struct continuation
*continuation_ptr
;
501 while (cmd_continuation
)
503 continuation_ptr
= cmd_continuation
;
504 cmd_continuation
= continuation_ptr
->next
;
505 xfree (continuation_ptr
);
509 /* Add a continuation to the continuation list, the global list
510 intermediate_continuation. The new continuation will be added at the front.*/
512 add_intermediate_continuation (void (*continuation_hook
)
513 (struct continuation_arg
*),
514 struct continuation_arg
*arg_list
)
516 struct continuation
*continuation_ptr
;
519 (struct continuation
*) xmalloc (sizeof (struct continuation
));
520 continuation_ptr
->continuation_hook
= continuation_hook
;
521 continuation_ptr
->arg_list
= arg_list
;
522 continuation_ptr
->next
= intermediate_continuation
;
523 intermediate_continuation
= continuation_ptr
;
526 /* Walk down the cmd_continuation list, and execute all the
527 continuations. There is a problem though. In some cases new
528 continuations may be added while we are in the middle of this
529 loop. If this happens they will be added in the front, and done
530 before we have a chance of exhausting those that were already
531 there. We need to then save the beginning of the list in a pointer
532 and do the continuations from there on, instead of using the
533 global beginning of list as our iteration pointer.*/
535 do_all_intermediate_continuations (void)
537 struct continuation
*continuation_ptr
;
538 struct continuation
*saved_continuation
;
540 /* Copy the list header into another pointer, and set the global
541 list header to null, so that the global list can change as a side
542 effect of invoking the continuations and the processing of
543 the preexisting continuations will not be affected. */
544 continuation_ptr
= intermediate_continuation
;
545 intermediate_continuation
= NULL
;
547 /* Work now on the list we have set aside. */
548 while (continuation_ptr
)
550 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
551 saved_continuation
= continuation_ptr
;
552 continuation_ptr
= continuation_ptr
->next
;
553 xfree (saved_continuation
);
557 /* Walk down the cmd_continuation list, and get rid of all the
560 discard_all_intermediate_continuations (void)
562 struct continuation
*continuation_ptr
;
564 while (intermediate_continuation
)
566 continuation_ptr
= intermediate_continuation
;
567 intermediate_continuation
= continuation_ptr
->next
;
568 xfree (continuation_ptr
);
574 /* Print a warning message. The first argument STRING is the warning
575 message, used as an fprintf format string, the second is the
576 va_list of arguments for that string. A warning is unfiltered (not
577 paginated) so that the user does not need to page through each
578 screen full of warnings when there are lots of them. */
581 vwarning (const char *string
, va_list args
)
583 if (deprecated_warning_hook
)
584 (*deprecated_warning_hook
) (string
, args
);
587 target_terminal_ours ();
588 wrap_here (""); /* Force out any buffered output */
589 gdb_flush (gdb_stdout
);
590 if (warning_pre_print
)
591 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
592 vfprintf_unfiltered (gdb_stderr
, string
, args
);
593 fprintf_unfiltered (gdb_stderr
, "\n");
598 /* Print a warning message.
599 The first argument STRING is the warning message, used as a fprintf string,
600 and the remaining args are passed as arguments to it.
601 The primary difference between warnings and errors is that a warning
602 does not force the return to command level. */
605 warning (const char *string
, ...)
608 va_start (args
, string
);
609 vwarning (string
, args
);
613 /* Print an error message and return to command level.
614 The first argument STRING is the error message, used as a fprintf string,
615 and the remaining args are passed as arguments to it. */
618 verror (const char *string
, va_list args
)
620 struct ui_file
*tmp_stream
= mem_fileopen ();
621 make_cleanup_ui_file_delete (tmp_stream
);
622 vfprintf_unfiltered (tmp_stream
, string
, args
);
623 error_stream (tmp_stream
);
627 error (const char *string
, ...)
630 va_start (args
, string
);
631 verror (string
, args
);
636 do_write (void *data
, const char *buffer
, long length_buffer
)
638 ui_file_write (data
, buffer
, length_buffer
);
641 /* Cause a silent error to occur. Any error message is recorded
642 though it is not issued. */
644 error_silent (const char *string
, ...)
647 struct ui_file
*tmp_stream
= mem_fileopen ();
648 va_start (args
, string
);
649 make_cleanup_ui_file_delete (tmp_stream
);
650 vfprintf_unfiltered (tmp_stream
, string
, args
);
651 /* Copy the stream into the GDB_LASTERR buffer. */
652 ui_file_rewind (gdb_lasterr
);
653 ui_file_put (tmp_stream
, do_write
, gdb_lasterr
);
656 throw_exception (RETURN_ERROR
);
659 /* Output an error message including any pre-print text to gdb_stderr. */
661 error_output_message (char *pre_print
, char *msg
)
663 target_terminal_ours ();
664 wrap_here (""); /* Force out any buffered output */
665 gdb_flush (gdb_stdout
);
666 annotate_error_begin ();
668 fputs_filtered (pre_print
, gdb_stderr
);
669 fputs_filtered (msg
, gdb_stderr
);
670 fprintf_filtered (gdb_stderr
, "\n");
674 error_stream (struct ui_file
*stream
)
676 if (deprecated_error_begin_hook
)
677 deprecated_error_begin_hook ();
679 /* Copy the stream into the GDB_LASTERR buffer. */
680 ui_file_rewind (gdb_lasterr
);
681 ui_file_put (stream
, do_write
, gdb_lasterr
);
683 /* Write the message plus any error_pre_print to gdb_stderr. */
684 target_terminal_ours ();
685 wrap_here (""); /* Force out any buffered output */
686 gdb_flush (gdb_stdout
);
687 annotate_error_begin ();
689 fputs_filtered (error_pre_print
, gdb_stderr
);
690 ui_file_put (stream
, do_write
, gdb_stderr
);
691 fprintf_filtered (gdb_stderr
, "\n");
693 throw_exception (RETURN_ERROR
);
696 /* Get the last error message issued by gdb */
699 error_last_message (void)
702 return ui_file_xstrdup (gdb_lasterr
, &len
);
705 /* This is to be called by main() at the very beginning */
710 gdb_lasterr
= mem_fileopen ();
713 /* Print a message reporting an internal error/warning. Ask the user
714 if they want to continue, dump core, or just exit. Return
715 something to indicate a quit. */
717 struct internal_problem
720 /* FIXME: cagney/2002-08-15: There should be ``maint set/show''
721 commands available for controlling these variables. */
722 enum auto_boolean should_quit
;
723 enum auto_boolean should_dump_core
;
726 /* Report a problem, internal to GDB, to the user. Once the problem
727 has been reported, and assuming GDB didn't quit, the caller can
728 either allow execution to resume or throw an error. */
731 internal_vproblem (struct internal_problem
*problem
,
732 const char *file
, int line
, const char *fmt
, va_list ap
)
739 /* Don't allow infinite error/warning recursion. */
741 static char msg
[] = "Recursive internal problem.\n";
749 fputs_unfiltered (msg
, gdb_stderr
);
750 abort (); /* NOTE: GDB has only three calls to abort(). */
753 write (STDERR_FILENO
, msg
, sizeof (msg
));
758 /* Try to get the message out and at the start of a new line. */
759 target_terminal_ours ();
762 /* Create a string containing the full error/warning message. Need
763 to call query with this full string, as otherwize the reason
764 (error/warning) and question become separated. Format using a
765 style similar to a compiler error message. Include extra detail
766 so that the user knows that they are living on the edge. */
769 msg
= xstrvprintf (fmt
, ap
);
770 reason
= xstrprintf ("\
772 A problem internal to GDB has been detected,\n\
773 further debugging may prove unreliable.", file
, line
, problem
->name
, msg
);
775 make_cleanup (xfree
, reason
);
778 switch (problem
->should_quit
)
780 case AUTO_BOOLEAN_AUTO
:
781 /* Default (yes/batch case) is to quit GDB. When in batch mode
782 this lessens the likelhood of GDB going into an infinate
784 quit_p
= query ("%s\nQuit this debugging session? ", reason
);
786 case AUTO_BOOLEAN_TRUE
:
789 case AUTO_BOOLEAN_FALSE
:
793 internal_error (__FILE__
, __LINE__
, "bad switch");
796 switch (problem
->should_dump_core
)
798 case AUTO_BOOLEAN_AUTO
:
799 /* Default (yes/batch case) is to dump core. This leaves a GDB
800 `dropping' so that it is easier to see that something went
802 dump_core_p
= query ("%s\nCreate a core file of GDB? ", reason
);
805 case AUTO_BOOLEAN_TRUE
:
808 case AUTO_BOOLEAN_FALSE
:
812 internal_error (__FILE__
, __LINE__
, "bad switch");
818 abort (); /* NOTE: GDB has only three calls to abort(). */
827 abort (); /* NOTE: GDB has only three calls to abort(). */
834 static struct internal_problem internal_error_problem
= {
835 "internal-error", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
839 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
841 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
842 throw_exception (RETURN_ERROR
);
846 internal_error (const char *file
, int line
, const char *string
, ...)
849 va_start (ap
, string
);
850 internal_verror (file
, line
, string
, ap
);
854 static struct internal_problem internal_warning_problem
= {
855 "internal-warning", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
859 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
861 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
865 internal_warning (const char *file
, int line
, const char *string
, ...)
868 va_start (ap
, string
);
869 internal_vwarning (file
, line
, string
, ap
);
873 /* The strerror() function can return NULL for errno values that are
874 out of range. Provide a "safe" version that always returns a
878 safe_strerror (int errnum
)
883 msg
= strerror (errnum
);
886 sprintf (buf
, "(undocumented errno %d)", errnum
);
892 /* Print the system error message for errno, and also mention STRING
893 as the file name for which the error was encountered.
894 Then return to command level. */
897 perror_with_name (const char *string
)
902 err
= safe_strerror (errno
);
903 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
904 strcpy (combined
, string
);
905 strcat (combined
, ": ");
906 strcat (combined
, err
);
908 /* I understand setting these is a matter of taste. Still, some people
909 may clear errno but not know about bfd_error. Doing this here is not
911 bfd_set_error (bfd_error_no_error
);
914 error ("%s.", combined
);
917 /* Print the system error message for ERRCODE, and also mention STRING
918 as the file name for which the error was encountered. */
921 print_sys_errmsg (const char *string
, int errcode
)
926 err
= safe_strerror (errcode
);
927 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
928 strcpy (combined
, string
);
929 strcat (combined
, ": ");
930 strcat (combined
, err
);
932 /* We want anything which was printed on stdout to come out first, before
934 gdb_flush (gdb_stdout
);
935 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
938 /* Control C eventually causes this to be called, at a convenient time. */
943 struct serial
*gdb_stdout_serial
= serial_fdopen (1);
945 target_terminal_ours ();
947 /* We want all output to appear now, before we print "Quit". We
948 have 3 levels of buffering we have to flush (it's possible that
949 some of these should be changed to flush the lower-level ones
952 /* 1. The _filtered buffer. */
953 wrap_here ((char *) 0);
955 /* 2. The stdio buffer. */
956 gdb_flush (gdb_stdout
);
957 gdb_flush (gdb_stderr
);
959 /* 3. The system-level buffer. */
960 serial_drain_output (gdb_stdout_serial
);
961 serial_un_fdopen (gdb_stdout_serial
);
963 annotate_error_begin ();
965 /* Don't use *_filtered; we don't want to prompt the user to continue. */
967 fputs_unfiltered (quit_pre_print
, gdb_stderr
);
970 /* No steenking SIGINT will ever be coming our way when the
971 program is resumed. Don't lie. */
972 fprintf_unfiltered (gdb_stderr
, "Quit\n");
975 /* If there is no terminal switching for this target, then we can't
976 possibly get screwed by the lack of job control. */
977 || current_target
.to_terminal_ours
== NULL
)
978 fprintf_unfiltered (gdb_stderr
, "Quit\n");
980 fprintf_unfiltered (gdb_stderr
,
981 "Quit (expect signal SIGINT when the program is resumed)\n");
983 throw_exception (RETURN_QUIT
);
986 /* Control C comes here */
988 request_quit (int signo
)
991 /* Restore the signal handler. Harmless with BSD-style signals,
992 needed for System V-style signals. */
993 signal (signo
, request_quit
);
999 /* Called when a memory allocation fails, with the number of bytes of
1000 memory requested in SIZE. */
1007 internal_error (__FILE__
, __LINE__
,
1008 "virtual memory exhausted: can't allocate %ld bytes.",
1013 internal_error (__FILE__
, __LINE__
, "virtual memory exhausted.");
1017 /* The xmalloc() (libiberty.h) family of memory management routines.
1019 These are like the ISO-C malloc() family except that they implement
1020 consistent semantics and guard against typical memory management
1023 /* NOTE: These are declared using PTR to ensure consistency with
1024 "libiberty.h". xfree() is GDB local. */
1027 xmalloc (size_t size
)
1031 /* See libiberty/xmalloc.c. This function need's to match that's
1032 semantics. It never returns NULL. */
1036 val
= malloc (size
); /* OK: malloc */
1044 xrealloc (PTR ptr
, size_t size
) /* OK: PTR */
1048 /* See libiberty/xmalloc.c. This function need's to match that's
1049 semantics. It never returns NULL. */
1054 val
= realloc (ptr
, size
); /* OK: realloc */
1056 val
= malloc (size
); /* OK: malloc */
1064 xcalloc (size_t number
, size_t size
)
1068 /* See libiberty/xmalloc.c. This function need's to match that's
1069 semantics. It never returns NULL. */
1070 if (number
== 0 || size
== 0)
1076 mem
= calloc (number
, size
); /* OK: xcalloc */
1078 nomem (number
* size
);
1087 free (ptr
); /* OK: free */
1091 /* Like asprintf/vasprintf but get an internal_error if the call
1095 xstrprintf (const char *format
, ...)
1099 va_start (args
, format
);
1100 ret
= xstrvprintf (format
, args
);
1106 xasprintf (char **ret
, const char *format
, ...)
1109 va_start (args
, format
);
1110 (*ret
) = xstrvprintf (format
, args
);
1115 xvasprintf (char **ret
, const char *format
, va_list ap
)
1117 (*ret
) = xstrvprintf (format
, ap
);
1121 xstrvprintf (const char *format
, va_list ap
)
1124 int status
= vasprintf (&ret
, format
, ap
);
1125 /* NULL is returned when there was a memory allocation problem. */
1128 /* A negative status (the printed length) with a non-NULL buffer
1129 should never happen, but just to be sure. */
1131 internal_error (__FILE__
, __LINE__
,
1132 "vasprintf call failed (errno %d)", errno
);
1136 /* My replacement for the read system call.
1137 Used like `read' but keeps going if `read' returns too soon. */
1140 myread (int desc
, char *addr
, int len
)
1147 val
= read (desc
, addr
, len
);
1151 return orglen
- len
;
1158 /* Make a copy of the string at PTR with SIZE characters
1159 (and add a null character at the end in the copy).
1160 Uses malloc to get the space. Returns the address of the copy. */
1163 savestring (const char *ptr
, size_t size
)
1165 char *p
= (char *) xmalloc (size
+ 1);
1166 memcpy (p
, ptr
, size
);
1172 print_spaces (int n
, struct ui_file
*file
)
1174 fputs_unfiltered (n_spaces (n
), file
);
1177 /* Print a host address. */
1180 gdb_print_host_address (const void *addr
, struct ui_file
*stream
)
1183 /* We could use the %p conversion specifier to fprintf if we had any
1184 way of knowing whether this host supports it. But the following
1185 should work on the Alpha and on 32 bit machines. */
1187 fprintf_filtered (stream
, "0x%lx", (unsigned long) addr
);
1190 /* Ask user a y-or-n question and return 1 iff answer is yes.
1191 Takes three args which are given to printf to print the question.
1192 The first, a control string, should end in "? ".
1193 It should not say how to answer, because we do that. */
1197 query (const char *ctlstr
, ...)
1204 if (deprecated_query_hook
)
1206 va_start (args
, ctlstr
);
1207 return deprecated_query_hook (ctlstr
, args
);
1210 /* Automatically answer "yes" if input is not from a terminal. */
1211 if (!input_from_terminal_p ())
1216 wrap_here (""); /* Flush any buffered output */
1217 gdb_flush (gdb_stdout
);
1219 if (annotation_level
> 1)
1220 printf_filtered ("\n\032\032pre-query\n");
1222 va_start (args
, ctlstr
);
1223 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1225 printf_filtered ("(y or n) ");
1227 if (annotation_level
> 1)
1228 printf_filtered ("\n\032\032query\n");
1231 gdb_flush (gdb_stdout
);
1233 answer
= fgetc (stdin
);
1234 clearerr (stdin
); /* in case of C-d */
1235 if (answer
== EOF
) /* C-d */
1240 /* Eat rest of input line, to EOF or newline */
1244 ans2
= fgetc (stdin
);
1247 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1261 printf_filtered ("Please answer y or n.\n");
1264 if (annotation_level
> 1)
1265 printf_filtered ("\n\032\032post-query\n");
1270 /* This function supports the nquery() and yquery() functions.
1271 Ask user a y-or-n question and return 0 if answer is no, 1 if
1272 answer is yes, or default the answer to the specified default.
1273 DEFCHAR is either 'y' or 'n' and refers to the default answer.
1274 CTLSTR is the control string and should end in "? ". It should
1275 not say how to answer, because we do that.
1276 ARGS are the arguments passed along with the CTLSTR argument to
1280 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
1286 char def_answer
, not_def_answer
;
1287 char *y_string
, *n_string
;
1289 /* Set up according to which answer is the default. */
1294 not_def_answer
= 'N';
1302 not_def_answer
= 'Y';
1307 if (deprecated_query_hook
)
1309 return deprecated_query_hook (ctlstr
, args
);
1312 /* Automatically answer default value if input is not from a terminal. */
1313 if (!input_from_terminal_p ())
1318 wrap_here (""); /* Flush any buffered output */
1319 gdb_flush (gdb_stdout
);
1321 if (annotation_level
> 1)
1322 printf_filtered ("\n\032\032pre-query\n");
1324 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1325 printf_filtered ("(%s or %s) ", y_string
, n_string
);
1327 if (annotation_level
> 1)
1328 printf_filtered ("\n\032\032query\n");
1331 gdb_flush (gdb_stdout
);
1333 answer
= fgetc (stdin
);
1334 clearerr (stdin
); /* in case of C-d */
1335 if (answer
== EOF
) /* C-d */
1340 /* Eat rest of input line, to EOF or newline */
1344 ans2
= fgetc (stdin
);
1347 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1351 /* Check answer. For the non-default, the user must specify
1352 the non-default explicitly. */
1353 if (answer
== not_def_answer
)
1355 retval
= !def_value
;
1358 /* Otherwise, for the default, the user may either specify
1359 the required input or have it default by entering nothing. */
1360 if (answer
== def_answer
|| answer
== '\n' ||
1361 answer
== '\r' || answer
== EOF
)
1366 /* Invalid entries are not defaulted and require another selection. */
1367 printf_filtered ("Please answer %s or %s.\n",
1368 y_string
, n_string
);
1371 if (annotation_level
> 1)
1372 printf_filtered ("\n\032\032post-query\n");
1377 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1378 answer is yes, or 0 if answer is defaulted.
1379 Takes three args which are given to printf to print the question.
1380 The first, a control string, should end in "? ".
1381 It should not say how to answer, because we do that. */
1384 nquery (const char *ctlstr
, ...)
1388 va_start (args
, ctlstr
);
1389 return defaulted_query (ctlstr
, 'n', args
);
1393 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1394 answer is yes, or 1 if answer is defaulted.
1395 Takes three args which are given to printf to print the question.
1396 The first, a control string, should end in "? ".
1397 It should not say how to answer, because we do that. */
1400 yquery (const char *ctlstr
, ...)
1404 va_start (args
, ctlstr
);
1405 return defaulted_query (ctlstr
, 'y', args
);
1409 /* Print an error message saying that we couldn't make sense of a
1410 \^mumble sequence in a string or character constant. START and END
1411 indicate a substring of some larger string that contains the
1412 erroneous backslash sequence, missing the initial backslash. */
1414 no_control_char_error (const char *start
, const char *end
)
1416 int len
= end
- start
;
1417 char *copy
= alloca (end
- start
+ 1);
1419 memcpy (copy
, start
, len
);
1422 error ("There is no control character `\\%s' in the `%s' character set.",
1423 copy
, target_charset ());
1426 /* Parse a C escape sequence. STRING_PTR points to a variable
1427 containing a pointer to the string to parse. That pointer
1428 should point to the character after the \. That pointer
1429 is updated past the characters we use. The value of the
1430 escape sequence is returned.
1432 A negative value means the sequence \ newline was seen,
1433 which is supposed to be equivalent to nothing at all.
1435 If \ is followed by a null character, we return a negative
1436 value and leave the string pointer pointing at the null character.
1438 If \ is followed by 000, we return 0 and leave the string pointer
1439 after the zeros. A value of 0 does not mean end of string. */
1442 parse_escape (char **string_ptr
)
1445 int c
= *(*string_ptr
)++;
1446 if (c_parse_backslash (c
, &target_char
))
1458 /* Remember where this escape sequence started, for reporting
1460 char *sequence_start_pos
= *string_ptr
- 1;
1462 c
= *(*string_ptr
)++;
1466 /* XXXCHARSET: What is `delete' in the host character set? */
1469 if (!host_char_to_target (c
, &target_char
))
1470 error ("There is no character corresponding to `Delete' "
1471 "in the target character set `%s'.", host_charset ());
1476 target_char
= parse_escape (string_ptr
);
1479 if (!host_char_to_target (c
, &target_char
))
1480 no_control_char_error (sequence_start_pos
, *string_ptr
);
1483 /* Now target_char is something like `c', and we want to find
1484 its control-character equivalent. */
1485 if (!target_char_to_control_char (target_char
, &target_char
))
1486 no_control_char_error (sequence_start_pos
, *string_ptr
);
1491 /* XXXCHARSET: we need to use isdigit and value-of-digit
1492 methods of the host character set here. */
1508 if (c
>= '0' && c
<= '7')
1522 if (!host_char_to_target (c
, &target_char
))
1524 ("The escape sequence `\%c' is equivalent to plain `%c', which"
1525 " has no equivalent\n" "in the `%s' character set.", c
, c
,
1531 /* Print the character C on STREAM as part of the contents of a literal
1532 string whose delimiter is QUOTER. Note that this routine should only
1533 be call for printing things which are independent of the language
1534 of the program being debugged. */
1537 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1538 void (*do_fprintf
) (struct ui_file
*, const char *, ...),
1539 struct ui_file
*stream
, int quoter
)
1542 c
&= 0xFF; /* Avoid sign bit follies */
1544 if (c
< 0x20 || /* Low control chars */
1545 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1546 (sevenbit_strings
&& c
>= 0x80))
1547 { /* high order bit set */
1551 do_fputs ("\\n", stream
);
1554 do_fputs ("\\b", stream
);
1557 do_fputs ("\\t", stream
);
1560 do_fputs ("\\f", stream
);
1563 do_fputs ("\\r", stream
);
1566 do_fputs ("\\e", stream
);
1569 do_fputs ("\\a", stream
);
1572 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1578 if (c
== '\\' || c
== quoter
)
1579 do_fputs ("\\", stream
);
1580 do_fprintf (stream
, "%c", c
);
1584 /* Print the character C on STREAM as part of the contents of a
1585 literal string whose delimiter is QUOTER. Note that these routines
1586 should only be call for printing things which are independent of
1587 the language of the program being debugged. */
1590 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1593 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1597 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1600 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1604 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1605 struct ui_file
*stream
)
1608 for (i
= 0; i
< n
; i
++)
1609 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1613 /* Number of lines per page or UINT_MAX if paging is disabled. */
1614 static unsigned int lines_per_page
;
1616 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1617 static unsigned int chars_per_line
;
1619 /* Current count of lines printed on this page, chars on this line. */
1620 static unsigned int lines_printed
, chars_printed
;
1622 /* Buffer and start column of buffered text, for doing smarter word-
1623 wrapping. When someone calls wrap_here(), we start buffering output
1624 that comes through fputs_filtered(). If we see a newline, we just
1625 spit it out and forget about the wrap_here(). If we see another
1626 wrap_here(), we spit it out and remember the newer one. If we see
1627 the end of the line, we spit out a newline, the indent, and then
1628 the buffered output. */
1630 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1631 are waiting to be output (they have already been counted in chars_printed).
1632 When wrap_buffer[0] is null, the buffer is empty. */
1633 static char *wrap_buffer
;
1635 /* Pointer in wrap_buffer to the next character to fill. */
1636 static char *wrap_pointer
;
1638 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1640 static char *wrap_indent
;
1642 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1643 is not in effect. */
1644 static int wrap_column
;
1647 /* Inialize the number of lines per page and chars per line. */
1650 init_page_info (void)
1653 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1658 #if defined(__GO32__)
1659 rows
= ScreenRows ();
1660 cols
= ScreenCols ();
1661 lines_per_page
= rows
;
1662 chars_per_line
= cols
;
1664 /* Make sure Readline has initialized its terminal settings. */
1665 rl_reset_terminal (NULL
);
1667 /* Get the screen size from Readline. */
1668 rl_get_screen_size (&rows
, &cols
);
1669 lines_per_page
= rows
;
1670 chars_per_line
= cols
;
1672 /* Readline should have fetched the termcap entry for us. */
1673 if (tgetnum ("li") < 0 || getenv ("EMACS"))
1675 /* The number of lines per page is not mentioned in the
1676 terminal description. This probably means that paging is
1677 not useful (e.g. emacs shell window), so disable paging. */
1678 lines_per_page
= UINT_MAX
;
1681 /* FIXME: Get rid of this junk. */
1682 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1683 SIGWINCH_HANDLER (SIGWINCH
);
1686 /* If the output is not a terminal, don't paginate it. */
1687 if (!ui_file_isatty (gdb_stdout
))
1688 lines_per_page
= UINT_MAX
;
1696 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1699 set_screen_size (void)
1701 int rows
= lines_per_page
;
1702 int cols
= chars_per_line
;
1708 rl_get_screen_size (NULL
, &cols
);
1710 /* Update Readline's idea of the terminal size. */
1711 rl_set_screen_size (rows
, cols
);
1714 /* Reinitialize WRAP_BUFFER according to the current value of
1720 if (chars_per_line
== 0)
1725 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1726 wrap_buffer
[0] = '\0';
1729 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1730 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
1734 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1741 set_height_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1746 /* Wait, so the user can read what's on the screen. Prompt the user
1747 to continue by pressing RETURN. */
1750 prompt_for_continue (void)
1753 char cont_prompt
[120];
1755 if (annotation_level
> 1)
1756 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1758 strcpy (cont_prompt
,
1759 "---Type <return> to continue, or q <return> to quit---");
1760 if (annotation_level
> 1)
1761 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1763 /* We must do this *before* we call gdb_readline, else it will eventually
1764 call us -- thinking that we're trying to print beyond the end of the
1766 reinitialize_more_filter ();
1769 /* On a real operating system, the user can quit with SIGINT.
1772 'q' is provided on all systems so users don't have to change habits
1773 from system to system, and because telling them what to do in
1774 the prompt is more user-friendly than expecting them to think of
1776 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1777 whereas control-C to gdb_readline will cause the user to get dumped
1779 ignore
= gdb_readline_wrapper (cont_prompt
);
1781 if (annotation_level
> 1)
1782 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1787 while (*p
== ' ' || *p
== '\t')
1790 async_request_quit (0);
1795 /* Now we have to do this again, so that GDB will know that it doesn't
1796 need to save the ---Type <return>--- line at the top of the screen. */
1797 reinitialize_more_filter ();
1799 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1802 /* Reinitialize filter; ie. tell it to reset to original values. */
1805 reinitialize_more_filter (void)
1811 /* Indicate that if the next sequence of characters overflows the line,
1812 a newline should be inserted here rather than when it hits the end.
1813 If INDENT is non-null, it is a string to be printed to indent the
1814 wrapped part on the next line. INDENT must remain accessible until
1815 the next call to wrap_here() or until a newline is printed through
1818 If the line is already overfull, we immediately print a newline and
1819 the indentation, and disable further wrapping.
1821 If we don't know the width of lines, but we know the page height,
1822 we must not wrap words, but should still keep track of newlines
1823 that were explicitly printed.
1825 INDENT should not contain tabs, as that will mess up the char count
1826 on the next line. FIXME.
1828 This routine is guaranteed to force out any output which has been
1829 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1830 used to force out output from the wrap_buffer. */
1833 wrap_here (char *indent
)
1835 /* This should have been allocated, but be paranoid anyway. */
1837 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1841 *wrap_pointer
= '\0';
1842 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1844 wrap_pointer
= wrap_buffer
;
1845 wrap_buffer
[0] = '\0';
1846 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1850 else if (chars_printed
>= chars_per_line
)
1852 puts_filtered ("\n");
1854 puts_filtered (indent
);
1859 wrap_column
= chars_printed
;
1863 wrap_indent
= indent
;
1867 /* Print input string to gdb_stdout, filtered, with wrap,
1868 arranging strings in columns of n chars. String can be
1869 right or left justified in the column. Never prints
1870 trailing spaces. String should never be longer than
1871 width. FIXME: this could be useful for the EXAMINE
1872 command, which currently doesn't tabulate very well */
1875 puts_filtered_tabular (char *string
, int width
, int right
)
1881 gdb_assert (chars_per_line
> 0);
1882 if (chars_per_line
== UINT_MAX
)
1884 fputs_filtered (string
, gdb_stdout
);
1885 fputs_filtered ("\n", gdb_stdout
);
1889 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
1890 fputs_filtered ("\n", gdb_stdout
);
1892 if (width
>= chars_per_line
)
1893 width
= chars_per_line
- 1;
1895 stringlen
= strlen (string
);
1897 if (chars_printed
> 0)
1898 spaces
= width
- (chars_printed
- 1) % width
- 1;
1900 spaces
+= width
- stringlen
;
1902 spacebuf
= alloca (spaces
+ 1);
1903 spacebuf
[spaces
] = '\0';
1905 spacebuf
[spaces
] = ' ';
1907 fputs_filtered (spacebuf
, gdb_stdout
);
1908 fputs_filtered (string
, gdb_stdout
);
1912 /* Ensure that whatever gets printed next, using the filtered output
1913 commands, starts at the beginning of the line. I.E. if there is
1914 any pending output for the current line, flush it and start a new
1915 line. Otherwise do nothing. */
1920 if (chars_printed
> 0)
1922 puts_filtered ("\n");
1927 /* Like fputs but if FILTER is true, pause after every screenful.
1929 Regardless of FILTER can wrap at points other than the final
1930 character of a line.
1932 Unlike fputs, fputs_maybe_filtered does not return a value.
1933 It is OK for LINEBUFFER to be NULL, in which case just don't print
1936 Note that a longjmp to top level may occur in this routine (only if
1937 FILTER is true) (since prompt_for_continue may do so) so this
1938 routine should not be called when cleanups are not in place. */
1941 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1944 const char *lineptr
;
1946 if (linebuffer
== 0)
1949 /* Don't do any filtering if it is disabled. */
1950 if ((stream
!= gdb_stdout
) || !pagination_enabled
1951 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
1953 fputs_unfiltered (linebuffer
, stream
);
1957 /* Go through and output each character. Show line extension
1958 when this is necessary; prompt user for new page when this is
1961 lineptr
= linebuffer
;
1964 /* Possible new page. */
1965 if (filter
&& (lines_printed
>= lines_per_page
- 1))
1966 prompt_for_continue ();
1968 while (*lineptr
&& *lineptr
!= '\n')
1970 /* Print a single line. */
1971 if (*lineptr
== '\t')
1974 *wrap_pointer
++ = '\t';
1976 fputc_unfiltered ('\t', stream
);
1977 /* Shifting right by 3 produces the number of tab stops
1978 we have already passed, and then adding one and
1979 shifting left 3 advances to the next tab stop. */
1980 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1986 *wrap_pointer
++ = *lineptr
;
1988 fputc_unfiltered (*lineptr
, stream
);
1993 if (chars_printed
>= chars_per_line
)
1995 unsigned int save_chars
= chars_printed
;
1999 /* If we aren't actually wrapping, don't output newline --
2000 if chars_per_line is right, we probably just overflowed
2001 anyway; if it's wrong, let us keep going. */
2003 fputc_unfiltered ('\n', stream
);
2005 /* Possible new page. */
2006 if (lines_printed
>= lines_per_page
- 1)
2007 prompt_for_continue ();
2009 /* Now output indentation and wrapped string */
2012 fputs_unfiltered (wrap_indent
, stream
);
2013 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
2014 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
2015 /* FIXME, this strlen is what prevents wrap_indent from
2016 containing tabs. However, if we recurse to print it
2017 and count its chars, we risk trouble if wrap_indent is
2018 longer than (the user settable) chars_per_line.
2019 Note also that this can set chars_printed > chars_per_line
2020 if we are printing a long string. */
2021 chars_printed
= strlen (wrap_indent
)
2022 + (save_chars
- wrap_column
);
2023 wrap_pointer
= wrap_buffer
; /* Reset buffer */
2024 wrap_buffer
[0] = '\0';
2025 wrap_column
= 0; /* And disable fancy wrap */
2030 if (*lineptr
== '\n')
2033 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
2035 fputc_unfiltered ('\n', stream
);
2042 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
2044 fputs_maybe_filtered (linebuffer
, stream
, 1);
2048 putchar_unfiltered (int c
)
2051 ui_file_write (gdb_stdout
, &buf
, 1);
2055 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2056 May return nonlocally. */
2059 putchar_filtered (int c
)
2061 return fputc_filtered (c
, gdb_stdout
);
2065 fputc_unfiltered (int c
, struct ui_file
*stream
)
2068 ui_file_write (stream
, &buf
, 1);
2073 fputc_filtered (int c
, struct ui_file
*stream
)
2079 fputs_filtered (buf
, stream
);
2083 /* puts_debug is like fputs_unfiltered, except it prints special
2084 characters in printable fashion. */
2087 puts_debug (char *prefix
, char *string
, char *suffix
)
2091 /* Print prefix and suffix after each line. */
2092 static int new_line
= 1;
2093 static int return_p
= 0;
2094 static char *prev_prefix
= "";
2095 static char *prev_suffix
= "";
2097 if (*string
== '\n')
2100 /* If the prefix is changing, print the previous suffix, a new line,
2101 and the new prefix. */
2102 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2104 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2105 fputs_unfiltered ("\n", gdb_stdlog
);
2106 fputs_unfiltered (prefix
, gdb_stdlog
);
2109 /* Print prefix if we printed a newline during the previous call. */
2113 fputs_unfiltered (prefix
, gdb_stdlog
);
2116 prev_prefix
= prefix
;
2117 prev_suffix
= suffix
;
2119 /* Output characters in a printable format. */
2120 while ((ch
= *string
++) != '\0')
2126 fputc_unfiltered (ch
, gdb_stdlog
);
2129 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2133 fputs_unfiltered ("\\\\", gdb_stdlog
);
2136 fputs_unfiltered ("\\b", gdb_stdlog
);
2139 fputs_unfiltered ("\\f", gdb_stdlog
);
2143 fputs_unfiltered ("\\n", gdb_stdlog
);
2146 fputs_unfiltered ("\\r", gdb_stdlog
);
2149 fputs_unfiltered ("\\t", gdb_stdlog
);
2152 fputs_unfiltered ("\\v", gdb_stdlog
);
2156 return_p
= ch
== '\r';
2159 /* Print suffix if we printed a newline. */
2162 fputs_unfiltered (suffix
, gdb_stdlog
);
2163 fputs_unfiltered ("\n", gdb_stdlog
);
2168 /* Print a variable number of ARGS using format FORMAT. If this
2169 information is going to put the amount written (since the last call
2170 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2171 call prompt_for_continue to get the users permision to continue.
2173 Unlike fprintf, this function does not return a value.
2175 We implement three variants, vfprintf (takes a vararg list and stream),
2176 fprintf (takes a stream to write on), and printf (the usual).
2178 Note also that a longjmp to top level may occur in this routine
2179 (since prompt_for_continue may do so) so this routine should not be
2180 called when cleanups are not in place. */
2183 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2184 va_list args
, int filter
)
2187 struct cleanup
*old_cleanups
;
2189 linebuffer
= xstrvprintf (format
, args
);
2190 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2191 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2192 do_cleanups (old_cleanups
);
2197 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2199 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2203 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2206 struct cleanup
*old_cleanups
;
2208 linebuffer
= xstrvprintf (format
, args
);
2209 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2210 fputs_unfiltered (linebuffer
, stream
);
2211 do_cleanups (old_cleanups
);
2215 vprintf_filtered (const char *format
, va_list args
)
2217 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2221 vprintf_unfiltered (const char *format
, va_list args
)
2223 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2227 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2230 va_start (args
, format
);
2231 vfprintf_filtered (stream
, format
, args
);
2236 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2239 va_start (args
, format
);
2240 vfprintf_unfiltered (stream
, format
, args
);
2244 /* Like fprintf_filtered, but prints its result indented.
2245 Called as fprintfi_filtered (spaces, stream, format, ...); */
2248 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2252 va_start (args
, format
);
2253 print_spaces_filtered (spaces
, stream
);
2255 vfprintf_filtered (stream
, format
, args
);
2261 printf_filtered (const char *format
, ...)
2264 va_start (args
, format
);
2265 vfprintf_filtered (gdb_stdout
, format
, args
);
2271 printf_unfiltered (const char *format
, ...)
2274 va_start (args
, format
);
2275 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2279 /* Like printf_filtered, but prints it's result indented.
2280 Called as printfi_filtered (spaces, format, ...); */
2283 printfi_filtered (int spaces
, const char *format
, ...)
2286 va_start (args
, format
);
2287 print_spaces_filtered (spaces
, gdb_stdout
);
2288 vfprintf_filtered (gdb_stdout
, format
, args
);
2292 /* Easy -- but watch out!
2294 This routine is *not* a replacement for puts()! puts() appends a newline.
2295 This one doesn't, and had better not! */
2298 puts_filtered (const char *string
)
2300 fputs_filtered (string
, gdb_stdout
);
2304 puts_unfiltered (const char *string
)
2306 fputs_unfiltered (string
, gdb_stdout
);
2309 /* Return a pointer to N spaces and a null. The pointer is good
2310 until the next call to here. */
2315 static char *spaces
= 0;
2316 static int max_spaces
= -1;
2322 spaces
= (char *) xmalloc (n
+ 1);
2323 for (t
= spaces
+ n
; t
!= spaces
;)
2329 return spaces
+ max_spaces
- n
;
2332 /* Print N spaces. */
2334 print_spaces_filtered (int n
, struct ui_file
*stream
)
2336 fputs_filtered (n_spaces (n
), stream
);
2339 /* C++/ObjC demangler stuff. */
2341 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2342 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2343 If the name is not mangled, or the language for the name is unknown, or
2344 demangling is off, the name is printed in its "raw" form. */
2347 fprintf_symbol_filtered (struct ui_file
*stream
, char *name
,
2348 enum language lang
, int arg_mode
)
2354 /* If user wants to see raw output, no problem. */
2357 fputs_filtered (name
, stream
);
2361 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2362 fputs_filtered (demangled
? demangled
: name
, stream
);
2363 if (demangled
!= NULL
)
2371 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2372 differences in whitespace. Returns 0 if they match, non-zero if they
2373 don't (slightly different than strcmp()'s range of return values).
2375 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2376 This "feature" is useful when searching for matching C++ function names
2377 (such as if the user types 'break FOO', where FOO is a mangled C++
2381 strcmp_iw (const char *string1
, const char *string2
)
2383 while ((*string1
!= '\0') && (*string2
!= '\0'))
2385 while (isspace (*string1
))
2389 while (isspace (*string2
))
2393 if (*string1
!= *string2
)
2397 if (*string1
!= '\0')
2403 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2406 /* This is like strcmp except that it ignores whitespace and treats
2407 '(' as the first non-NULL character in terms of ordering. Like
2408 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2409 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2410 according to that ordering.
2412 If a list is sorted according to this function and if you want to
2413 find names in the list that match some fixed NAME according to
2414 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2415 where this function would put NAME.
2417 Here are some examples of why using strcmp to sort is a bad idea:
2421 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2422 we try to do a search for "foo<char*>", strcmp will locate this
2423 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2424 will start looking at strings beginning with "goo", and will never
2425 see the correct match of "foo<char *>".
2427 Parenthesis example:
2429 In practice, this is less like to be an issue, but I'll give it a
2430 shot. Let's assume that '$' is a legitimate character to occur in
2431 symbols. (Which may well even be the case on some systems.) Then
2432 say that the partial symbol table contains "foo$" and "foo(int)".
2433 strcmp will put them in this order, since '$' < '('. Now, if the
2434 user searches for "foo", then strcmp will sort "foo" before "foo$".
2435 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2436 "foo") is false, so it won't proceed to the actual match of
2437 "foo(int)" with "foo". */
2440 strcmp_iw_ordered (const char *string1
, const char *string2
)
2442 while ((*string1
!= '\0') && (*string2
!= '\0'))
2444 while (isspace (*string1
))
2448 while (isspace (*string2
))
2452 if (*string1
!= *string2
)
2456 if (*string1
!= '\0')
2465 /* Characters are non-equal unless they're both '\0'; we want to
2466 make sure we get the comparison right according to our
2467 comparison in the cases where one of them is '\0' or '('. */
2469 if (*string2
== '\0')
2474 if (*string2
== '\0')
2479 if (*string2
== '(')
2482 return *string1
- *string2
;
2486 /* A simple comparison function with opposite semantics to strcmp. */
2489 streq (const char *lhs
, const char *rhs
)
2491 return !strcmp (lhs
, rhs
);
2497 ** Answer whether string_to_compare is a full or partial match to
2498 ** template_string. The partial match must be in sequence starting
2502 subset_compare (char *string_to_compare
, char *template_string
)
2505 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2506 && strlen (string_to_compare
) <= strlen (template_string
))
2509 (template_string
, string_to_compare
, strlen (string_to_compare
)) == 0);
2516 static void pagination_on_command (char *arg
, int from_tty
);
2518 pagination_on_command (char *arg
, int from_tty
)
2520 pagination_enabled
= 1;
2523 static void pagination_on_command (char *arg
, int from_tty
);
2525 pagination_off_command (char *arg
, int from_tty
)
2527 pagination_enabled
= 0;
2532 initialize_utils (void)
2534 struct cmd_list_element
*c
;
2536 c
= add_set_cmd ("width", class_support
, var_uinteger
, &chars_per_line
,
2537 "Set number of characters gdb thinks are in a line.",
2539 deprecated_add_show_from_set (c
, &showlist
);
2540 set_cmd_sfunc (c
, set_width_command
);
2542 c
= add_set_cmd ("height", class_support
, var_uinteger
, &lines_per_page
,
2543 "Set number of lines gdb thinks are in a page.", &setlist
);
2544 deprecated_add_show_from_set (c
, &showlist
);
2545 set_cmd_sfunc (c
, set_height_command
);
2549 deprecated_add_show_from_set
2550 (add_set_cmd ("demangle", class_support
, var_boolean
,
2552 "Set demangling of encoded C++/ObjC names when displaying symbols.",
2553 &setprintlist
), &showprintlist
);
2555 deprecated_add_show_from_set
2556 (add_set_cmd ("pagination", class_support
,
2557 var_boolean
, (char *) &pagination_enabled
,
2558 "Set state of pagination.", &setlist
), &showlist
);
2562 add_com ("am", class_support
, pagination_on_command
,
2563 "Enable pagination");
2564 add_com ("sm", class_support
, pagination_off_command
,
2565 "Disable pagination");
2568 deprecated_add_show_from_set
2569 (add_set_cmd ("sevenbit-strings", class_support
, var_boolean
,
2570 (char *) &sevenbit_strings
,
2571 "Set printing of 8-bit characters in strings as \\nnn.",
2572 &setprintlist
), &showprintlist
);
2574 deprecated_add_show_from_set
2575 (add_set_cmd ("asm-demangle", class_support
, var_boolean
,
2576 (char *) &asm_demangle
,
2577 "Set demangling of C++/ObjC names in disassembly listings.",
2578 &setprintlist
), &showprintlist
);
2581 /* Machine specific function to handle SIGWINCH signal. */
2583 #ifdef SIGWINCH_HANDLER_BODY
2584 SIGWINCH_HANDLER_BODY
2586 /* print routines to handle variable size regs, etc. */
2587 /* temporary storage using circular buffer */
2593 static char buf
[NUMCELLS
][CELLSIZE
];
2594 static int cell
= 0;
2595 if (++cell
>= NUMCELLS
)
2603 return (TARGET_ADDR_BIT
/ 8 * 2);
2607 paddr (CORE_ADDR addr
)
2609 return phex (addr
, TARGET_ADDR_BIT
/ 8);
2613 paddr_nz (CORE_ADDR addr
)
2615 return phex_nz (addr
, TARGET_ADDR_BIT
/ 8);
2619 decimal2str (char *paddr_str
, char *sign
, ULONGEST addr
, int width
)
2621 /* steal code from valprint.c:print_decimal(). Should this worry
2622 about the real size of addr as the above does? */
2623 unsigned long temp
[3];
2627 temp
[i
] = addr
% (1000 * 1000 * 1000);
2628 addr
/= (1000 * 1000 * 1000);
2632 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2639 sprintf (paddr_str
, "%s%0*lu", sign
, width
, temp
[0]);
2642 sprintf (paddr_str
, "%s%0*lu%09lu", sign
, width
, temp
[1], temp
[0]);
2645 sprintf (paddr_str
, "%s%0*lu%09lu%09lu", sign
, width
,
2646 temp
[2], temp
[1], temp
[0]);
2649 internal_error (__FILE__
, __LINE__
,
2650 "failed internal consistency check");
2655 octal2str (char *paddr_str
, ULONGEST addr
, int width
)
2657 unsigned long temp
[3];
2661 temp
[i
] = addr
% (0100000 * 0100000);
2662 addr
/= (0100000 * 0100000);
2666 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2674 sprintf (paddr_str
, "%*o", width
, 0);
2676 sprintf (paddr_str
, "0%0*lo", width
, temp
[0]);
2679 sprintf (paddr_str
, "0%0*lo%010lo", width
, temp
[1], temp
[0]);
2682 sprintf (paddr_str
, "0%0*lo%010lo%010lo", width
,
2683 temp
[2], temp
[1], temp
[0]);
2686 internal_error (__FILE__
, __LINE__
,
2687 "failed internal consistency check");
2692 paddr_u (CORE_ADDR addr
)
2694 char *paddr_str
= get_cell ();
2695 decimal2str (paddr_str
, "", addr
, 0);
2700 paddr_d (LONGEST addr
)
2702 char *paddr_str
= get_cell ();
2704 decimal2str (paddr_str
, "-", -addr
, 0);
2706 decimal2str (paddr_str
, "", addr
, 0);
2710 /* eliminate warning from compiler on 32-bit systems */
2711 static int thirty_two
= 32;
2714 phex (ULONGEST l
, int sizeof_l
)
2721 sprintf (str
, "%08lx%08lx",
2722 (unsigned long) (l
>> thirty_two
),
2723 (unsigned long) (l
& 0xffffffff));
2727 sprintf (str
, "%08lx", (unsigned long) l
);
2731 sprintf (str
, "%04x", (unsigned short) (l
& 0xffff));
2734 str
= phex (l
, sizeof (l
));
2741 phex_nz (ULONGEST l
, int sizeof_l
)
2748 unsigned long high
= (unsigned long) (l
>> thirty_two
);
2751 sprintf (str
, "%lx", (unsigned long) (l
& 0xffffffff));
2753 sprintf (str
, "%lx%08lx", high
, (unsigned long) (l
& 0xffffffff));
2758 sprintf (str
, "%lx", (unsigned long) l
);
2762 sprintf (str
, "%x", (unsigned short) (l
& 0xffff));
2765 str
= phex_nz (l
, sizeof (l
));
2771 /* Converts a LONGEST to a C-format hexadecimal literal and stores it
2772 in a static string. Returns a pointer to this string. */
2774 hex_string (LONGEST num
)
2776 char *result
= get_cell ();
2777 snprintf (result
, CELLSIZE
, "0x%s", phex_nz (num
, sizeof (num
)));
2781 /* Converts a LONGEST number to a C-format hexadecimal literal and
2782 stores it in a static string. Returns a pointer to this string
2783 that is valid until the next call. The number is padded on the
2784 left with 0s to at least WIDTH characters. */
2786 hex_string_custom (LONGEST num
, int width
)
2788 char *result
= get_cell ();
2789 char *result_end
= result
+ CELLSIZE
- 1;
2790 const char *hex
= phex_nz (num
, sizeof (num
));
2791 int hex_len
= strlen (hex
);
2793 if (hex_len
> width
)
2795 if (width
+ 2 >= CELLSIZE
)
2796 internal_error (__FILE__
, __LINE__
,
2797 "hex_string_custom: insufficient space to store result");
2799 strcpy (result_end
- width
- 2, "0x");
2800 memset (result_end
- width
, '0', width
);
2801 strcpy (result_end
- hex_len
, hex
);
2802 return result_end
- width
- 2;
2805 /* Convert VAL to a numeral in the given radix. For
2806 * radix 10, IS_SIGNED may be true, indicating a signed quantity;
2807 * otherwise VAL is interpreted as unsigned. If WIDTH is supplied,
2808 * it is the minimum width (0-padded if needed). USE_C_FORMAT means
2809 * to use C format in all cases. If it is false, then 'x'
2810 * and 'o' formats do not include a prefix (0x or leading 0). */
2813 int_string (LONGEST val
, int radix
, int is_signed
, int width
,
2822 result
= hex_string (val
);
2824 result
= hex_string_custom (val
, width
);
2831 char *result
= get_cell ();
2832 if (is_signed
&& val
< 0)
2833 decimal2str (result
, "-", -val
, width
);
2835 decimal2str (result
, "", val
, width
);
2840 char *result
= get_cell ();
2841 octal2str (result
, val
, width
);
2842 if (use_c_format
|| val
== 0)
2848 internal_error (__FILE__
, __LINE__
,
2849 "failed internal consistency check");
2853 /* Convert a CORE_ADDR into a string. */
2855 core_addr_to_string (const CORE_ADDR addr
)
2857 char *str
= get_cell ();
2859 strcat (str
, phex (addr
, sizeof (addr
)));
2864 core_addr_to_string_nz (const CORE_ADDR addr
)
2866 char *str
= get_cell ();
2868 strcat (str
, phex_nz (addr
, sizeof (addr
)));
2872 /* Convert a string back into a CORE_ADDR. */
2874 string_to_core_addr (const char *my_string
)
2877 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2879 /* Assume that it is in decimal. */
2881 for (i
= 2; my_string
[i
] != '\0'; i
++)
2883 if (isdigit (my_string
[i
]))
2884 addr
= (my_string
[i
] - '0') + (addr
* 16);
2885 else if (isxdigit (my_string
[i
]))
2886 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2888 internal_error (__FILE__
, __LINE__
, "invalid hex");
2893 /* Assume that it is in decimal. */
2895 for (i
= 0; my_string
[i
] != '\0'; i
++)
2897 if (isdigit (my_string
[i
]))
2898 addr
= (my_string
[i
] - '0') + (addr
* 10);
2900 internal_error (__FILE__
, __LINE__
, "invalid decimal");
2907 gdb_realpath (const char *filename
)
2909 /* Method 1: The system has a compile time upper bound on a filename
2910 path. Use that and realpath() to canonicalize the name. This is
2911 the most common case. Note that, if there isn't a compile time
2912 upper bound, you want to avoid realpath() at all costs. */
2913 #if defined(HAVE_REALPATH)
2915 # if defined (PATH_MAX)
2917 # define USE_REALPATH
2918 # elif defined (MAXPATHLEN)
2919 char buf
[MAXPATHLEN
];
2920 # define USE_REALPATH
2922 # if defined (USE_REALPATH)
2923 const char *rp
= realpath (filename
, buf
);
2926 return xstrdup (rp
);
2929 #endif /* HAVE_REALPATH */
2931 /* Method 2: The host system (i.e., GNU) has the function
2932 canonicalize_file_name() which malloc's a chunk of memory and
2933 returns that, use that. */
2934 #if defined(HAVE_CANONICALIZE_FILE_NAME)
2936 char *rp
= canonicalize_file_name (filename
);
2938 return xstrdup (filename
);
2944 /* FIXME: cagney/2002-11-13:
2946 Method 2a: Use realpath() with a NULL buffer. Some systems, due
2947 to the problems described in in method 3, have modified their
2948 realpath() implementation so that it will allocate a buffer when
2949 NULL is passed in. Before this can be used, though, some sort of
2950 configure time test would need to be added. Otherwize the code
2951 will likely core dump. */
2953 /* Method 3: Now we're getting desperate! The system doesn't have a
2954 compile time buffer size and no alternative function. Query the
2955 OS, using pathconf(), for the buffer limit. Care is needed
2956 though, some systems do not limit PATH_MAX (return -1 for
2957 pathconf()) making it impossible to pass a correctly sized buffer
2958 to realpath() (it could always overflow). On those systems, we
2960 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
2962 /* Find out the max path size. */
2963 long path_max
= pathconf ("/", _PC_PATH_MAX
);
2966 /* PATH_MAX is bounded. */
2967 char *buf
= alloca (path_max
);
2968 char *rp
= realpath (filename
, buf
);
2969 return xstrdup (rp
? rp
: filename
);
2974 /* This system is a lost cause, just dup the buffer. */
2975 return xstrdup (filename
);
2978 /* Return a copy of FILENAME, with its directory prefix canonicalized
2982 xfullpath (const char *filename
)
2984 const char *base_name
= lbasename (filename
);
2989 /* Extract the basename of filename, and return immediately
2990 a copy of filename if it does not contain any directory prefix. */
2991 if (base_name
== filename
)
2992 return xstrdup (filename
);
2994 dir_name
= alloca ((size_t) (base_name
- filename
+ 2));
2995 /* Allocate enough space to store the dir_name + plus one extra
2996 character sometimes needed under Windows (see below), and
2997 then the closing \000 character */
2998 strncpy (dir_name
, filename
, base_name
- filename
);
2999 dir_name
[base_name
- filename
] = '\000';
3001 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3002 /* We need to be careful when filename is of the form 'd:foo', which
3003 is equivalent of d:./foo, which is totally different from d:/foo. */
3004 if (strlen (dir_name
) == 2 && isalpha (dir_name
[0]) && dir_name
[1] == ':')
3007 dir_name
[3] = '\000';
3011 /* Canonicalize the directory prefix, and build the resulting
3012 filename. If the dirname realpath already contains an ending
3013 directory separator, avoid doubling it. */
3014 real_path
= gdb_realpath (dir_name
);
3015 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
3016 result
= concat (real_path
, base_name
, NULL
);
3018 result
= concat (real_path
, SLASH_STRING
, base_name
, NULL
);
3025 /* This is the 32-bit CRC function used by the GNU separate debug
3026 facility. An executable may contain a section named
3027 .gnu_debuglink, which holds the name of a separate executable file
3028 containing its debug info, and a checksum of that file's contents,
3029 computed using this function. */
3031 gnu_debuglink_crc32 (unsigned long crc
, unsigned char *buf
, size_t len
)
3033 static const unsigned long crc32_table
[256] = {
3034 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
3035 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
3036 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
3037 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
3038 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
3039 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
3040 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
3041 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
3042 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
3043 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
3044 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
3045 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
3046 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
3047 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
3048 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
3049 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
3050 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
3051 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
3052 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
3053 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
3054 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
3055 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
3056 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
3057 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
3058 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
3059 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
3060 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
3061 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
3062 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
3063 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
3064 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
3065 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
3066 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
3067 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
3068 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
3069 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
3070 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
3071 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
3072 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
3073 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
3074 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
3075 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
3076 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
3077 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
3078 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
3079 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
3080 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
3081 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
3082 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
3083 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
3084 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
3089 crc
= ~crc
& 0xffffffff;
3090 for (end
= buf
+ len
; buf
< end
; ++buf
)
3091 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
3092 return ~crc
& 0xffffffff;;
3096 align_up (ULONGEST v
, int n
)
3098 /* Check that N is really a power of two. */
3099 gdb_assert (n
&& (n
& (n
-1)) == 0);
3100 return (v
+ n
- 1) & -n
;
3104 align_down (ULONGEST v
, int n
)
3106 /* Check that N is really a power of two. */
3107 gdb_assert (n
&& (n
& (n
-1)) == 0);