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"
29 #include "exceptions.h"
32 #include "tui/tui.h" /* For tui_get_command_dimension. */
39 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
50 #include "expression.h"
54 #include "filenames.h"
57 #include "inferior.h" /* for signed_pointer_to_address */
59 #include <sys/param.h> /* For MAXPATHLEN */
61 #include "gdb_curses.h"
63 #include "readline/readline.h"
65 #ifdef NEED_DECLARATION_MALLOC
66 extern PTR
malloc (); /* OK: PTR */
68 #ifdef NEED_DECLARATION_REALLOC
69 extern PTR
realloc (); /* OK: PTR */
71 #ifdef NEED_DECLARATION_FREE
74 /* Actually, we'll never have the decl, since we don't define _GNU_SOURCE. */
75 #if defined(HAVE_CANONICALIZE_FILE_NAME) \
76 && defined(NEED_DECLARATION_CANONICALIZE_FILE_NAME)
77 extern char *canonicalize_file_name (const char *);
80 /* readline defines this. */
83 void (*deprecated_error_begin_hook
) (void);
85 /* Holds the last error message issued by gdb */
87 static struct ui_file
*gdb_lasterr
;
89 /* Prototypes for local functions */
91 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
94 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
96 static void do_my_cleanups (struct cleanup
**, struct cleanup
*);
98 static void prompt_for_continue (void);
100 static void set_screen_size (void);
101 static void set_width (void);
103 static NORETURN
void error_stream_1 (struct ui_file
*stream
,
104 enum return_reason reason
) ATTR_NORETURN
;
106 /* Chain of cleanup actions established with make_cleanup,
107 to be executed if an error happens. */
109 static struct cleanup
*cleanup_chain
; /* cleaned up after a failed command */
110 static struct cleanup
*final_cleanup_chain
; /* cleaned up when gdb exits */
111 static struct cleanup
*run_cleanup_chain
; /* cleaned up on each 'run' */
112 static struct cleanup
*exec_cleanup_chain
; /* cleaned up on each execution command */
113 /* cleaned up on each error from within an execution command */
114 static struct cleanup
*exec_error_cleanup_chain
;
116 /* Pointer to what is left to do for an execution command after the
117 target stops. Used only in asynchronous mode, by targets that
118 support async execution. The finish and until commands use it. So
119 does the target extended-remote command. */
120 struct continuation
*cmd_continuation
;
121 struct continuation
*intermediate_continuation
;
123 /* Nonzero if we have job control. */
127 /* Nonzero means a quit has been requested. */
131 /* Nonzero means quit immediately if Control-C is typed now, rather
132 than waiting until QUIT is executed. Be careful in setting this;
133 code which executes with immediate_quit set has to be very careful
134 about being able to deal with being interrupted at any time. It is
135 almost always better to use QUIT; the only exception I can think of
136 is being able to quit out of a system call (using EINTR loses if
137 the SIGINT happens between the previous QUIT and the system call).
138 To immediately quit in the case in which a SIGINT happens between
139 the previous QUIT and setting immediate_quit (desirable anytime we
140 expect to block), call QUIT after setting immediate_quit. */
144 /* Nonzero means that encoded C++/ObjC names should be printed out in their
145 C++/ObjC form rather than raw. */
149 /* Nonzero means that encoded C++/ObjC names should be printed out in their
150 C++/ObjC form even in assembler language displays. If this is set, but
151 DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
153 int asm_demangle
= 0;
155 /* Nonzero means that strings with character values >0x7F should be printed
156 as octal escapes. Zero means just print the value (e.g. it's an
157 international character, and the terminal or window can cope.) */
159 int sevenbit_strings
= 0;
161 /* String to be printed before error messages, if any. */
163 char *error_pre_print
;
165 /* String to be printed before quit messages, if any. */
167 char *quit_pre_print
;
169 /* String to be printed before warning messages, if any. */
171 char *warning_pre_print
= "\nwarning: ";
173 int pagination_enabled
= 1;
176 /* Add a new cleanup to the cleanup_chain,
177 and return the previous chain pointer
178 to be passed later to do_cleanups or discard_cleanups.
179 Args are FUNCTION to clean up with, and ARG to pass to it. */
182 make_cleanup (make_cleanup_ftype
*function
, void *arg
)
184 return make_my_cleanup (&cleanup_chain
, function
, arg
);
188 make_final_cleanup (make_cleanup_ftype
*function
, void *arg
)
190 return make_my_cleanup (&final_cleanup_chain
, function
, arg
);
194 make_run_cleanup (make_cleanup_ftype
*function
, void *arg
)
196 return make_my_cleanup (&run_cleanup_chain
, function
, arg
);
200 make_exec_cleanup (make_cleanup_ftype
*function
, void *arg
)
202 return make_my_cleanup (&exec_cleanup_chain
, function
, arg
);
206 make_exec_error_cleanup (make_cleanup_ftype
*function
, void *arg
)
208 return make_my_cleanup (&exec_error_cleanup_chain
, function
, arg
);
212 do_freeargv (void *arg
)
214 freeargv ((char **) arg
);
218 make_cleanup_freeargv (char **arg
)
220 return make_my_cleanup (&cleanup_chain
, do_freeargv
, arg
);
224 do_bfd_close_cleanup (void *arg
)
230 make_cleanup_bfd_close (bfd
*abfd
)
232 return make_cleanup (do_bfd_close_cleanup
, abfd
);
236 do_close_cleanup (void *arg
)
244 make_cleanup_close (int fd
)
246 int *saved_fd
= xmalloc (sizeof (fd
));
248 return make_cleanup (do_close_cleanup
, saved_fd
);
252 do_ui_file_delete (void *arg
)
254 ui_file_delete (arg
);
258 make_cleanup_ui_file_delete (struct ui_file
*arg
)
260 return make_my_cleanup (&cleanup_chain
, do_ui_file_delete
, arg
);
264 do_free_section_addr_info (void *arg
)
266 free_section_addr_info (arg
);
270 make_cleanup_free_section_addr_info (struct section_addr_info
*addrs
)
272 return make_my_cleanup (&cleanup_chain
, do_free_section_addr_info
, addrs
);
277 make_my_cleanup (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
281 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
282 struct cleanup
*old_chain
= *pmy_chain
;
284 new->next
= *pmy_chain
;
285 new->function
= function
;
292 /* Discard cleanups and do the actions they describe
293 until we get back to the point OLD_CHAIN in the cleanup_chain. */
296 do_cleanups (struct cleanup
*old_chain
)
298 do_my_cleanups (&cleanup_chain
, old_chain
);
302 do_final_cleanups (struct cleanup
*old_chain
)
304 do_my_cleanups (&final_cleanup_chain
, old_chain
);
308 do_run_cleanups (struct cleanup
*old_chain
)
310 do_my_cleanups (&run_cleanup_chain
, old_chain
);
314 do_exec_cleanups (struct cleanup
*old_chain
)
316 do_my_cleanups (&exec_cleanup_chain
, old_chain
);
320 do_exec_error_cleanups (struct cleanup
*old_chain
)
322 do_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
326 do_my_cleanups (struct cleanup
**pmy_chain
,
327 struct cleanup
*old_chain
)
330 while ((ptr
= *pmy_chain
) != old_chain
)
332 *pmy_chain
= ptr
->next
; /* Do this first incase recursion */
333 (*ptr
->function
) (ptr
->arg
);
338 /* Discard cleanups, not doing the actions they describe,
339 until we get back to the point OLD_CHAIN in the cleanup_chain. */
342 discard_cleanups (struct cleanup
*old_chain
)
344 discard_my_cleanups (&cleanup_chain
, old_chain
);
348 discard_final_cleanups (struct cleanup
*old_chain
)
350 discard_my_cleanups (&final_cleanup_chain
, old_chain
);
354 discard_exec_error_cleanups (struct cleanup
*old_chain
)
356 discard_my_cleanups (&exec_error_cleanup_chain
, old_chain
);
360 discard_my_cleanups (struct cleanup
**pmy_chain
,
361 struct cleanup
*old_chain
)
364 while ((ptr
= *pmy_chain
) != old_chain
)
366 *pmy_chain
= ptr
->next
;
371 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
375 return save_my_cleanups (&cleanup_chain
);
379 save_final_cleanups (void)
381 return save_my_cleanups (&final_cleanup_chain
);
385 save_my_cleanups (struct cleanup
**pmy_chain
)
387 struct cleanup
*old_chain
= *pmy_chain
;
393 /* Restore the cleanup chain from a previously saved chain. */
395 restore_cleanups (struct cleanup
*chain
)
397 restore_my_cleanups (&cleanup_chain
, chain
);
401 restore_final_cleanups (struct cleanup
*chain
)
403 restore_my_cleanups (&final_cleanup_chain
, chain
);
407 restore_my_cleanups (struct cleanup
**pmy_chain
, struct cleanup
*chain
)
412 /* This function is useful for cleanups.
416 old_chain = make_cleanup (free_current_contents, &foo);
418 to arrange to free the object thus allocated. */
421 free_current_contents (void *ptr
)
423 void **location
= ptr
;
424 if (location
== NULL
)
425 internal_error (__FILE__
, __LINE__
,
426 "free_current_contents: NULL pointer");
427 if (*location
!= NULL
)
434 /* Provide a known function that does nothing, to use as a base for
435 for a possibly long chain of cleanups. This is useful where we
436 use the cleanup chain for handling normal cleanups as well as dealing
437 with cleanups that need to be done as a result of a call to error().
438 In such cases, we may not be certain where the first cleanup is, unless
439 we have a do-nothing one to always use as the base. */
442 null_cleanup (void *arg
)
446 /* Add a continuation to the continuation list, the global list
447 cmd_continuation. The new continuation will be added at the front.*/
449 add_continuation (void (*continuation_hook
) (struct continuation_arg
*),
450 struct continuation_arg
*arg_list
)
452 struct continuation
*continuation_ptr
;
455 (struct continuation
*) xmalloc (sizeof (struct continuation
));
456 continuation_ptr
->continuation_hook
= continuation_hook
;
457 continuation_ptr
->arg_list
= arg_list
;
458 continuation_ptr
->next
= cmd_continuation
;
459 cmd_continuation
= continuation_ptr
;
462 /* Walk down the cmd_continuation list, and execute all the
463 continuations. There is a problem though. In some cases new
464 continuations may be added while we are in the middle of this
465 loop. If this happens they will be added in the front, and done
466 before we have a chance of exhausting those that were already
467 there. We need to then save the beginning of the list in a pointer
468 and do the continuations from there on, instead of using the
469 global beginning of list as our iteration pointer.*/
471 do_all_continuations (void)
473 struct continuation
*continuation_ptr
;
474 struct continuation
*saved_continuation
;
476 /* Copy the list header into another pointer, and set the global
477 list header to null, so that the global list can change as a side
478 effect of invoking the continuations and the processing of
479 the preexisting continuations will not be affected. */
480 continuation_ptr
= cmd_continuation
;
481 cmd_continuation
= NULL
;
483 /* Work now on the list we have set aside. */
484 while (continuation_ptr
)
486 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
487 saved_continuation
= continuation_ptr
;
488 continuation_ptr
= continuation_ptr
->next
;
489 xfree (saved_continuation
);
493 /* Walk down the cmd_continuation list, and get rid of all the
496 discard_all_continuations (void)
498 struct continuation
*continuation_ptr
;
500 while (cmd_continuation
)
502 continuation_ptr
= cmd_continuation
;
503 cmd_continuation
= continuation_ptr
->next
;
504 xfree (continuation_ptr
);
508 /* Add a continuation to the continuation list, the global list
509 intermediate_continuation. The new continuation will be added at the front.*/
511 add_intermediate_continuation (void (*continuation_hook
)
512 (struct continuation_arg
*),
513 struct continuation_arg
*arg_list
)
515 struct continuation
*continuation_ptr
;
518 (struct continuation
*) xmalloc (sizeof (struct continuation
));
519 continuation_ptr
->continuation_hook
= continuation_hook
;
520 continuation_ptr
->arg_list
= arg_list
;
521 continuation_ptr
->next
= intermediate_continuation
;
522 intermediate_continuation
= continuation_ptr
;
525 /* Walk down the cmd_continuation list, and execute all the
526 continuations. There is a problem though. In some cases new
527 continuations may be added while we are in the middle of this
528 loop. If this happens they will be added in the front, and done
529 before we have a chance of exhausting those that were already
530 there. We need to then save the beginning of the list in a pointer
531 and do the continuations from there on, instead of using the
532 global beginning of list as our iteration pointer.*/
534 do_all_intermediate_continuations (void)
536 struct continuation
*continuation_ptr
;
537 struct continuation
*saved_continuation
;
539 /* Copy the list header into another pointer, and set the global
540 list header to null, so that the global list can change as a side
541 effect of invoking the continuations and the processing of
542 the preexisting continuations will not be affected. */
543 continuation_ptr
= intermediate_continuation
;
544 intermediate_continuation
= NULL
;
546 /* Work now on the list we have set aside. */
547 while (continuation_ptr
)
549 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
);
550 saved_continuation
= continuation_ptr
;
551 continuation_ptr
= continuation_ptr
->next
;
552 xfree (saved_continuation
);
556 /* Walk down the cmd_continuation list, and get rid of all the
559 discard_all_intermediate_continuations (void)
561 struct continuation
*continuation_ptr
;
563 while (intermediate_continuation
)
565 continuation_ptr
= intermediate_continuation
;
566 intermediate_continuation
= continuation_ptr
->next
;
567 xfree (continuation_ptr
);
573 /* Print a warning message. The first argument STRING is the warning
574 message, used as an fprintf format string, the second is the
575 va_list of arguments for that string. A warning is unfiltered (not
576 paginated) so that the user does not need to page through each
577 screen full of warnings when there are lots of them. */
580 vwarning (const char *string
, va_list args
)
582 if (deprecated_warning_hook
)
583 (*deprecated_warning_hook
) (string
, args
);
586 target_terminal_ours ();
587 wrap_here (""); /* Force out any buffered output */
588 gdb_flush (gdb_stdout
);
589 if (warning_pre_print
)
590 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
591 vfprintf_unfiltered (gdb_stderr
, string
, args
);
592 fprintf_unfiltered (gdb_stderr
, "\n");
597 /* Print a warning message.
598 The first argument STRING is the warning message, used as a fprintf string,
599 and the remaining args are passed as arguments to it.
600 The primary difference between warnings and errors is that a warning
601 does not force the return to command level. */
604 warning (const char *string
, ...)
607 va_start (args
, string
);
608 vwarning (string
, args
);
612 /* Print an error message and return to command level.
613 The first argument STRING is the error message, used as a fprintf string,
614 and the remaining args are passed as arguments to it. */
617 verror (const char *string
, va_list args
)
619 struct ui_file
*tmp_stream
= mem_fileopen ();
620 make_cleanup_ui_file_delete (tmp_stream
);
621 vfprintf_unfiltered (tmp_stream
, string
, args
);
622 error_stream_1 (tmp_stream
, RETURN_ERROR
);
626 error (const char *string
, ...)
629 va_start (args
, string
);
630 verror (string
, args
);
634 /* Print an error message and quit.
635 The first argument STRING is the error message, used as a fprintf string,
636 and the remaining args are passed as arguments to it. */
639 vfatal (const char *string
, va_list args
)
641 struct ui_file
*tmp_stream
= mem_fileopen ();
642 make_cleanup_ui_file_delete (tmp_stream
);
643 vfprintf_unfiltered (tmp_stream
, string
, args
);
644 error_stream_1 (tmp_stream
, RETURN_QUIT
);
648 fatal (const char *string
, ...)
651 va_start (args
, string
);
652 vfatal (string
, args
);
657 do_write (void *data
, const char *buffer
, long length_buffer
)
659 ui_file_write (data
, buffer
, length_buffer
);
662 /* Cause a silent error to occur. Any error message is recorded
663 though it is not issued. */
665 error_silent (const char *string
, ...)
668 struct ui_file
*tmp_stream
= mem_fileopen ();
669 va_start (args
, string
);
670 make_cleanup_ui_file_delete (tmp_stream
);
671 vfprintf_unfiltered (tmp_stream
, string
, args
);
672 /* Copy the stream into the GDB_LASTERR buffer. */
673 ui_file_rewind (gdb_lasterr
);
674 ui_file_put (tmp_stream
, do_write
, gdb_lasterr
);
677 throw_exception (RETURN_ERROR
);
680 /* Output an error message including any pre-print text to gdb_stderr. */
682 error_output_message (char *pre_print
, char *msg
)
684 target_terminal_ours ();
685 wrap_here (""); /* Force out any buffered output */
686 gdb_flush (gdb_stdout
);
687 annotate_error_begin ();
689 fputs_filtered (pre_print
, gdb_stderr
);
690 fputs_filtered (msg
, gdb_stderr
);
691 fprintf_filtered (gdb_stderr
, "\n");
695 error_stream_1 (struct ui_file
*stream
, enum return_reason reason
)
697 if (deprecated_error_begin_hook
)
698 deprecated_error_begin_hook ();
700 /* Copy the stream into the GDB_LASTERR buffer. */
701 ui_file_rewind (gdb_lasterr
);
702 ui_file_put (stream
, do_write
, gdb_lasterr
);
704 /* Write the message plus any error_pre_print to gdb_stderr. */
705 target_terminal_ours ();
706 wrap_here (""); /* Force out any buffered output */
707 gdb_flush (gdb_stdout
);
708 annotate_error_begin ();
710 fputs_filtered (error_pre_print
, gdb_stderr
);
711 ui_file_put (stream
, do_write
, gdb_stderr
);
712 fprintf_filtered (gdb_stderr
, "\n");
714 throw_exception (reason
);
718 error_stream (struct ui_file
*stream
)
720 error_stream_1 (stream
, RETURN_ERROR
);
723 /* Get the last error message issued by gdb */
726 error_last_message (void)
729 return ui_file_xstrdup (gdb_lasterr
, &len
);
732 /* This is to be called by main() at the very beginning */
737 gdb_lasterr
= mem_fileopen ();
740 /* Print a message reporting an internal error/warning. Ask the user
741 if they want to continue, dump core, or just exit. Return
742 something to indicate a quit. */
744 struct internal_problem
747 /* FIXME: cagney/2002-08-15: There should be ``maint set/show''
748 commands available for controlling these variables. */
749 enum auto_boolean should_quit
;
750 enum auto_boolean should_dump_core
;
753 /* Report a problem, internal to GDB, to the user. Once the problem
754 has been reported, and assuming GDB didn't quit, the caller can
755 either allow execution to resume or throw an error. */
758 internal_vproblem (struct internal_problem
*problem
,
759 const char *file
, int line
, const char *fmt
, va_list ap
)
766 /* Don't allow infinite error/warning recursion. */
768 static char msg
[] = "Recursive internal problem.\n";
776 fputs_unfiltered (msg
, gdb_stderr
);
777 abort (); /* NOTE: GDB has only three calls to abort(). */
780 write (STDERR_FILENO
, msg
, sizeof (msg
));
785 /* Try to get the message out and at the start of a new line. */
786 target_terminal_ours ();
789 /* Create a string containing the full error/warning message. Need
790 to call query with this full string, as otherwize the reason
791 (error/warning) and question become separated. Format using a
792 style similar to a compiler error message. Include extra detail
793 so that the user knows that they are living on the edge. */
796 msg
= xstrvprintf (fmt
, ap
);
797 reason
= xstrprintf ("\
799 A problem internal to GDB has been detected,\n\
800 further debugging may prove unreliable.", file
, line
, problem
->name
, msg
);
802 make_cleanup (xfree
, reason
);
805 switch (problem
->should_quit
)
807 case AUTO_BOOLEAN_AUTO
:
808 /* Default (yes/batch case) is to quit GDB. When in batch mode
809 this lessens the likelhood of GDB going into an infinate
811 quit_p
= query ("%s\nQuit this debugging session? ", reason
);
813 case AUTO_BOOLEAN_TRUE
:
816 case AUTO_BOOLEAN_FALSE
:
820 internal_error (__FILE__
, __LINE__
, "bad switch");
823 switch (problem
->should_dump_core
)
825 case AUTO_BOOLEAN_AUTO
:
826 /* Default (yes/batch case) is to dump core. This leaves a GDB
827 `dropping' so that it is easier to see that something went
829 dump_core_p
= query ("%s\nCreate a core file of GDB? ", reason
);
832 case AUTO_BOOLEAN_TRUE
:
835 case AUTO_BOOLEAN_FALSE
:
839 internal_error (__FILE__
, __LINE__
, "bad switch");
845 abort (); /* NOTE: GDB has only three calls to abort(). */
854 abort (); /* NOTE: GDB has only three calls to abort(). */
861 static struct internal_problem internal_error_problem
= {
862 "internal-error", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
866 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
868 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
869 throw_exception (RETURN_ERROR
);
873 internal_error (const char *file
, int line
, const char *string
, ...)
876 va_start (ap
, string
);
877 internal_verror (file
, line
, string
, ap
);
881 static struct internal_problem internal_warning_problem
= {
882 "internal-warning", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
886 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
888 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
892 internal_warning (const char *file
, int line
, const char *string
, ...)
895 va_start (ap
, string
);
896 internal_vwarning (file
, line
, string
, ap
);
900 /* The strerror() function can return NULL for errno values that are
901 out of range. Provide a "safe" version that always returns a
905 safe_strerror (int errnum
)
910 msg
= strerror (errnum
);
913 sprintf (buf
, "(undocumented errno %d)", errnum
);
919 /* Print the system error message for errno, and also mention STRING
920 as the file name for which the error was encountered.
921 Then return to command level. */
924 perror_with_name (const char *string
)
929 err
= safe_strerror (errno
);
930 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
931 strcpy (combined
, string
);
932 strcat (combined
, ": ");
933 strcat (combined
, err
);
935 /* I understand setting these is a matter of taste. Still, some people
936 may clear errno but not know about bfd_error. Doing this here is not
938 bfd_set_error (bfd_error_no_error
);
941 error ("%s.", combined
);
944 /* Print the system error message for ERRCODE, and also mention STRING
945 as the file name for which the error was encountered. */
948 print_sys_errmsg (const char *string
, int errcode
)
953 err
= safe_strerror (errcode
);
954 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
955 strcpy (combined
, string
);
956 strcat (combined
, ": ");
957 strcat (combined
, err
);
959 /* We want anything which was printed on stdout to come out first, before
961 gdb_flush (gdb_stdout
);
962 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
965 /* Control C eventually causes this to be called, at a convenient time. */
970 struct serial
*gdb_stdout_serial
= serial_fdopen (1);
972 target_terminal_ours ();
974 /* We want all output to appear now, before we print "Quit". We
975 have 3 levels of buffering we have to flush (it's possible that
976 some of these should be changed to flush the lower-level ones
979 /* 1. The _filtered buffer. */
980 wrap_here ((char *) 0);
982 /* 2. The stdio buffer. */
983 gdb_flush (gdb_stdout
);
984 gdb_flush (gdb_stderr
);
986 /* 3. The system-level buffer. */
987 serial_drain_output (gdb_stdout_serial
);
988 serial_un_fdopen (gdb_stdout_serial
);
990 annotate_error_begin ();
992 /* Don't use *_filtered; we don't want to prompt the user to continue. */
994 fputs_unfiltered (quit_pre_print
, gdb_stderr
);
997 /* No steenking SIGINT will ever be coming our way when the
998 program is resumed. Don't lie. */
999 fprintf_unfiltered (gdb_stderr
, "Quit\n");
1002 /* If there is no terminal switching for this target, then we can't
1003 possibly get screwed by the lack of job control. */
1004 || current_target
.to_terminal_ours
== NULL
)
1005 fprintf_unfiltered (gdb_stderr
, "Quit\n");
1007 fprintf_unfiltered (gdb_stderr
,
1008 "Quit (expect signal SIGINT when the program is resumed)\n");
1010 throw_exception (RETURN_QUIT
);
1013 /* Control C comes here */
1015 request_quit (int signo
)
1018 /* Restore the signal handler. Harmless with BSD-style signals,
1019 needed for System V-style signals. */
1020 signal (signo
, request_quit
);
1026 /* Called when a memory allocation fails, with the number of bytes of
1027 memory requested in SIZE. */
1034 internal_error (__FILE__
, __LINE__
,
1035 "virtual memory exhausted: can't allocate %ld bytes.",
1040 internal_error (__FILE__
, __LINE__
, "virtual memory exhausted.");
1044 /* The xmalloc() (libiberty.h) family of memory management routines.
1046 These are like the ISO-C malloc() family except that they implement
1047 consistent semantics and guard against typical memory management
1050 /* NOTE: These are declared using PTR to ensure consistency with
1051 "libiberty.h". xfree() is GDB local. */
1054 xmalloc (size_t size
)
1058 /* See libiberty/xmalloc.c. This function need's to match that's
1059 semantics. It never returns NULL. */
1063 val
= malloc (size
); /* OK: malloc */
1071 xrealloc (PTR ptr
, size_t size
) /* OK: PTR */
1075 /* See libiberty/xmalloc.c. This function need's to match that's
1076 semantics. It never returns NULL. */
1081 val
= realloc (ptr
, size
); /* OK: realloc */
1083 val
= malloc (size
); /* OK: malloc */
1091 xcalloc (size_t number
, size_t size
)
1095 /* See libiberty/xmalloc.c. This function need's to match that's
1096 semantics. It never returns NULL. */
1097 if (number
== 0 || size
== 0)
1103 mem
= calloc (number
, size
); /* OK: xcalloc */
1105 nomem (number
* size
);
1114 free (ptr
); /* OK: free */
1118 /* Like asprintf/vasprintf but get an internal_error if the call
1122 xstrprintf (const char *format
, ...)
1126 va_start (args
, format
);
1127 ret
= xstrvprintf (format
, args
);
1133 xasprintf (char **ret
, const char *format
, ...)
1136 va_start (args
, format
);
1137 (*ret
) = xstrvprintf (format
, args
);
1142 xvasprintf (char **ret
, const char *format
, va_list ap
)
1144 (*ret
) = xstrvprintf (format
, ap
);
1148 xstrvprintf (const char *format
, va_list ap
)
1151 int status
= vasprintf (&ret
, format
, ap
);
1152 /* NULL is returned when there was a memory allocation problem. */
1155 /* A negative status (the printed length) with a non-NULL buffer
1156 should never happen, but just to be sure. */
1158 internal_error (__FILE__
, __LINE__
,
1159 "vasprintf call failed (errno %d)", errno
);
1163 /* My replacement for the read system call.
1164 Used like `read' but keeps going if `read' returns too soon. */
1167 myread (int desc
, char *addr
, int len
)
1174 val
= read (desc
, addr
, len
);
1178 return orglen
- len
;
1185 /* Make a copy of the string at PTR with SIZE characters
1186 (and add a null character at the end in the copy).
1187 Uses malloc to get the space. Returns the address of the copy. */
1190 savestring (const char *ptr
, size_t size
)
1192 char *p
= (char *) xmalloc (size
+ 1);
1193 memcpy (p
, ptr
, size
);
1199 print_spaces (int n
, struct ui_file
*file
)
1201 fputs_unfiltered (n_spaces (n
), file
);
1204 /* Print a host address. */
1207 gdb_print_host_address (const void *addr
, struct ui_file
*stream
)
1210 /* We could use the %p conversion specifier to fprintf if we had any
1211 way of knowing whether this host supports it. But the following
1212 should work on the Alpha and on 32 bit machines. */
1214 fprintf_filtered (stream
, "0x%lx", (unsigned long) addr
);
1217 /* Ask user a y-or-n question and return 1 iff answer is yes.
1218 Takes three args which are given to printf to print the question.
1219 The first, a control string, should end in "? ".
1220 It should not say how to answer, because we do that. */
1224 query (const char *ctlstr
, ...)
1231 if (deprecated_query_hook
)
1233 va_start (args
, ctlstr
);
1234 return deprecated_query_hook (ctlstr
, args
);
1237 /* Automatically answer "yes" if input is not from a terminal. */
1238 if (!input_from_terminal_p ())
1243 wrap_here (""); /* Flush any buffered output */
1244 gdb_flush (gdb_stdout
);
1246 if (annotation_level
> 1)
1247 printf_filtered ("\n\032\032pre-query\n");
1249 va_start (args
, ctlstr
);
1250 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1252 printf_filtered ("(y or n) ");
1254 if (annotation_level
> 1)
1255 printf_filtered ("\n\032\032query\n");
1258 gdb_flush (gdb_stdout
);
1260 answer
= fgetc (stdin
);
1261 clearerr (stdin
); /* in case of C-d */
1262 if (answer
== EOF
) /* C-d */
1267 /* Eat rest of input line, to EOF or newline */
1271 ans2
= fgetc (stdin
);
1274 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1288 printf_filtered ("Please answer y or n.\n");
1291 if (annotation_level
> 1)
1292 printf_filtered ("\n\032\032post-query\n");
1297 /* This function supports the nquery() and yquery() functions.
1298 Ask user a y-or-n question and return 0 if answer is no, 1 if
1299 answer is yes, or default the answer to the specified default.
1300 DEFCHAR is either 'y' or 'n' and refers to the default answer.
1301 CTLSTR is the control string and should end in "? ". It should
1302 not say how to answer, because we do that.
1303 ARGS are the arguments passed along with the CTLSTR argument to
1307 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
1313 char def_answer
, not_def_answer
;
1314 char *y_string
, *n_string
;
1316 /* Set up according to which answer is the default. */
1321 not_def_answer
= 'N';
1329 not_def_answer
= 'Y';
1334 if (deprecated_query_hook
)
1336 return deprecated_query_hook (ctlstr
, args
);
1339 /* Automatically answer default value if input is not from a terminal. */
1340 if (!input_from_terminal_p ())
1345 wrap_here (""); /* Flush any buffered output */
1346 gdb_flush (gdb_stdout
);
1348 if (annotation_level
> 1)
1349 printf_filtered ("\n\032\032pre-query\n");
1351 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1352 printf_filtered ("(%s or %s) ", y_string
, n_string
);
1354 if (annotation_level
> 1)
1355 printf_filtered ("\n\032\032query\n");
1358 gdb_flush (gdb_stdout
);
1360 answer
= fgetc (stdin
);
1361 clearerr (stdin
); /* in case of C-d */
1362 if (answer
== EOF
) /* C-d */
1367 /* Eat rest of input line, to EOF or newline */
1371 ans2
= fgetc (stdin
);
1374 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1378 /* Check answer. For the non-default, the user must specify
1379 the non-default explicitly. */
1380 if (answer
== not_def_answer
)
1382 retval
= !def_value
;
1385 /* Otherwise, for the default, the user may either specify
1386 the required input or have it default by entering nothing. */
1387 if (answer
== def_answer
|| answer
== '\n' ||
1388 answer
== '\r' || answer
== EOF
)
1393 /* Invalid entries are not defaulted and require another selection. */
1394 printf_filtered ("Please answer %s or %s.\n",
1395 y_string
, n_string
);
1398 if (annotation_level
> 1)
1399 printf_filtered ("\n\032\032post-query\n");
1404 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1405 answer is yes, or 0 if answer is defaulted.
1406 Takes three args which are given to printf to print the question.
1407 The first, a control string, should end in "? ".
1408 It should not say how to answer, because we do that. */
1411 nquery (const char *ctlstr
, ...)
1415 va_start (args
, ctlstr
);
1416 return defaulted_query (ctlstr
, 'n', args
);
1420 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1421 answer is yes, or 1 if answer is defaulted.
1422 Takes three args which are given to printf to print the question.
1423 The first, a control string, should end in "? ".
1424 It should not say how to answer, because we do that. */
1427 yquery (const char *ctlstr
, ...)
1431 va_start (args
, ctlstr
);
1432 return defaulted_query (ctlstr
, 'y', args
);
1436 /* Print an error message saying that we couldn't make sense of a
1437 \^mumble sequence in a string or character constant. START and END
1438 indicate a substring of some larger string that contains the
1439 erroneous backslash sequence, missing the initial backslash. */
1441 no_control_char_error (const char *start
, const char *end
)
1443 int len
= end
- start
;
1444 char *copy
= alloca (end
- start
+ 1);
1446 memcpy (copy
, start
, len
);
1449 error ("There is no control character `\\%s' in the `%s' character set.",
1450 copy
, target_charset ());
1453 /* Parse a C escape sequence. STRING_PTR points to a variable
1454 containing a pointer to the string to parse. That pointer
1455 should point to the character after the \. That pointer
1456 is updated past the characters we use. The value of the
1457 escape sequence is returned.
1459 A negative value means the sequence \ newline was seen,
1460 which is supposed to be equivalent to nothing at all.
1462 If \ is followed by a null character, we return a negative
1463 value and leave the string pointer pointing at the null character.
1465 If \ is followed by 000, we return 0 and leave the string pointer
1466 after the zeros. A value of 0 does not mean end of string. */
1469 parse_escape (char **string_ptr
)
1472 int c
= *(*string_ptr
)++;
1473 if (c_parse_backslash (c
, &target_char
))
1485 /* Remember where this escape sequence started, for reporting
1487 char *sequence_start_pos
= *string_ptr
- 1;
1489 c
= *(*string_ptr
)++;
1493 /* XXXCHARSET: What is `delete' in the host character set? */
1496 if (!host_char_to_target (c
, &target_char
))
1497 error ("There is no character corresponding to `Delete' "
1498 "in the target character set `%s'.", host_charset ());
1503 target_char
= parse_escape (string_ptr
);
1506 if (!host_char_to_target (c
, &target_char
))
1507 no_control_char_error (sequence_start_pos
, *string_ptr
);
1510 /* Now target_char is something like `c', and we want to find
1511 its control-character equivalent. */
1512 if (!target_char_to_control_char (target_char
, &target_char
))
1513 no_control_char_error (sequence_start_pos
, *string_ptr
);
1518 /* XXXCHARSET: we need to use isdigit and value-of-digit
1519 methods of the host character set here. */
1535 if (c
>= '0' && c
<= '7')
1549 if (!host_char_to_target (c
, &target_char
))
1551 ("The escape sequence `\%c' is equivalent to plain `%c', which"
1552 " has no equivalent\n" "in the `%s' character set.", c
, c
,
1558 /* Print the character C on STREAM as part of the contents of a literal
1559 string whose delimiter is QUOTER. Note that this routine should only
1560 be call for printing things which are independent of the language
1561 of the program being debugged. */
1564 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1565 void (*do_fprintf
) (struct ui_file
*, const char *, ...),
1566 struct ui_file
*stream
, int quoter
)
1569 c
&= 0xFF; /* Avoid sign bit follies */
1571 if (c
< 0x20 || /* Low control chars */
1572 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1573 (sevenbit_strings
&& c
>= 0x80))
1574 { /* high order bit set */
1578 do_fputs ("\\n", stream
);
1581 do_fputs ("\\b", stream
);
1584 do_fputs ("\\t", stream
);
1587 do_fputs ("\\f", stream
);
1590 do_fputs ("\\r", stream
);
1593 do_fputs ("\\e", stream
);
1596 do_fputs ("\\a", stream
);
1599 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1605 if (c
== '\\' || c
== quoter
)
1606 do_fputs ("\\", stream
);
1607 do_fprintf (stream
, "%c", c
);
1611 /* Print the character C on STREAM as part of the contents of a
1612 literal string whose delimiter is QUOTER. Note that these routines
1613 should only be call for printing things which are independent of
1614 the language of the program being debugged. */
1617 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1620 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1624 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1627 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1631 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1632 struct ui_file
*stream
)
1635 for (i
= 0; i
< n
; i
++)
1636 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1640 /* Number of lines per page or UINT_MAX if paging is disabled. */
1641 static unsigned int lines_per_page
;
1643 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1644 static unsigned int chars_per_line
;
1646 /* Current count of lines printed on this page, chars on this line. */
1647 static unsigned int lines_printed
, chars_printed
;
1649 /* Buffer and start column of buffered text, for doing smarter word-
1650 wrapping. When someone calls wrap_here(), we start buffering output
1651 that comes through fputs_filtered(). If we see a newline, we just
1652 spit it out and forget about the wrap_here(). If we see another
1653 wrap_here(), we spit it out and remember the newer one. If we see
1654 the end of the line, we spit out a newline, the indent, and then
1655 the buffered output. */
1657 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1658 are waiting to be output (they have already been counted in chars_printed).
1659 When wrap_buffer[0] is null, the buffer is empty. */
1660 static char *wrap_buffer
;
1662 /* Pointer in wrap_buffer to the next character to fill. */
1663 static char *wrap_pointer
;
1665 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1667 static char *wrap_indent
;
1669 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1670 is not in effect. */
1671 static int wrap_column
;
1674 /* Inialize the number of lines per page and chars per line. */
1677 init_page_info (void)
1680 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1685 #if defined(__GO32__)
1686 rows
= ScreenRows ();
1687 cols
= ScreenCols ();
1688 lines_per_page
= rows
;
1689 chars_per_line
= cols
;
1691 /* Make sure Readline has initialized its terminal settings. */
1692 rl_reset_terminal (NULL
);
1694 /* Get the screen size from Readline. */
1695 rl_get_screen_size (&rows
, &cols
);
1696 lines_per_page
= rows
;
1697 chars_per_line
= cols
;
1699 /* Readline should have fetched the termcap entry for us. */
1700 if (tgetnum ("li") < 0 || getenv ("EMACS"))
1702 /* The number of lines per page is not mentioned in the
1703 terminal description. This probably means that paging is
1704 not useful (e.g. emacs shell window), so disable paging. */
1705 lines_per_page
= UINT_MAX
;
1708 /* FIXME: Get rid of this junk. */
1709 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1710 SIGWINCH_HANDLER (SIGWINCH
);
1713 /* If the output is not a terminal, don't paginate it. */
1714 if (!ui_file_isatty (gdb_stdout
))
1715 lines_per_page
= UINT_MAX
;
1723 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1726 set_screen_size (void)
1728 int rows
= lines_per_page
;
1729 int cols
= chars_per_line
;
1735 rl_get_screen_size (NULL
, &cols
);
1737 /* Update Readline's idea of the terminal size. */
1738 rl_set_screen_size (rows
, cols
);
1741 /* Reinitialize WRAP_BUFFER according to the current value of
1747 if (chars_per_line
== 0)
1752 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1753 wrap_buffer
[0] = '\0';
1756 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1757 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
1761 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1768 set_height_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1773 /* Wait, so the user can read what's on the screen. Prompt the user
1774 to continue by pressing RETURN. */
1777 prompt_for_continue (void)
1780 char cont_prompt
[120];
1782 if (annotation_level
> 1)
1783 printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
1785 strcpy (cont_prompt
,
1786 "---Type <return> to continue, or q <return> to quit---");
1787 if (annotation_level
> 1)
1788 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1790 /* We must do this *before* we call gdb_readline, else it will eventually
1791 call us -- thinking that we're trying to print beyond the end of the
1793 reinitialize_more_filter ();
1796 /* On a real operating system, the user can quit with SIGINT.
1799 'q' is provided on all systems so users don't have to change habits
1800 from system to system, and because telling them what to do in
1801 the prompt is more user-friendly than expecting them to think of
1803 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1804 whereas control-C to gdb_readline will cause the user to get dumped
1806 ignore
= gdb_readline_wrapper (cont_prompt
);
1808 if (annotation_level
> 1)
1809 printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
1814 while (*p
== ' ' || *p
== '\t')
1817 async_request_quit (0);
1822 /* Now we have to do this again, so that GDB will know that it doesn't
1823 need to save the ---Type <return>--- line at the top of the screen. */
1824 reinitialize_more_filter ();
1826 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1829 /* Reinitialize filter; ie. tell it to reset to original values. */
1832 reinitialize_more_filter (void)
1838 /* Indicate that if the next sequence of characters overflows the line,
1839 a newline should be inserted here rather than when it hits the end.
1840 If INDENT is non-null, it is a string to be printed to indent the
1841 wrapped part on the next line. INDENT must remain accessible until
1842 the next call to wrap_here() or until a newline is printed through
1845 If the line is already overfull, we immediately print a newline and
1846 the indentation, and disable further wrapping.
1848 If we don't know the width of lines, but we know the page height,
1849 we must not wrap words, but should still keep track of newlines
1850 that were explicitly printed.
1852 INDENT should not contain tabs, as that will mess up the char count
1853 on the next line. FIXME.
1855 This routine is guaranteed to force out any output which has been
1856 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1857 used to force out output from the wrap_buffer. */
1860 wrap_here (char *indent
)
1862 /* This should have been allocated, but be paranoid anyway. */
1864 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1868 *wrap_pointer
= '\0';
1869 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1871 wrap_pointer
= wrap_buffer
;
1872 wrap_buffer
[0] = '\0';
1873 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1877 else if (chars_printed
>= chars_per_line
)
1879 puts_filtered ("\n");
1881 puts_filtered (indent
);
1886 wrap_column
= chars_printed
;
1890 wrap_indent
= indent
;
1894 /* Print input string to gdb_stdout, filtered, with wrap,
1895 arranging strings in columns of n chars. String can be
1896 right or left justified in the column. Never prints
1897 trailing spaces. String should never be longer than
1898 width. FIXME: this could be useful for the EXAMINE
1899 command, which currently doesn't tabulate very well */
1902 puts_filtered_tabular (char *string
, int width
, int right
)
1908 gdb_assert (chars_per_line
> 0);
1909 if (chars_per_line
== UINT_MAX
)
1911 fputs_filtered (string
, gdb_stdout
);
1912 fputs_filtered ("\n", gdb_stdout
);
1916 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
1917 fputs_filtered ("\n", gdb_stdout
);
1919 if (width
>= chars_per_line
)
1920 width
= chars_per_line
- 1;
1922 stringlen
= strlen (string
);
1924 if (chars_printed
> 0)
1925 spaces
= width
- (chars_printed
- 1) % width
- 1;
1927 spaces
+= width
- stringlen
;
1929 spacebuf
= alloca (spaces
+ 1);
1930 spacebuf
[spaces
] = '\0';
1932 spacebuf
[spaces
] = ' ';
1934 fputs_filtered (spacebuf
, gdb_stdout
);
1935 fputs_filtered (string
, gdb_stdout
);
1939 /* Ensure that whatever gets printed next, using the filtered output
1940 commands, starts at the beginning of the line. I.E. if there is
1941 any pending output for the current line, flush it and start a new
1942 line. Otherwise do nothing. */
1947 if (chars_printed
> 0)
1949 puts_filtered ("\n");
1954 /* Like fputs but if FILTER is true, pause after every screenful.
1956 Regardless of FILTER can wrap at points other than the final
1957 character of a line.
1959 Unlike fputs, fputs_maybe_filtered does not return a value.
1960 It is OK for LINEBUFFER to be NULL, in which case just don't print
1963 Note that a longjmp to top level may occur in this routine (only if
1964 FILTER is true) (since prompt_for_continue may do so) so this
1965 routine should not be called when cleanups are not in place. */
1968 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1971 const char *lineptr
;
1973 if (linebuffer
== 0)
1976 /* Don't do any filtering if it is disabled. */
1977 if ((stream
!= gdb_stdout
) || !pagination_enabled
1978 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
1980 fputs_unfiltered (linebuffer
, stream
);
1984 /* Go through and output each character. Show line extension
1985 when this is necessary; prompt user for new page when this is
1988 lineptr
= linebuffer
;
1991 /* Possible new page. */
1992 if (filter
&& (lines_printed
>= lines_per_page
- 1))
1993 prompt_for_continue ();
1995 while (*lineptr
&& *lineptr
!= '\n')
1997 /* Print a single line. */
1998 if (*lineptr
== '\t')
2001 *wrap_pointer
++ = '\t';
2003 fputc_unfiltered ('\t', stream
);
2004 /* Shifting right by 3 produces the number of tab stops
2005 we have already passed, and then adding one and
2006 shifting left 3 advances to the next tab stop. */
2007 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
2013 *wrap_pointer
++ = *lineptr
;
2015 fputc_unfiltered (*lineptr
, stream
);
2020 if (chars_printed
>= chars_per_line
)
2022 unsigned int save_chars
= chars_printed
;
2026 /* If we aren't actually wrapping, don't output newline --
2027 if chars_per_line is right, we probably just overflowed
2028 anyway; if it's wrong, let us keep going. */
2030 fputc_unfiltered ('\n', stream
);
2032 /* Possible new page. */
2033 if (lines_printed
>= lines_per_page
- 1)
2034 prompt_for_continue ();
2036 /* Now output indentation and wrapped string */
2039 fputs_unfiltered (wrap_indent
, stream
);
2040 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
2041 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
2042 /* FIXME, this strlen is what prevents wrap_indent from
2043 containing tabs. However, if we recurse to print it
2044 and count its chars, we risk trouble if wrap_indent is
2045 longer than (the user settable) chars_per_line.
2046 Note also that this can set chars_printed > chars_per_line
2047 if we are printing a long string. */
2048 chars_printed
= strlen (wrap_indent
)
2049 + (save_chars
- wrap_column
);
2050 wrap_pointer
= wrap_buffer
; /* Reset buffer */
2051 wrap_buffer
[0] = '\0';
2052 wrap_column
= 0; /* And disable fancy wrap */
2057 if (*lineptr
== '\n')
2060 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
2062 fputc_unfiltered ('\n', stream
);
2069 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
2071 fputs_maybe_filtered (linebuffer
, stream
, 1);
2075 putchar_unfiltered (int c
)
2078 ui_file_write (gdb_stdout
, &buf
, 1);
2082 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
2083 May return nonlocally. */
2086 putchar_filtered (int c
)
2088 return fputc_filtered (c
, gdb_stdout
);
2092 fputc_unfiltered (int c
, struct ui_file
*stream
)
2095 ui_file_write (stream
, &buf
, 1);
2100 fputc_filtered (int c
, struct ui_file
*stream
)
2106 fputs_filtered (buf
, stream
);
2110 /* puts_debug is like fputs_unfiltered, except it prints special
2111 characters in printable fashion. */
2114 puts_debug (char *prefix
, char *string
, char *suffix
)
2118 /* Print prefix and suffix after each line. */
2119 static int new_line
= 1;
2120 static int return_p
= 0;
2121 static char *prev_prefix
= "";
2122 static char *prev_suffix
= "";
2124 if (*string
== '\n')
2127 /* If the prefix is changing, print the previous suffix, a new line,
2128 and the new prefix. */
2129 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2131 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2132 fputs_unfiltered ("\n", gdb_stdlog
);
2133 fputs_unfiltered (prefix
, gdb_stdlog
);
2136 /* Print prefix if we printed a newline during the previous call. */
2140 fputs_unfiltered (prefix
, gdb_stdlog
);
2143 prev_prefix
= prefix
;
2144 prev_suffix
= suffix
;
2146 /* Output characters in a printable format. */
2147 while ((ch
= *string
++) != '\0')
2153 fputc_unfiltered (ch
, gdb_stdlog
);
2156 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2160 fputs_unfiltered ("\\\\", gdb_stdlog
);
2163 fputs_unfiltered ("\\b", gdb_stdlog
);
2166 fputs_unfiltered ("\\f", gdb_stdlog
);
2170 fputs_unfiltered ("\\n", gdb_stdlog
);
2173 fputs_unfiltered ("\\r", gdb_stdlog
);
2176 fputs_unfiltered ("\\t", gdb_stdlog
);
2179 fputs_unfiltered ("\\v", gdb_stdlog
);
2183 return_p
= ch
== '\r';
2186 /* Print suffix if we printed a newline. */
2189 fputs_unfiltered (suffix
, gdb_stdlog
);
2190 fputs_unfiltered ("\n", gdb_stdlog
);
2195 /* Print a variable number of ARGS using format FORMAT. If this
2196 information is going to put the amount written (since the last call
2197 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2198 call prompt_for_continue to get the users permision to continue.
2200 Unlike fprintf, this function does not return a value.
2202 We implement three variants, vfprintf (takes a vararg list and stream),
2203 fprintf (takes a stream to write on), and printf (the usual).
2205 Note also that a longjmp to top level may occur in this routine
2206 (since prompt_for_continue may do so) so this routine should not be
2207 called when cleanups are not in place. */
2210 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2211 va_list args
, int filter
)
2214 struct cleanup
*old_cleanups
;
2216 linebuffer
= xstrvprintf (format
, args
);
2217 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2218 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2219 do_cleanups (old_cleanups
);
2224 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2226 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2230 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2233 struct cleanup
*old_cleanups
;
2235 linebuffer
= xstrvprintf (format
, args
);
2236 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2237 fputs_unfiltered (linebuffer
, stream
);
2238 do_cleanups (old_cleanups
);
2242 vprintf_filtered (const char *format
, va_list args
)
2244 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2248 vprintf_unfiltered (const char *format
, va_list args
)
2250 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2254 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2257 va_start (args
, format
);
2258 vfprintf_filtered (stream
, format
, args
);
2263 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2266 va_start (args
, format
);
2267 vfprintf_unfiltered (stream
, format
, args
);
2271 /* Like fprintf_filtered, but prints its result indented.
2272 Called as fprintfi_filtered (spaces, stream, format, ...); */
2275 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2279 va_start (args
, format
);
2280 print_spaces_filtered (spaces
, stream
);
2282 vfprintf_filtered (stream
, format
, args
);
2288 printf_filtered (const char *format
, ...)
2291 va_start (args
, format
);
2292 vfprintf_filtered (gdb_stdout
, format
, args
);
2298 printf_unfiltered (const char *format
, ...)
2301 va_start (args
, format
);
2302 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2306 /* Like printf_filtered, but prints it's result indented.
2307 Called as printfi_filtered (spaces, format, ...); */
2310 printfi_filtered (int spaces
, const char *format
, ...)
2313 va_start (args
, format
);
2314 print_spaces_filtered (spaces
, gdb_stdout
);
2315 vfprintf_filtered (gdb_stdout
, format
, args
);
2319 /* Easy -- but watch out!
2321 This routine is *not* a replacement for puts()! puts() appends a newline.
2322 This one doesn't, and had better not! */
2325 puts_filtered (const char *string
)
2327 fputs_filtered (string
, gdb_stdout
);
2331 puts_unfiltered (const char *string
)
2333 fputs_unfiltered (string
, gdb_stdout
);
2336 /* Return a pointer to N spaces and a null. The pointer is good
2337 until the next call to here. */
2342 static char *spaces
= 0;
2343 static int max_spaces
= -1;
2349 spaces
= (char *) xmalloc (n
+ 1);
2350 for (t
= spaces
+ n
; t
!= spaces
;)
2356 return spaces
+ max_spaces
- n
;
2359 /* Print N spaces. */
2361 print_spaces_filtered (int n
, struct ui_file
*stream
)
2363 fputs_filtered (n_spaces (n
), stream
);
2366 /* C++/ObjC demangler stuff. */
2368 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2369 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2370 If the name is not mangled, or the language for the name is unknown, or
2371 demangling is off, the name is printed in its "raw" form. */
2374 fprintf_symbol_filtered (struct ui_file
*stream
, char *name
,
2375 enum language lang
, int arg_mode
)
2381 /* If user wants to see raw output, no problem. */
2384 fputs_filtered (name
, stream
);
2388 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2389 fputs_filtered (demangled
? demangled
: name
, stream
);
2390 if (demangled
!= NULL
)
2398 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2399 differences in whitespace. Returns 0 if they match, non-zero if they
2400 don't (slightly different than strcmp()'s range of return values).
2402 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2403 This "feature" is useful when searching for matching C++ function names
2404 (such as if the user types 'break FOO', where FOO is a mangled C++
2408 strcmp_iw (const char *string1
, const char *string2
)
2410 while ((*string1
!= '\0') && (*string2
!= '\0'))
2412 while (isspace (*string1
))
2416 while (isspace (*string2
))
2420 if (*string1
!= *string2
)
2424 if (*string1
!= '\0')
2430 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2433 /* This is like strcmp except that it ignores whitespace and treats
2434 '(' as the first non-NULL character in terms of ordering. Like
2435 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2436 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2437 according to that ordering.
2439 If a list is sorted according to this function and if you want to
2440 find names in the list that match some fixed NAME according to
2441 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2442 where this function would put NAME.
2444 Here are some examples of why using strcmp to sort is a bad idea:
2448 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2449 we try to do a search for "foo<char*>", strcmp will locate this
2450 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2451 will start looking at strings beginning with "goo", and will never
2452 see the correct match of "foo<char *>".
2454 Parenthesis example:
2456 In practice, this is less like to be an issue, but I'll give it a
2457 shot. Let's assume that '$' is a legitimate character to occur in
2458 symbols. (Which may well even be the case on some systems.) Then
2459 say that the partial symbol table contains "foo$" and "foo(int)".
2460 strcmp will put them in this order, since '$' < '('. Now, if the
2461 user searches for "foo", then strcmp will sort "foo" before "foo$".
2462 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2463 "foo") is false, so it won't proceed to the actual match of
2464 "foo(int)" with "foo". */
2467 strcmp_iw_ordered (const char *string1
, const char *string2
)
2469 while ((*string1
!= '\0') && (*string2
!= '\0'))
2471 while (isspace (*string1
))
2475 while (isspace (*string2
))
2479 if (*string1
!= *string2
)
2483 if (*string1
!= '\0')
2492 /* Characters are non-equal unless they're both '\0'; we want to
2493 make sure we get the comparison right according to our
2494 comparison in the cases where one of them is '\0' or '('. */
2496 if (*string2
== '\0')
2501 if (*string2
== '\0')
2506 if (*string2
== '(')
2509 return *string1
- *string2
;
2513 /* A simple comparison function with opposite semantics to strcmp. */
2516 streq (const char *lhs
, const char *rhs
)
2518 return !strcmp (lhs
, rhs
);
2524 ** Answer whether string_to_compare is a full or partial match to
2525 ** template_string. The partial match must be in sequence starting
2529 subset_compare (char *string_to_compare
, char *template_string
)
2532 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2533 && strlen (string_to_compare
) <= strlen (template_string
))
2536 (template_string
, string_to_compare
, strlen (string_to_compare
)) == 0);
2543 static void pagination_on_command (char *arg
, int from_tty
);
2545 pagination_on_command (char *arg
, int from_tty
)
2547 pagination_enabled
= 1;
2550 static void pagination_on_command (char *arg
, int from_tty
);
2552 pagination_off_command (char *arg
, int from_tty
)
2554 pagination_enabled
= 0;
2559 initialize_utils (void)
2561 struct cmd_list_element
*c
;
2563 c
= add_set_cmd ("width", class_support
, var_uinteger
, &chars_per_line
,
2564 "Set number of characters gdb thinks are in a line.",
2566 deprecated_add_show_from_set (c
, &showlist
);
2567 set_cmd_sfunc (c
, set_width_command
);
2569 c
= add_set_cmd ("height", class_support
, var_uinteger
, &lines_per_page
,
2570 "Set number of lines gdb thinks are in a page.", &setlist
);
2571 deprecated_add_show_from_set (c
, &showlist
);
2572 set_cmd_sfunc (c
, set_height_command
);
2576 deprecated_add_show_from_set
2577 (add_set_cmd ("demangle", class_support
, var_boolean
,
2579 "Set demangling of encoded C++/ObjC names when displaying symbols.",
2580 &setprintlist
), &showprintlist
);
2582 deprecated_add_show_from_set
2583 (add_set_cmd ("pagination", class_support
,
2584 var_boolean
, (char *) &pagination_enabled
,
2585 "Set state of pagination.", &setlist
), &showlist
);
2589 add_com ("am", class_support
, pagination_on_command
,
2590 "Enable pagination");
2591 add_com ("sm", class_support
, pagination_off_command
,
2592 "Disable pagination");
2595 deprecated_add_show_from_set
2596 (add_set_cmd ("sevenbit-strings", class_support
, var_boolean
,
2597 (char *) &sevenbit_strings
,
2598 "Set printing of 8-bit characters in strings as \\nnn.",
2599 &setprintlist
), &showprintlist
);
2601 deprecated_add_show_from_set
2602 (add_set_cmd ("asm-demangle", class_support
, var_boolean
,
2603 (char *) &asm_demangle
,
2604 "Set demangling of C++/ObjC names in disassembly listings.",
2605 &setprintlist
), &showprintlist
);
2608 /* Machine specific function to handle SIGWINCH signal. */
2610 #ifdef SIGWINCH_HANDLER_BODY
2611 SIGWINCH_HANDLER_BODY
2613 /* print routines to handle variable size regs, etc. */
2614 /* temporary storage using circular buffer */
2620 static char buf
[NUMCELLS
][CELLSIZE
];
2621 static int cell
= 0;
2622 if (++cell
>= NUMCELLS
)
2630 return (TARGET_ADDR_BIT
/ 8 * 2);
2634 paddr (CORE_ADDR addr
)
2636 return phex (addr
, TARGET_ADDR_BIT
/ 8);
2640 paddr_nz (CORE_ADDR addr
)
2642 return phex_nz (addr
, TARGET_ADDR_BIT
/ 8);
2646 decimal2str (char *paddr_str
, char *sign
, ULONGEST addr
, int width
)
2648 /* steal code from valprint.c:print_decimal(). Should this worry
2649 about the real size of addr as the above does? */
2650 unsigned long temp
[3];
2654 temp
[i
] = addr
% (1000 * 1000 * 1000);
2655 addr
/= (1000 * 1000 * 1000);
2659 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2666 sprintf (paddr_str
, "%s%0*lu", sign
, width
, temp
[0]);
2669 sprintf (paddr_str
, "%s%0*lu%09lu", sign
, width
, temp
[1], temp
[0]);
2672 sprintf (paddr_str
, "%s%0*lu%09lu%09lu", sign
, width
,
2673 temp
[2], temp
[1], temp
[0]);
2676 internal_error (__FILE__
, __LINE__
,
2677 "failed internal consistency check");
2682 octal2str (char *paddr_str
, ULONGEST addr
, int width
)
2684 unsigned long temp
[3];
2688 temp
[i
] = addr
% (0100000 * 0100000);
2689 addr
/= (0100000 * 0100000);
2693 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2701 sprintf (paddr_str
, "%*o", width
, 0);
2703 sprintf (paddr_str
, "0%0*lo", width
, temp
[0]);
2706 sprintf (paddr_str
, "0%0*lo%010lo", width
, temp
[1], temp
[0]);
2709 sprintf (paddr_str
, "0%0*lo%010lo%010lo", width
,
2710 temp
[2], temp
[1], temp
[0]);
2713 internal_error (__FILE__
, __LINE__
,
2714 "failed internal consistency check");
2719 paddr_u (CORE_ADDR addr
)
2721 char *paddr_str
= get_cell ();
2722 decimal2str (paddr_str
, "", addr
, 0);
2727 paddr_d (LONGEST addr
)
2729 char *paddr_str
= get_cell ();
2731 decimal2str (paddr_str
, "-", -addr
, 0);
2733 decimal2str (paddr_str
, "", addr
, 0);
2737 /* eliminate warning from compiler on 32-bit systems */
2738 static int thirty_two
= 32;
2741 phex (ULONGEST l
, int sizeof_l
)
2748 sprintf (str
, "%08lx%08lx",
2749 (unsigned long) (l
>> thirty_two
),
2750 (unsigned long) (l
& 0xffffffff));
2754 sprintf (str
, "%08lx", (unsigned long) l
);
2758 sprintf (str
, "%04x", (unsigned short) (l
& 0xffff));
2761 str
= phex (l
, sizeof (l
));
2768 phex_nz (ULONGEST l
, int sizeof_l
)
2775 unsigned long high
= (unsigned long) (l
>> thirty_two
);
2778 sprintf (str
, "%lx", (unsigned long) (l
& 0xffffffff));
2780 sprintf (str
, "%lx%08lx", high
, (unsigned long) (l
& 0xffffffff));
2785 sprintf (str
, "%lx", (unsigned long) l
);
2789 sprintf (str
, "%x", (unsigned short) (l
& 0xffff));
2792 str
= phex_nz (l
, sizeof (l
));
2798 /* Converts a LONGEST to a C-format hexadecimal literal and stores it
2799 in a static string. Returns a pointer to this string. */
2801 hex_string (LONGEST num
)
2803 char *result
= get_cell ();
2804 snprintf (result
, CELLSIZE
, "0x%s", phex_nz (num
, sizeof (num
)));
2808 /* Converts a LONGEST number to a C-format hexadecimal literal and
2809 stores it in a static string. Returns a pointer to this string
2810 that is valid until the next call. The number is padded on the
2811 left with 0s to at least WIDTH characters. */
2813 hex_string_custom (LONGEST num
, int width
)
2815 char *result
= get_cell ();
2816 char *result_end
= result
+ CELLSIZE
- 1;
2817 const char *hex
= phex_nz (num
, sizeof (num
));
2818 int hex_len
= strlen (hex
);
2820 if (hex_len
> width
)
2822 if (width
+ 2 >= CELLSIZE
)
2823 internal_error (__FILE__
, __LINE__
,
2824 "hex_string_custom: insufficient space to store result");
2826 strcpy (result_end
- width
- 2, "0x");
2827 memset (result_end
- width
, '0', width
);
2828 strcpy (result_end
- hex_len
, hex
);
2829 return result_end
- width
- 2;
2832 /* Convert VAL to a numeral in the given radix. For
2833 * radix 10, IS_SIGNED may be true, indicating a signed quantity;
2834 * otherwise VAL is interpreted as unsigned. If WIDTH is supplied,
2835 * it is the minimum width (0-padded if needed). USE_C_FORMAT means
2836 * to use C format in all cases. If it is false, then 'x'
2837 * and 'o' formats do not include a prefix (0x or leading 0). */
2840 int_string (LONGEST val
, int radix
, int is_signed
, int width
,
2849 result
= hex_string (val
);
2851 result
= hex_string_custom (val
, width
);
2858 char *result
= get_cell ();
2859 if (is_signed
&& val
< 0)
2860 decimal2str (result
, "-", -val
, width
);
2862 decimal2str (result
, "", val
, width
);
2867 char *result
= get_cell ();
2868 octal2str (result
, val
, width
);
2869 if (use_c_format
|| val
== 0)
2875 internal_error (__FILE__
, __LINE__
,
2876 "failed internal consistency check");
2880 /* Convert a CORE_ADDR into a string. */
2882 core_addr_to_string (const CORE_ADDR addr
)
2884 char *str
= get_cell ();
2886 strcat (str
, phex (addr
, sizeof (addr
)));
2891 core_addr_to_string_nz (const CORE_ADDR addr
)
2893 char *str
= get_cell ();
2895 strcat (str
, phex_nz (addr
, sizeof (addr
)));
2899 /* Convert a string back into a CORE_ADDR. */
2901 string_to_core_addr (const char *my_string
)
2904 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2906 /* Assume that it is in decimal. */
2908 for (i
= 2; my_string
[i
] != '\0'; i
++)
2910 if (isdigit (my_string
[i
]))
2911 addr
= (my_string
[i
] - '0') + (addr
* 16);
2912 else if (isxdigit (my_string
[i
]))
2913 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2915 internal_error (__FILE__
, __LINE__
, "invalid hex");
2920 /* Assume that it is in decimal. */
2922 for (i
= 0; my_string
[i
] != '\0'; i
++)
2924 if (isdigit (my_string
[i
]))
2925 addr
= (my_string
[i
] - '0') + (addr
* 10);
2927 internal_error (__FILE__
, __LINE__
, "invalid decimal");
2934 gdb_realpath (const char *filename
)
2936 /* Method 1: The system has a compile time upper bound on a filename
2937 path. Use that and realpath() to canonicalize the name. This is
2938 the most common case. Note that, if there isn't a compile time
2939 upper bound, you want to avoid realpath() at all costs. */
2940 #if defined(HAVE_REALPATH)
2942 # if defined (PATH_MAX)
2944 # define USE_REALPATH
2945 # elif defined (MAXPATHLEN)
2946 char buf
[MAXPATHLEN
];
2947 # define USE_REALPATH
2949 # if defined (USE_REALPATH)
2950 const char *rp
= realpath (filename
, buf
);
2953 return xstrdup (rp
);
2956 #endif /* HAVE_REALPATH */
2958 /* Method 2: The host system (i.e., GNU) has the function
2959 canonicalize_file_name() which malloc's a chunk of memory and
2960 returns that, use that. */
2961 #if defined(HAVE_CANONICALIZE_FILE_NAME)
2963 char *rp
= canonicalize_file_name (filename
);
2965 return xstrdup (filename
);
2971 /* FIXME: cagney/2002-11-13:
2973 Method 2a: Use realpath() with a NULL buffer. Some systems, due
2974 to the problems described in in method 3, have modified their
2975 realpath() implementation so that it will allocate a buffer when
2976 NULL is passed in. Before this can be used, though, some sort of
2977 configure time test would need to be added. Otherwize the code
2978 will likely core dump. */
2980 /* Method 3: Now we're getting desperate! The system doesn't have a
2981 compile time buffer size and no alternative function. Query the
2982 OS, using pathconf(), for the buffer limit. Care is needed
2983 though, some systems do not limit PATH_MAX (return -1 for
2984 pathconf()) making it impossible to pass a correctly sized buffer
2985 to realpath() (it could always overflow). On those systems, we
2987 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
2989 /* Find out the max path size. */
2990 long path_max
= pathconf ("/", _PC_PATH_MAX
);
2993 /* PATH_MAX is bounded. */
2994 char *buf
= alloca (path_max
);
2995 char *rp
= realpath (filename
, buf
);
2996 return xstrdup (rp
? rp
: filename
);
3001 /* This system is a lost cause, just dup the buffer. */
3002 return xstrdup (filename
);
3005 /* Return a copy of FILENAME, with its directory prefix canonicalized
3009 xfullpath (const char *filename
)
3011 const char *base_name
= lbasename (filename
);
3016 /* Extract the basename of filename, and return immediately
3017 a copy of filename if it does not contain any directory prefix. */
3018 if (base_name
== filename
)
3019 return xstrdup (filename
);
3021 dir_name
= alloca ((size_t) (base_name
- filename
+ 2));
3022 /* Allocate enough space to store the dir_name + plus one extra
3023 character sometimes needed under Windows (see below), and
3024 then the closing \000 character */
3025 strncpy (dir_name
, filename
, base_name
- filename
);
3026 dir_name
[base_name
- filename
] = '\000';
3028 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3029 /* We need to be careful when filename is of the form 'd:foo', which
3030 is equivalent of d:./foo, which is totally different from d:/foo. */
3031 if (strlen (dir_name
) == 2 && isalpha (dir_name
[0]) && dir_name
[1] == ':')
3034 dir_name
[3] = '\000';
3038 /* Canonicalize the directory prefix, and build the resulting
3039 filename. If the dirname realpath already contains an ending
3040 directory separator, avoid doubling it. */
3041 real_path
= gdb_realpath (dir_name
);
3042 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
3043 result
= concat (real_path
, base_name
, NULL
);
3045 result
= concat (real_path
, SLASH_STRING
, base_name
, NULL
);
3052 /* This is the 32-bit CRC function used by the GNU separate debug
3053 facility. An executable may contain a section named
3054 .gnu_debuglink, which holds the name of a separate executable file
3055 containing its debug info, and a checksum of that file's contents,
3056 computed using this function. */
3058 gnu_debuglink_crc32 (unsigned long crc
, unsigned char *buf
, size_t len
)
3060 static const unsigned long crc32_table
[256] = {
3061 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
3062 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
3063 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
3064 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
3065 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
3066 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
3067 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
3068 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
3069 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
3070 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
3071 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
3072 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
3073 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
3074 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
3075 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
3076 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
3077 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
3078 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
3079 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
3080 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
3081 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
3082 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
3083 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
3084 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
3085 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
3086 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
3087 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
3088 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
3089 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
3090 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
3091 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
3092 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
3093 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
3094 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
3095 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
3096 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
3097 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
3098 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
3099 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
3100 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
3101 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
3102 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
3103 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
3104 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
3105 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
3106 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
3107 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
3108 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
3109 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
3110 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
3111 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
3116 crc
= ~crc
& 0xffffffff;
3117 for (end
= buf
+ len
; buf
< end
; ++buf
)
3118 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
3119 return ~crc
& 0xffffffff;;
3123 align_up (ULONGEST v
, int n
)
3125 /* Check that N is really a power of two. */
3126 gdb_assert (n
&& (n
& (n
-1)) == 0);
3127 return (v
+ n
- 1) & -n
;
3131 align_down (ULONGEST v
, int n
)
3133 /* Check that N is really a power of two. */
3134 gdb_assert (n
&& (n
& (n
-1)) == 0);