1 /* General utility routines for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
5 Free Software Foundation, Inc.
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 3 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, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_assert.h"
25 #include "gdb_string.h"
26 #include "event-top.h"
27 #include "exceptions.h"
30 #include "tui/tui.h" /* For tui_get_command_dimension. */
37 /* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
48 #include "expression.h"
52 #include "filenames.h"
54 #include "gdb_obstack.h"
58 #include "inferior.h" /* for signed_pointer_to_address */
60 #include <sys/param.h> /* For MAXPATHLEN */
62 #include "gdb_curses.h"
64 #include "readline/readline.h"
70 extern PTR
malloc (); /* OK: PTR */
72 #if !HAVE_DECL_REALLOC
73 extern PTR
realloc (); /* OK: PTR */
79 /* readline defines this. */
82 void (*deprecated_error_begin_hook
) (void);
84 /* Prototypes for local functions */
86 static void vfprintf_maybe_filtered (struct ui_file
*, const char *,
87 va_list, int) ATTR_FORMAT (printf
, 2, 0);
89 static void fputs_maybe_filtered (const char *, struct ui_file
*, int);
91 static void do_my_cleanups (struct cleanup
**, struct cleanup
*);
93 static void prompt_for_continue (void);
95 static void set_screen_size (void);
96 static void set_width (void);
98 /* A flag indicating whether to timestamp debugging messages. */
100 static int debug_timestamp
= 0;
102 /* Chain of cleanup actions established with make_cleanup,
103 to be executed if an error happens. */
105 static struct cleanup
*cleanup_chain
; /* cleaned up after a failed command */
106 static struct cleanup
*final_cleanup_chain
; /* cleaned up when gdb exits */
108 /* Pointer to what is left to do for an execution command after the
109 target stops. Used only in asynchronous mode, by targets that
110 support async execution. The finish and until commands use it. So
111 does the target extended-remote command. */
112 struct continuation
*cmd_continuation
;
113 struct continuation
*intermediate_continuation
;
115 /* Nonzero if we have job control. */
119 /* Nonzero means a quit has been requested. */
123 /* Nonzero means quit immediately if Control-C is typed now, rather
124 than waiting until QUIT is executed. Be careful in setting this;
125 code which executes with immediate_quit set has to be very careful
126 about being able to deal with being interrupted at any time. It is
127 almost always better to use QUIT; the only exception I can think of
128 is being able to quit out of a system call (using EINTR loses if
129 the SIGINT happens between the previous QUIT and the system call).
130 To immediately quit in the case in which a SIGINT happens between
131 the previous QUIT and setting immediate_quit (desirable anytime we
132 expect to block), call QUIT after setting immediate_quit. */
136 /* Nonzero means that encoded C++/ObjC names should be printed out in their
137 C++/ObjC form rather than raw. */
141 show_demangle (struct ui_file
*file
, int from_tty
,
142 struct cmd_list_element
*c
, const char *value
)
144 fprintf_filtered (file
, _("\
145 Demangling of encoded C++/ObjC names when displaying symbols is %s.\n"),
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 show_asm_demangle (struct ui_file
*file
, int from_tty
,
156 struct cmd_list_element
*c
, const char *value
)
158 fprintf_filtered (file
, _("\
159 Demangling of C++/ObjC names in disassembly listings is %s.\n"),
163 /* Nonzero means that strings with character values >0x7F should be printed
164 as octal escapes. Zero means just print the value (e.g. it's an
165 international character, and the terminal or window can cope.) */
167 int sevenbit_strings
= 0;
169 show_sevenbit_strings (struct ui_file
*file
, int from_tty
,
170 struct cmd_list_element
*c
, const char *value
)
172 fprintf_filtered (file
, _("\
173 Printing of 8-bit characters in strings as \\nnn is %s.\n"),
177 /* String to be printed before error messages, if any. */
179 char *error_pre_print
;
181 /* String to be printed before quit messages, if any. */
183 char *quit_pre_print
;
185 /* String to be printed before warning messages, if any. */
187 char *warning_pre_print
= "\nwarning: ";
189 int pagination_enabled
= 1;
191 show_pagination_enabled (struct ui_file
*file
, int from_tty
,
192 struct cmd_list_element
*c
, const char *value
)
194 fprintf_filtered (file
, _("State of pagination is %s.\n"), value
);
199 /* Add a new cleanup to the cleanup_chain,
200 and return the previous chain pointer
201 to be passed later to do_cleanups or discard_cleanups.
202 Args are FUNCTION to clean up with, and ARG to pass to it. */
205 make_cleanup (make_cleanup_ftype
*function
, void *arg
)
207 return make_my_cleanup (&cleanup_chain
, function
, arg
);
211 make_final_cleanup (make_cleanup_ftype
*function
, void *arg
)
213 return make_my_cleanup (&final_cleanup_chain
, function
, arg
);
217 do_freeargv (void *arg
)
219 freeargv ((char **) arg
);
223 make_cleanup_freeargv (char **arg
)
225 return make_my_cleanup (&cleanup_chain
, do_freeargv
, arg
);
229 do_bfd_close_cleanup (void *arg
)
235 make_cleanup_bfd_close (bfd
*abfd
)
237 return make_cleanup (do_bfd_close_cleanup
, abfd
);
241 do_close_cleanup (void *arg
)
249 make_cleanup_close (int fd
)
251 int *saved_fd
= xmalloc (sizeof (fd
));
253 return make_cleanup (do_close_cleanup
, saved_fd
);
257 do_ui_file_delete (void *arg
)
259 ui_file_delete (arg
);
263 make_cleanup_ui_file_delete (struct ui_file
*arg
)
265 return make_my_cleanup (&cleanup_chain
, do_ui_file_delete
, arg
);
269 do_free_section_addr_info (void *arg
)
271 free_section_addr_info (arg
);
275 make_cleanup_free_section_addr_info (struct section_addr_info
*addrs
)
277 return make_my_cleanup (&cleanup_chain
, do_free_section_addr_info
, addrs
);
280 struct restore_integer_closure
287 restore_integer (void *p
)
289 struct restore_integer_closure
*closure
= p
;
290 *(closure
->variable
) = closure
->value
;
293 /* Remember the current value of *VARIABLE and make it restored when the cleanup
296 make_cleanup_restore_integer (int *variable
)
298 struct restore_integer_closure
*c
=
299 xmalloc (sizeof (struct restore_integer_closure
));
300 c
->variable
= variable
;
301 c
->value
= *variable
;
303 return make_my_cleanup2 (&cleanup_chain
, restore_integer
, (void *)c
,
308 make_my_cleanup2 (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
309 void *arg
, void (*free_arg
) (void *))
312 = (struct cleanup
*) xmalloc (sizeof (struct cleanup
));
313 struct cleanup
*old_chain
= *pmy_chain
;
315 new->next
= *pmy_chain
;
316 new->function
= function
;
317 new->free_arg
= free_arg
;
325 make_my_cleanup (struct cleanup
**pmy_chain
, make_cleanup_ftype
*function
,
328 return make_my_cleanup2 (pmy_chain
, function
, arg
, NULL
);
331 /* Discard cleanups and do the actions they describe
332 until we get back to the point OLD_CHAIN in the cleanup_chain. */
335 do_cleanups (struct cleanup
*old_chain
)
337 do_my_cleanups (&cleanup_chain
, old_chain
);
341 do_final_cleanups (struct cleanup
*old_chain
)
343 do_my_cleanups (&final_cleanup_chain
, old_chain
);
347 do_my_cleanups (struct cleanup
**pmy_chain
,
348 struct cleanup
*old_chain
)
351 while ((ptr
= *pmy_chain
) != old_chain
)
353 *pmy_chain
= ptr
->next
; /* Do this first incase recursion */
354 (*ptr
->function
) (ptr
->arg
);
356 (*ptr
->free_arg
) (ptr
->arg
);
361 /* Discard cleanups, not doing the actions they describe,
362 until we get back to the point OLD_CHAIN in the cleanup_chain. */
365 discard_cleanups (struct cleanup
*old_chain
)
367 discard_my_cleanups (&cleanup_chain
, old_chain
);
371 discard_final_cleanups (struct cleanup
*old_chain
)
373 discard_my_cleanups (&final_cleanup_chain
, old_chain
);
377 discard_my_cleanups (struct cleanup
**pmy_chain
,
378 struct cleanup
*old_chain
)
381 while ((ptr
= *pmy_chain
) != old_chain
)
383 *pmy_chain
= ptr
->next
;
385 (*ptr
->free_arg
) (ptr
->arg
);
390 /* Set the cleanup_chain to 0, and return the old cleanup chain. */
394 return save_my_cleanups (&cleanup_chain
);
398 save_final_cleanups (void)
400 return save_my_cleanups (&final_cleanup_chain
);
404 save_my_cleanups (struct cleanup
**pmy_chain
)
406 struct cleanup
*old_chain
= *pmy_chain
;
412 /* Restore the cleanup chain from a previously saved chain. */
414 restore_cleanups (struct cleanup
*chain
)
416 restore_my_cleanups (&cleanup_chain
, chain
);
420 restore_final_cleanups (struct cleanup
*chain
)
422 restore_my_cleanups (&final_cleanup_chain
, chain
);
426 restore_my_cleanups (struct cleanup
**pmy_chain
, struct cleanup
*chain
)
431 /* This function is useful for cleanups.
435 old_chain = make_cleanup (free_current_contents, &foo);
437 to arrange to free the object thus allocated. */
440 free_current_contents (void *ptr
)
442 void **location
= ptr
;
443 if (location
== NULL
)
444 internal_error (__FILE__
, __LINE__
,
445 _("free_current_contents: NULL pointer"));
446 if (*location
!= NULL
)
453 /* Provide a known function that does nothing, to use as a base for
454 for a possibly long chain of cleanups. This is useful where we
455 use the cleanup chain for handling normal cleanups as well as dealing
456 with cleanups that need to be done as a result of a call to error().
457 In such cases, we may not be certain where the first cleanup is, unless
458 we have a do-nothing one to always use as the base. */
461 null_cleanup (void *arg
)
465 /* Add a continuation to the continuation list, the global list
466 cmd_continuation. The new continuation will be added at the front.*/
468 add_continuation (void (*continuation_hook
) (struct continuation_arg
*, int),
469 struct continuation_arg
*arg_list
)
471 struct continuation
*continuation_ptr
;
474 (struct continuation
*) xmalloc (sizeof (struct continuation
));
475 continuation_ptr
->continuation_hook
= continuation_hook
;
476 continuation_ptr
->arg_list
= arg_list
;
477 continuation_ptr
->next
= cmd_continuation
;
478 cmd_continuation
= continuation_ptr
;
481 /* Walk down the cmd_continuation list, and execute all the
482 continuations. There is a problem though. In some cases new
483 continuations may be added while we are in the middle of this
484 loop. If this happens they will be added in the front, and done
485 before we have a chance of exhausting those that were already
486 there. We need to then save the beginning of the list in a pointer
487 and do the continuations from there on, instead of using the
488 global beginning of list as our iteration pointer. */
490 do_all_continuations (int error
)
492 struct continuation
*continuation_ptr
;
493 struct continuation
*saved_continuation
;
495 /* Copy the list header into another pointer, and set the global
496 list header to null, so that the global list can change as a side
497 effect of invoking the continuations and the processing of
498 the preexisting continuations will not be affected. */
499 continuation_ptr
= cmd_continuation
;
500 cmd_continuation
= NULL
;
502 /* Work now on the list we have set aside. */
503 while (continuation_ptr
)
505 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
, error
);
506 saved_continuation
= continuation_ptr
;
507 continuation_ptr
= continuation_ptr
->next
;
508 xfree (saved_continuation
);
512 /* Walk down the cmd_continuation list, and get rid of all the
515 discard_all_continuations (void)
517 struct continuation
*continuation_ptr
;
519 while (cmd_continuation
)
521 continuation_ptr
= cmd_continuation
;
522 cmd_continuation
= continuation_ptr
->next
;
523 xfree (continuation_ptr
);
527 /* Add a continuation to the continuation list, the global list
528 intermediate_continuation. The new continuation will be added at
531 add_intermediate_continuation (void (*continuation_hook
)
532 (struct continuation_arg
*, int),
533 struct continuation_arg
*arg_list
)
535 struct continuation
*continuation_ptr
;
538 (struct continuation
*) xmalloc (sizeof (struct continuation
));
539 continuation_ptr
->continuation_hook
= continuation_hook
;
540 continuation_ptr
->arg_list
= arg_list
;
541 continuation_ptr
->next
= intermediate_continuation
;
542 intermediate_continuation
= continuation_ptr
;
545 /* Walk down the cmd_continuation list, and execute all the
546 continuations. There is a problem though. In some cases new
547 continuations may be added while we are in the middle of this
548 loop. If this happens they will be added in the front, and done
549 before we have a chance of exhausting those that were already
550 there. We need to then save the beginning of the list in a pointer
551 and do the continuations from there on, instead of using the
552 global beginning of list as our iteration pointer.*/
554 do_all_intermediate_continuations (int error
)
556 struct continuation
*continuation_ptr
;
557 struct continuation
*saved_continuation
;
559 /* Copy the list header into another pointer, and set the global
560 list header to null, so that the global list can change as a side
561 effect of invoking the continuations and the processing of
562 the preexisting continuations will not be affected. */
563 continuation_ptr
= intermediate_continuation
;
564 intermediate_continuation
= NULL
;
566 /* Work now on the list we have set aside. */
567 while (continuation_ptr
)
569 (continuation_ptr
->continuation_hook
) (continuation_ptr
->arg_list
, error
);
570 saved_continuation
= continuation_ptr
;
571 continuation_ptr
= continuation_ptr
->next
;
572 xfree (saved_continuation
);
576 /* Walk down the cmd_continuation list, and get rid of all the
579 discard_all_intermediate_continuations (void)
581 struct continuation
*continuation_ptr
;
583 while (intermediate_continuation
)
585 continuation_ptr
= intermediate_continuation
;
586 intermediate_continuation
= continuation_ptr
->next
;
587 xfree (continuation_ptr
);
593 /* Print a warning message. The first argument STRING is the warning
594 message, used as an fprintf format string, the second is the
595 va_list of arguments for that string. A warning is unfiltered (not
596 paginated) so that the user does not need to page through each
597 screen full of warnings when there are lots of them. */
600 vwarning (const char *string
, va_list args
)
602 if (deprecated_warning_hook
)
603 (*deprecated_warning_hook
) (string
, args
);
606 target_terminal_ours ();
607 wrap_here (""); /* Force out any buffered output */
608 gdb_flush (gdb_stdout
);
609 if (warning_pre_print
)
610 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
611 vfprintf_unfiltered (gdb_stderr
, string
, args
);
612 fprintf_unfiltered (gdb_stderr
, "\n");
617 /* Print a warning message.
618 The first argument STRING is the warning message, used as a fprintf string,
619 and the remaining args are passed as arguments to it.
620 The primary difference between warnings and errors is that a warning
621 does not force the return to command level. */
624 warning (const char *string
, ...)
627 va_start (args
, string
);
628 vwarning (string
, args
);
632 /* Print an error message and return to command level.
633 The first argument STRING is the error message, used as a fprintf string,
634 and the remaining args are passed as arguments to it. */
637 verror (const char *string
, va_list args
)
639 throw_verror (GENERIC_ERROR
, string
, args
);
643 error (const char *string
, ...)
646 va_start (args
, string
);
647 throw_verror (GENERIC_ERROR
, string
, args
);
651 /* Print an error message and quit.
652 The first argument STRING is the error message, used as a fprintf string,
653 and the remaining args are passed as arguments to it. */
656 vfatal (const char *string
, va_list args
)
658 throw_vfatal (string
, args
);
662 fatal (const char *string
, ...)
665 va_start (args
, string
);
666 throw_vfatal (string
, args
);
671 error_stream (struct ui_file
*stream
)
674 char *message
= ui_file_xstrdup (stream
, &len
);
675 make_cleanup (xfree
, message
);
676 error (("%s"), message
);
679 /* Print a message reporting an internal error/warning. Ask the user
680 if they want to continue, dump core, or just exit. Return
681 something to indicate a quit. */
683 struct internal_problem
686 /* FIXME: cagney/2002-08-15: There should be ``maint set/show''
687 commands available for controlling these variables. */
688 enum auto_boolean should_quit
;
689 enum auto_boolean should_dump_core
;
692 /* Report a problem, internal to GDB, to the user. Once the problem
693 has been reported, and assuming GDB didn't quit, the caller can
694 either allow execution to resume or throw an error. */
696 static void ATTR_FORMAT (printf
, 4, 0)
697 internal_vproblem (struct internal_problem
*problem
,
698 const char *file
, int line
, const char *fmt
, va_list ap
)
705 /* Don't allow infinite error/warning recursion. */
707 static char msg
[] = "Recursive internal problem.\n";
715 fputs_unfiltered (msg
, gdb_stderr
);
716 abort (); /* NOTE: GDB has only three calls to abort(). */
719 write (STDERR_FILENO
, msg
, sizeof (msg
));
724 /* Try to get the message out and at the start of a new line. */
725 target_terminal_ours ();
728 /* Create a string containing the full error/warning message. Need
729 to call query with this full string, as otherwize the reason
730 (error/warning) and question become separated. Format using a
731 style similar to a compiler error message. Include extra detail
732 so that the user knows that they are living on the edge. */
735 msg
= xstrvprintf (fmt
, ap
);
736 reason
= xstrprintf ("\
738 A problem internal to GDB has been detected,\n\
739 further debugging may prove unreliable.", file
, line
, problem
->name
, msg
);
741 make_cleanup (xfree
, reason
);
744 switch (problem
->should_quit
)
746 case AUTO_BOOLEAN_AUTO
:
747 /* Default (yes/batch case) is to quit GDB. When in batch mode
748 this lessens the likelhood of GDB going into an infinate
750 quit_p
= query (_("%s\nQuit this debugging session? "), reason
);
752 case AUTO_BOOLEAN_TRUE
:
755 case AUTO_BOOLEAN_FALSE
:
759 internal_error (__FILE__
, __LINE__
, _("bad switch"));
762 switch (problem
->should_dump_core
)
764 case AUTO_BOOLEAN_AUTO
:
765 /* Default (yes/batch case) is to dump core. This leaves a GDB
766 `dropping' so that it is easier to see that something went
768 dump_core_p
= query (_("%s\nCreate a core file of GDB? "), reason
);
771 case AUTO_BOOLEAN_TRUE
:
774 case AUTO_BOOLEAN_FALSE
:
778 internal_error (__FILE__
, __LINE__
, _("bad switch"));
784 abort (); /* NOTE: GDB has only three calls to abort(). */
792 #ifdef HAVE_WORKING_FORK
794 abort (); /* NOTE: GDB has only three calls to abort(). */
802 static struct internal_problem internal_error_problem
= {
803 "internal-error", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
807 internal_verror (const char *file
, int line
, const char *fmt
, va_list ap
)
809 internal_vproblem (&internal_error_problem
, file
, line
, fmt
, ap
);
810 deprecated_throw_reason (RETURN_ERROR
);
814 internal_error (const char *file
, int line
, const char *string
, ...)
817 va_start (ap
, string
);
818 internal_verror (file
, line
, string
, ap
);
822 static struct internal_problem internal_warning_problem
= {
823 "internal-warning", AUTO_BOOLEAN_AUTO
, AUTO_BOOLEAN_AUTO
827 internal_vwarning (const char *file
, int line
, const char *fmt
, va_list ap
)
829 internal_vproblem (&internal_warning_problem
, file
, line
, fmt
, ap
);
833 internal_warning (const char *file
, int line
, const char *string
, ...)
836 va_start (ap
, string
);
837 internal_vwarning (file
, line
, string
, ap
);
841 /* Print the system error message for errno, and also mention STRING
842 as the file name for which the error was encountered.
843 Then return to command level. */
846 perror_with_name (const char *string
)
851 err
= safe_strerror (errno
);
852 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
853 strcpy (combined
, string
);
854 strcat (combined
, ": ");
855 strcat (combined
, err
);
857 /* I understand setting these is a matter of taste. Still, some people
858 may clear errno but not know about bfd_error. Doing this here is not
860 bfd_set_error (bfd_error_no_error
);
863 error (_("%s."), combined
);
866 /* Print the system error message for ERRCODE, and also mention STRING
867 as the file name for which the error was encountered. */
870 print_sys_errmsg (const char *string
, int errcode
)
875 err
= safe_strerror (errcode
);
876 combined
= (char *) alloca (strlen (err
) + strlen (string
) + 3);
877 strcpy (combined
, string
);
878 strcat (combined
, ": ");
879 strcat (combined
, err
);
881 /* We want anything which was printed on stdout to come out first, before
883 gdb_flush (gdb_stdout
);
884 fprintf_unfiltered (gdb_stderr
, "%s.\n", combined
);
887 /* Control C eventually causes this to be called, at a convenient time. */
893 /* No steenking SIGINT will ever be coming our way when the
894 program is resumed. Don't lie. */
898 /* If there is no terminal switching for this target, then we can't
899 possibly get screwed by the lack of job control. */
900 || current_target
.to_terminal_ours
== NULL
)
903 fatal ("Quit (expect signal SIGINT when the program is resumed)");
908 /* Called when a memory allocation fails, with the number of bytes of
909 memory requested in SIZE. */
916 internal_error (__FILE__
, __LINE__
,
917 _("virtual memory exhausted: can't allocate %ld bytes."),
922 internal_error (__FILE__
, __LINE__
, _("virtual memory exhausted."));
926 /* The xmalloc() (libiberty.h) family of memory management routines.
928 These are like the ISO-C malloc() family except that they implement
929 consistent semantics and guard against typical memory management
932 /* NOTE: These are declared using PTR to ensure consistency with
933 "libiberty.h". xfree() is GDB local. */
936 xmalloc (size_t size
)
940 /* See libiberty/xmalloc.c. This function need's to match that's
941 semantics. It never returns NULL. */
945 val
= malloc (size
); /* OK: malloc */
953 xzalloc (size_t size
)
955 return xcalloc (1, size
);
959 xrealloc (PTR ptr
, size_t size
) /* OK: PTR */
963 /* See libiberty/xmalloc.c. This function need's to match that's
964 semantics. It never returns NULL. */
969 val
= realloc (ptr
, size
); /* OK: realloc */
971 val
= malloc (size
); /* OK: malloc */
979 xcalloc (size_t number
, size_t size
)
983 /* See libiberty/xmalloc.c. This function need's to match that's
984 semantics. It never returns NULL. */
985 if (number
== 0 || size
== 0)
991 mem
= calloc (number
, size
); /* OK: xcalloc */
993 nomem (number
* size
);
1002 free (ptr
); /* OK: free */
1006 /* Like asprintf/vasprintf but get an internal_error if the call
1010 xstrprintf (const char *format
, ...)
1014 va_start (args
, format
);
1015 ret
= xstrvprintf (format
, args
);
1021 xasprintf (char **ret
, const char *format
, ...)
1024 va_start (args
, format
);
1025 (*ret
) = xstrvprintf (format
, args
);
1030 xvasprintf (char **ret
, const char *format
, va_list ap
)
1032 (*ret
) = xstrvprintf (format
, ap
);
1036 xstrvprintf (const char *format
, va_list ap
)
1039 int status
= vasprintf (&ret
, format
, ap
);
1040 /* NULL is returned when there was a memory allocation problem, or
1041 any other error (for instance, a bad format string). A negative
1042 status (the printed length) with a non-NULL buffer should never
1043 happen, but just to be sure. */
1044 if (ret
== NULL
|| status
< 0)
1045 internal_error (__FILE__
, __LINE__
, _("vasprintf call failed"));
1050 xsnprintf (char *str
, size_t size
, const char *format
, ...)
1055 va_start (args
, format
);
1056 ret
= vsnprintf (str
, size
, format
, args
);
1057 gdb_assert (ret
< size
);
1063 /* My replacement for the read system call.
1064 Used like `read' but keeps going if `read' returns too soon. */
1067 myread (int desc
, char *addr
, int len
)
1074 val
= read (desc
, addr
, len
);
1078 return orglen
- len
;
1085 /* Make a copy of the string at PTR with SIZE characters
1086 (and add a null character at the end in the copy).
1087 Uses malloc to get the space. Returns the address of the copy. */
1090 savestring (const char *ptr
, size_t size
)
1092 char *p
= (char *) xmalloc (size
+ 1);
1093 memcpy (p
, ptr
, size
);
1099 print_spaces (int n
, struct ui_file
*file
)
1101 fputs_unfiltered (n_spaces (n
), file
);
1104 /* Print a host address. */
1107 gdb_print_host_address (const void *addr
, struct ui_file
*stream
)
1110 /* We could use the %p conversion specifier to fprintf if we had any
1111 way of knowing whether this host supports it. But the following
1112 should work on the Alpha and on 32 bit machines. */
1114 fprintf_filtered (stream
, "0x%lx", (unsigned long) addr
);
1118 /* This function supports the query, nquery, and yquery functions.
1119 Ask user a y-or-n question and return 0 if answer is no, 1 if
1120 answer is yes, or default the answer to the specified default
1121 (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
1122 default answer, or '\0' for no default.
1123 CTLSTR is the control string and should end in "? ". It should
1124 not say how to answer, because we do that.
1125 ARGS are the arguments passed along with the CTLSTR argument to
1128 static int ATTR_FORMAT (printf
, 1, 0)
1129 defaulted_query (const char *ctlstr
, const char defchar
, va_list args
)
1135 char def_answer
, not_def_answer
;
1136 char *y_string
, *n_string
, *question
;
1138 /* Set up according to which answer is the default. */
1139 if (defchar
== '\0')
1143 not_def_answer
= 'N';
1147 else if (defchar
== 'y')
1151 not_def_answer
= 'N';
1159 not_def_answer
= 'Y';
1164 /* Automatically answer the default value if the user did not want
1169 /* If input isn't coming from the user directly, just say what
1170 question we're asking, and then answer "yes" automatically. This
1171 way, important error messages don't get lost when talking to GDB
1173 if (! input_from_terminal_p ())
1176 vfprintf_filtered (gdb_stdout
, ctlstr
, args
);
1178 printf_filtered (_("(%s or %s) [answered %c; input not from terminal]\n"),
1179 y_string
, n_string
, def_answer
);
1180 gdb_flush (gdb_stdout
);
1185 /* Automatically answer the default value if input is not from the user
1186 directly, or if the user did not want prompts. */
1187 if (!input_from_terminal_p () || !caution
)
1190 if (deprecated_query_hook
)
1192 return deprecated_query_hook (ctlstr
, args
);
1195 /* Format the question outside of the loop, to avoid reusing args. */
1196 question
= xstrvprintf (ctlstr
, args
);
1200 wrap_here (""); /* Flush any buffered output */
1201 gdb_flush (gdb_stdout
);
1203 if (annotation_level
> 1)
1204 printf_filtered (("\n\032\032pre-query\n"));
1206 fputs_filtered (question
, gdb_stdout
);
1207 printf_filtered (_("(%s or %s) "), y_string
, n_string
);
1209 if (annotation_level
> 1)
1210 printf_filtered (("\n\032\032query\n"));
1213 gdb_flush (gdb_stdout
);
1215 answer
= fgetc (stdin
);
1216 clearerr (stdin
); /* in case of C-d */
1217 if (answer
== EOF
) /* C-d */
1219 printf_filtered ("EOF [assumed %c]\n", def_answer
);
1223 /* Eat rest of input line, to EOF or newline */
1227 ans2
= fgetc (stdin
);
1230 while (ans2
!= EOF
&& ans2
!= '\n' && ans2
!= '\r');
1234 /* Check answer. For the non-default, the user must specify
1235 the non-default explicitly. */
1236 if (answer
== not_def_answer
)
1238 retval
= !def_value
;
1241 /* Otherwise, if a default was specified, the user may either
1242 specify the required input or have it default by entering
1244 if (answer
== def_answer
1245 || (defchar
!= '\0' &&
1246 (answer
== '\n' || answer
== '\r' || answer
== EOF
)))
1251 /* Invalid entries are not defaulted and require another selection. */
1252 printf_filtered (_("Please answer %s or %s.\n"),
1253 y_string
, n_string
);
1257 if (annotation_level
> 1)
1258 printf_filtered (("\n\032\032post-query\n"));
1263 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1264 answer is yes, or 0 if answer is defaulted.
1265 Takes three args which are given to printf to print the question.
1266 The first, a control string, should end in "? ".
1267 It should not say how to answer, because we do that. */
1270 nquery (const char *ctlstr
, ...)
1274 va_start (args
, ctlstr
);
1275 return defaulted_query (ctlstr
, 'n', args
);
1279 /* Ask user a y-or-n question and return 0 if answer is no, 1 if
1280 answer is yes, or 1 if answer is defaulted.
1281 Takes three args which are given to printf to print the question.
1282 The first, a control string, should end in "? ".
1283 It should not say how to answer, because we do that. */
1286 yquery (const char *ctlstr
, ...)
1290 va_start (args
, ctlstr
);
1291 return defaulted_query (ctlstr
, 'y', args
);
1295 /* Ask user a y-or-n question and return 1 iff answer is yes.
1296 Takes three args which are given to printf to print the question.
1297 The first, a control string, should end in "? ".
1298 It should not say how to answer, because we do that. */
1301 query (const char *ctlstr
, ...)
1305 va_start (args
, ctlstr
);
1306 return defaulted_query (ctlstr
, '\0', args
);
1310 /* Print an error message saying that we couldn't make sense of a
1311 \^mumble sequence in a string or character constant. START and END
1312 indicate a substring of some larger string that contains the
1313 erroneous backslash sequence, missing the initial backslash. */
1315 no_control_char_error (const char *start
, const char *end
)
1317 int len
= end
- start
;
1318 char *copy
= alloca (end
- start
+ 1);
1320 memcpy (copy
, start
, len
);
1323 error (_("There is no control character `\\%s' in the `%s' character set."),
1324 copy
, target_charset ());
1327 /* Parse a C escape sequence. STRING_PTR points to a variable
1328 containing a pointer to the string to parse. That pointer
1329 should point to the character after the \. That pointer
1330 is updated past the characters we use. The value of the
1331 escape sequence is returned.
1333 A negative value means the sequence \ newline was seen,
1334 which is supposed to be equivalent to nothing at all.
1336 If \ is followed by a null character, we return a negative
1337 value and leave the string pointer pointing at the null character.
1339 If \ is followed by 000, we return 0 and leave the string pointer
1340 after the zeros. A value of 0 does not mean end of string. */
1343 parse_escape (char **string_ptr
)
1346 int c
= *(*string_ptr
)++;
1347 if (c_parse_backslash (c
, &target_char
))
1359 /* Remember where this escape sequence started, for reporting
1361 char *sequence_start_pos
= *string_ptr
- 1;
1363 c
= *(*string_ptr
)++;
1367 /* XXXCHARSET: What is `delete' in the host character set? */
1370 if (!host_char_to_target (c
, &target_char
))
1371 error (_("There is no character corresponding to `Delete' "
1372 "in the target character set `%s'."), host_charset ());
1377 target_char
= parse_escape (string_ptr
);
1380 if (!host_char_to_target (c
, &target_char
))
1381 no_control_char_error (sequence_start_pos
, *string_ptr
);
1384 /* Now target_char is something like `c', and we want to find
1385 its control-character equivalent. */
1386 if (!target_char_to_control_char (target_char
, &target_char
))
1387 no_control_char_error (sequence_start_pos
, *string_ptr
);
1392 /* XXXCHARSET: we need to use isdigit and value-of-digit
1393 methods of the host character set here. */
1409 if (c
>= '0' && c
<= '7')
1423 if (!host_char_to_target (c
, &target_char
))
1425 ("The escape sequence `\%c' is equivalent to plain `%c', which"
1426 " has no equivalent\n" "in the `%s' character set.", c
, c
,
1432 /* Print the character C on STREAM as part of the contents of a literal
1433 string whose delimiter is QUOTER. Note that this routine should only
1434 be call for printing things which are independent of the language
1435 of the program being debugged. */
1438 printchar (int c
, void (*do_fputs
) (const char *, struct ui_file
*),
1439 void (*do_fprintf
) (struct ui_file
*, const char *, ...)
1440 ATTRIBUTE_FPTR_PRINTF_2
, struct ui_file
*stream
, int quoter
)
1443 c
&= 0xFF; /* Avoid sign bit follies */
1445 if (c
< 0x20 || /* Low control chars */
1446 (c
>= 0x7F && c
< 0xA0) || /* DEL, High controls */
1447 (sevenbit_strings
&& c
>= 0x80))
1448 { /* high order bit set */
1452 do_fputs ("\\n", stream
);
1455 do_fputs ("\\b", stream
);
1458 do_fputs ("\\t", stream
);
1461 do_fputs ("\\f", stream
);
1464 do_fputs ("\\r", stream
);
1467 do_fputs ("\\e", stream
);
1470 do_fputs ("\\a", stream
);
1473 do_fprintf (stream
, "\\%.3o", (unsigned int) c
);
1479 if (c
== '\\' || c
== quoter
)
1480 do_fputs ("\\", stream
);
1481 do_fprintf (stream
, "%c", c
);
1485 /* Print the character C on STREAM as part of the contents of a
1486 literal string whose delimiter is QUOTER. Note that these routines
1487 should only be call for printing things which are independent of
1488 the language of the program being debugged. */
1491 fputstr_filtered (const char *str
, int quoter
, struct ui_file
*stream
)
1494 printchar (*str
++, fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1498 fputstr_unfiltered (const char *str
, int quoter
, struct ui_file
*stream
)
1501 printchar (*str
++, fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1505 fputstrn_filtered (const char *str
, int n
, int quoter
,
1506 struct ui_file
*stream
)
1509 for (i
= 0; i
< n
; i
++)
1510 printchar (str
[i
], fputs_filtered
, fprintf_filtered
, stream
, quoter
);
1514 fputstrn_unfiltered (const char *str
, int n
, int quoter
,
1515 struct ui_file
*stream
)
1518 for (i
= 0; i
< n
; i
++)
1519 printchar (str
[i
], fputs_unfiltered
, fprintf_unfiltered
, stream
, quoter
);
1523 /* Number of lines per page or UINT_MAX if paging is disabled. */
1524 static unsigned int lines_per_page
;
1526 show_lines_per_page (struct ui_file
*file
, int from_tty
,
1527 struct cmd_list_element
*c
, const char *value
)
1529 fprintf_filtered (file
, _("\
1530 Number of lines gdb thinks are in a page is %s.\n"),
1534 /* Number of chars per line or UINT_MAX if line folding is disabled. */
1535 static unsigned int chars_per_line
;
1537 show_chars_per_line (struct ui_file
*file
, int from_tty
,
1538 struct cmd_list_element
*c
, const char *value
)
1540 fprintf_filtered (file
, _("\
1541 Number of characters gdb thinks are in a line is %s.\n"),
1545 /* Current count of lines printed on this page, chars on this line. */
1546 static unsigned int lines_printed
, chars_printed
;
1548 /* Buffer and start column of buffered text, for doing smarter word-
1549 wrapping. When someone calls wrap_here(), we start buffering output
1550 that comes through fputs_filtered(). If we see a newline, we just
1551 spit it out and forget about the wrap_here(). If we see another
1552 wrap_here(), we spit it out and remember the newer one. If we see
1553 the end of the line, we spit out a newline, the indent, and then
1554 the buffered output. */
1556 /* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
1557 are waiting to be output (they have already been counted in chars_printed).
1558 When wrap_buffer[0] is null, the buffer is empty. */
1559 static char *wrap_buffer
;
1561 /* Pointer in wrap_buffer to the next character to fill. */
1562 static char *wrap_pointer
;
1564 /* String to indent by if the wrap occurs. Must not be NULL if wrap_column
1566 static char *wrap_indent
;
1568 /* Column number on the screen where wrap_buffer begins, or 0 if wrapping
1569 is not in effect. */
1570 static int wrap_column
;
1573 /* Inialize the number of lines per page and chars per line. */
1576 init_page_info (void)
1579 if (!tui_get_command_dimension (&chars_per_line
, &lines_per_page
))
1584 #if defined(__GO32__)
1585 rows
= ScreenRows ();
1586 cols
= ScreenCols ();
1587 lines_per_page
= rows
;
1588 chars_per_line
= cols
;
1590 /* Make sure Readline has initialized its terminal settings. */
1591 rl_reset_terminal (NULL
);
1593 /* Get the screen size from Readline. */
1594 rl_get_screen_size (&rows
, &cols
);
1595 lines_per_page
= rows
;
1596 chars_per_line
= cols
;
1598 /* Readline should have fetched the termcap entry for us. */
1599 if (tgetnum ("li") < 0 || getenv ("EMACS"))
1601 /* The number of lines per page is not mentioned in the
1602 terminal description. This probably means that paging is
1603 not useful (e.g. emacs shell window), so disable paging. */
1604 lines_per_page
= UINT_MAX
;
1607 /* FIXME: Get rid of this junk. */
1608 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1609 SIGWINCH_HANDLER (SIGWINCH
);
1612 /* If the output is not a terminal, don't paginate it. */
1613 if (!ui_file_isatty (gdb_stdout
))
1614 lines_per_page
= UINT_MAX
;
1622 /* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
1625 set_screen_size (void)
1627 int rows
= lines_per_page
;
1628 int cols
= chars_per_line
;
1636 /* Update Readline's idea of the terminal size. */
1637 rl_set_screen_size (rows
, cols
);
1640 /* Reinitialize WRAP_BUFFER according to the current value of
1646 if (chars_per_line
== 0)
1651 wrap_buffer
= (char *) xmalloc (chars_per_line
+ 2);
1652 wrap_buffer
[0] = '\0';
1655 wrap_buffer
= (char *) xrealloc (wrap_buffer
, chars_per_line
+ 2);
1656 wrap_pointer
= wrap_buffer
; /* Start it at the beginning. */
1660 set_width_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1667 set_height_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1672 /* Wait, so the user can read what's on the screen. Prompt the user
1673 to continue by pressing RETURN. */
1676 prompt_for_continue (void)
1679 char cont_prompt
[120];
1681 if (annotation_level
> 1)
1682 printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
1684 strcpy (cont_prompt
,
1685 "---Type <return> to continue, or q <return> to quit---");
1686 if (annotation_level
> 1)
1687 strcat (cont_prompt
, "\n\032\032prompt-for-continue\n");
1689 /* We must do this *before* we call gdb_readline, else it will eventually
1690 call us -- thinking that we're trying to print beyond the end of the
1692 reinitialize_more_filter ();
1695 /* On a real operating system, the user can quit with SIGINT.
1698 'q' is provided on all systems so users don't have to change habits
1699 from system to system, and because telling them what to do in
1700 the prompt is more user-friendly than expecting them to think of
1702 /* Call readline, not gdb_readline, because GO32 readline handles control-C
1703 whereas control-C to gdb_readline will cause the user to get dumped
1705 ignore
= gdb_readline_wrapper (cont_prompt
);
1707 if (annotation_level
> 1)
1708 printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
1713 while (*p
== ' ' || *p
== '\t')
1716 async_request_quit (0);
1721 /* Now we have to do this again, so that GDB will know that it doesn't
1722 need to save the ---Type <return>--- line at the top of the screen. */
1723 reinitialize_more_filter ();
1725 dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
1728 /* Reinitialize filter; ie. tell it to reset to original values. */
1731 reinitialize_more_filter (void)
1737 /* Indicate that if the next sequence of characters overflows the line,
1738 a newline should be inserted here rather than when it hits the end.
1739 If INDENT is non-null, it is a string to be printed to indent the
1740 wrapped part on the next line. INDENT must remain accessible until
1741 the next call to wrap_here() or until a newline is printed through
1744 If the line is already overfull, we immediately print a newline and
1745 the indentation, and disable further wrapping.
1747 If we don't know the width of lines, but we know the page height,
1748 we must not wrap words, but should still keep track of newlines
1749 that were explicitly printed.
1751 INDENT should not contain tabs, as that will mess up the char count
1752 on the next line. FIXME.
1754 This routine is guaranteed to force out any output which has been
1755 squirreled away in the wrap_buffer, so wrap_here ((char *)0) can be
1756 used to force out output from the wrap_buffer. */
1759 wrap_here (char *indent
)
1761 /* This should have been allocated, but be paranoid anyway. */
1763 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
1767 *wrap_pointer
= '\0';
1768 fputs_unfiltered (wrap_buffer
, gdb_stdout
);
1770 wrap_pointer
= wrap_buffer
;
1771 wrap_buffer
[0] = '\0';
1772 if (chars_per_line
== UINT_MAX
) /* No line overflow checking */
1776 else if (chars_printed
>= chars_per_line
)
1778 puts_filtered ("\n");
1780 puts_filtered (indent
);
1785 wrap_column
= chars_printed
;
1789 wrap_indent
= indent
;
1793 /* Print input string to gdb_stdout, filtered, with wrap,
1794 arranging strings in columns of n chars. String can be
1795 right or left justified in the column. Never prints
1796 trailing spaces. String should never be longer than
1797 width. FIXME: this could be useful for the EXAMINE
1798 command, which currently doesn't tabulate very well */
1801 puts_filtered_tabular (char *string
, int width
, int right
)
1807 gdb_assert (chars_per_line
> 0);
1808 if (chars_per_line
== UINT_MAX
)
1810 fputs_filtered (string
, gdb_stdout
);
1811 fputs_filtered ("\n", gdb_stdout
);
1815 if (((chars_printed
- 1) / width
+ 2) * width
>= chars_per_line
)
1816 fputs_filtered ("\n", gdb_stdout
);
1818 if (width
>= chars_per_line
)
1819 width
= chars_per_line
- 1;
1821 stringlen
= strlen (string
);
1823 if (chars_printed
> 0)
1824 spaces
= width
- (chars_printed
- 1) % width
- 1;
1826 spaces
+= width
- stringlen
;
1828 spacebuf
= alloca (spaces
+ 1);
1829 spacebuf
[spaces
] = '\0';
1831 spacebuf
[spaces
] = ' ';
1833 fputs_filtered (spacebuf
, gdb_stdout
);
1834 fputs_filtered (string
, gdb_stdout
);
1838 /* Ensure that whatever gets printed next, using the filtered output
1839 commands, starts at the beginning of the line. I.E. if there is
1840 any pending output for the current line, flush it and start a new
1841 line. Otherwise do nothing. */
1846 if (chars_printed
> 0)
1848 puts_filtered ("\n");
1853 /* Like fputs but if FILTER is true, pause after every screenful.
1855 Regardless of FILTER can wrap at points other than the final
1856 character of a line.
1858 Unlike fputs, fputs_maybe_filtered does not return a value.
1859 It is OK for LINEBUFFER to be NULL, in which case just don't print
1862 Note that a longjmp to top level may occur in this routine (only if
1863 FILTER is true) (since prompt_for_continue may do so) so this
1864 routine should not be called when cleanups are not in place. */
1867 fputs_maybe_filtered (const char *linebuffer
, struct ui_file
*stream
,
1870 const char *lineptr
;
1872 if (linebuffer
== 0)
1875 /* Don't do any filtering if it is disabled. */
1876 if ((stream
!= gdb_stdout
) || !pagination_enabled
1877 || (lines_per_page
== UINT_MAX
&& chars_per_line
== UINT_MAX
))
1879 fputs_unfiltered (linebuffer
, stream
);
1883 /* Go through and output each character. Show line extension
1884 when this is necessary; prompt user for new page when this is
1887 lineptr
= linebuffer
;
1890 /* Possible new page. */
1891 if (filter
&& (lines_printed
>= lines_per_page
- 1))
1892 prompt_for_continue ();
1894 while (*lineptr
&& *lineptr
!= '\n')
1896 /* Print a single line. */
1897 if (*lineptr
== '\t')
1900 *wrap_pointer
++ = '\t';
1902 fputc_unfiltered ('\t', stream
);
1903 /* Shifting right by 3 produces the number of tab stops
1904 we have already passed, and then adding one and
1905 shifting left 3 advances to the next tab stop. */
1906 chars_printed
= ((chars_printed
>> 3) + 1) << 3;
1912 *wrap_pointer
++ = *lineptr
;
1914 fputc_unfiltered (*lineptr
, stream
);
1919 if (chars_printed
>= chars_per_line
)
1921 unsigned int save_chars
= chars_printed
;
1925 /* If we aren't actually wrapping, don't output newline --
1926 if chars_per_line is right, we probably just overflowed
1927 anyway; if it's wrong, let us keep going. */
1929 fputc_unfiltered ('\n', stream
);
1931 /* Possible new page. */
1932 if (lines_printed
>= lines_per_page
- 1)
1933 prompt_for_continue ();
1935 /* Now output indentation and wrapped string */
1938 fputs_unfiltered (wrap_indent
, stream
);
1939 *wrap_pointer
= '\0'; /* Null-terminate saved stuff */
1940 fputs_unfiltered (wrap_buffer
, stream
); /* and eject it */
1941 /* FIXME, this strlen is what prevents wrap_indent from
1942 containing tabs. However, if we recurse to print it
1943 and count its chars, we risk trouble if wrap_indent is
1944 longer than (the user settable) chars_per_line.
1945 Note also that this can set chars_printed > chars_per_line
1946 if we are printing a long string. */
1947 chars_printed
= strlen (wrap_indent
)
1948 + (save_chars
- wrap_column
);
1949 wrap_pointer
= wrap_buffer
; /* Reset buffer */
1950 wrap_buffer
[0] = '\0';
1951 wrap_column
= 0; /* And disable fancy wrap */
1956 if (*lineptr
== '\n')
1959 wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
1961 fputc_unfiltered ('\n', stream
);
1968 fputs_filtered (const char *linebuffer
, struct ui_file
*stream
)
1970 fputs_maybe_filtered (linebuffer
, stream
, 1);
1974 putchar_unfiltered (int c
)
1977 ui_file_write (gdb_stdout
, &buf
, 1);
1981 /* Write character C to gdb_stdout using GDB's paging mechanism and return C.
1982 May return nonlocally. */
1985 putchar_filtered (int c
)
1987 return fputc_filtered (c
, gdb_stdout
);
1991 fputc_unfiltered (int c
, struct ui_file
*stream
)
1994 ui_file_write (stream
, &buf
, 1);
1999 fputc_filtered (int c
, struct ui_file
*stream
)
2005 fputs_filtered (buf
, stream
);
2009 /* puts_debug is like fputs_unfiltered, except it prints special
2010 characters in printable fashion. */
2013 puts_debug (char *prefix
, char *string
, char *suffix
)
2017 /* Print prefix and suffix after each line. */
2018 static int new_line
= 1;
2019 static int return_p
= 0;
2020 static char *prev_prefix
= "";
2021 static char *prev_suffix
= "";
2023 if (*string
== '\n')
2026 /* If the prefix is changing, print the previous suffix, a new line,
2027 and the new prefix. */
2028 if ((return_p
|| (strcmp (prev_prefix
, prefix
) != 0)) && !new_line
)
2030 fputs_unfiltered (prev_suffix
, gdb_stdlog
);
2031 fputs_unfiltered ("\n", gdb_stdlog
);
2032 fputs_unfiltered (prefix
, gdb_stdlog
);
2035 /* Print prefix if we printed a newline during the previous call. */
2039 fputs_unfiltered (prefix
, gdb_stdlog
);
2042 prev_prefix
= prefix
;
2043 prev_suffix
= suffix
;
2045 /* Output characters in a printable format. */
2046 while ((ch
= *string
++) != '\0')
2052 fputc_unfiltered (ch
, gdb_stdlog
);
2055 fprintf_unfiltered (gdb_stdlog
, "\\x%02x", ch
& 0xff);
2059 fputs_unfiltered ("\\\\", gdb_stdlog
);
2062 fputs_unfiltered ("\\b", gdb_stdlog
);
2065 fputs_unfiltered ("\\f", gdb_stdlog
);
2069 fputs_unfiltered ("\\n", gdb_stdlog
);
2072 fputs_unfiltered ("\\r", gdb_stdlog
);
2075 fputs_unfiltered ("\\t", gdb_stdlog
);
2078 fputs_unfiltered ("\\v", gdb_stdlog
);
2082 return_p
= ch
== '\r';
2085 /* Print suffix if we printed a newline. */
2088 fputs_unfiltered (suffix
, gdb_stdlog
);
2089 fputs_unfiltered ("\n", gdb_stdlog
);
2094 /* Print a variable number of ARGS using format FORMAT. If this
2095 information is going to put the amount written (since the last call
2096 to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
2097 call prompt_for_continue to get the users permision to continue.
2099 Unlike fprintf, this function does not return a value.
2101 We implement three variants, vfprintf (takes a vararg list and stream),
2102 fprintf (takes a stream to write on), and printf (the usual).
2104 Note also that a longjmp to top level may occur in this routine
2105 (since prompt_for_continue may do so) so this routine should not be
2106 called when cleanups are not in place. */
2109 vfprintf_maybe_filtered (struct ui_file
*stream
, const char *format
,
2110 va_list args
, int filter
)
2113 struct cleanup
*old_cleanups
;
2115 linebuffer
= xstrvprintf (format
, args
);
2116 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2117 fputs_maybe_filtered (linebuffer
, stream
, filter
);
2118 do_cleanups (old_cleanups
);
2123 vfprintf_filtered (struct ui_file
*stream
, const char *format
, va_list args
)
2125 vfprintf_maybe_filtered (stream
, format
, args
, 1);
2129 vfprintf_unfiltered (struct ui_file
*stream
, const char *format
, va_list args
)
2132 struct cleanup
*old_cleanups
;
2134 linebuffer
= xstrvprintf (format
, args
);
2135 old_cleanups
= make_cleanup (xfree
, linebuffer
);
2136 if (debug_timestamp
&& stream
== gdb_stdlog
)
2141 gettimeofday (&tm
, NULL
);
2142 timestamp
= xstrprintf ("%ld:%ld ", (long) tm
.tv_sec
, (long) tm
.tv_usec
);
2143 make_cleanup (xfree
, timestamp
);
2144 fputs_unfiltered (timestamp
, stream
);
2146 fputs_unfiltered (linebuffer
, stream
);
2147 do_cleanups (old_cleanups
);
2151 vprintf_filtered (const char *format
, va_list args
)
2153 vfprintf_maybe_filtered (gdb_stdout
, format
, args
, 1);
2157 vprintf_unfiltered (const char *format
, va_list args
)
2159 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2163 fprintf_filtered (struct ui_file
*stream
, const char *format
, ...)
2166 va_start (args
, format
);
2167 vfprintf_filtered (stream
, format
, args
);
2172 fprintf_unfiltered (struct ui_file
*stream
, const char *format
, ...)
2175 va_start (args
, format
);
2176 vfprintf_unfiltered (stream
, format
, args
);
2180 /* Like fprintf_filtered, but prints its result indented.
2181 Called as fprintfi_filtered (spaces, stream, format, ...); */
2184 fprintfi_filtered (int spaces
, struct ui_file
*stream
, const char *format
,
2188 va_start (args
, format
);
2189 print_spaces_filtered (spaces
, stream
);
2191 vfprintf_filtered (stream
, format
, args
);
2197 printf_filtered (const char *format
, ...)
2200 va_start (args
, format
);
2201 vfprintf_filtered (gdb_stdout
, format
, args
);
2207 printf_unfiltered (const char *format
, ...)
2210 va_start (args
, format
);
2211 vfprintf_unfiltered (gdb_stdout
, format
, args
);
2215 /* Like printf_filtered, but prints it's result indented.
2216 Called as printfi_filtered (spaces, format, ...); */
2219 printfi_filtered (int spaces
, const char *format
, ...)
2222 va_start (args
, format
);
2223 print_spaces_filtered (spaces
, gdb_stdout
);
2224 vfprintf_filtered (gdb_stdout
, format
, args
);
2228 /* Easy -- but watch out!
2230 This routine is *not* a replacement for puts()! puts() appends a newline.
2231 This one doesn't, and had better not! */
2234 puts_filtered (const char *string
)
2236 fputs_filtered (string
, gdb_stdout
);
2240 puts_unfiltered (const char *string
)
2242 fputs_unfiltered (string
, gdb_stdout
);
2245 /* Return a pointer to N spaces and a null. The pointer is good
2246 until the next call to here. */
2251 static char *spaces
= 0;
2252 static int max_spaces
= -1;
2258 spaces
= (char *) xmalloc (n
+ 1);
2259 for (t
= spaces
+ n
; t
!= spaces
;)
2265 return spaces
+ max_spaces
- n
;
2268 /* Print N spaces. */
2270 print_spaces_filtered (int n
, struct ui_file
*stream
)
2272 fputs_filtered (n_spaces (n
), stream
);
2275 /* C++/ObjC demangler stuff. */
2277 /* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
2278 LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
2279 If the name is not mangled, or the language for the name is unknown, or
2280 demangling is off, the name is printed in its "raw" form. */
2283 fprintf_symbol_filtered (struct ui_file
*stream
, char *name
,
2284 enum language lang
, int arg_mode
)
2290 /* If user wants to see raw output, no problem. */
2293 fputs_filtered (name
, stream
);
2297 demangled
= language_demangle (language_def (lang
), name
, arg_mode
);
2298 fputs_filtered (demangled
? demangled
: name
, stream
);
2299 if (demangled
!= NULL
)
2307 /* Do a strcmp() type operation on STRING1 and STRING2, ignoring any
2308 differences in whitespace. Returns 0 if they match, non-zero if they
2309 don't (slightly different than strcmp()'s range of return values).
2311 As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
2312 This "feature" is useful when searching for matching C++ function names
2313 (such as if the user types 'break FOO', where FOO is a mangled C++
2317 strcmp_iw (const char *string1
, const char *string2
)
2319 while ((*string1
!= '\0') && (*string2
!= '\0'))
2321 while (isspace (*string1
))
2325 while (isspace (*string2
))
2329 if (*string1
!= *string2
)
2333 if (*string1
!= '\0')
2339 return (*string1
!= '\0' && *string1
!= '(') || (*string2
!= '\0');
2342 /* This is like strcmp except that it ignores whitespace and treats
2343 '(' as the first non-NULL character in terms of ordering. Like
2344 strcmp (and unlike strcmp_iw), it returns negative if STRING1 <
2345 STRING2, 0 if STRING2 = STRING2, and positive if STRING1 > STRING2
2346 according to that ordering.
2348 If a list is sorted according to this function and if you want to
2349 find names in the list that match some fixed NAME according to
2350 strcmp_iw(LIST_ELT, NAME), then the place to start looking is right
2351 where this function would put NAME.
2353 Here are some examples of why using strcmp to sort is a bad idea:
2357 Say your partial symtab contains: "foo<char *>", "goo". Then, if
2358 we try to do a search for "foo<char*>", strcmp will locate this
2359 after "foo<char *>" and before "goo". Then lookup_partial_symbol
2360 will start looking at strings beginning with "goo", and will never
2361 see the correct match of "foo<char *>".
2363 Parenthesis example:
2365 In practice, this is less like to be an issue, but I'll give it a
2366 shot. Let's assume that '$' is a legitimate character to occur in
2367 symbols. (Which may well even be the case on some systems.) Then
2368 say that the partial symbol table contains "foo$" and "foo(int)".
2369 strcmp will put them in this order, since '$' < '('. Now, if the
2370 user searches for "foo", then strcmp will sort "foo" before "foo$".
2371 Then lookup_partial_symbol will notice that strcmp_iw("foo$",
2372 "foo") is false, so it won't proceed to the actual match of
2373 "foo(int)" with "foo". */
2376 strcmp_iw_ordered (const char *string1
, const char *string2
)
2378 while ((*string1
!= '\0') && (*string2
!= '\0'))
2380 while (isspace (*string1
))
2384 while (isspace (*string2
))
2388 if (*string1
!= *string2
)
2392 if (*string1
!= '\0')
2401 /* Characters are non-equal unless they're both '\0'; we want to
2402 make sure we get the comparison right according to our
2403 comparison in the cases where one of them is '\0' or '('. */
2405 if (*string2
== '\0')
2410 if (*string2
== '\0')
2415 if (*string2
== '(')
2418 return *string1
- *string2
;
2422 /* A simple comparison function with opposite semantics to strcmp. */
2425 streq (const char *lhs
, const char *rhs
)
2427 return !strcmp (lhs
, rhs
);
2433 ** Answer whether string_to_compare is a full or partial match to
2434 ** template_string. The partial match must be in sequence starting
2438 subset_compare (char *string_to_compare
, char *template_string
)
2441 if (template_string
!= (char *) NULL
&& string_to_compare
!= (char *) NULL
2442 && strlen (string_to_compare
) <= strlen (template_string
))
2445 (template_string
, string_to_compare
, strlen (string_to_compare
)) == 0);
2452 pagination_on_command (char *arg
, int from_tty
)
2454 pagination_enabled
= 1;
2458 pagination_off_command (char *arg
, int from_tty
)
2460 pagination_enabled
= 0;
2464 show_debug_timestamp (struct ui_file
*file
, int from_tty
,
2465 struct cmd_list_element
*c
, const char *value
)
2467 fprintf_filtered (file
, _("Timestamping debugging messages is %s.\n"), value
);
2472 initialize_utils (void)
2474 struct cmd_list_element
*c
;
2476 add_setshow_uinteger_cmd ("width", class_support
, &chars_per_line
, _("\
2477 Set number of characters gdb thinks are in a line."), _("\
2478 Show number of characters gdb thinks are in a line."), NULL
,
2480 show_chars_per_line
,
2481 &setlist
, &showlist
);
2483 add_setshow_uinteger_cmd ("height", class_support
, &lines_per_page
, _("\
2484 Set number of lines gdb thinks are in a page."), _("\
2485 Show number of lines gdb thinks are in a page."), NULL
,
2487 show_lines_per_page
,
2488 &setlist
, &showlist
);
2492 add_setshow_boolean_cmd ("demangle", class_support
, &demangle
, _("\
2493 Set demangling of encoded C++/ObjC names when displaying symbols."), _("\
2494 Show demangling of encoded C++/ObjC names when displaying symbols."), NULL
,
2497 &setprintlist
, &showprintlist
);
2499 add_setshow_boolean_cmd ("pagination", class_support
,
2500 &pagination_enabled
, _("\
2501 Set state of pagination."), _("\
2502 Show state of pagination."), NULL
,
2504 show_pagination_enabled
,
2505 &setlist
, &showlist
);
2509 add_com ("am", class_support
, pagination_on_command
,
2510 _("Enable pagination"));
2511 add_com ("sm", class_support
, pagination_off_command
,
2512 _("Disable pagination"));
2515 add_setshow_boolean_cmd ("sevenbit-strings", class_support
,
2516 &sevenbit_strings
, _("\
2517 Set printing of 8-bit characters in strings as \\nnn."), _("\
2518 Show printing of 8-bit characters in strings as \\nnn."), NULL
,
2520 show_sevenbit_strings
,
2521 &setprintlist
, &showprintlist
);
2523 add_setshow_boolean_cmd ("asm-demangle", class_support
, &asm_demangle
, _("\
2524 Set demangling of C++/ObjC names in disassembly listings."), _("\
2525 Show demangling of C++/ObjC names in disassembly listings."), NULL
,
2528 &setprintlist
, &showprintlist
);
2530 add_setshow_boolean_cmd ("timestamp", class_maintenance
,
2531 &debug_timestamp
, _("\
2532 Set timestamping of debugging messages."), _("\
2533 Show timestamping of debugging messages."), _("\
2534 When set, debugging messages will be marked with seconds and microseconds."),
2536 show_debug_timestamp
,
2537 &setdebuglist
, &showdebuglist
);
2540 /* Machine specific function to handle SIGWINCH signal. */
2542 #ifdef SIGWINCH_HANDLER_BODY
2543 SIGWINCH_HANDLER_BODY
2545 /* print routines to handle variable size regs, etc. */
2546 /* temporary storage using circular buffer */
2552 static char buf
[NUMCELLS
][CELLSIZE
];
2553 static int cell
= 0;
2554 if (++cell
>= NUMCELLS
)
2562 return (gdbarch_addr_bit (current_gdbarch
) / 8 * 2);
2566 paddr (CORE_ADDR addr
)
2568 return phex (addr
, gdbarch_addr_bit (current_gdbarch
) / 8);
2572 paddr_nz (CORE_ADDR addr
)
2574 return phex_nz (addr
, gdbarch_addr_bit (current_gdbarch
) / 8);
2578 paddress (CORE_ADDR addr
)
2580 /* Truncate address to the size of a target address, avoiding shifts
2581 larger or equal than the width of a CORE_ADDR. The local
2582 variable ADDR_BIT stops the compiler reporting a shift overflow
2583 when it won't occur. */
2584 /* NOTE: This assumes that the significant address information is
2585 kept in the least significant bits of ADDR - the upper bits were
2586 either zero or sign extended. Should gdbarch_address_to_pointer or
2587 some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
2589 int addr_bit
= gdbarch_addr_bit (current_gdbarch
);
2591 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2592 addr
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
2593 return hex_string (addr
);
2597 decimal2str (char *sign
, ULONGEST addr
, int width
)
2599 /* Steal code from valprint.c:print_decimal(). Should this worry
2600 about the real size of addr as the above does? */
2601 unsigned long temp
[3];
2602 char *str
= get_cell ();
2607 temp
[i
] = addr
% (1000 * 1000 * 1000);
2608 addr
/= (1000 * 1000 * 1000);
2612 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2621 xsnprintf (str
, CELLSIZE
, "%s%0*lu", sign
, width
, temp
[0]);
2624 xsnprintf (str
, CELLSIZE
, "%s%0*lu%09lu", sign
, width
,
2628 xsnprintf (str
, CELLSIZE
, "%s%0*lu%09lu%09lu", sign
, width
,
2629 temp
[2], temp
[1], temp
[0]);
2632 internal_error (__FILE__
, __LINE__
,
2633 _("failed internal consistency check"));
2640 octal2str (ULONGEST addr
, int width
)
2642 unsigned long temp
[3];
2643 char *str
= get_cell ();
2648 temp
[i
] = addr
% (0100000 * 0100000);
2649 addr
/= (0100000 * 0100000);
2653 while (addr
!= 0 && i
< (sizeof (temp
) / sizeof (temp
[0])));
2663 xsnprintf (str
, CELLSIZE
, "%*o", width
, 0);
2665 xsnprintf (str
, CELLSIZE
, "0%0*lo", width
, temp
[0]);
2668 xsnprintf (str
, CELLSIZE
, "0%0*lo%010lo", width
, temp
[1], temp
[0]);
2671 xsnprintf (str
, CELLSIZE
, "0%0*lo%010lo%010lo", width
,
2672 temp
[2], temp
[1], temp
[0]);
2675 internal_error (__FILE__
, __LINE__
,
2676 _("failed internal consistency check"));
2683 paddr_u (CORE_ADDR addr
)
2685 return decimal2str ("", addr
, 0);
2689 paddr_d (LONGEST addr
)
2692 return decimal2str ("-", -addr
, 0);
2694 return decimal2str ("", addr
, 0);
2697 /* Eliminate warning from compiler on 32-bit systems. */
2698 static int thirty_two
= 32;
2701 phex (ULONGEST l
, int sizeof_l
)
2709 xsnprintf (str
, CELLSIZE
, "%08lx%08lx",
2710 (unsigned long) (l
>> thirty_two
),
2711 (unsigned long) (l
& 0xffffffff));
2715 xsnprintf (str
, CELLSIZE
, "%08lx", (unsigned long) l
);
2719 xsnprintf (str
, CELLSIZE
, "%04x", (unsigned short) (l
& 0xffff));
2722 str
= phex (l
, sizeof (l
));
2730 phex_nz (ULONGEST l
, int sizeof_l
)
2738 unsigned long high
= (unsigned long) (l
>> thirty_two
);
2741 xsnprintf (str
, CELLSIZE
, "%lx",
2742 (unsigned long) (l
& 0xffffffff));
2744 xsnprintf (str
, CELLSIZE
, "%lx%08lx", high
,
2745 (unsigned long) (l
& 0xffffffff));
2750 xsnprintf (str
, CELLSIZE
, "%lx", (unsigned long) l
);
2754 xsnprintf (str
, CELLSIZE
, "%x", (unsigned short) (l
& 0xffff));
2757 str
= phex_nz (l
, sizeof (l
));
2764 /* Converts a LONGEST to a C-format hexadecimal literal and stores it
2765 in a static string. Returns a pointer to this string. */
2767 hex_string (LONGEST num
)
2769 char *result
= get_cell ();
2770 xsnprintf (result
, CELLSIZE
, "0x%s", phex_nz (num
, sizeof (num
)));
2774 /* Converts a LONGEST number to a C-format hexadecimal literal and
2775 stores it in a static string. Returns a pointer to this string
2776 that is valid until the next call. The number is padded on the
2777 left with 0s to at least WIDTH characters. */
2779 hex_string_custom (LONGEST num
, int width
)
2781 char *result
= get_cell ();
2782 char *result_end
= result
+ CELLSIZE
- 1;
2783 const char *hex
= phex_nz (num
, sizeof (num
));
2784 int hex_len
= strlen (hex
);
2786 if (hex_len
> width
)
2788 if (width
+ 2 >= CELLSIZE
)
2789 internal_error (__FILE__
, __LINE__
,
2790 _("hex_string_custom: insufficient space to store result"));
2792 strcpy (result_end
- width
- 2, "0x");
2793 memset (result_end
- width
, '0', width
);
2794 strcpy (result_end
- hex_len
, hex
);
2795 return result_end
- width
- 2;
2798 /* Convert VAL to a numeral in the given radix. For
2799 * radix 10, IS_SIGNED may be true, indicating a signed quantity;
2800 * otherwise VAL is interpreted as unsigned. If WIDTH is supplied,
2801 * it is the minimum width (0-padded if needed). USE_C_FORMAT means
2802 * to use C format in all cases. If it is false, then 'x'
2803 * and 'o' formats do not include a prefix (0x or leading 0). */
2806 int_string (LONGEST val
, int radix
, int is_signed
, int width
,
2815 result
= hex_string (val
);
2817 result
= hex_string_custom (val
, width
);
2824 if (is_signed
&& val
< 0)
2825 return decimal2str ("-", -val
, width
);
2827 return decimal2str ("", val
, width
);
2831 char *result
= octal2str (val
, width
);
2832 if (use_c_format
|| val
== 0)
2838 internal_error (__FILE__
, __LINE__
,
2839 _("failed internal consistency check"));
2843 /* Convert a CORE_ADDR into a string. */
2845 core_addr_to_string (const CORE_ADDR addr
)
2847 char *str
= get_cell ();
2849 strcat (str
, phex (addr
, sizeof (addr
)));
2854 core_addr_to_string_nz (const CORE_ADDR addr
)
2856 char *str
= get_cell ();
2858 strcat (str
, phex_nz (addr
, sizeof (addr
)));
2862 /* Convert a string back into a CORE_ADDR. */
2864 string_to_core_addr (const char *my_string
)
2866 int addr_bit
= gdbarch_addr_bit (current_gdbarch
);
2869 if (my_string
[0] == '0' && tolower (my_string
[1]) == 'x')
2871 /* Assume that it is in hex. */
2873 for (i
= 2; my_string
[i
] != '\0'; i
++)
2875 if (isdigit (my_string
[i
]))
2876 addr
= (my_string
[i
] - '0') + (addr
* 16);
2877 else if (isxdigit (my_string
[i
]))
2878 addr
= (tolower (my_string
[i
]) - 'a' + 0xa) + (addr
* 16);
2880 error (_("invalid hex \"%s\""), my_string
);
2883 /* Not very modular, but if the executable format expects
2884 addresses to be sign-extended, then do so if the address was
2885 specified with only 32 significant bits. Really this should
2886 be determined by the target architecture, not by the object
2888 if (i
- 2 == addr_bit
/ 4
2890 && bfd_get_sign_extend_vma (exec_bfd
))
2891 addr
= (addr
^ ((CORE_ADDR
) 1 << (addr_bit
- 1)))
2892 - ((CORE_ADDR
) 1 << (addr_bit
- 1));
2896 /* Assume that it is in decimal. */
2898 for (i
= 0; my_string
[i
] != '\0'; i
++)
2900 if (isdigit (my_string
[i
]))
2901 addr
= (my_string
[i
] - '0') + (addr
* 10);
2903 error (_("invalid decimal \"%s\""), my_string
);
2911 host_address_to_string (const void *addr
)
2913 char *str
= get_cell ();
2914 sprintf (str
, "0x%lx", (unsigned long) addr
);
2919 gdb_realpath (const char *filename
)
2921 /* Method 1: The system has a compile time upper bound on a filename
2922 path. Use that and realpath() to canonicalize the name. This is
2923 the most common case. Note that, if there isn't a compile time
2924 upper bound, you want to avoid realpath() at all costs. */
2925 #if defined(HAVE_REALPATH)
2927 # if defined (PATH_MAX)
2929 # define USE_REALPATH
2930 # elif defined (MAXPATHLEN)
2931 char buf
[MAXPATHLEN
];
2932 # define USE_REALPATH
2934 # if defined (USE_REALPATH)
2935 const char *rp
= realpath (filename
, buf
);
2938 return xstrdup (rp
);
2941 #endif /* HAVE_REALPATH */
2943 /* Method 2: The host system (i.e., GNU) has the function
2944 canonicalize_file_name() which malloc's a chunk of memory and
2945 returns that, use that. */
2946 #if defined(HAVE_CANONICALIZE_FILE_NAME)
2948 char *rp
= canonicalize_file_name (filename
);
2950 return xstrdup (filename
);
2956 /* FIXME: cagney/2002-11-13:
2958 Method 2a: Use realpath() with a NULL buffer. Some systems, due
2959 to the problems described in in method 3, have modified their
2960 realpath() implementation so that it will allocate a buffer when
2961 NULL is passed in. Before this can be used, though, some sort of
2962 configure time test would need to be added. Otherwize the code
2963 will likely core dump. */
2965 /* Method 3: Now we're getting desperate! The system doesn't have a
2966 compile time buffer size and no alternative function. Query the
2967 OS, using pathconf(), for the buffer limit. Care is needed
2968 though, some systems do not limit PATH_MAX (return -1 for
2969 pathconf()) making it impossible to pass a correctly sized buffer
2970 to realpath() (it could always overflow). On those systems, we
2972 #if defined (HAVE_REALPATH) && defined (HAVE_UNISTD_H) && defined(HAVE_ALLOCA)
2974 /* Find out the max path size. */
2975 long path_max
= pathconf ("/", _PC_PATH_MAX
);
2978 /* PATH_MAX is bounded. */
2979 char *buf
= alloca (path_max
);
2980 char *rp
= realpath (filename
, buf
);
2981 return xstrdup (rp
? rp
: filename
);
2986 /* This system is a lost cause, just dup the buffer. */
2987 return xstrdup (filename
);
2990 /* Return a copy of FILENAME, with its directory prefix canonicalized
2994 xfullpath (const char *filename
)
2996 const char *base_name
= lbasename (filename
);
3001 /* Extract the basename of filename, and return immediately
3002 a copy of filename if it does not contain any directory prefix. */
3003 if (base_name
== filename
)
3004 return xstrdup (filename
);
3006 dir_name
= alloca ((size_t) (base_name
- filename
+ 2));
3007 /* Allocate enough space to store the dir_name + plus one extra
3008 character sometimes needed under Windows (see below), and
3009 then the closing \000 character */
3010 strncpy (dir_name
, filename
, base_name
- filename
);
3011 dir_name
[base_name
- filename
] = '\000';
3013 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3014 /* We need to be careful when filename is of the form 'd:foo', which
3015 is equivalent of d:./foo, which is totally different from d:/foo. */
3016 if (strlen (dir_name
) == 2 && isalpha (dir_name
[0]) && dir_name
[1] == ':')
3019 dir_name
[3] = '\000';
3023 /* Canonicalize the directory prefix, and build the resulting
3024 filename. If the dirname realpath already contains an ending
3025 directory separator, avoid doubling it. */
3026 real_path
= gdb_realpath (dir_name
);
3027 if (IS_DIR_SEPARATOR (real_path
[strlen (real_path
) - 1]))
3028 result
= concat (real_path
, base_name
, (char *)NULL
);
3030 result
= concat (real_path
, SLASH_STRING
, base_name
, (char *)NULL
);
3037 /* This is the 32-bit CRC function used by the GNU separate debug
3038 facility. An executable may contain a section named
3039 .gnu_debuglink, which holds the name of a separate executable file
3040 containing its debug info, and a checksum of that file's contents,
3041 computed using this function. */
3043 gnu_debuglink_crc32 (unsigned long crc
, unsigned char *buf
, size_t len
)
3045 static const unsigned long crc32_table
[256] = {
3046 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
3047 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
3048 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
3049 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
3050 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
3051 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
3052 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
3053 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
3054 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
3055 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
3056 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
3057 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
3058 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
3059 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
3060 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
3061 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
3062 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
3063 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
3064 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
3065 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
3066 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
3067 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
3068 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
3069 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
3070 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
3071 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
3072 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
3073 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
3074 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
3075 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
3076 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
3077 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
3078 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
3079 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
3080 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
3081 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
3082 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
3083 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
3084 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
3085 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
3086 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
3087 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
3088 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
3089 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
3090 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
3091 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
3092 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
3093 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
3094 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
3095 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
3096 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
3101 crc
= ~crc
& 0xffffffff;
3102 for (end
= buf
+ len
; buf
< end
; ++buf
)
3103 crc
= crc32_table
[(crc
^ *buf
) & 0xff] ^ (crc
>> 8);
3104 return ~crc
& 0xffffffff;;
3108 align_up (ULONGEST v
, int n
)
3110 /* Check that N is really a power of two. */
3111 gdb_assert (n
&& (n
& (n
-1)) == 0);
3112 return (v
+ n
- 1) & -n
;
3116 align_down (ULONGEST v
, int n
)
3118 /* Check that N is really a power of two. */
3119 gdb_assert (n
&& (n
& (n
-1)) == 0);
3123 /* Allocation function for the libiberty hash table which uses an
3124 obstack. The obstack is passed as DATA. */
3127 hashtab_obstack_allocate (void *data
, size_t size
, size_t count
)
3129 unsigned int total
= size
* count
;
3130 void *ptr
= obstack_alloc ((struct obstack
*) data
, total
);
3131 memset (ptr
, 0, total
);
3135 /* Trivial deallocation function for the libiberty splay tree and hash
3136 table - don't deallocate anything. Rely on later deletion of the
3137 obstack. DATA will be the obstack, although it is not needed
3141 dummy_obstack_deallocate (void *object
, void *data
)
3146 /* The bit offset of the highest byte in a ULONGEST, for overflow
3149 #define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
3151 /* True (non-zero) iff DIGIT is a valid digit in radix BASE,
3152 where 2 <= BASE <= 36. */
3155 is_digit_in_base (unsigned char digit
, int base
)
3157 if (!isalnum (digit
))
3160 return (isdigit (digit
) && digit
< base
+ '0');
3162 return (isdigit (digit
) || tolower (digit
) < base
- 10 + 'a');
3166 digit_to_int (unsigned char c
)
3171 return tolower (c
) - 'a' + 10;
3174 /* As for strtoul, but for ULONGEST results. */
3177 strtoulst (const char *num
, const char **trailer
, int base
)
3179 unsigned int high_part
;
3184 /* Skip leading whitespace. */
3185 while (isspace (num
[i
]))
3188 /* Handle prefixes. */
3191 else if (num
[i
] == '-')
3197 if (base
== 0 || base
== 16)
3199 if (num
[i
] == '0' && (num
[i
+ 1] == 'x' || num
[i
+ 1] == 'X'))
3207 if (base
== 0 && num
[i
] == '0')
3213 if (base
< 2 || base
> 36)
3219 result
= high_part
= 0;
3220 for (; is_digit_in_base (num
[i
], base
); i
+= 1)
3222 result
= result
* base
+ digit_to_int (num
[i
]);
3223 high_part
= high_part
* base
+ (unsigned int) (result
>> HIGH_BYTE_POSN
);
3224 result
&= ((ULONGEST
) 1 << HIGH_BYTE_POSN
) - 1;
3225 if (high_part
> 0xff)
3228 result
= ~ (ULONGEST
) 0;
3235 if (trailer
!= NULL
)
3238 result
= result
+ ((ULONGEST
) high_part
<< HIGH_BYTE_POSN
);
3245 /* Simple, portable version of dirname that does not modify its
3249 ldirname (const char *filename
)
3251 const char *base
= lbasename (filename
);
3254 while (base
> filename
&& IS_DIR_SEPARATOR (base
[-1]))
3257 if (base
== filename
)
3260 dirname
= xmalloc (base
- filename
+ 2);
3261 memcpy (dirname
, filename
, base
- filename
);
3263 /* On DOS based file systems, convert "d:foo" to "d:.", so that we
3264 create "d:./bar" later instead of the (different) "d:/bar". */
3265 if (base
- filename
== 2 && IS_ABSOLUTE_PATH (base
)
3266 && !IS_DIR_SEPARATOR (filename
[0]))
3267 dirname
[base
++ - filename
] = '.';
3269 dirname
[base
- filename
] = '\0';