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 msavestring (void *md
, const char *ptr
, size_t size
)
1174 char *p
= (char *) xmalloc (size
+ 1);
1175 memcpy (p
, ptr
, size
);
1181 mstrsave (void *md
, const char *ptr
)
1183 return (msavestring (md
, ptr
, strlen (ptr
)));
1187 print_spaces (int n
, struct ui_file
*file
)
1189 fputs_unfiltered (n_spaces (n
), file
);
1192 /* Print a host address. */
1195 gdb_print_host_address (const void *addr
, struct ui_file
*stream
)
1198 /* We could use the %p conversion specifier to fprintf if we had any
1199 way of knowing whether this host supports it. But the following
1200 should work on the Alpha and on 32 bit machines. */
1202 fprintf_filtered (stream
, "0x%lx", (unsigned long) addr
);
1205 /* Ask user a y-or-n question and return 1 iff answer is yes.
1206 Takes three args which are given to printf to print the question.
1207 The first, a control string, should end in "? ".
1208 It should not say how to answer, because we do that. */
1212 query (const char *ctlstr
, ...)
1219 if (deprecated_query_hook
)
1221 va_start (args
, ctlstr
);
1222 return deprecated_query_hook (ctlstr
, args
);
1225 /* Automatically answer "yes" if input is not from a terminal. */
1226 if (!input_from_terminal_p ())
1231 wrap_here (""); /* Flush any buffered output */
1232 gdb_flush (gdb_stdout
);
1234 if (annotation_level
> 1)
1235 printf_filtered ("\n\032\032pre-query\n");
1237 va_start (args
, ctlstr
);
1238 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1240 printf_filtered ("(y or n) ");
1242 if (annotation_level
> 1)
1243 printf_filtered ("\n\032\032query\n");
1246 gdb_flush (gdb_stdout
);
1248 answer
= fgetc (stdin
);
1249 clearerr (stdin
); /* in case of C-d */
1250 if (answer
== EOF
) /* C-d */
1255 /* Eat rest of input line, to EOF or newline */
1259 ans2
= fgetc (stdin
);
1262 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1276 printf_filtered ("Please answer y or n.\n");
1279 if (annotation_level
> 1)
1280 printf_filtered ("\n\032\032post-query\n");
1285 /* This function supports the nquery() and yquery() functions.
1286 Ask user a y-or-n question and return 0 if answer is no, 1 if
1287 answer is yes, or default the answer to the specified default.
1288 DEFCHAR is either 'y' or 'n' and refers to the default answer.
1289 CTLSTR is the control string and should end in "? ". It should
1290 not say how to answer, because we do that.
1291 ARGS are the arguments passed along with the CTLSTR argument to
1295 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
1301 char def_answer
, not_def_answer
;
1302 char *y_string
, *n_string
;
1304 /* Set up according to which answer is the default. */
1309 not_def_answer
= 'N';
1317 not_def_answer
= 'Y';
1322 if (deprecated_query_hook
)
1324 return deprecated_query_hook (ctlstr
, args
);
1327 /* Automatically answer default value if input is not from a terminal. */
1328 if (!input_from_terminal_p ())
1333 wrap_here (""); /* Flush any buffered output */
1334 gdb_flush (gdb_stdout
);
1336 if (annotation_level
> 1)
1337 printf_filtered ("\n\032\032pre-query\n");
1339 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1340 printf_filtered ("(%s or %s) ", y_string
, n_string
);
1342 if (annotation_level
> 1)
1343 printf_filtered ("\n\032\032query\n");
1346 gdb_flush (gdb_stdout
);
1348 answer
= fgetc (stdin
);
1349 clearerr (stdin
); /* in case of C-d */
1350 if (answer
== EOF
) /* C-d */
1355 /* Eat rest of input line, to EOF or newline */
1359 ans2
= fgetc (stdin
);
1362 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1366 /* Check answer. For the non-default, the user must specify
1367 the non-default explicitly. */
1368 if (answer
== not_def_answer
)
1370 retval
= !def_value
;
1373 /* Otherwise, for the default, the user may either specify
1374 the required input or have it default by entering nothing. */
1375 if (answer
== def_answer
|| answer
== '\n' ||
1376 answer
== '\r' || answer
== EOF
)
1381 /* Invalid entries are not defaulted and require another selection. */
1382 printf_filtered ("Please answer %s or %s.\n",
1383 y_string
, n_string
);
1386 if (annotation_level
> 1)
1387 printf_filtered ("\n\032\032post-query\n");
1392 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1393 answer is yes, or 0 if answer is defaulted.
1394 Takes three args which are given to printf to print the question.
1395 The first, a control string, should end in "? ".
1396 It should not say how to answer, because we do that. */
1399 nquery (const char *ctlstr
, ...)
1403 va_start (args
, ctlstr
);
1404 return defaulted_query (ctlstr
, 'n', args
);
1408 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1409 answer is yes, or 1 if answer is defaulted.
1410 Takes three args which are given to printf to print the question.
1411 The first, a control string, should end in "? ".
1412 It should not say how to answer, because we do that. */
1415 yquery (const char *ctlstr
, ...)
1419 va_start (args
, ctlstr
);
1420 return defaulted_query (ctlstr
, 'y', args
);
1424 /* Print an error message saying that we couldn't make sense of a
1425 \^mumble sequence in a string or character constant. START and END
1426 indicate a substring of some larger string that contains the
1427 erroneous backslash sequence, missing the initial backslash. */
1429 no_control_char_error (const char *start
, const char *end
)
1431 int len
= end
- start
;
1432 char *copy
= alloca (end
- start
+ 1);
1434 memcpy (copy
, start
, len
);
1437 error ("There is no control character `\\%s' in the `%s' character set.",
1438 copy
, target_charset ());
1441 /* Parse a C escape sequence. STRING_PTR points to a variable
1442 containing a pointer to the string to parse. That pointer
1443 should point to the character after the \. That pointer
1444 is updated past the characters we use. The value of the
1445 escape sequence is returned.
1447 A negative value means the sequence \ newline was seen,
1448 which is supposed to be equivalent to nothing at all.
1450 If \ is followed by a null character, we return a negative
1451 value and leave the string pointer pointing at the null character.
1453 If \ is followed by 000, we return 0 and leave the string pointer
1454 after the zeros. A value of 0 does not mean end of string. */
1457 parse_escape (char **string_ptr
)
1460 int c
= *(*string_ptr
)++;
1461 if (c_parse_backslash (c
, &target_char
))
1473 /* Remember where this escape sequence started, for reporting
1475 char *sequence_start_pos
= *string_ptr
- 1;
1477 c
= *(*string_ptr
)++;
1481 /* XXXCHARSET: What is `delete' in the host character set? */
1484 if (!host_char_to_target (c
, &target_char
))
1485 error ("There is no character corresponding to `Delete' "
1486 "in the target character set `%s'.", host_charset ());
1491 target_char
= parse_escape (string_ptr
);
1494 if (!host_char_to_target (c
, &target_char
))
1495 no_control_char_error (sequence_start_pos
, *string_ptr
);
1498 /* Now target_char is something like `c', and we want to find
1499 its control-character equivalent. */
1500 if (!target_char_to_control_char (target_char
, &target_char
))
1501 no_control_char_error (sequence_start_pos
, *string_ptr
);
1506 /* XXXCHARSET: we need to use isdigit and value-of-digit
1507 methods of the host character set here. */
1523 if (c
>= '0' && c
<= '7')
1537 if (!host_char_to_target (c
, &target_char
))
1539 ("The escape sequence `\%c' is equivalent to plain `%c', which"
1540 " has no equivalent\n" "in the `%s' character set.", c
, c
,
1546 /* Print the character C on STREAM as part of the contents of a literal
1547 string whose delimiter is QUOTER. Note that this routine should only
1548 be call for printing things which are independent of the language
1549 of the program being debugged. */
1552 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1553 void (*do_fprintf
) (struct ui_file
*, const char *, ...),
1554 struct ui_file
*stream
, int quoter
)
1557 c
&= 0xFF; /* Avoid sign bit follies */
1559 if (c
< 0x20 || /* Low control chars */
1560 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1561 (sevenbit_strings
&& c
>= 0x80))
1562 { /* high order bit set */
1566 do_fputs ("\\n", stream
);
1569 do_fputs ("\\b", stream
);
1572 do_fputs ("\\t", stream
);
1575 do_fputs ("\\f", stream
);
1578 do_fputs ("\\r", stream
);
1581 do_fputs ("\\e", stream
);
1584 do_fputs ("\\a", stream
);
1587 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1593 if (c
== '\\' || c
== quoter
)
1594 do_fputs ("\\", stream
);
1595 do_fprintf (stream
, "%c", c
);
1599 /* Print the character C on STREAM as part of the contents of a
1600 literal string whose delimiter is QUOTER. Note that these routines
1601 should only be call for printing things which are independent of
1602 the language of the program being debugged. */
1605 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1608 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1612 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1615 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1619 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1620 struct ui_file
*stream
)
1623 for (i
= 0; i
< n
; i
++)
1624 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1628 /* Number of lines per page or UINT_MAX if paging is disabled. */
1629 static unsigned int lines_per_page
;
1631 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1632 static unsigned int chars_per_line
;
1634 /* Current count of lines printed on this page, chars on this line. */
1635 static unsigned int lines_printed
, chars_printed
;
1637 /* Buffer and start column of buffered text, for doing smarter word-
1638 wrapping. When someone calls wrap_here(), we start buffering output
1639 that comes through fputs_filtered(). If we see a newline, we just
1640 spit it out and forget about the wrap_here(). If we see another
1641 wrap_here(), we spit it out and remember the newer one. If we see
1642 the end of the line, we spit out a newline, the indent, and then
1643 the buffered output. */
1645 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1646 are waiting to be output (they have already been counted in chars_printed).
1647 When wrap_buffer[0] is null, the buffer is empty. */
1648 static char *wrap_buffer
;
1650 /* Pointer in wrap_buffer to the next character to fill. */
1651 static char *wrap_pointer
;
1653 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1655 static char *wrap_indent
;
1657 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1658 is not in effect. */
1659 static int wrap_column
;
1662 /* Inialize the number of lines per page and chars per line. */
1665 init_page_info (void)
1668 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1673 #if defined(__GO32__)
1674 rows
= ScreenRows ();
1675 cols
= ScreenCols ();
1676 lines_per_page
= rows
;
1677 chars_per_line
= cols
;
1679 /* Make sure Readline has initialized its terminal settings. */
1680 rl_reset_terminal (NULL
);
1682 /* Get the screen size from Readline. */
1683 rl_get_screen_size (&rows
, &cols
);
1684 lines_per_page
= rows
;
1685 chars_per_line
= cols
;
1687 /* Readline should have fetched the termcap entry for us. */
1688 if (tgetnum ("li") < 0 || getenv ("EMACS"))
1690 /* The number of lines per page is not mentioned in the
1691 terminal description. This probably means that paging is
1692 not useful (e.g. emacs shell window), so disable paging. */
1693 lines_per_page
= UINT_MAX
;
1696 /* FIXME: Get rid of this junk. */
1697 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1698 SIGWINCH_HANDLER (SIGWINCH
);
1701 /* If the output is not a terminal, don't paginate it. */
1702 if (!ui_file_isatty (gdb_stdout
))
1703 lines_per_page
= UINT_MAX
;
1711 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1714 set_screen_size (void)
1716 int rows
= lines_per_page
;
1717 int cols
= chars_per_line
;
1723 rl_get_screen_size (NULL
, &cols
);
1725 /* Update Readline's idea of the terminal size. */
1726 rl_set_screen_size (rows
, cols
);
1729 /* Reinitialize WRAP_BUFFER according to the current value of
1735 if (chars_per_line
== 0)
1740 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1741 wrap_buffer
[0] = '\0';
1744 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1745 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
1749 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1756 set_height_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1761 /* Wait, so the user can read what's on the screen. Prompt the user
1762 to continue by pressing RETURN. */
1765 prompt_for_continue (void)
1768 char cont_prompt
[120];
1770 if (annotation_level
> 1)
1771 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1773 strcpy (cont_prompt
,
1774 "---Type <return> to continue, or q <return> to quit---");
1775 if (annotation_level
> 1)
1776 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1778 /* We must do this *before* we call gdb_readline, else it will eventually
1779 call us -- thinking that we're trying to print beyond the end of the
1781 reinitialize_more_filter ();
1784 /* On a real operating system, the user can quit with SIGINT.
1787 'q' is provided on all systems so users don't have to change habits
1788 from system to system, and because telling them what to do in
1789 the prompt is more user-friendly than expecting them to think of
1791 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1792 whereas control-C to gdb_readline will cause the user to get dumped
1794 ignore
= gdb_readline_wrapper (cont_prompt
);
1796 if (annotation_level
> 1)
1797 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1802 while (*p
== ' ' || *p
== '\t')
1807 request_quit (SIGINT
);
1809 async_request_quit (0);
1815 /* Now we have to do this again, so that GDB will know that it doesn't
1816 need to save the ---Type <return>--- line at the top of the screen. */
1817 reinitialize_more_filter ();
1819 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1822 /* Reinitialize filter; ie. tell it to reset to original values. */
1825 reinitialize_more_filter (void)
1831 /* Indicate that if the next sequence of characters overflows the line,
1832 a newline should be inserted here rather than when it hits the end.
1833 If INDENT is non-null, it is a string to be printed to indent the
1834 wrapped part on the next line. INDENT must remain accessible until
1835 the next call to wrap_here() or until a newline is printed through
1838 If the line is already overfull, we immediately print a newline and
1839 the indentation, and disable further wrapping.
1841 If we don't know the width of lines, but we know the page height,
1842 we must not wrap words, but should still keep track of newlines
1843 that were explicitly printed.
1845 INDENT should not contain tabs, as that will mess up the char count
1846 on the next line. FIXME.
1848 This routine is guaranteed to force out any output which has been
1849 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1850 used to force out output from the wrap_buffer. */
1853 wrap_here (char *indent
)
1855 /* This should have been allocated, but be paranoid anyway. */
1857 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1861 *wrap_pointer
= '\0';
1862 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1864 wrap_pointer
= wrap_buffer
;
1865 wrap_buffer
[0] = '\0';
1866 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1870 else if (chars_printed
>= chars_per_line
)
1872 puts_filtered ("\n");
1874 puts_filtered (indent
);
1879 wrap_column
= chars_printed
;
1883 wrap_indent
= indent
;
1887 /* Print input string to gdb_stdout, filtered, with wrap,
1888 arranging strings in columns of n chars. String can be
1889 right or left justified in the column. Never prints
1890 trailing spaces. String should never be longer than
1891 width. FIXME: this could be useful for the EXAMINE
1892 command, which currently doesn't tabulate very well */
1895 puts_filtered_tabular (char *string
, int width
, int right
)
1901 gdb_assert (chars_per_line
> 0);
1902 if (chars_per_line
== UINT_MAX
)
1904 fputs_filtered (string
, gdb_stdout
);
1905 fputs_filtered ("\n", gdb_stdout
);
1909 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
1910 fputs_filtered ("\n", gdb_stdout
);
1912 if (width
>= chars_per_line
)
1913 width
= chars_per_line
- 1;
1915 stringlen
= strlen (string
);
1917 if (chars_printed
> 0)
1918 spaces
= width
- (chars_printed
- 1) % width
- 1;
1920 spaces
+= width
- stringlen
;
1922 spacebuf
= alloca (spaces
+ 1);
1923 spacebuf
[spaces
] = '\0';
1925 spacebuf
[spaces
] = ' ';
1927 fputs_filtered (spacebuf
, gdb_stdout
);
1928 fputs_filtered (string
, gdb_stdout
);
1932 /* Ensure that whatever gets printed next, using the filtered output
1933 commands, starts at the beginning of the line. I.E. if there is
1934 any pending output for the current line, flush it and start a new
1935 line. Otherwise do nothing. */
1940 if (chars_printed
> 0)
1942 puts_filtered ("\n");
1947 /* Like fputs but if FILTER is true, pause after every screenful.
1949 Regardless of FILTER can wrap at points other than the final
1950 character of a line.
1952 Unlike fputs, fputs_maybe_filtered does not return a value.
1953 It is OK for LINEBUFFER to be NULL, in which case just don't print
1956 Note that a longjmp to top level may occur in this routine (only if
1957 FILTER is true) (since prompt_for_continue may do so) so this
1958 routine should not be called when cleanups are not in place. */
1961 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1964 const char *lineptr
;
1966 if (linebuffer
== 0)
1969 /* Don't do any filtering if it is disabled. */
1970 if ((stream
!= gdb_stdout
) || !pagination_enabled
1971 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
1973 fputs_unfiltered (linebuffer
, stream
);
1977 /* Go through and output each character. Show line extension
1978 when this is necessary; prompt user for new page when this is
1981 lineptr
= linebuffer
;
1984 /* Possible new page. */
1985 if (filter
&& (lines_printed
>= lines_per_page
- 1))
1986 prompt_for_continue ();
1988 while (*lineptr
&& *lineptr
!= '\n')
1990 /* Print a single line. */
1991 if (*lineptr
== '\t')
1994 *wrap_pointer
++ = '\t';
1996 fputc_unfiltered ('\t', stream
);
1997 /* Shifting right by 3 produces the number of tab stops
1998 we have already passed, and then adding one and
1999 shifting left 3 advances to the next tab stop. */
2000 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
2006 *wrap_pointer
++ = *lineptr
;
2008 fputc_unfiltered (*lineptr
, stream
);
2013 if (chars_printed
>= chars_per_line
)
2015 unsigned int save_chars
= chars_printed
;
2019 /* If we aren't actually wrapping, don't output newline --
2020 if chars_per_line is right, we probably just overflowed
2021 anyway; if it's wrong, let us keep going. */
2023 fputc_unfiltered ('\n', stream
);
2025 /* Possible new page. */
2026 if (lines_printed
>= lines_per_page
- 1)
2027 prompt_for_continue ();
2029 /* Now output indentation and wrapped string */
2032 fputs_unfiltered (wrap_indent
, stream
);
2033 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
2034 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
2035 /* FIXME, this strlen is what prevents wrap_indent from
2036 containing tabs. However, if we recurse to print it
2037 and count its chars, we risk trouble if wrap_indent is
2038 longer than (the user settable) chars_per_line.
2039 Note also that this can set chars_printed > chars_per_line
2040 if we are printing a long string. */
2041 chars_printed
= strlen (wrap_indent
)
2042 + (save_chars
- wrap_column
);
2043 wrap_pointer
= wrap_buffer
; /* Reset buffer */
2044 wrap_buffer
[0] = '\0';
2045 wrap_column
= 0; /* And disable fancy wrap */
2050 if (*lineptr
== '\n')
2053 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
2055 fputc_unfiltered ('\n', stream
);
2062 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
2064 fputs_maybe_filtered (linebuffer
, stream
, 1);
2068 putchar_unfiltered (int c
)
2071 ui_file_write (gdb_stdout
, &buf
, 1);
2075 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2076 May return nonlocally. */
2079 putchar_filtered (int c
)
2081 return fputc_filtered (c
, gdb_stdout
);
2085 fputc_unfiltered (int c
, struct ui_file
*stream
)
2088 ui_file_write (stream
, &buf
, 1);
2093 fputc_filtered (int c
, struct ui_file
*stream
)
2099 fputs_filtered (buf
, stream
);
2103 /* puts_debug is like fputs_unfiltered, except it prints special
2104 characters in printable fashion. */
2107 puts_debug (char *prefix
, char *string
, char *suffix
)
2111 /* Print prefix and suffix after each line. */
2112 static int new_line
= 1;
2113 static int return_p
= 0;
2114 static char *prev_prefix
= "";
2115 static char *prev_suffix
= "";
2117 if (*string
== '\n')
2120 /* If the prefix is changing, print the previous suffix, a new line,
2121 and the new prefix. */
2122 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2124 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2125 fputs_unfiltered ("\n", gdb_stdlog
);
2126 fputs_unfiltered (prefix
, gdb_stdlog
);
2129 /* Print prefix if we printed a newline during the previous call. */
2133 fputs_unfiltered (prefix
, gdb_stdlog
);
2136 prev_prefix
= prefix
;
2137 prev_suffix
= suffix
;
2139 /* Output characters in a printable format. */
2140 while ((ch
= *string
++) != '\0')
2146 fputc_unfiltered (ch
, gdb_stdlog
);
2149 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2153 fputs_unfiltered ("\\\\", gdb_stdlog
);
2156 fputs_unfiltered ("\\b", gdb_stdlog
);
2159 fputs_unfiltered ("\\f", gdb_stdlog
);
2163 fputs_unfiltered ("\\n", gdb_stdlog
);
2166 fputs_unfiltered ("\\r", gdb_stdlog
);
2169 fputs_unfiltered ("\\t", gdb_stdlog
);
2172 fputs_unfiltered ("\\v", gdb_stdlog
);
2176 return_p
= ch
== '\r';
2179 /* Print suffix if we printed a newline. */
2182 fputs_unfiltered (suffix
, gdb_stdlog
);
2183 fputs_unfiltered ("\n", gdb_stdlog
);
2188 /* Print a variable number of ARGS using format FORMAT. If this
2189 information is going to put the amount written (since the last call
2190 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2191 call prompt_for_continue to get the users permision to continue.
2193 Unlike fprintf, this function does not return a value.
2195 We implement three variants, vfprintf (takes a vararg list and stream),
2196 fprintf (takes a stream to write on), and printf (the usual).
2198 Note also that a longjmp to top level may occur in this routine
2199 (since prompt_for_continue may do so) so this routine should not be
2200 called when cleanups are not in place. */
2203 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2204 va_list args
, int filter
)
2207 struct cleanup
*old_cleanups
;
2209 linebuffer
= xstrvprintf (format
, args
);
2210 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2211 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2212 do_cleanups (old_cleanups
);
2217 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2219 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2223 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2226 struct cleanup
*old_cleanups
;
2228 linebuffer
= xstrvprintf (format
, args
);
2229 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2230 fputs_unfiltered (linebuffer
, stream
);
2231 do_cleanups (old_cleanups
);
2235 vprintf_filtered (const char *format
, va_list args
)
2237 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2241 vprintf_unfiltered (const char *format
, va_list args
)
2243 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2247 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2250 va_start (args
, format
);
2251 vfprintf_filtered (stream
, format
, args
);
2256 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2259 va_start (args
, format
);
2260 vfprintf_unfiltered (stream
, format
, args
);
2264 /* Like fprintf_filtered, but prints its result indented.
2265 Called as fprintfi_filtered (spaces, stream, format, ...); */
2268 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2272 va_start (args
, format
);
2273 print_spaces_filtered (spaces
, stream
);
2275 vfprintf_filtered (stream
, format
, args
);
2281 printf_filtered (const char *format
, ...)
2284 va_start (args
, format
);
2285 vfprintf_filtered (gdb_stdout
, format
, args
);
2291 printf_unfiltered (const char *format
, ...)
2294 va_start (args
, format
);
2295 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2299 /* Like printf_filtered, but prints it's result indented.
2300 Called as printfi_filtered (spaces, format, ...); */
2303 printfi_filtered (int spaces
, const char *format
, ...)
2306 va_start (args
, format
);
2307 print_spaces_filtered (spaces
, gdb_stdout
);
2308 vfprintf_filtered (gdb_stdout
, format
, args
);
2312 /* Easy -- but watch out!
2314 This routine is *not* a replacement for puts()! puts() appends a newline.
2315 This one doesn't, and had better not! */
2318 puts_filtered (const char *string
)
2320 fputs_filtered (string
, gdb_stdout
);
2324 puts_unfiltered (const char *string
)
2326 fputs_unfiltered (string
, gdb_stdout
);
2329 /* Return a pointer to N spaces and a null. The pointer is good
2330 until the next call to here. */
2335 static char *spaces
= 0;
2336 static int max_spaces
= -1;
2342 spaces
= (char *) xmalloc (n
+ 1);
2343 for (t
= spaces
+ n
; t
!= spaces
;)
2349 return spaces
+ max_spaces
- n
;
2352 /* Print N spaces. */
2354 print_spaces_filtered (int n
, struct ui_file
*stream
)
2356 fputs_filtered (n_spaces (n
), stream
);
2359 /* C++/ObjC demangler stuff. */
2361 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2362 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2363 If the name is not mangled, or the language for the name is unknown, or
2364 demangling is off, the name is printed in its "raw" form. */
2367 fprintf_symbol_filtered (struct ui_file
*stream
, char *name
,
2368 enum language lang
, int arg_mode
)
2374 /* If user wants to see raw output, no problem. */
2377 fputs_filtered (name
, stream
);
2381 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2382 fputs_filtered (demangled
? demangled
: name
, stream
);
2383 if (demangled
!= NULL
)
2391 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2392 differences in whitespace. Returns 0 if they match, non-zero if they
2393 don't (slightly different than strcmp()'s range of return values).
2395 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2396 This "feature" is useful when searching for matching C++ function names
2397 (such as if the user types 'break FOO', where FOO is a mangled C++
2401 strcmp_iw (const char *string1
, const char *string2
)
2403 while ((*string1
!= '\0') && (*string2
!= '\0'))
2405 while (isspace (*string1
))
2409 while (isspace (*string2
))
2413 if (*string1
!= *string2
)
2417 if (*string1
!= '\0')
2423 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2426 /* This is like strcmp except that it ignores whitespace and treats
2427 '(' as the first non-NULL character in terms of ordering. Like
2428 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2429 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2430 according to that ordering.
2432 If a list is sorted according to this function and if you want to
2433 find names in the list that match some fixed NAME according to
2434 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2435 where this function would put NAME.
2437 Here are some examples of why using strcmp to sort is a bad idea:
2441 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2442 we try to do a search for "foo<char*>", strcmp will locate this
2443 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2444 will start looking at strings beginning with "goo", and will never
2445 see the correct match of "foo<char *>".
2447 Parenthesis example:
2449 In practice, this is less like to be an issue, but I'll give it a
2450 shot. Let's assume that '$' is a legitimate character to occur in
2451 symbols. (Which may well even be the case on some systems.) Then
2452 say that the partial symbol table contains "foo$" and "foo(int)".
2453 strcmp will put them in this order, since '$' < '('. Now, if the
2454 user searches for "foo", then strcmp will sort "foo" before "foo$".
2455 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2456 "foo") is false, so it won't proceed to the actual match of
2457 "foo(int)" with "foo". */
2460 strcmp_iw_ordered (const char *string1
, const char *string2
)
2462 while ((*string1
!= '\0') && (*string2
!= '\0'))
2464 while (isspace (*string1
))
2468 while (isspace (*string2
))
2472 if (*string1
!= *string2
)
2476 if (*string1
!= '\0')
2485 /* Characters are non-equal unless they're both '\0'; we want to
2486 make sure we get the comparison right according to our
2487 comparison in the cases where one of them is '\0' or '('. */
2489 if (*string2
== '\0')
2494 if (*string2
== '\0')
2499 if (*string2
== '(')
2502 return *string1
- *string2
;
2506 /* A simple comparison function with opposite semantics to strcmp. */
2509 streq (const char *lhs
, const char *rhs
)
2511 return !strcmp (lhs
, rhs
);
2517 ** Answer whether string_to_compare is a full or partial match to
2518 ** template_string. The partial match must be in sequence starting
2522 subset_compare (char *string_to_compare
, char *template_string
)
2525 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2526 && strlen (string_to_compare
) <= strlen (template_string
))
2529 (template_string
, string_to_compare
, strlen (string_to_compare
)) == 0);
2536 static void pagination_on_command (char *arg
, int from_tty
);
2538 pagination_on_command (char *arg
, int from_tty
)
2540 pagination_enabled
= 1;
2543 static void pagination_on_command (char *arg
, int from_tty
);
2545 pagination_off_command (char *arg
, int from_tty
)
2547 pagination_enabled
= 0;
2552 initialize_utils (void)
2554 struct cmd_list_element
*c
;
2556 c
= add_set_cmd ("width", class_support
, var_uinteger
, &chars_per_line
,
2557 "Set number of characters gdb thinks are in a line.",
2559 deprecated_add_show_from_set (c
, &showlist
);
2560 set_cmd_sfunc (c
, set_width_command
);
2562 c
= add_set_cmd ("height", class_support
, var_uinteger
, &lines_per_page
,
2563 "Set number of lines gdb thinks are in a page.", &setlist
);
2564 deprecated_add_show_from_set (c
, &showlist
);
2565 set_cmd_sfunc (c
, set_height_command
);
2569 deprecated_add_show_from_set
2570 (add_set_cmd ("demangle", class_support
, var_boolean
,
2572 "Set demangling of encoded C++/ObjC names when displaying symbols.",
2573 &setprintlist
), &showprintlist
);
2575 deprecated_add_show_from_set
2576 (add_set_cmd ("pagination", class_support
,
2577 var_boolean
, (char *) &pagination_enabled
,
2578 "Set state of pagination.", &setlist
), &showlist
);
2582 add_com ("am", class_support
, pagination_on_command
,
2583 "Enable pagination");
2584 add_com ("sm", class_support
, pagination_off_command
,
2585 "Disable pagination");
2588 deprecated_add_show_from_set
2589 (add_set_cmd ("sevenbit-strings", class_support
, var_boolean
,
2590 (char *) &sevenbit_strings
,
2591 "Set printing of 8-bit characters in strings as \\nnn.",
2592 &setprintlist
), &showprintlist
);
2594 deprecated_add_show_from_set
2595 (add_set_cmd ("asm-demangle", class_support
, var_boolean
,
2596 (char *) &asm_demangle
,
2597 "Set demangling of C++/ObjC names in disassembly listings.",
2598 &setprintlist
), &showprintlist
);
2601 /* Machine specific function to handle SIGWINCH signal. */
2603 #ifdef SIGWINCH_HANDLER_BODY
2604 SIGWINCH_HANDLER_BODY
2606 /* print routines to handle variable size regs, etc. */
2607 /* temporary storage using circular buffer */
2613 static char buf
[NUMCELLS
][CELLSIZE
];
2614 static int cell
= 0;
2615 if (++cell
>= NUMCELLS
)
2623 return (TARGET_ADDR_BIT
/ 8 * 2);
2627 paddr (CORE_ADDR addr
)
2629 return phex (addr
, TARGET_ADDR_BIT
/ 8);
2633 paddr_nz (CORE_ADDR addr
)
2635 return phex_nz (addr
, TARGET_ADDR_BIT
/ 8);
2639 decimal2str (char *paddr_str
, char *sign
, ULONGEST addr
, int width
)
2641 /* steal code from valprint.c:print_decimal(). Should this worry
2642 about the real size of addr as the above does? */
2643 unsigned long temp
[3];
2647 temp
[i
] = addr
% (1000 * 1000 * 1000);
2648 addr
/= (1000 * 1000 * 1000);
2652 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2659 sprintf (paddr_str
, "%s%0*lu", sign
, width
, temp
[0]);
2662 sprintf (paddr_str
, "%s%0*lu%09lu", sign
, width
, temp
[1], temp
[0]);
2665 sprintf (paddr_str
, "%s%0*lu%09lu%09lu", sign
, width
,
2666 temp
[2], temp
[1], temp
[0]);
2669 internal_error (__FILE__
, __LINE__
,
2670 "failed internal consistency check");
2675 octal2str (char *paddr_str
, ULONGEST addr
, int width
)
2677 unsigned long temp
[3];
2681 temp
[i
] = addr
% (0100000 * 0100000);
2682 addr
/= (0100000 * 0100000);
2686 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2694 sprintf (paddr_str
, "%*o", width
, 0);
2696 sprintf (paddr_str
, "0%0*lo", width
, temp
[0]);
2699 sprintf (paddr_str
, "0%0*lo%010lo", width
, temp
[1], temp
[0]);
2702 sprintf (paddr_str
, "0%0*lo%010lo%010lo", width
,
2703 temp
[2], temp
[1], temp
[0]);
2706 internal_error (__FILE__
, __LINE__
,
2707 "failed internal consistency check");
2712 paddr_u (CORE_ADDR addr
)
2714 char *paddr_str
= get_cell ();
2715 decimal2str (paddr_str
, "", addr
, 0);
2720 paddr_d (LONGEST addr
)
2722 char *paddr_str
= get_cell ();
2724 decimal2str (paddr_str
, "-", -addr
, 0);
2726 decimal2str (paddr_str
, "", addr
, 0);
2730 /* eliminate warning from compiler on 32-bit systems */
2731 static int thirty_two
= 32;
2734 phex (ULONGEST l
, int sizeof_l
)
2741 sprintf (str
, "%08lx%08lx",
2742 (unsigned long) (l
>> thirty_two
),
2743 (unsigned long) (l
& 0xffffffff));
2747 sprintf (str
, "%08lx", (unsigned long) l
);
2751 sprintf (str
, "%04x", (unsigned short) (l
& 0xffff));
2754 str
= phex (l
, sizeof (l
));
2761 phex_nz (ULONGEST l
, int sizeof_l
)
2768 unsigned long high
= (unsigned long) (l
>> thirty_two
);
2771 sprintf (str
, "%lx", (unsigned long) (l
& 0xffffffff));
2773 sprintf (str
, "%lx%08lx", high
, (unsigned long) (l
& 0xffffffff));
2778 sprintf (str
, "%lx", (unsigned long) l
);
2782 sprintf (str
, "%x", (unsigned short) (l
& 0xffff));
2785 str
= phex_nz (l
, sizeof (l
));
2791 /* Converts a LONGEST to a C-format hexadecimal literal and stores it
2792 in a static string. Returns a pointer to this string. */
2794 hex_string (LONGEST num
)
2796 char *result
= get_cell ();
2797 snprintf (result
, CELLSIZE
, "0x%s", phex_nz (num
, sizeof (num
)));
2801 /* Converts a LONGEST number to a C-format hexadecimal literal and
2802 stores it in a static string. Returns a pointer to this string
2803 that is valid until the next call. The number is padded on the
2804 left with 0s to at least WIDTH characters. */
2806 hex_string_custom (LONGEST num
, int width
)
2808 char *result
= get_cell ();
2809 char *result_end
= result
+ CELLSIZE
- 1;
2810 const char *hex
= phex_nz (num
, sizeof (num
));
2811 int hex_len
= strlen (hex
);
2813 if (hex_len
> width
)
2815 if (width
+ 2 >= CELLSIZE
)
2816 internal_error (__FILE__
, __LINE__
,
2817 "hex_string_custom: insufficient space to store result");
2819 strcpy (result_end
- width
- 2, "0x");
2820 memset (result_end
- width
, '0', width
);
2821 strcpy (result_end
- hex_len
, hex
);
2822 return result_end
- width
- 2;
2825 /* Convert VAL to a numeral in the given radix. For
2826 * radix 10, IS_SIGNED may be true, indicating a signed quantity;
2827 * otherwise VAL is interpreted as unsigned. If WIDTH is supplied,
2828 * it is the minimum width (0-padded if needed). USE_C_FORMAT means
2829 * to use C format in all cases. If it is false, then 'x'
2830 * and 'o' formats do not include a prefix (0x or leading 0). */
2833 int_string (LONGEST val
, int radix
, int is_signed
, int width
,
2842 result
= hex_string (val
);
2844 result
= hex_string_custom (val
, width
);
2851 char *result
= get_cell ();
2852 if (is_signed
&& val
< 0)
2853 decimal2str (result
, "-", -val
, width
);
2855 decimal2str (result
, "", val
, width
);
2860 char *result
= get_cell ();
2861 octal2str (result
, val
, width
);
2862 if (use_c_format
|| val
== 0)
2868 internal_error (__FILE__
, __LINE__
,
2869 "failed internal consistency check");
2873 /* Convert a CORE_ADDR into a string. */
2875 core_addr_to_string (const CORE_ADDR addr
)
2877 char *str
= get_cell ();
2879 strcat (str
, phex (addr
, sizeof (addr
)));
2884 core_addr_to_string_nz (const CORE_ADDR addr
)
2886 char *str
= get_cell ();
2888 strcat (str
, phex_nz (addr
, sizeof (addr
)));
2892 /* Convert a string back into a CORE_ADDR. */
2894 string_to_core_addr (const char *my_string
)
2897 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2899 /* Assume that it is in decimal. */
2901 for (i
= 2; my_string
[i
] != '\0'; i
++)
2903 if (isdigit (my_string
[i
]))
2904 addr
= (my_string
[i
] - '0') + (addr
* 16);
2905 else if (isxdigit (my_string
[i
]))
2906 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2908 internal_error (__FILE__
, __LINE__
, "invalid hex");
2913 /* Assume that it is in decimal. */
2915 for (i
= 0; my_string
[i
] != '\0'; i
++)
2917 if (isdigit (my_string
[i
]))
2918 addr
= (my_string
[i
] - '0') + (addr
* 10);
2920 internal_error (__FILE__
, __LINE__
, "invalid decimal");
2927 gdb_realpath (const char *filename
)
2929 /* Method 1: The system has a compile time upper bound on a filename
2930 path. Use that and realpath() to canonicalize the name. This is
2931 the most common case. Note that, if there isn't a compile time
2932 upper bound, you want to avoid realpath() at all costs. */
2933 #if defined(HAVE_REALPATH)
2935 # if defined (PATH_MAX)
2937 # define USE_REALPATH
2938 # elif defined (MAXPATHLEN)
2939 char buf
[MAXPATHLEN
];
2940 # define USE_REALPATH
2942 # if defined (USE_REALPATH)
2943 const char *rp
= realpath (filename
, buf
);
2946 return xstrdup (rp
);
2949 #endif /* HAVE_REALPATH */
2951 /* Method 2: The host system (i.e., GNU) has the function
2952 canonicalize_file_name() which malloc's a chunk of memory and
2953 returns that, use that. */
2954 #if defined(HAVE_CANONICALIZE_FILE_NAME)
2956 char *rp
= canonicalize_file_name (filename
);
2958 return xstrdup (filename
);
2964 /* FIXME: cagney/2002-11-13:
2966 Method 2a: Use realpath() with a NULL buffer. Some systems, due
2967 to the problems described in in method 3, have modified their
2968 realpath() implementation so that it will allocate a buffer when
2969 NULL is passed in. Before this can be used, though, some sort of
2970 configure time test would need to be added. Otherwize the code
2971 will likely core dump. */
2973 /* Method 3: Now we're getting desperate! The system doesn't have a
2974 compile time buffer size and no alternative function. Query the
2975 OS, using pathconf(), for the buffer limit. Care is needed
2976 though, some systems do not limit PATH_MAX (return -1 for
2977 pathconf()) making it impossible to pass a correctly sized buffer
2978 to realpath() (it could always overflow). On those systems, we
2980 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
2982 /* Find out the max path size. */
2983 long path_max
= pathconf ("/", _PC_PATH_MAX
);
2986 /* PATH_MAX is bounded. */
2987 char *buf
= alloca (path_max
);
2988 char *rp
= realpath (filename
, buf
);
2989 return xstrdup (rp
? rp
: filename
);
2994 /* This system is a lost cause, just dup the buffer. */
2995 return xstrdup (filename
);
2998 /* Return a copy of FILENAME, with its directory prefix canonicalized
3002 xfullpath (const char *filename
)
3004 const char *base_name
= lbasename (filename
);
3009 /* Extract the basename of filename, and return immediately
3010 a copy of filename if it does not contain any directory prefix. */
3011 if (base_name
== filename
)
3012 return xstrdup (filename
);
3014 dir_name
= alloca ((size_t) (base_name
- filename
+ 2));
3015 /* Allocate enough space to store the dir_name + plus one extra
3016 character sometimes needed under Windows (see below), and
3017 then the closing \000 character */
3018 strncpy (dir_name
, filename
, base_name
- filename
);
3019 dir_name
[base_name
- filename
] = '\000';
3021 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3022 /* We need to be careful when filename is of the form 'd:foo', which
3023 is equivalent of d:./foo, which is totally different from d:/foo. */
3024 if (strlen (dir_name
) == 2 && isalpha (dir_name
[0]) && dir_name
[1] == ':')
3027 dir_name
[3] = '\000';
3031 /* Canonicalize the directory prefix, and build the resulting
3032 filename. If the dirname realpath already contains an ending
3033 directory separator, avoid doubling it. */
3034 real_path
= gdb_realpath (dir_name
);
3035 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
3036 result
= concat (real_path
, base_name
, NULL
);
3038 result
= concat (real_path
, SLASH_STRING
, base_name
, NULL
);
3045 /* This is the 32-bit CRC function used by the GNU separate debug
3046 facility. An executable may contain a section named
3047 .gnu_debuglink, which holds the name of a separate executable file
3048 containing its debug info, and a checksum of that file's contents,
3049 computed using this function. */
3051 gnu_debuglink_crc32 (unsigned long crc
, unsigned char *buf
, size_t len
)
3053 static const unsigned long crc32_table
[256] = {
3054 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
3055 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
3056 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
3057 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
3058 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
3059 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
3060 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
3061 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
3062 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
3063 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
3064 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
3065 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
3066 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
3067 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
3068 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
3069 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
3070 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
3071 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
3072 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
3073 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
3074 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
3075 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
3076 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
3077 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
3078 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
3079 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
3080 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
3081 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
3082 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
3083 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
3084 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
3085 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
3086 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
3087 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
3088 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
3089 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
3090 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
3091 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
3092 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
3093 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
3094 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
3095 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
3096 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
3097 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
3098 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
3099 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
3100 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
3101 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
3102 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
3103 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
3104 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
3109 crc
= ~crc
& 0xffffffff;
3110 for (end
= buf
+ len
; buf
< end
; ++buf
)
3111 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
3112 return ~crc
& 0xffffffff;;
3116 align_up (ULONGEST v
, int n
)
3118 /* Check that N is really a power of two. */
3119 gdb_assert (n
&& (n
& (n
-1)) == 0);
3120 return (v
+ n
- 1) & -n
;
3124 align_down (ULONGEST v
, int n
)
3126 /* Check that N is really a power of two. */
3127 gdb_assert (n
&& (n
& (n
-1)) == 0);